机器学习十大算法案例

网摘文苑 2023-03-20 发表于新疆

展开全文

机器学习十大算法与案例实现

监督学习
1. 线性回归
2. 逻辑回归
3. 神经网络
4. SVM支持向量机
5. K邻近
6. 贝叶斯
7. 决策树
8. 集成学习(Adaboost)
非监督学习
9. 降维—主成分分析
10. 聚类分析

监督学习

1. 线性回归

梯度下降一元线性回归

import numpy as npimport matplotlib.pyplot as plt# 载入数据data = np.genfromtxt('data.csv', delimiter=',')x_data = data[:,0]y_data = data[:,1]# 学习率learning ratelr = 0.0001# 截距b = 0 # 斜率k = 0 # 最大迭代次数epochs = 50# 最小二乘法def compute_error(b, k, x_data, y_data):    totalError = 0    for i in range(0, len(x_data)):        totalError += (y_data[i] - (k * x_data[i] + b)) ** 2    return totalError / float(len(x_data)) / 2.0def gradient_descent_runner(x_data, y_data, b, k, lr, epochs):    # 计算总数据量    m = float(len(x_data))    # 循环epochs次    for i in range(epochs):        b_grad = 0        k_grad = 0        # 计算梯度的总和再求平均        for j in range(0, len(x_data)):            b_grad += (1/m) * (((k * x_data[j]) + b) - y_data[j])            k_grad += (1/m) * x_data[j] * (((k * x_data[j]) + b) - y_data[j])        # 更新b和k        b = b - (lr * b_grad)        k = k - (lr * k_grad)    return b, kprint('Starting b = {0}, k = {1}, error = {2}'.format(b, k, compute_error(b, k, x_data, y_data)))print('Running...')b, k = gradient_descent_runner(x_data, y_data, b, k, lr, epochs)print('After {0} iterations b = {1}, k = {2}, error = {3}'.format(epochs, b, k, compute_error(b, k, x_data, y_data)))#画图plt.plot(x_data, y_data, 'b.')plt.plot(x_data, k*x_data + b, 'r')plt.show()

梯度下降法-多元线性回归

import numpy as npfrom numpy import genfromtxtimport matplotlib.pyplot as plt  from mpl_toolkits.mplot3d import Axes3D  # 读入数据 data = genfromtxt(r'Delivery.csv',delimiter=',')# 切分数据x_data = data[:,:-1]y_data = data[:,-1]# 学习率learning ratelr = 0.0001# 参数theta0 = 0theta1 = 0theta2 = 0# 最大迭代次数epochs = 1000# 最小二乘法def compute_error(theta0, theta1, theta2, x_data, y_data):    totalError = 0    for i in range(0, len(x_data)):        totalError += (y_data[i] - (theta1 * x_data[i,0] + theta2*x_data[i,1] + theta0)) ** 2    return totalError / float(len(x_data))def gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs):    # 计算总数据量    m = float(len(x_data))    # 循环epochs次    for i in range(epochs):        theta0_grad = 0        theta1_grad = 0        theta2_grad = 0        # 计算梯度的总和再求平均        for j in range(0, len(x_data)):            theta0_grad += (1/m) * ((theta1 * x_data[j,0] + theta2*x_data[j,1] + theta0) - y_data[j])            theta1_grad += (1/m) * x_data[j,0] * ((theta1 * x_data[j,0] + theta2*x_data[j,1] + theta0) - y_data[j])            theta2_grad += (1/m) * x_data[j,1] * ((theta1 * x_data[j,0] + theta2*x_data[j,1] + theta0) - y_data[j])        # 更新b和k        theta0 = theta0 - (lr*theta0_grad)        theta1 = theta1 - (lr*theta1_grad)        theta2 = theta2 - (lr*theta2_grad)    return theta0, theta1, theta2print('Starting theta0 = {0}, theta1 = {1}, theta2 = {2}, error = {3}'.      format(theta0, theta1, theta2, compute_error(theta0, theta1, theta2, x_data, y_data)))print('Running...')theta0, theta1, theta2 = gradient_descent_runner(x_data, y_data, theta0, theta1, theta2, lr, epochs)print('After {0} iterations theta0 = {1}, theta1 = {2}, theta2 = {3}, error = {4}'.      format(epochs, theta0, theta1, theta2, compute_error(theta0, theta1, theta2, x_data, y_data)))ax = plt.figure().add_subplot(111, projection = '3d') ax.scatter(x_data[:,0], x_data[:,1], y_data, c = 'r', marker = 'o', s = 100) #点为红色三角形  x0 = x_data[:,0]x1 = x_data[:,1]# 生成网格矩阵x0, x1 = np.meshgrid(x0, x1)z = theta0 + x0*theta1 + x1*theta2# 画3D图ax.plot_surface(x0, x1, z)#设置坐标轴  ax.set_xlabel('Miles')  ax.set_ylabel('Num of Deliveries')  ax.set_zlabel('Time')    #显示图像  plt.show()

2.逻辑回归

逻辑回归原理与推导
梯度下降法-逻辑回归

import matplotlib.pyplot as pltimport numpy as npfrom sklearn.metrics import classification_reportfrom sklearn import preprocessing# 数据是否需要标准化scale = True# 载入数据data = np.genfromtxt('LR-testSet.csv', delimiter=',')x_data = data[:,:-1]y_data = data[:,-1]    def plot():    x0 = []    x1 = []    y0 = []    y1 = []    # 切分不同类别的数据    for i in range(len(x_data)):        if y_data[i]==0:            x0.append(x_data[i,0])            y0.append(x_data[i,1])        else:            x1.append(x_data[i,0])            y1.append(x_data[i,1])    # 画图    scatter0 = plt.scatter(x0, y0, c='b', marker='o')    scatter1 = plt.scatter(x1, y1, c='r', marker='x')    #画图例    plt.legend(handles=[scatter0,scatter1],labels=['label0','label1'],loc='best')    plot()#查看数据plt.show()

# 数据处理，添加偏置项x_data = data[:,:-1]y_data = data[:,-1,np.newaxis]print(np.mat(x_data).shape)print(np.mat(y_data).shape)# 给样本添加偏置项X_data = np.concatenate((np.ones((100,1)),x_data),axis=1)def sigmoid(x):    return 1.0/(1+np.exp(-x))def cost(xMat, yMat, ws):    left = np.multiply(yMat, np.log(sigmoid(xMat*ws)))    right = np.multiply(1 - yMat, np.log(1 - sigmoid(xMat*ws)))    return np.sum(left + right) / -(len(xMat))def gradAscent(xArr, yArr):        if scale == True:        xArr = preprocessing.scale(xArr)    xMat = np.mat(xArr)    yMat = np.mat(yArr)        lr = 0.001    epochs = 10000    costList = []    # 计算数据行列数    # 行代表数据个数，列代表权值个数    m,n = np.shape(xMat)    # 初始化权值    ws = np.mat(np.ones((n,1)))        for i in range(epochs+1):                     # xMat和weights矩阵相乘        h = sigmoid(xMat*ws)           # 计算误差        ws_grad = xMat.T*(h - yMat)/m        ws = ws - lr*ws_grad                 if i % 50 == 0:            costList.append(cost(xMat,yMat,ws))    return ws,costList# 训练模型，得到权值和cost值的变化ws,costList = gradAscent(X_data, y_data)print(ws)if scale == False:    # 画图决策边界    plot()    x_test = [[-4],[3]]    y_test = (-ws[0] - x_test*ws[1])/ws[2]    plt.plot(x_test, y_test, 'k')    plt.show()# 画图 loss值的变化x = np.linspace(0,10000,201)plt.plot(x, costList, c='r')plt.title('Train')plt.xlabel('Epochs')plt.ylabel('Cost')plt.show()

# 预测def predict(x_data, ws):    if scale == True:        x_data = preprocessing.scale(x_data)    xMat = np.mat(x_data)    ws = np.mat(ws)    return [1 if x >= 0.5 else 0 for x in sigmoid(xMat*ws)]predictions = predict(X_data, ws)print(classification_report(y_data, predictions))

梯度下降法-非线性逻辑回归

import matplotlib.pyplot as pltimport numpy as npfrom sklearn.metrics import classification_reportfrom sklearn import preprocessingfrom sklearn.preprocessing import PolynomialFeatures# 数据是否需要标准化scale = False# 载入数据data = np.genfromtxt('LR-testSet2.txt', delimiter=',')x_data = data[:,:-1]y_data = data[:,-1,np.newaxis]    def plot():    x0 = []    x1 = []    y0 = []    y1 = []    # 切分不同类别的数据    for i in range(len(x_data)):        if y_data[i]==0:            x0.append(x_data[i,0])            y0.append(x_data[i,1])        else:            x1.append(x_data[i,0])            y1.append(x_data[i,1])    # 画图    scatter0 = plt.scatter(x0, y0, c='b', marker='o')    scatter1 = plt.scatter(x1, y1, c='r', marker='x')    #画图例    plt.legend(handles=[scatter0,scatter1],labels=['label0','label1'],loc='best')    plot()plt.show()

# 定义多项式回归,degree的值可以调节多项式的特征poly_reg  = PolynomialFeatures(degree=3) # 特征处理x_poly = poly_reg.fit_transform(x_data)def sigmoid(x):    return 1.0/(1+np.exp(-x))def cost(xMat, yMat, ws):    left = np.multiply(yMat, np.log(sigmoid(xMat*ws)))    right = np.multiply(1 - yMat, np.log(1 - sigmoid(xMat*ws)))    return np.sum(left + right) / -(len(xMat))def gradAscent(xArr, yArr):        if scale == True:        xArr = preprocessing.scale(xArr)    xMat = np.mat(xArr)    yMat = np.mat(yArr)        lr = 0.03    epochs = 50000    costList = []    # 计算数据列数，有几列就有几个权值    m,n = np.shape(xMat)    # 初始化权值    ws = np.mat(np.ones((n,1)))        for i in range(epochs+1):                     # xMat和weights矩阵相乘        h = sigmoid(xMat*ws)           # 计算误差        ws_grad = xMat.T*(h - yMat)/m        ws = ws - lr*ws_grad                 if i % 50 == 0:            costList.append(cost(xMat,yMat,ws))    return ws,costList# 训练模型，得到权值和cost值的变化ws,costList = gradAscent(x_poly, y_data)print(ws)# 获取数据值所在的范围x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1# 生成网格矩阵xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),                     np.arange(y_min, y_max, 0.02))# np.r_按row来组合array， # np.c_按colunm来组合array# >>> a = np.array([1,2,3])# >>> b = np.array([5,2,5])# >>> np.r_[a,b]# array([1, 2, 3, 5, 2, 5])# >>> np.c_[a,b]# array([[1, 5],#        [2, 2],#        [3, 5]])# >>> np.c_[a,[0,0,0],b]# array([[1, 0, 5],#        [2, 0, 2],#        [3, 0, 5]])z = sigmoid(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]).dot(np.array(ws)))# ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据for i in range(len(z)):    if z[i] > 0.5:        z[i] = 1    else:        z[i] = 0z = z.reshape(xx.shape)# 等高线图cs = plt.contourf(xx, yy, z)plot() plt.show()

# 预测def predict(x_data, ws):#     if scale == True:#         x_data = preprocessing.scale(x_data)    xMat = np.mat(x_data)    ws = np.mat(ws)    return [1 if x >= 0.5 else 0 for x in sigmoid(xMat*ws)]predictions = predict(x_poly, ws)print(classification_report(y_data, predictions))

3.神经网络

神经网络

4. SVM支持向量机

SVM-非线性

import matplotlib.pyplot as pltimport numpy as npfrom sklearn.metrics import classification_reportfrom sklearn import svm# 载入数据data = np.genfromtxt('LR-testSet2.txt', delimiter=',')x_data = data[:,:-1]y_data = data[:,-1]    def plot():    x0 = []    x1 = []    y0 = []    y1 = []    # 切分不同类别的数据    for i in range(len(x_data)):        if y_data[i]==0:            x0.append(x_data[i,0])            y0.append(x_data[i,1])        else:            x1.append(x_data[i,0])            y1.append(x_data[i,1])    # 画图    scatter0 = plt.scatter(x0, y0, c='b', marker='o')    scatter1 = plt.scatter(x1, y1, c='r', marker='x')    #画图例    plt.legend(handles=[scatter0,scatter1],labels=['label0','label1'],loc='best')    plot()plt.show()# fit the model# C和gammamodel = svm.SVC(kernel='rbf')model.fit(x_data, y_data)model.score(x_data,y_data)# 获取数据值所在的范围x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1# 生成网格矩阵xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),                     np.arange(y_min, y_max, 0.02))z = model.predict(np.c_[xx.ravel(), yy.ravel()])# ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据z = z.reshape(xx.shape)# 等高线图cs = plt.contourf(xx, yy, z)plot() plt.show()

5. K邻近

主要过程

# 导入算法包以及数据集import numpy as npfrom sklearn import datasetsfrom sklearn.model_selection import train_test_splitfrom tqdm.notebook import tqdmfrom sklearn.metrics import classification_report,confusion_matriximport operatorimport randomdef knn(x_test, x_data, y_data, k):    # 计算样本数量    x_data_size = x_data.shape[0]    # 复制x_test    np.tile(x_test, (x_data_size,1))    # 计算x_test与每一个样本的差值    diffMat = np.tile(x_test, (x_data_size,1)) - x_data    # 计算差值的平方    sqDiffMat = diffMat**2    # 求和    sqDistances = sqDiffMat.sum(axis=1)    # 开方    distances = sqDistances**0.5    # 从小到大排序    sortedDistances = distances.argsort()    classCount = {}    for i in range(k):        # 获取标签        votelabel = y_data[sortedDistances[i]]        # 统计标签数量        classCount[votelabel] = classCount.get(votelabel,0) + 1    # 根据operator.itemgetter(1)-第1个值对classCount排序，然后再取倒序    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1), reverse=True)    # 获取数量最多的标签    return sortedClassCount[0][0]# 载入数据iris = datasets.load_iris()#打乱数据data_size = iris.data.shape[0]index = [i for i in range(data_size)] random.shuffle(index)  iris.data = iris.data[index]iris.target = iris.target[index]#切分数据集test_size = 40x_train = iris.data[test_size:]x_test =  iris.data[:test_size]y_train = iris.target[test_size:]y_test = iris.target[:test_size]#分类predictions = []for i in tqdm(range(x_test.shape[0])):    predictions.append(knn(x_test[i], x_train, y_train, 5))    #评估target_names = ['class 0', 'class 1', 'class 2']print(classification_report(y_test, predictions,target_names=target_names))

6. 贝叶斯

设每个数据样本用一个n维特征向量来描述n个属性的值，即：X={x1，x2，…，xn}，假定有m个类，分别用C1, C2,…，Cm表示。给定一个未知的数据样本X（即没有类标号），若朴素贝叶斯分类法将未知的样本X分配给类Ci，则一定是

P(Ci|X)>P(Cj|X) 1≤j≤m，j≠i

from sklearn.naive_bayes import  GaussianNBfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import accuracy_scorefrom sklearn.preprocessing import LabelEncoderimport pandas as pdfrom numpy import *import operator#计算高斯分布密度函数的值def calculate_gaussian_probability(mean, var, x):    coeff = (1.0 / (math.sqrt((2.0 * math.pi) * var)))    exponent = math.exp(-(math.pow(x - mean, 2) / (2 * var)))    c= coeff * exponent    return c#计算均值def averagenum(num):    nsum = 0    for i in range(len(num)):        nsum += num[i]    return nsum / len(num)#计算方差def var(list,avg):     var1=0     for i in list:       var1+=float((i-avg)**2)     var2=(math.sqrt(var1/(len(list)*1.0)))     return var2#朴素贝叶斯分类模型def Naivebeys(splitData, classset, test):    classify = []    for s in range(len(test)):        c = {}        for i in classset:            splitdata = splitData[i]            num = len(splitdata)            mu = num + 2            character = len(splitdata[0])-1    #具体数据集，个数有变            classp = []            for j in range(character):                zi = 1                if isinstance(splitdata[0][j], (int, float)):                    numlist=[example[j] for example in splitdata]                    Mean=averagenum(numlist)                    Var=var(numlist,Mean)                    a = calculate_gaussian_probability(Mean, Var, test[s][j])                else:                    for l in range(num):                        if test[s][j] == splitdata[l][j]:                            zi += 1                    a=zi/mu                classp.append(a)            zhi = 1            for k in range(character):                zhi *= classp[k]            c.setdefault(i, zhi)        sorta = sorted(c.items(), key=operator.itemgetter(1), reverse=True)        classify.append(sorta[0][0])    return classify#评估def accuracy(y, y_pred):    yarr=array(y)    y_predarr=array(y_pred)    yarr = yarr.reshape(yarr.shape[0], -1)    y_predarr = y_predarr.reshape(y_predarr.shape[0], -1)    return sum(yarr == y_predarr) / len(yarr)#数据处理def splitDataset(dataSet):   #按照属性把数据划分    classList = [example[-1] for example in dataSet]    classSet = set(classList)    splitDir = {}    for i in classSet:        for j in range(len(dataSet)):            if dataSet[j][-1] == i:                splitDir.setdefault(i, []).append(dataSet[j])    return splitDir, classSet    open('test.txt')df = pd.read_csv('test.txt')class_le = LabelEncoder()dataSet = df.values[:, :]dataset_train,dataset_test=train_test_split(dataSet, test_size=0.1)splitDataset_train, classSet_train = splitDataset(dataset_train)classSet_test=[example[-1] for example in dataset_test]y_pred= Naivebeys(splitDataset_train, classSet_train, dataset_test)accu=accuracy(classSet_test,y_pred)print('Accuracy:', accu)

Accuracy: 0.65

7. 决策树

决策树的分类模型是树状结构，简单直观，比较符合人类的理解方式。决策树分类器的构造不需要任何领域知识和参数设置，适合于探索式知识的发现。由于决策树分类步骤简单快速，而且一般来说具有较高的准确率，因此得到了较多的使用。

数据集介绍
本实验采用西瓜数据集，根据西瓜的几种属性判断西瓜是否是好瓜。数据集包含17条记录，数据格式如下：

实验
首先我们引入必要的库：

import pandas as pdfrom math import log2from pylab import *import matplotlib.pyplot as plt

导入数据
读取csv文件中的数据记录并转为列表

def load_dataset():    # 数据集文件所在位置    path = './西瓜.csv'    data = pd.read_csv(path, header=0)    dataset = []    for a in data.values:        dataset.append(list(a))    # 返回数据列表    attribute = list(data.keys())    # 返回数据集和每个维度的名称    return dataset, attributedataset,attribute = load_dataset()attribute,dataset

(['色泽', '根蒂', '敲声', '纹理', '脐部', '触感', '好瓜'], [['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '是'],  ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', '是'],  ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '是'],  ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑', '是'],  ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑', '是'],  ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘', '是'],  ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘', '是'],  ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑', '是'],  ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑', '否'],  ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘', '否'],  ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑', '否'],  ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘', '否'],  ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑', '否'],  ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑', '否'],  ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘', '否'],  ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑', '否'],  ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑', '否']])

计算信息熵

def calculate_info_entropy(dataset):    # 记录样本数量    n = len(dataset)    # 记录分类属性数量    attribute_count = {}    # 遍历所有实例，统计类别出现频次    for attribute in dataset:        # 每一个实例最后一列为类别属性，因此取最后一列        class_attribute = attribute[-1]        # 如果当前类标号不在label_count中，则加入该类标号        if class_attribute not in attribute_count.keys():            attribute_count[class_attribute] = 0        # 类标号出现次数加1        attribute_count[class_attribute] += 1    info_entropy = 0    for class_attribute in attribute_count:        # 计算该类在实例中出现的概率        p = float(attribute_count[class_attribute]) / n        info_entropy -= p * log2(p)    return info_entropy

数据集划分

def split_dataset(dataset,i,value):    split_set = []    for attribute in dataset:        if attribute[i] == value:            # 删除该维属性            reduce_attribute = attribute[:i]            reduce_attribute.extend(attribute[i+1:])            split_set.append(reduce_attribute)    return split_set

计算属性划分数据集的熵

def calculate_attribute_entropy(dataset,i,values):    attribute_entropy = 0    for value in values:        sub_dataset = split_dataset(dataset,i,value)        p = len(sub_dataset) / float(len(dataset))        attribute_entropy += p*calculate_info_entropy(sub_dataset)    return attribute_entropy

计算信息增益

def calculate_info_gain(dataset,info_entropy,i):    # 第i维特征列表    attribute = [example[i] for example in dataset]    # 转为不重复元素的集合    values = set(attribute)    attribute_entropy = calculate_attribute_entropy(dataset,i,values)    info_gain = info_entropy - attribute_entropy    return info_gain

根据信息增益进行划分

def split_by_info_gain(dataset):    # 描述属性数量    attribute_num = len(dataset[0]) - 1    # 整个数据集的信息熵    info_entropy = calculate_info_entropy(dataset)    # 最高的信息增益    max_info_gain = 0    # 最佳划分维度属性    best_attribute = -1    for i in range(attribute_num):        info_gain = calculate_info_gain(dataset,info_entropy,i)        if(info_gain > max_info_gain):            max_info_gain = info_gain            best_attribute = i    return best_attribute

构造决策树

def create_tree(dataset,attribute):    # 类别列表    class_list = [example[-1] for example in dataset]    # 统计类别class_list[0]的数量    if class_list.count(class_list[0]) == len(class_list):        # 当类别相同则停止划分        return class_list[0]    # 最佳划分维度对应的索引    best_attribute = split_by_info_gain(dataset)    # 最佳划分维度对应的名称    best_attribute_name = attribute[best_attribute]    tree = {best_attribute_name:{}}    del(attribute[best_attribute])    # 查找需要分类的特征子集    attribute_values = [example[best_attribute] for example in dataset]    values = set(attribute_values)    for value in values:        sub_attribute = attribute[:]        tree[best_attribute_name][value] =create_tree(split_dataset(dataset,best_attribute,value),sub_attribute)    return treetree = create_tree(dataset,attribute)tree

{'纹理': {'清晰': {'根蒂': {'蜷缩': '是',    '硬挺': '否',    '稍蜷': {'色泽': {'青绿': '是', '乌黑': {'触感': {'软粘': '否', '硬滑': '是'}}}}}},  '模糊': '否',  '稍糊': {'触感': {'软粘': '是', '硬滑': '否'}}}}

# 定义划分属性节点样式attribute_node = dict(boxstyle='round', color='#00B0F0')# 定义分类属性节点样式class_node = dict(boxstyle='circle', color='#00F064')# 定义箭头样式arrow = dict(arrowstyle='<-', color='#000000')

# 计算叶结点数def get_num_leaf(tree):    numLeafs = 0    firstStr = list(tree.keys())[0]    secondDict = tree[firstStr]    for key in secondDict.keys():        if type(secondDict[key]).__name__ == 'dict':            numLeafs += get_num_leaf(secondDict[key])        else:            numLeafs += 1    return numLeafs

# 计算树的层数def get_depth_tree(tree):    maxDepth = 0    firstStr = list(tree.keys())[0]    secondDict = tree[firstStr]    for key in secondDict.keys():        if type(secondDict[key]).__name__ == 'dict':            thisDepth = 1 + get_depth_tree(secondDict[key])        else:            thisDepth = 1        if thisDepth > maxDepth:            maxDepth = thisDepth    return maxDepth

# 绘制文本框def plot_text(cntrPt, parentPt, txtString):    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]    createPlot.ax1.text(xMid, yMid, txtString, va='center', ha='center', rotation=30)

绘制树结构

def plotTree(tree, parentPt, nodeTxt):    numLeafs = get_num_leaf(tree)    depth = get_depth_tree(tree)    firstStr = list(tree.keys())[0]    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalW, plotTree.yOff)    plot_text(cntrPt, parentPt, nodeTxt)  #在父子结点间绘制文本框并填充文本信息    plotNode(firstStr, cntrPt, parentPt, attribute_node)  #绘制带箭头的注释    secondDict = tree[firstStr]    plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD    for key in secondDict.keys():        if type(secondDict[key]).__name__ == 'dict':            plotTree(secondDict[key], cntrPt, str(key))        else:            plotTree.xOff = plotTree.xOff + 1.0 / plotTree.totalW            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, class_node)            plot_text((plotTree.xOff, plotTree.yOff), cntrPt, str(key))    plotTree.yOff = plotTree.yOff + 1.0 / plotTree.totalD

# 绘制箭头def plotNode(nodeTxt, centerPt, parentPt, nodeType):    createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',                            xytext=centerPt, textcoords='axes fraction',                            va='center', ha='center', bbox=nodeType, arrowprops=arrow)

# 绘图def createPlot(tree):    fig = plt.figure(1, facecolor='white')    fig.clf()    axprops = dict(xticks=[], yticks=[])    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)    plotTree.totalW = float(get_num_leaf(tree))    plotTree.totalD = float(get_depth_tree(tree))    plotTree.xOff = -0.5 / plotTree.totalW;    plotTree.yOff = 1.0;    plotTree(tree, (0.5, 1.0), '')    plt.show()

#指定默认字体mpl.rcParams['font.sans-serif'] = ['SimHei']mpl.rcParams['axes.unicode_minus'] = False# 绘制决策树createPlot(tree)

8. 集成学习(Adaboost)

集成学习（Ensemble Learning），就是使用一系列学习器进行学习，并使用某种规则将各个学习器的结果进行整合，从而获得比单个学习器效果更好的学习效果的一种方法。

集成学习的条件

通过集成学习提高分类器的整体泛化能力有以下两个条件：

基分类器之间具有差异性。如果使用的是同一个分类器集成，集成分类器的性能是不会有提升的。
每个基分类器的分类精度必须大于0.5。如下图所示，当基分类器精度小于0.5时，随着集成规模的增加，分类集成分类器的分类精度会下降；但是如果基分类器的精度大于0.5时，集成分类器的最终分类精度是趋近于1的。

集成学习的两个关键点：

如何构建具有差异性的基分类器
如何对基分类器的结果进行整合

构建差异性分类器一般有以下三种方法：

通过处理数据集生成差异性分类器
通过处理数据特征构建差异性分类器
对分类器的处理构建差异性分类器

集成学习常见的三种元算法是Bagging, Boosting和Stacking。Bagging用于提升机器学习算法的稳定性和准确性。Boosting主要用于减少bias（偏差）和variance（方差），是将一个弱分类器转化为强分类器的算法。Stacking是一种组合多个模型的方法。

Boosting与AdaBoost算法的训练

Boosting分类方法，其过程如下所示：

1）先通过对N个训练数据的学习得到第一个弱分类器h1；

2）将h1分错的数据和其他的新数据一起构成一个新的有N个训练数据的样本，通过对这个样本的学习得到第二个弱分类器h2；

3）将h1和h2都分错了的数据加上其他的新数据构成另一个新的有N个训练数据的样本，通过对这个样本的学习得到第三个弱分类器h3；

4）最终经过提升的强分类器h_final=Majority Vote(h1,h2,h3)。即某个数据被分为哪一类要通过h1,h2,h3的多数表决。

上述Boosting算法，存在两个问题：

①如何调整训练集，使得在训练集上训练弱分类器得以进行。

②如何将训练得到的各个弱分类器联合起来形成强分类器。

针对以上两个问题，AdaBoost算法进行了调整：

①使用加权后选取的训练数据代替随机选取的训练数据，这样将训练的焦点集中在比较难分的训练数据上。

②将弱分类器联合起来时，使用加权的投票机制代替平均投票机制。让分类效果好的弱分类器具有较大的权重，而分类效果差的分类器具有较小的权重。

import numpy as npimport matplotlib.pyplot as pltfrom sklearn import treefrom sklearn.ensemble import AdaBoostClassifierfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.datasets import make_gaussian_quantilesfrom sklearn.metrics import classification_report

# 生成2维正态分布，生成的数据按分位数分为两类，500个样本,2个样本特征x1, y1 = make_gaussian_quantiles(n_samples=500, n_features=2,n_classes=2)# 生成2维正态分布，生成的数据按分位数分为两类，400个样本,2个样本特征均值都为3x2, y2 = make_gaussian_quantiles(mean=(3, 3), n_samples=500, n_features=2, n_classes=2)# 将两组数据合成一组数据x_data = np.concatenate((x1, x2))y_data = np.concatenate((y1, - y2 + 1))

plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)plt.show()

# 决策树模型model = tree.DecisionTreeClassifier(max_depth=3)# 输入数据建立模型model.fit(x_data, y_data)# 获取数据值所在的范围x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1# 生成网格矩阵xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),                     np.arange(y_min, y_max, 0.02))z = model.predict(np.c_[xx.ravel(), yy.ravel()])# ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据z = z.reshape(xx.shape)# 等高线图cs = plt.contourf(xx, yy, z)# 样本散点图plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)plt.show()

# 模型准确率model.score(x_data,y_data)

0.777

# AdaBoost模型model = AdaBoostClassifier(DecisionTreeClassifier(max_depth=3),n_estimators=10)# 训练模型model.fit(x_data, y_data)# 获取数据值所在的范围x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1# 生成网格矩阵xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),                     np.arange(y_min, y_max, 0.02))# 获取预测值z = model.predict(np.c_[xx.ravel(), yy.ravel()])z = z.reshape(xx.shape)# 等高线图cs = plt.contourf(xx, yy, z)# 样本散点图plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)plt.show()

# 模型准确率model.score(x_data,y_data)

0.976

总结一下，组合算法（combiner algorithm）使用所有其他算法的预测作为附加输入（additional inputs）来训练得到最终的预测结果。理论上可以表示任何一种组合学习方法（ensemble techniques）；实际中，单层的逻辑回归模型（single-layer logistic regression model）通常被用作组合器（combiner）。

非监督学习

9. 降维—主成分分析

import numpy as npimport matplotlib.pyplot as plt

# 载入数据data = np.genfromtxt('data.csv', delimiter=',')x_data = data[:,0]y_data = data[:,1]plt.scatter(x_data,y_data)plt.show()print(x_data.shape)

# 数据中心化def zeroMean(dataMat):    # 按列求平均，即各个特征的平均    meanVal = np.mean(dataMat, axis=0)     newData = dataMat - meanVal    return newData, meanVal

newData,meanVal=zeroMean(data)  # np.cov用于求协方差矩阵，参数rowvar=0说明数据一行代表一个样本covMat = np.cov(newData, rowvar=0)

# 协方差矩阵covMat

array([[ 94.99190951, 125.62024804], [125.62024804, 277.49520751]])

# np.linalg.eig求矩阵的特征值和特征向量eigVals, eigVects = np.linalg.eig(np.mat(covMat))

# 特征值eigVals

array([ 30.97826888, 341.50884814])

# 特征向量eigVects

matrix([[-0.89098665, -0.45402951],        [ 0.45402951, -0.89098665]])

# 对特征值从小到大排序eigValIndice = np.argsort(eigVals)eigValIndice

array([0, 1], dtype=int64)

top = 1# 最大的n个特征值的下标n_eigValIndice = eigValIndice[-1:-(top+1):-1]

n_eigValIndice

array([1], dtype=int64)

# 最大的n个特征值对应的特征向量n_eigVect = eigVects[:,n_eigValIndice]n_eigVect

matrix([[-0.45402951], [-0.89098665]])

# 低维特征空间的数据lowDDataMat = newData*n_eigVectlowDDataMat

# 利用低纬度数据来重构数据reconMat = (lowDDataMat*n_eigVect.T) + meanValreconMat

# 载入数据data = np.genfromtxt('data.csv', delimiter=',')x_data = data[:,0]y_data = data[:,1]plt.scatter(x_data,y_data)# 重构的数据x_data = np.array(reconMat)[:,0]y_data = np.array(reconMat)[:,1]plt.scatter(x_data,y_data,c='r')plt.show()