有监督学习

用一组带有标签的数据，学习从输入到输出的映射，然后将这种映射关系应用到位置数据上，达到分类或者回归的目的

分类：输出是离散的
回归：输出是连续的

1. 分类学习

输入：一组有标签的训练数据（观察或评估），标签表明了这些蜀的所述类别
输出：分类模型根据这些训练数据，训练自己的模型参数，学习出一个合适这组数据的分类器，当有新数据需要判断时，就可以将它输入给分类器进行判断
训练集（training set）：训练模型的以标注数据，用来建立模型，发现规律
测试集（testing set）：隐藏标记，输入给训练好的模型。通过对比输出结果和标记进行对比，评估模型的学习能力
训练/测试集划分：随机7：3比，还可配合交叉验证法、自助法用来评估分类模型

评价分类指标：

精确率：针对预测结果，预测为正的样本中有多少真正正类。TP/(TP+FP)，即误报率
召回率：针对原来样本，样本中多少正例被预测出。TP/(TP+FN)，即遗漏率
准确率：(TP+TN)/所有样本

样本为正例，被分为正例，称为真正类（TP）
样本为正例，被分为反例，称为假反类（FN）
样本为反例，被分为正例，称为假正类（FP）
样本为反例，被分为反例，称为真反类（TN）

分类模型	加载模块
最近邻算法	neighbors.NearestNeighbors
决策树	tree.DecisionTreeClassifier
支持向量机	svm.SVC
集成方法	ensemble.BaggingClassifier
朴素贝叶斯	naive_bayes.GaussianNB
神经网络	neural_network.MLPClassifier
k近邻	neighbors.KNeighboesClaassifier

1.1 KNN

K近邻分类器，通过计算待分类数据点，与已有数据集中的素有数据点的距离。取距离最小的前K个点，根据“少数服从多数”的原则，将这个数据点划分为出现次数最多打我那个类别
Sklearn库中，使用sklearn.neighbors.KNeighboesClaassifier创建一个K近邻分类器，主要参数如下

n_neighbors：用于指定分类器中K的大小（默认值为5）
weights：设置选中的K个点对分类结果的权重，默认值为平均权重uniform，可选distance代表临近点权重最高，或者传入自己编写的以距离为参数的权重计算函数
algorithm：设置用于计算临近的方法，所有选项有ball_tree、kd_tree、brute，分别代表不同优化方法，默认值为auto，

# 导入KNN
from sklearn.neighbors import KNeighborsClassifier
# 设定数据X，标签y
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]

# 设置K，其他参数默认
neigh = KNeighborsClassifier(n_neighbors=3)

# 将训练数据X和标签y送入分类器，进行分类学习
neigh.fit(X, y) # KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=None, n_neighbors=3, p=2, weights='uniform')

# 对未知样本进行分类
print(neigh.predict([[1.1]])) # [0]

调用fit()函数，进行分类学习
调用predict()函数，对未知样本进行分类，得到分类标签作为返回值

使用经验：

K值较大时，相当于使用较大邻域中的训练实例进行预测，可以减少误差。但是有时较远样本也会对预测结果起作用，导致预测错误
K值较小时，相当于使用较小邻域中的训练实例进行预测，如果邻域恰好是噪声点，会导致过拟合
一本情况下，K值较小，并使用交叉验证的方法选取最优K值

1.2 决策树

一种树形结构的分类器，通过顺序询问分类点的属性，决定分类点最终的类别
Sklearn库中，使用sklearn.tree.DecisionTreeClassifier创建一个决策树用于分类，主要参数如下：

criterion：用于选择属性的准则，可以传入gini代表基尼系数，或者entropy代表信息增益
max_features：表示在决策树节点进行分裂时，从众多特征中选择最优特征。可以设定固定数目、百分比或其他标准。默认值是使用所有特征个数

# 调用鸢尾花数据集
from sklearn.datasets import load_iris
# 导入决策树
from sklearn.tree import DecisionTreeClassifier
# 导入计算交叉验证值的函数
from sklearn.model_selection import cross_val_score

# 使用默认参数，创建基于基尼系数的决策树，并赋值给tree
tree = DecisionTreeClassifier()
# 以列表形式提取鸢尾花数据
iris = load_iris(return_X_y=True)
# 观察鸢尾花数据，将其中的数据特征赋值给data，标签特征赋值给target
data = iris[0]
target = iris[1]

# 设定cv=10，使用10折交叉验证，得到交叉验证得分
cross_val_score(tree, data, target, cv=10) # array([1.        , 0.93333333, 1., 0.93333333, 0.93333333, 0.86666667, 0.93333333, 0.93333333, 1., 1.])

# 训练并预测
tree.fit(data, target)
tree.predict([[5., 3.1, 4.6, 1.4]]) # array([1])

决策树本质上是寻找一种对特征空间上的划分，旨在构建一个训练数据拟合的好，并且复杂度小的决策树
在使用中，需呀根据数据情况调整criterion等参数

1.3 朴素贝叶斯

以贝叶斯定理为基础的分类方器。对于给定数据，首先基于特征的条件独立性假设，学习输入输出的联合概率分布，然后基于此模型对于给定输入x，输出概率最大y
朴素贝叶斯分为高斯朴素贝叶斯、针对多项式模型的朴素贝叶斯、针对多元伯努利模型的朴素贝叶斯

区别在于，假设某一特征的所有属于某个类别的观测值符合特定分布
身高符合高斯分布，这类问题适合高斯朴素贝叶斯

Sklearn库中，使用sklearn.naive_bayes.GaussianNB创建一个朴素分类器，主要参数如下：

priors：给定各个类别的先验概率。不设定，默认按照数据实际情况进行统计，如果给定先验概率，在训练过程中不能更改

# 导入朴素贝叶斯
from sklearn.naive_bayes import GaussianNB
import numpy as np

X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
Y = np.array([1,1,1,2,2,2])
# 创建分类器
clf = GaussianNB(priors=None)
# 训练并预测
clf.fit(X, Y)
print(clf.predict([[-0.8, -1]])) # [1]

朴素贝叶斯是典型的生成学习方法，由训练数据学习联合概率分布，并求得最后验证概率分布。一般在小规模数据上表现很好，适合进行多分类任务

1.4 人体运动状态预测

收集ABCDE，5人可穿戴设备上的传感数据，每个人的数据包含特征文件（a.feature）和标签文件（a.label）

特征文件共包含41列特征：第1列时间戳，第2列心率，第3-15列、16-28列、29-41分别为3个姿态传感器的数据。问号代表缺失值
传感器的13列数据特征中，有1项温度、3项一型三轴加速度数据、3项二型三轴加速度数据、3项三轴陀螺仪数据、3项三轴磁场数据
温度反映当前活动的剧烈运动、加速度数据反映用户姿态、陀螺数据反映身体角度、磁场数据反映当前环境
标签文件，每一行代表与特征文件中对应的用户姿态类别。共有0-24种姿态

import pandas as pd
import numpy as np  

# 导入预处理数据模块
from sklearn.impute import SimpleImputer 
# 导入自动生成训练集和测试集的模块
from sklearn.model_selection import train_test_split 
# 导入预测结果评估函数
from sklearn.metrics import classification_report

# 导入KNN、决策树、高斯朴素贝叶斯
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
 
def load_datasets(feature_paths, label_paths):
    '''
    读取特征文件列表和标签文件列表
    feature_paths, label_paths分别为特征we年和标签文件的文件路径
    '''
    # 定义变量,列数量和特征维度一致，为41
    feature = np.ndarray(shape=(0,41))
    # 定义变量，列数量与标签维度一致，为1
    label = np.ndarray(shape=(0,1))
    # 遍历特征文件路径（有5个特征文件）
    for file in feature_paths:
        # 使用np.read_table读取文件，file代表文件路径
        # 使用逗号分隔读取特征数据，将问好替代标记为缺失值，文件中不包含表头
        df = pd.read_table(file, delimiter=',', na_values='?', header=None)
        # 使用平均值补全缺失值，然后将数据进行补全
        imp = SimpleImputer(missing_values=np.nan, strategy='mean')
        # 训练预处理器
        imp.fit(df)
        # 生成预处理结果,即将数据df中的NaN替换成平均值输出
        df = imp.transform(df)
        # 将新读入的数据合并到特征集中（没有维度信息,但是之前设置了feature的列数41，即二维数据个数）
        feature = np.concatenate((feature, df))
    # 遍历标签文件路径
    for file in label_paths:
        df = pd.read_table(file, delimiter=',', header=None)
        label = np.concatenate((label, df))
    # 将标签归整为一维向量
    label = np.ravel(label)
    return feature, label

if __name__ == '__main__':
    ''' 数据路径 '''
    featurePaths = [r'E:\TDRDIS Book\编程\Python应用\dataset\A\A.feature',
                    r'E:\TDRDIS Book\编程\Python应用\dataset\B\B.feature',
                    r'E:\TDRDIS Book\编程\Python应用\dataset\C\C.feature',
                    r'E:\TDRDIS Book\编程\Python应用\dataset\D\D.feature',
                    r'E:\TDRDIS Book\编程\Python应用\dataset\E\E.feature']
    labelPaths = [r'E:\TDRDIS Book\编程\Python应用\dataset\A\A.label',
                  r'E:\TDRDIS Book\编程\Python应用\dataset\B\B.label',
                  r'E:\TDRDIS Book\编程\Python应用\dataset\C\C.label',
                  r'E:\TDRDIS Book\编程\Python应用\dataset\D\D.label',
                  r'E:\TDRDIS Book\编程\Python应用\dataset\E\E.label']
    ''' 读入数据  '''
    # 将前4个数据作为训练集读入
    x_train,y_train = load_datasets(featurePaths[:4],labelPaths[:4])
    # 将最后一个数据作为测试集读入
    x_test,y_test = load_datasets(featurePaths[4:],labelPaths[4:])
    # 使用train_test_split()函数,将数据随机打乱，便于分类器的初始化和训练
    x_train, x_, y_train, y_ = train_test_split(x_train, y_train)
     
    print('Start training knn')
    # 创建KNN，并训练数据，返回训练结果
    knn = KNeighborsClassifier().fit(x_train, y_train)
    print('Training done')
    # 对测试集进行预测，返回预测结果
    answer_knn = knn.predict(x_test)
    print('Prediction done')
    
    print('Start training DT')
    # 创建决策树，并训练数据，返回训练结果
    dt = DecisionTreeClassifier().fit(x_train, y_train)
    print('Training done')
    answer_dt = dt.predict(x_test)
    print('Prediction done')
     
    print('Start training Bayes')
    # 创建高斯朴素贝叶斯，并训练数据，返回训练结果
    gnb = GaussianNB().fit(x_train, y_train)
    print('Training done')
    answer_gnb = gnb.predict(x_test)
    print('Prediction done')
     
    print('\n\nThe classification report for knn:')
    # 使用classification_report函数对分类结果进行衡量
    # 精确度precision、召回率recall、f1值f1-score、支持度support
    print(classification_report(y_test, answer_knn))
    print('\n\nThe classification report for DT:')
    print(classification_report(y_test, answer_dt))
    print('\n\nThe classification report for Bayes:')
    print(classification_report(y_test, answer_gnb))

输出结果

Start training knn
Training done
Prediction done
Start training DT
Training done
Prediction done
Start training Bayes
Training done
Prediction done

The classification report for knn:
              precision    recall  f1-score   support

         0.0       0.56      0.59      0.58    102341
         1.0       0.92      0.93      0.93     23699
         2.0       0.93      0.77      0.84     26864
         3.0       0.83      0.82      0.82     22132
         4.0       0.85      0.88      0.86     32033
         5.0       0.39      0.21      0.27     24646
         6.0       0.77      0.89      0.82     24577
         7.0       0.80      0.95      0.87     26271
        12.0       0.32      0.33      0.32     14281
        13.0       0.16      0.22      0.18     12727
        16.0       0.90      0.67      0.77     24445
        17.0       0.88      0.96      0.92     33034
        24.0       0.00      0.00      0.00      7733

    accuracy                           0.69    374783
   macro avg       0.64      0.63      0.63    374783
weighted avg       0.69      0.69      0.68    374783


The classification report for DT:
              precision    recall  f1-score   support

         0.0       0.51      0.77      0.61    102341
         1.0       0.66      0.96      0.78     23699
         2.0       0.90      0.84      0.87     26864
         3.0       0.94      0.73      0.82     22132
         4.0       0.71      0.87      0.79     32033
         5.0       0.79      0.52      0.63     24646
         6.0       0.04      0.01      0.02     24577
         7.0       0.33      0.14      0.20     26271
        12.0       0.59      0.59      0.59     14281
        13.0       0.60      0.49      0.54     12727
        16.0       0.56      0.06      0.11     24445
        17.0       0.85      0.85      0.85     33034
        24.0       0.35      0.44      0.39      7733

    accuracy                           0.62    374783
   macro avg       0.60      0.56      0.55    374783
weighted avg       0.60      0.62      0.58    374783

The classification report for Bayes:
              precision    recall  f1-score   support

         0.0       0.62      0.81      0.70    102341
         1.0       0.97      0.91      0.94     23699
         2.0       1.00      0.66      0.79     26864
         3.0       0.61      0.66      0.63     22132
         4.0       0.91      0.77      0.83     32033
         5.0       1.00      0.00      0.00     24646
         6.0       0.87      0.72      0.78     24577
         7.0       0.31      0.47      0.37     26271
        12.0       0.52      0.59      0.55     14281
        13.0       0.61      0.50      0.55     12727
        16.0       0.89      0.72      0.80     24445
        17.0       0.75      0.91      0.82     33034
        24.0       0.58      0.25      0.35      7733

    accuracy                           0.68    374783
   macro avg       0.74      0.61      0.63    374783
weighted avg       0.74      0.68      0.67    374783

准确率：贝叶斯效果好
召回率和F1值：k近邻效果好

1.5 上证指数涨跌预测

数据介绍：列为特征指标，第一列是时间，选择4-7和12列为特征，分别是收盘价、最高价、最低价、开盘价、成交量
目的：根据数据预测当天上证指数的涨跌
技术路线：sklearn.svm.SVC

import pandas as pd
import numpy as np
from sklearn import svm
# 导入交叉验证包，用于随机划分训练集和测试集
from sklearn.model_selection import train_test_split

# 利用pd.read_csv将数据读入
data=pd.read_csv(r'E:\TDRDIS Book\编程\Python应用\上证指数\000777.csv',encoding='gbk',parse_dates=[0],index_col=0)
# 将数据安装时间升序排列
data.sort_index(0,ascending=True,inplace=True)

# 定义需要选取150天数据
dayfeature=150
# 定义记录这150天数据
featurenum=5*dayfeature
# 记录前150天的5个特征值，+1是记录当天的开盘价
# 每一个x，是一个特征数据
x=np.zeros((data.shape[0]-dayfeature,featurenum+1))
# 记录涨跌
# 每一个y对应一个x的标签。相当于用150天的数据，记录一次涨跌
y=np.zeros((data.shape[0]-dayfeature))
 
for i in range(0,data.shape[0]-dayfeature):
    # 将前150天数据，同一存入x中
    x[i,0:featurenum]=np.array(data[i:i+dayfeature] \
          [[u'收盘价',u'最高价',u'最低价',u'开盘价',u'成交量']]).reshape((1,featurenum))
    # 记录当日开盘价
    x[i,featurenum]=data.iloc[i+dayfeature][u'开盘价']
for i in range(0,data.shape[0]-dayfeature):
    # 1为涨，0为跌
    if data.iloc[i+dayfeature][u'收盘价']>=data.iloc[i+dayfeature][u'开盘价']:
        y[i]=1
    else:
        y[i]=0
# 创建svm实例
clf=svm.SVC(kernel='rbf')
result = []
for i in range(5):
    # 设置交叉验证的训练集和测试集，切分80-20%的测试集
    x_train, x_test, y_train, y_test = \
                train_test_split(x, y, test_size = 0.2)
    # 训练
    clf.fit(x_train, y_train)
    # 将测试结果与测试集的验证数据进行对比
    result.append(np.mean(y_test == clf.predict(x_test)))
    print(np.mean(y_test == clf.predict(x_test)))
print("svm classifier accuacy:")
print(result) # [0.5244299674267101, 0.5255157437567861, 0.5200868621064061, 0.5211726384364821, 0.5211726384364821]

预测当天涨跌

clf.fit(x, y) # SVC(C=1.0, break_ties=False, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='scale', kernel='rbf', max_iter=-1, probability=False, random_state=None, shrinking=True, tol=0.001, verbose=False)
today = x[0:1]
clf.predict(today) # array([1.])

2. 回归分析

统计学分析数据的方法，目的在于了解两个或者多个变数间是否相关、研究部其相关方向与强度，并建立数学模型，以贯彻特定变数来预测研究者感兴趣的变。回归分析帮助了解只剩变量变化时，因变量的变化量，一般来说，通过回归分析，可以由给出的自变量估计因变量的条件期望
Sklearn提供的回归函数主要被封装在linear_model和preprocessing中，前者主要是一些线性函数

回归模型	加载模块
岭回归	linear_model.Ridge
贝叶斯回归	linear_model.BayesianRidge
Lasso回归	linear_model.Lasso
逻辑回归	linear_model.LogisticRegression
最小角回归	linear_model.Lars
多项式回归	preprocessing.PolynomialFeatures
弹性网络	linear_model.ElasticNet
线性回归	linear_model.LinearRegression()

2.2 线性回归

利用线性回归方程的最小评分函数，对一个或多个自变量和因变量之间关系建立模型。只有1个自变量，称为简单回归，大于1个，称为多元回归
用途：

目标是预测或者映射，线性回归可以用来观察数据集y合X的值拟合出一个预测模型。此模型可预测新X的y值
给定一个因变量y和一些自变量x，线性回归可用来量化y与x之间相关性的强度

调用

from sklearn import linear_model
linear = linear_model.LinearRegression()
linear.fit(X, Y, sample_weight=None)

fit_intercept：布尔型参数，表示是否计算该模型的截距，可选

normalize：布尔型，True表示X在回归前进行归一化，默认False，可选

sample_weight：fie()参数，表示分配给各个样本权重数组，可选

房价实例分析：

目标：对房屋成交信息建立回归方程，并依据回归方程预测房屋价格（房屋尺寸和成交价格）
可行性分析：通过数据可视化，直接观察房屋成交价格与房屋尺寸是否存在线性关系（散点图）

import matplotlib.pyplot as plt
import numpy as np
from sklearn import linear_model
 
# 创建变量，存储房屋尺寸和成交价格
datasets_X = []
datasets_Y = []
# 以读取模式打开数据文件
fr = open(r'E:\TDRDIS Book\编程\Python应用\房屋信息\prices.txt','r')
# 逐行读入文件内容
lines = fr.readlines()
# 遍历所有数据
for line in lines:
    # 去除空格，以逗号为分隔，将数据存储到列表中
    items = line.strip().split(',')
    # 将数据以int型分别存入
    datasets_X.append(int(items[0]))
    datasets_Y.append(int(items[1]))

length = len(datasets_X)
# 将数据变为数组型，其中将datasets_X变为二维数组，以符合线性归回输入参数的要求
datasets_X = np.array(datasets_X).reshape([length,1])
datasets_Y = np.array(datasets_Y)
 
minX = min(datasets_X)
maxX = max(datasets_X)
# 以最大值和最小值为范围建立等差数组
X = np.arange(minX,maxX).reshape([-1,1])

# 调用一元线性归回模块
linear = linear_model.LinearRegression()
# 建立归回方程，拟合数据
linear.fit(datasets_X, datasets_Y)
# 查看回归方程系数
print('Coefficient:', linear.coef_) # Coefficient:[0.14839484]
# 查看回归方程截距
print('intercept:', linear.intercept_) # intercept: 43.92337096187816

# 绘制散点图
plt.scatter(datasets_X, datasets_Y, color = 'red')
# 以X为横坐标，以预测X的房价为纵坐标
plt.plot(X, linear.predict(X), color = 'blue')
plt.xlabel('Area')
plt.ylabel('Price')
plt.show()

房价预测 1.png

2.3 多项式回归

研究一个因变量与一个（一元多项式）或多个自变量（多元多项式）间的多项式回归

在一元回归分析中，如果y与x的关系非线性，但又找不到合适的函数曲线来拟合，则可采用一元多项式回归
多项式追到的有点是可以通过增加x的高次项对实测点进行逼近，直至满意为止
多项式可以出来非线性问题，在胡桂分析中占重要地位，因为任意函数都可以用多段多项式来逼近

线性回归：用直线来拟合数据之间的线性关系
多项式回归：用曲线来拟合数据之间的映射关系

调用

from sklearn import linear_model
from sklearn.preprocessing import PolynomialFeaturesol
ploy_reg = PolynomialFeatures(degree = 2)
X_poly = ploy_reg.fit_transform(X)
lin_reg_2 = linear_model.LinearRegression()
lin_reg_2.fit(X_poly, Y)

多项式回归实际上先将数据处理成多项式特征，然后使用线性模型学习多项式特征参数，以达到多项式回归的目的

用PolynomialFeaturesol构造X的二次多项式特征X_Ploy

使用linear_model学习X_Ploy和y之间的映射关系

degree = 2：建立数据的二元多项式特征

房价实例分析：（数据与上列相同）

import matplotlib.pyplot as plt
import numpy as np
from sklearn import linear_model
from sklearn.preprocessing import PolynomialFeatures

datasets_X = []
datasets_Y = []
fr = open(r'E:\TDRDIS Book\编程\Python应用\房屋信息\prices.txt','r')
lines = fr.readlines()
for line in lines:
    items = line.strip().split(',')
    datasets_X.append(int(items[0]))
    datasets_Y.append(int(items[1]))

length = len(datasets_X)
datasets_X = np.array(datasets_X).reshape([length,1])
datasets_Y = np.array(datasets_Y)
minX = min(datasets_X)
maxX = max(datasets_X)
X = np.arange(minX,maxX).reshape([-1,1])

# 创建多项式回归，多项式类型为2元多项式
ploy_reg = PolynomialFeatures(degree = 2)
# 创建数据多项式特征
X_poly = ploy_reg.fit_transform(datasets_X)
# 调用线性归回模块
lin_reg_2 = linear_model.LinearRegression()
# 用线性模型学习数据和y之间的映射关系
lin_reg_2.fit(X_poly, datasets_Y)


# 绘制散点图
plt.scatter(datasets_X, datasets_Y, color = 'red')
# 以X为横坐标，以预测X被多项式特征后的房价为纵坐标
plt.plot(X, lin_reg_2.predict(ploy_reg.fit_transform(X)), color = 'blue')
plt.xlabel('Area')
plt.ylabel('Price')
plt.show()

房价预测 2.png

2.3 岭回归

基于最小二乘的线性回归法缺乏稳定性，岭回归就是对线性回归最小二乘法的优化

专门用于共线性数据分析的有偏估计回归方法
改良的最小二乘估计法

调用：linear_model.Ridge

alpha：正规化因子，对应于损失函数中的α

fit_intercept：表示是否计算截距

solver：设置计算参数的方法，可选参数auto、svd、sag等

交通流量预测实例

数据介绍：某路口交通流量监测数据，记录全年小时级别的车流量

HR：一天中的第一个小时（0-23）
WEEK_DAY：一周中的第几天（0-6）
DAY_OF_YEAR：一年中的第几天（1-365）
WEEK_OF_YEAR：一年中的第几周（1-53）
TRAFFIC_COUNT：交通流量

目的：根据数据穿件多项式特征，使用岭回归模型代替一般的线性模型，赌车流量信息进行多项式回归

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
# 加载岭回归方法
from sklearn.linear_model import Ridge
from sklearn.preprocessing import PolynomialFeatures
# 加载交叉验证模块，用于随机划分训练集和测试集
from sklearn.model_selection import train_test_split

# 读取数据集，使用pd方法从csv中加载数据
data = pd.read_csv(r'E:\TDRDIS Book\编程\Python应用\机器学习数据\岭回归\岭回归.csv')
# 数据格式是pandas.core.frame.DataFrame，可用DataFrame操作数据
# 展示车流量信息图（下图）
plt.subplot(2,1,1)
plt.plot(data['TRAFFIC_COUNT'])

X = data.drop(['ID', 'HR', 'TRAFFIC_COUNT'], axis = 1)
y = data['TRAFFIC_COUNT']

# 创建最高次，6次方的多项式特征
poly = PolynomialFeatures(degree = 6)
# 创建X的多项式特征
X = poly.fit_transform(X)
# 将所有数据换分训练集合测试集，test_size表示划分比例，random_state表示随机种子
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size = 0.3, random_state=0)

# 创建岭回归实例
clf = Ridge(alpha=1.0, fit_intercept=True)
# 训练岭回归
clf.fit(train_X, train_y)
# 利用测试集计算岭回归的拟合优度
print(clf.score(test_X, test_y)) # 0.13194612461788768

# 调用岭回归对X进行预测
y_pre = clf.predict(X)
# 创建一个200-300范围的数组
time = np.arange(200, 300)

plt.subplot(2,1,1)
plt.plot(y_pre, 'r', label = 'predict')
# 绘制200-300段的真实（蓝色）和预测（红色）的车流量
plt.subplot(2,1,2)
plt.plot(time, y[200:300], 'b', label = 'real')
plt.plot(time, y_pre[200:300], 'r', label = 'predict')
# 设置图例位置
plt.legend(loc = 'upper left')
plt.show()

拟合优度（Goodness of Fit）：回归直线对观测值的拟合程度。度量拟合优度的统计量是可决系数（亦称确定系数）R²。R²最大值为1，无最小值。R²的值越接近1，说明回归直线对观测值的拟合程度越好。当对所有输入都输出同一个值时，拟合优度为0

岭回归 1.png

3. 手写数字识别

图像识别：计算机对图像的处理、分析和理解。将此类魏转化为分类问题
图像识别分为三个阶段：文字识别、数字图像处理与识别、物体识别

MNIST数据集：包含0-9的手写体图片数据集，图片已归一化为以手写数字为中心的28*28规格的图片。由训练集（6万）和测试集（1万）两部分组成

DBRHD数据集：UCI的机器学习中提供的数字手写数据库。包含0-9的手写体图片数据集，图片已归一化为以手写数字为中心的32*32规格的图片。由训练集（7494，40位手写者）和测试集（3498，14位手写者）组成

3.1 神经网络

任务：利用sklearn训练简单的连接神经网络，即多层感知机（Multilayer perceptron, MLP）用于识别DBRHD数据集的手写数字
MLP输入：DBRHD数据集优0或1组成的3232的文本矩阵。MLP输入为图片矩阵展开的11024个根据元
MLP输出：one-hot vectors

一个one-hot向量除了某一位的数字是1以外的数字都是0
图片标签将表示一个只有在第n维度数字为1的10维向量，比如标签0将表示成[1,0,0,0,0,0,0,0,0,0]
MLP输出层具有10个神经元

MPL结构：MLP的输入与输出层间还有一个隐藏层，层数和神经元的个数设置将影响该MLP模型的准确率

MLP结构 1.jpg

import numpy as np
# 使用listdir模块，用于访问本地文件
from os import listdir
# 加载神经网络模块
from sklearn.neural_network import MLPClassifier 

def img2vector(fileName):
    '''加载的图片矩阵展开成一列向量，输出数据数组'''
    # 定义返回的矩阵，大小为1*1024，数值为0
    retMat = np.zeros([1024],int)
    # 打开包含32*32大小的数字文件 
    fr = open(fileName)
    # 读取文件的所有行
    lines = fr.readlines()
    # 遍历，并将数字存放在retMat矩阵中
    for i in range(32):
        for j in range(32):
            # 改动相应数字
            retMat[i*32+j] = lines[i][j]    
    return retMat
 
def readDataSet(path):
    '''
    加载训练数据，并将样本标签转化为one-hot向量
    输入：文件路径/名称
    输出：特征文图片、标签文件
    '''
    # listdir()方法是返回某个目录下所有文件名称，返回的是File数组
    fileList = listdir(path)
    # 统计需要读取的文件的数目
    numFiles = len(fileList)
    # 用于存放所有的数字文件
    dataSet = np.zeros([numFiles,1024],int) 
    # 用于存放对应的one-hot标签
    hwLabels = np.zeros([numFiles,10]) 
    # 遍历所有的文件
    for i in range(numFiles):   
        # 获得单个文件名
        filePath = fileList[i]
        # 通过文件名获得标签
        digit = int(filePath.split('_')[0])
        # 将对应的one-hot标签置1,假设第2个标签是2，将对应数组的第3位数值改为1
        hwLabels[i][digit] = 1.0
        # 调用img2vector()函数，读取文件内容
        dataSet[i] = img2vector(path +'/'+filePath)    
    return dataSet,hwLabels

# 调用函数，分别获得训练集的数据和标签
train_dataSet, train_hwLabels = readDataSet(r'E:\TDRDIS Book\编程\Python应用\机器学习数据\手写数据集\trainingDigits')

# 构建神经网络
clf = MLPClassifier(hidden_layer_sizes=(100,),
                    activation='logistic', solver='adam',
                    learning_rate_init = 0.0001, max_iter=2000)
print(clf)
# 训练
clf.fit(train_dataSet,train_hwLabels)
 
# 调用函数，分别获得测试集的数据和标签
dataSet,hwLabels = readDataSet(r'E:\TDRDIS Book\编程\Python应用\机器学习数据\手写数据集\testDigits')
# 对测试集进行预测
res = clf.predict(dataSet)
# 设置初始变量，存储统计预测错误的数目
error_num = 0
# 测试集的数目
num = len(dataSet)
# 遍历预测结果
for i in range(num):        
    # True为1, False为0，sum为10时说明2个数组相同，反之小于10
    if np.sum(res[i] == hwLabels[i]) < 10: 
        error_num += 1                     
print("Total num:",num," Wrong num:", \
      error_num,"  WrongRate:",error_num / float(num))

构建神经网络处代码：

hidden_layer_sizes=(100,)：含100个神经的1层隐藏层。元组类型，表示第i层里神经元个数
activation='logistic'：设置logistic为激活函数
solver='adam'：adam为优化方法
learning_rate_init = 0.0001：初始学习率为0.0001
max_iter=2000：迭代2000
fit()：能够训练集数据和标签自动设置MLP的输入与输出层的神经元个数。此例中fit()函数将MLP的输入层神经元个数设置为1024，输出层神经元个数设置为10

输出结果

MLPClassifier(activation='logistic', alpha=0.0001, batch_size='auto',
              beta_1=0.9, beta_2=0.999, early_stopping=False, epsilon=1e-08,
              hidden_layer_sizes=(100,), learning_rate='constant',
              learning_rate_init=0.0001, max_fun=15000, max_iter=2000,
              momentum=0.9, n_iter_no_change=10, nesterovs_momentum=True,
              power_t=0.5, random_state=None, shuffle=True, solver='adam',
              tol=0.0001, validation_fraction=0.1, verbose=False,
              warm_start=False)
Total num: 946  Wrong num: 35   WrongRate: 0.03699788583509514

随着隐藏神经元个数的增加，MLP准确率持上升趋势，但是过多带来的计算负担对结果的提升并不对等，需要探讨选择合适隐藏神经元
过小的迭代次数是的MLP早停，造成正确率低，迭代次数1000时，正确率基本不变，一般设置最大迭代次数来保证准确率
初始学习率也可以调整，一般低初始学习率对应高迭代次数

3.2 KNN

import numpy as np
from os import listdir 
from sklearn import neighbors
 
def img2vector(fileName): 
    '''加载的图片矩阵展开成一列向量，输出数据数组'''
    retMat = np.zeros([1024],int)
    fr = open(fileName)
    lines = fr.readlines()
    for i in range(32):
        for j in range(32):    
            retMat[i*32+j] = lines[i][j]    
    return retMat
 
def readDataSet(path): 
    '''
    加载训练数据，并将样本标签转化为one-hot向量
    输入：文件路径/名称
    输出：特征文图片、标签文件
    '''
    fileList = listdir(path)
    numFiles = len(fileList)
    dataSet = np.zeros([numFiles,1024],int)
    # 用于存储标签
    hwLabels = np.zeros([numFiles])
    for i in range(numFiles):     
        filePath = fileList[i]  
        digit = int(filePath.split('_')[0])
        # 获得标签
        hwLabels[i] = digit 
        dataSet[i] = img2vector(path +'/'+filePath)
    return dataSet,hwLabels
 
train_dataSet, train_hwLabels = readDataSet(r'E:\TDRDIS Book\编程\Python应用\机器学习数据\手写数据集\trainingDigits')
knn = neighbors.KNeighborsClassifier(algorithm='kd_tree', n_neighbors=3)
knn.fit(train_dataSet, train_hwLabels)
 
dataSet,hwLabels = readDataSet(r'E:\TDRDIS Book\编程\Python应用\机器学习数据\手写数据集\testDigits')

res = knn.predict(dataSet)
# 统计分类错误的数目
error_num = np.sum(res != hwLabels) 
num = len(dataSet)
print("Total num:",num," Wrong num:", \
      error_num,"  WrongRate:",error_num / float(num))
# Total num: 946  Wrong num: 12   WrongRate: 0.01268498942917547

K=3时正确率最高，因为当样本为稀疏数据集时，其k个邻居点可能与测试距离较远，从而影响最终结果

结论：

在本例中，KNN准确率高于MLP，这是由于MLP在小数据集上容易过拟合
MLP对于参数的调整比较敏感，若参数设置不合理，容易得到较差结果

目录
Python机器学习应用
一、Sklearn库
二、无监督学习
三、有监督学习

Python机器学习应用.jpg