机器学习算法系列(三)

本篇主要内容：
1、python实现基于iris数据集的决策树算法
2、线性回归基本思想及python模拟实现

上一篇文章主要分享了决策树的相关原理及算法思想，这一篇开头我们先用python实现一下，本案例基于sklearn自带的数据集iris，对于数据集iris不在详细介绍可自行百度；在这里对于数据集的训练及测试使用了两种方法：一种是于数据集中随机取值用于训练测试；一种是使用交叉验证的方式(对于交叉验证第一讲已经简单介绍过：其实就是轮询取，保证均匀训练及测试)。

#基于iris数据集，实现随机及交叉取值，算法决策树实现分类
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn import tree
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier

iris=datasets.load_iris() #加载数据

#features
X=iris.data    

#label
Y=iris.target
sum=0.0
epoch_size=20 #循环次数
k=30  #交叉验证次数

testLen=len(X)/k
#交叉取值
def cross_split(data,labels,j):
    X_train=[]
    X_test=[]
    Y_train=[]
    Y_test=[]

    for i in range(len(data)):
        if (i>=(len(data)-testLen*j)-1)and(len(Y_test)<testLen):
            X_test.append(data[i])
            Y_test.append(labels[i])
        else:
            X_train.append(data[i])
            Y_train.append(labels[i])
    print(len(X_train),len(X_test),len(Y_train),len(Y_test))
    return X_train,X_test,Y_train,Y_test

#交叉验证
for j in range(k):
    X_train=[]
    X_test=[]
    Y_train=[]
    Y_test=[]
    X_train,X_test,Y_train,Y_test=cross_split(X,Y,j+1)

    #决策树分类 
    # 生成决策树
    my_classification = tree.DecisionTreeClassifier()
    # 训练
    my_classification.fit(X_train, Y_train)
    # 预测
    predictions = my_classification.predict(X_test)
# 获得预测准确率
    acc= accuracy_score(Y_test, predictions)
    sum += acc
    print('Epoch: ',j, 'accuracy: %f'%acc)
print('mean: %f'%(sum/k))

'''#随机取值20次
for i in range(epoch_size):
    acc=0.0
    X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.06)
    print(len(X_train),len(X_test),len(Y_train),len(Y_test))

    #决策树分类 
    # 生成决策树
    my_classification = tree.DecisionTreeClassifier()
    # 训练
    my_classification.fit(X_train, Y_train) 
    # 预测
    predictions = my_classification.predict(X_test)
    # 获得预测准确率
    acc=accuracy_score(Y_test, predictions))
    print('Epoch: ',i, 'accuracy: %f'%acc)
print('mean: %f'%(sum/epoch_size))
'''

**

二、线性回归

**
线性回归就比较简单啦，在这里就不在非常详细介绍了，基本原理如下：

给定数据集D={(xi,yi)……},试图学得f(xi)=w*xi+b,使得f(xi)=yi;(这里的w、b就是参数啦，在学习过程当中就是不断地优化它们，使得学习到的f(xi)尽可能的接近真实的yi)

试图让均方误差最小化，其几何意义对应了常用的欧几里得距离；基于均方误差最小化来进行模型求解的方法称为最小二乘法，其就是试图找到一条直线，使所有样本到直线上的欧氏距离之和最小；

线性模型应用于分类任务：利用sigmoid函数将原线性模型产生的预测值转换为0/1值，预测值大于0则取正例1，小于0取反例0，等于0可任意判别；

线性判别分析(LDA):给定训练样例集，设法将样例投影到一条直线上，使得同类样例的投影点尽可能的接近，异类样例的投影点尽可能地远离；新样本分类时投影直线根据位置确定类别；

多分类学习：“拆解法”：一对一(OvO)、一对其余(OvR)、多对多(MvM)；
一对一：N个类别两两配对，产生N*(N-1)/2个二分类任务；一对其余：每次依次取一个为正例，其余均为反例来训练分类器，总共需训练N个分类器；

比较简单，就直接上实例啦；
这里用到了深度学习的pytorch框架，可以先简单了解一下就是相当于一个工具包而已，后续会有详细分享学习：

import torch
from torch import nn,optim
from torch.autograd import Variable
import numpy as np
import matplotlib.pyplot as plt

x_train=np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168],
                    [9.779], [6.182], [7.59], [2.167], [7.042],
                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573],
                    [3.366], [2.596], [2.53], [1.221], [2.827],
                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)

#转换为tensor类型
x_train=torch.from_numpy(x_train)
y_train=torch.from_numpy(y_train)

#Linear Regression Model
class LinearRegression(nn.Module):
        def __init__(self):
                super(LinearRegression,self).__init__()
                self.linear=nn.Linear(1,1)  #input and output is 1 dimension
                #nn.Linear表示的是y=w*x+y线性的，而两个参数1表示输入和输出均是一维的
        def forward(self,x):
                out=self.linear(x)
                return out

model=LinearRegression()
#定义loss和优化函数
criterion=nn.MSELoss()  #最小二乘loss
optimizer=optim.SGD(model.parameters(),lr=1e-4)  #随机梯度下降；注意parameters表示的是需要优化的模型参数

#开始训练
num_epochs=400
for epoch in range(num_epochs):
        inputs=Variable(x_train)
        target=Variable(y_train)

        #forward
        out=model(inputs)
        loss=criterion(out,target)

        #backward
        optimizer.zero_grad()  #梯度清零
        loss.backward()
        optimizer.step()       #更新参数

        if(epoch+1)%20==0:
                print('Epoch[{}/{}],loss:{:.6f}'.format(epoch+1,num_epochs,loss.data[0]))

model.eval()     #测试模式
predict=model(Variable(x_train))
predict=predict.data.numpy()
plt.plot(x_train.numpy(),y_train.numpy(),'ro',label='Original data')
plt.plot(x_train.numpy(), predict, label='Fitting Line')
# 显示图例
plt.legend()
plt.show()

# 保存模型
torch.save(model.state_dict(), './linear.pth')

同时这里也用到了一个绘图包及工具便于展示实际效果

看一下实际运行效果：