一、1、导论
统计学习分为监督学习和非监督学习（先学监督学习）
模型（假设空间）：决策函数、条件概率分布
策略：0-1损失函数、平方损失函数、绝对值损失函数、对数损失函数、经验风险最小化、结构风险最小化（正则项）
算法
训练集（用来训练）
验证集用来选出最好的一个拟合次数（因为训练模型在一遍又一遍的更新拟合，越来越符合训练集，但是可能出现过拟合的问题，所以需要确定一个最好的拟合次数）
最后再将选出来的模型在测试集上跑一个分数作为模型最终的得分
交叉验证：数据量太小的时候，选择这种方式进行随机选取组成训练集与验证集
经验误差：在训练集上的平均误差
泛化误差：不论是在训练中还是在实际应用中，的平均误差
生成模型与判别模型
生成方法：P（Y|X）=p(X,Y)/p(X)
判别方法：f(X)或p(Y|X)
生成模型一般好于判别模型，但是过程也会比较复杂
一、2、极大似然估计
Θ是未知的，但是可以求出似然函数的表达式。比如在题已知的条件下，抛出硬币的结果是在1 0 0 1 1 的概率为L（θ） = θ3 （1-θ）2
在求出表达式之后，我们需要让表达式的值最大，也就是达到我们要的抛硬币的结果的最大概率，此时求出的Θ为最可能的
不直接求L（Θ），而是求ln（L（Θ）），是因为L（Θ）是很多个小数的乘积，结果很小就会出现下溢出，所以使用ln
一、3、梯度下降法
选取一个初始点，求导，倒数大于零就减小x，导数小于零就增加x
随着递推的进行，f（x）’ 不断地减小，最终足够小，达到停止条件就可以停止。
二、感知机（最基础的算法，后面的算法都是在这个的基础上进行优化的）
1、导论
在一个线性可分模型中，确定一个超平面，将数据进行划分
原则：1、一个超平面不分错一个点，就是好的超平面
2、模型要尽可能的找到好的超平面
3、如果没有好的超平面，就在差的超平面中找到较好的直线
4、判断一个超平面有多差：分错的点到超平面的距离的求和
分错的点，计算到超平面的距离，使用几何间距，不使用函数间距。
因为函数间距中，如果同时缩小w 与 b，就会使函数间距变小，但实际上超平面并没有变化，几何间距因为分母的存在，相当于给间距加上了一个量纲，避免了这个问题，之后的学习中都主要使用几何间距不是函数间距
因为感知机的误分类驱动的，进行计算带入的点也都是被错误分类的点。这里使用函数间距就可以满足条件，使用几何间距只会无用的增加计算量。
使用方法就是不断的使用误分类的点进行梯度下降法
感知机只能进行线性分类，也就是二分类，如果使用多个感知机可以进行多分类
二、感知机2、感知机的对偶形式
对偶形式：就是目的是一样的，但是实现的方式是不同的
当一个点始终是误分类点，那就需要循环的对其进行梯度下降。当一个点进行n次梯度下降之后，这一个点对w、b的影响就是图中所示
1、使用这种对偶形式，初始值设置必须要α=0，因为最开始还没有对误分类点进行迭代
感知机中，初始值可以设置为任意值
2、这种方式的好处是：在判断一个点是不是误分类点时的判断公式中有Xj Xi，可以实现进行X * X的矩阵运算，用的时候直接读取，减少运行时间。
3、感知机的原始形式中，每次迭代都需要进行yi * xi + w，这种对偶形式的迭代只需要在α的基础上进行加法
二、感知机3、感知机的收敛性
二、感知机4、感知机的代码
Tqdm包是一个显示进度的包
#coding=utf-8
#Author:Dodo
#Date:2018-11-15
#Email:lvtengchao@pku.edu.cn
'''
数据集：Mnist
训练集数量：60000
测试集数量：10000
------------------------------
运行结果：
正确率：81.72%（二分类）
运行时长：78.6s
'''
import numpy as np
import time
from tqdm import tqdm
def loadData(fileName):
'''
加载Mnist数据集
:param fileName:要加载的数据集路径
:return: list形式的数据集及标记
'''
print('start to read data')
# 存放数据及标记的list
dataArr = []; labelArr = []
# 打开文件
fr = open(fileName, 'r')
# 将文件按行读取
for line in tqdm(fr.readlines()):
# 对每一行数据按切割福','进行切割，返回字段列表
curLine = line.strip().split(',')
# Mnsit有0-9是个标记，由于是二分类任务，所以将>=5的作为1，<5为-1
if int(curLine[0]) >= 5:
labelArr.append(1)
else:
labelArr.append(-1)
#存放标记
#[int(num) for num in curLine[1:]] -> 遍历每一行中除了以第一哥元素（标记）外将所有元素转换成int类型
#[int(num)/255 for num in curLine[1:]] -> 将所有数据除255归一化(非必须步骤，可以不归一化)
dataArr.append([int(num)/255 for num in curLine[1:]])
#返回data和label
return dataArr, labelArr
def perceptron(dataArr, labelArr, iter=50):
'''
感知器训练过程
:param dataArr:训练集的数据 (list)
:param labelArr: 训练集的标签(list)
:param iter: 迭代次数，默认50
:return: 训练好的w和b
'''
print('start to trans')
#将数据转换成矩阵形式（在机器学习中因为通常都是向量的运算，转换称矩阵形式方便运算）
#转换后的数据中每一个样本的向量都是横向的
dataMat = np.mat(dataArr)
#将标签转换成矩阵，之后转置(.T为转置)。
#转置是因为在运算中需要单独取label中的某一个元素，如果是1xN的矩阵的话，无法用label[i]的方式读取
#对于只有1xN的label可以不转换成矩阵，直接label[i]即可，这里转换是为了格式上的统一
labelMat = np.mat(labelArr).T
#获取数据矩阵的大小，为m*n
m, n = np.shape(dataMat)
#创建初始权重w，初始值全为0。
#np.shape(dataMat)的返回值为m，n -> np.shape(dataMat)[1])的值即为n，与
#样本长度保持一致
w = np.zeros((1, np.shape(dataMat)[1]))
#初始化偏置b为0
b = 0
#初始化步长，也就是梯度下降过程中的n，控制梯度下降速率
h = 0.0001
#进行iter次迭代计算
for k in range(iter):
#对于每一个样本进行梯度下降
#李航书中在2.3.1开头部分使用的梯度下降，是全部样本都算一遍以后，统一
#进行一次梯度下降
#在2.3.1的后半部分可以看到（例如公式2.6 2.7），求和符号没有了，此时用
#的是随机梯度下降，即计算一个样本就针对该样本进行一次梯度下降。
#两者的差异各有千秋，但较为常用的是随机梯度下降。
for i in range(m):
#获取当前样本的向量
xi = dataMat[i]
#获取当前样本所对应的标签
yi = labelMat[i]
#判断是否是误分类样本
#误分类样本特诊为： -yi(w*xi+b)>=0，详细可参考书中2.2.2小节
#在书的公式中写的是>0，实际上如果=0，说明改点在超平面上，也是不正确的
if -1 * yi * (w * xi.T + b) >= 0:
#对于误分类样本，进行梯度下降，更新w和b
w = w + h * yi * xi
b = b + h * yi
#打印训练进度
print('Round %d:%d training' % (k, iter))
#返回训练完的w、b
return w, b
def model_test(dataArr, labelArr, w, b):
'''
测试准确率
:param dataArr:测试集
:param labelArr: 测试集标签
:param w: 训练获得的权重w
:param b: 训练获得的偏置b
:return: 正确率
'''
print('start to test')
#将数据集转换为矩阵形式方便运算
dataMat = np.mat(dataArr)
#将label转换为矩阵并转置，详细信息参考上文perceptron中
#对于这部分的解说
labelMat = np.mat(labelArr).T
#获取测试数据集矩阵的大小
m, n = np.shape(dataMat)
#错误样本数计数
errorCnt = 0
#遍历所有测试样本
for i in range(m):
#获得单个样本向量
xi = dataMat[i]
#获得该样本标记
yi = labelMat[i]
#获得运算结果
result = -1 * yi * (w * xi.T + b)
#如果-yi(w*xi+b)>=0，说明该样本被误分类，错误样本数加一
if result >= 0: errorCnt += 1
#正确率 = 1 - （样本分类错误数 / 样本总数）
accruRate = 1 - (errorCnt / m)
#返回正确率
return accruRate
if __name__ == '__main__':
#获取当前时间
#在文末同样获取当前时间，两时间差即为程序运行时间
start = time.time()
#获取训练集及标签
trainData, trainLabel = loadData('../Mnist/mnist_train.csv')
#获取测试集及标签
testData, testLabel = loadData('../Mnist/mnist_test.csv')
#训练获得权重
w, b = perceptron(trainData, trainLabel, iter = 30)
#进行测试，获得正确率
accruRate = model_test(testData, testLabel, w, b)
#获取当前时间，作为结束时间
end = time.time()
#显示正确率
print('accuracy rate is:', accruRate)
#显示用时时长
print('time span:', end - start)
没眼看的课后习题
import numpy as np
#读入数据
dataArr = [[3,3],[4,3],[1,1]]
labelArr = [1,1,-1]
#设置初值
b = 0
data = np.mat(dataArr)
label = np.mat(labelArr).T
#将label值转成纵向
w = np.zeros(data.shape[1])
h = 1#步长
i = 0
while i <3:
if -1 * label[i] * (w * data[i].T + b) >= 0:
#data[i]进行转置，不然无法相乘
w = w + h * label[i] * data[i]
b = b + h * label[i]
i = 0
else:
i+=1
print(w,b)
import numpy as np
import matplotlib.pyplot as plt
class MyPerceptron:
def __init__(self):
self.w=None # 参数w的个数与x的特征数量对应，初始并不知道x的特征个数，故赋值None
self.b=0
self.l_rate=1 # 学习率 = 1
def fit(self,X_train,y_train):
#用样本点的特征数更新初始w，如x1=(3,3)T，有两个特征，则self.w=[0,0]
self.w=np.zeros(X_train.shape[1])
i=0
while i<X_train.shape[0]:
X=X_train[i]
y=y_train[i]
# 如果y*(wx+b)≤0 说明是误判点，更新w,b
if y*(np.dot(self.w, X) + self.b) <= 0:
#np.dot是向量的点集
self.w = self.w + self.l_rate * np.dot(y, X)
self.b = self.b + self.l_rate * y
i=0 #如果是误判点,从头进行检测
else:
i+=1
def draw(X,w,b):
#生产分离超平面上的两点
X_new=np.array([[0], [6]])
y_predict=-b-(w[0]*X_new)/w[1]
#绘制训练数据集的散点图
plt.plot(X[:2,0],X[:2,1],"g*",label="1")
plt.plot(X[2:,0], X[2:,0], "rx",label="-1")
#绘制分离超平面
plt.plot(X_new,y_predict,"b-")
#设置两坐标轴起止值
plt.axis([0,6,0,6])
#设置坐标轴标签
plt.xlabel('x1')
plt.ylabel('x2')
#显示图例
plt.legend()
#显示图像
plt.show()
def main():
# 构造训练数据集
X_train=np.array([[3,3],[4,3],[1,1]])
y_train=np.array([1,1,-1])
# 构建感知机对象，对数据集继续训练
perceptron=MyPerceptron()
perceptron.fit(X_train,y_train)
print(perceptron.w)
print(perceptron.b)
# 结果图像绘制
draw(X_train,perceptron.w,perceptron.b)
if __name__=="__main__":
main()
from sklearn.linear_model import Perceptron
import numpy as np
X_train = np.array([[3, 3], [4, 3], [1, 1]])
y = np.array([1, 1, -1])
perceptron=Perceptron()
perceptron.fit(X_train,y)
print("w:",perceptron.coef_,"\n","b:",perceptron.intercept_,"\n","n_iter:",perceptron.n_iter_)
res=perceptron.score(X_train,y)
print("correct rate:{:.0%}".format(res))仅用于个人学习
344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
