[机器学习西瓜书]3.线性回归

介于看完之后老是不知道看了些啥，所以开这么一部分blog对看到的内容进行记录整理
当然知识介绍肯定没有书上写的详细，仅限于自己对内容的整理

0. 线性模型概述

1. 试图学习一个通过属性的线性组合来进行预测的函数
2. 这里学到的主要内容
   线性回归——最小二乘法
   局部加权线性回归
   对数几率回归（逻辑斯蒂回归）
   感知机（书上是神经网络部分的内容，但是讲的时候把他放到这部分讲啦）

1. 线性回归

总体内容

线性回归：学习一个线性模型尽可能准确地预测实值输出标记
提到线性回归就需要涉及另外两个概念：均方误差和最小二乘法

• 均方误差：$$(w^{\ast },b^{\ast })=ar{g}_{w,b}min\sum (y_i-w{x}_i-b{)}^2$$
  均方误差是回归任务中最常用的性能度量
• 最小二乘法：
  基于均方误差来进行模型求解的方法
  最小二乘法试图找到一条直线，使所有样本到直线上的欧氏距离之和最小

线性回归模型的最小二乘“参数估计”是求解w和b使下面公式最小：
$$E_{w,b}=\sum _{i=1}^m(y_i-w{x}_i-b{)}^2$$
分别对w和b求偏导并令偏导=0，可以得到w和b的最优闭式解：
$$\begin{gathered} w=\frac{{\sum }_{i=1}^m{y}_i(x_i-\overline{x})}{{\sum }_{i=1}^m{x}_i^2-\frac{1}{m}({\sum }_{i=1}^m{x}_i{)}^2} \\ =\frac{{\sum }_{i=1}^m(y_i{x}_i-y_i\overline{x})}{{\sum }_{i=1}^m(x_i^2-x_i\overline{x})} \\ b=\frac{1}{m}\sum _{i=1}^m(y_i-w{x}_i) \end{gathered}$$

使用最小二乘法进行参数估计

$$f(x_i)=w^T{x}_i+b中，可以为x扩展一列常数1变为增广矩阵，b可以视为乘上这列常数1$$
常将w和b吸收入向量形式 $$\overline{w}=(w;b)$$
将均方误差写作向量的形式，即有：
$${\hat{w}}^{\ast }=argmi{n}_{\hat{w}}(y-X\hat{w}{)}^T(y-X\hat{w})$$
令$$E_{\hat{}x}=(y-X\hat{w}{)}^T(y-X\hat{w})$$
对w求导且XTX为满秩矩阵时令导数=0可得：
$${\hat{w}}^{\ast }=(X^{T}X{)}^{-1}{X}^{T}y$$

令xi=(xi;1)最终学得的多元线性回归模型为：
$$f(\widehat{x_i})={\widehat{x_i}}^T(X^{T}X{)}^{-1}{X}^{T}y$$

现实中XTX往往不满秩，此时可以解出多个w，他们都能使均方误差最小化，选择哪一个解作为输出将由学习算法的归纳偏好决定

实验代码

import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression

"""
函数说明：加载数据

Parameters:
    filename - 文件名
    
Returns:
    xArr - x数据集
    yArr - y数据集

"""
def loadDataSet(filename):
    
    
    xArr = [] # 输入数据
    yArr = []
    fr = open(filename)
    # 计算特征个数，由于最后一列为y值所以减1
    numFeat = len(fr.readline().split('\t')) - 1

    for line in fr.readlines():
        lineArr = [] # 每一行的输入数据
        curLine = line.strip().split('\t')
        for i in range(numFeat):
            lineArr.append(float(curLine[i]))
        xArr.append(lineArr)
        yArr.append(float(curLine[-1]))
    return xArr, yArr


"""
函数说明：计算回归系数w

Parameters:
    xArr - x数据集
    yArr - y数据集
    
Returns:
    ws - 回归系数

"""
def standRegres(xArr, yArr):
    xMat = np.mat(xArr)

    #学习xMat生成方式，生成yMat。  yMat为yArr转成矩阵后再转置的结果。
    yMat = np.mat(yArr).T
    #计算 xTx
    xTx = xMat.T * xMat
    
    # 求矩阵的行列式
    if np.linalg.det(xTx) == 0.0: # linalg: 线性代数函数库
        print("矩阵为奇异矩阵，不能求逆")
        return
    #求系数矩阵ws   提示：     .I  ：求逆矩阵
    ws = xTx.I * (xMat.T * yMat)
    return ws


"""
函数说明：绘制数据集以及回归直线

"""
def plotDataSet():
    xArr, yArr = loadDataSet('./实验3线性回归/ex0.txt')
    ws = standRegres(xArr, yArr)
    xMat = np.mat(xArr)
    yMat = np.mat(yArr)
    xCopy = xMat.copy()
    # 排序
    xCopy.sort(0) # 0表示按列排序，1表示按行排序
    yHat = xCopy * ws     
    
    plt.plot(xCopy[:,1],yHat,color='red')

    # 矩阵.A(等效于矩阵.getA())变成了数组
    plt.scatter(xMat[:, 1].flatten().A[0], yMat.flatten().A[0], s=20, c='blue', alpha=.5)
    plt.title('DataSet')
    plt.xlabel('X')
    plt.show()    
    
if __name__ == '__main__':
    plotDataSet()
    

局部加权线性回归

线性回归的一个问题是有可能出现欠拟合现象，因为它求的是具有最小均方误差的无偏估计。然鹅如果模型欠拟合将不能取得最好的预测效果。所以有些方法允许在估计中引人一些偏差，从而降低预测的均方误差。其中的一个方法是局部加权线性回归LWLR
在LWLR中，给待测点附近的每个店赋予一定的权重，于是公式就变成了：
$$f(\widehat{x_i})={\widehat{x_i}}^T(X^{T}WX{)}^{-1}{X}^{T}Wy$$
LWLR使用“核”来对附近的点赋予更高的权重，核的类型可以自由选择，最常用的就是高斯核
高斯核对应权重：
$$w(i,i)=exp(\frac{|x^{(i)}-x|}{-2k^2})$$

实验代码

# -*- coding: utf-8 -*-

from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
import numpy as np

"""
函数说明：加载数据

Parameters:
    filename - 文件名
    
Returns:
    xArr - x数据集
    yArr - y数据集


"""
def loadDataSet(filename):
    # 计算特征个数，由于最后一列为y值所以减一
    numFeat = len(open(filename).readline().split('\t')) - 1
    xArr = []
    yArr = []
    fr = open(filename)
    for line in fr.readlines():
        lineArr = []
        curLine = line.strip().split('\t')
        for i in range(numFeat):
            lineArr.append(float(curLine[i]))
        xArr.append(lineArr)
        yArr.append(float(curLine[-1]))
    return xArr, yArr


"""
函数说明：使用局部加权线性回归计算回归系数w

Parameters:
    testPoint - 测试样本点
    xArr - x数据集
    yArr - y数据集
    k - 高斯核的k，自定义参数
    
Returns:
    testPoint上的回归结果


"""
def lwlr(testPoint, xArr, yArr, k=1.0):
    xMat = np.mat(xArr)
    yMat = np.mat(yArr).T
    m = np.shape(xMat)[0]
    # 创建加权对角阵
    weights = np.mat(np.eye((m)))
    for j in range(m):
        # 高斯核
        diffMat = testPoint - xMat[j, :]
        #计算 w[j,j] 
        weights[j, j] = np.exp(diffMat * diffMat.T / (-2 * pow(k, 2)))
    
    #计算 xTx（局部加权后）
    xTx = xMat.T * weights * xMat
    
    # 求矩阵的行列式
    if np.linalg.det(xTx) == 0.0:
        print("矩阵为奇异矩阵，不能求逆")
        return
    #求系数矩阵ws   提示：     .I  ：求逆矩阵
    #
    ws = xTx.I * xMat.T * weights * yMat
    
    #返回测试样本点testPoint的预测结果
    return testPoint * ws


"""
函数说明：局部加权线性回归测试

Parameters:
    testArr - 测试数据集
    xArr - x数据集
    yArr - y数据集
    k - 高斯核的k,自定义参数
    
Returns:
    yHat - testArr上的回归结果


"""
def lwlrTest(testArr, xArr, yArr, k=1.0):
    m = np.shape(testArr)[0]
    yHat = np.zeros(m)
    for i in range(m):
        yHat[i] = lwlr(testArr[i], xArr, yArr, k)
    return yHat


"""
函数说明：绘制多条局部加权回归曲线

Parameters:
    None
    
Returns:
    None


"""
def plotlwlrRegression():
    # 设置中文字体
    font = FontProperties(fname=r"C:\Windows\Fonts\simsun.ttc", size=14)
    xArr, yArr = loadDataSet("./机器学习基础实验/实验4局部加权线性回归/ex1.txt")
    yHat_1 = lwlrTest(xArr, xArr, yArr, 1.0)
    yHat_2 = lwlrTest(xArr, xArr, yArr, 0.01)
    yHat_3 = lwlrTest(xArr, xArr, yArr, 0.003)
    xMat = np.mat(xArr)
    yMat = np.mat(yArr)
    
    yMat_1 = np.mat(yHat_1)
    yMat_2 = np.mat(yHat_2)
    yMat_3 = np.mat(yHat_3)
    
    
    
    
    ##########################   计算相关性 ############################
  
    print(np.corrcoef(yHat_1.T, yArr))
    print(np.corrcoef(yHat_2.T, yArr))
    print(np.corrcoef(yHat_3.T, yArr))
    
    # 排序，返回索引值
    srtInd = xMat[:, 1].argsort(0)
    xSort = xMat[srtInd][:, 0, :]
   
    fig, axs = plt.subplots(nrows=6, ncols=1, sharex=False, sharey=False, figsize=(10, 30))
    axs[0].plot(xSort[:, 1], yHat_1[srtInd], c='red')
    axs[1].plot(xSort[:, 1], yHat_2[srtInd], c='red')
    axs[2].plot(xSort[:, 1], yHat_3[srtInd], c='red')
    
    axs[0].scatter(xMat[:, 1].flatten().A[0], yMat.flatten().A[0], s=20, c='blue', alpha=.5)
    axs[1].scatter(xMat[:, 1].flatten().A[0], yMat.flatten().A[0], s=20, c='blue', alpha=.5)
    axs[2].scatter(xMat[:, 1].flatten().A[0], yMat.flatten().A[0], s=20, c='blue', alpha=.5)
    
    axs[3].scatter(xMat[:, 1].flatten().A[0], (yMat-yMat_1).flatten().A[0], s=20, c='blue', alpha=.5)
    axs[4].scatter(xMat[:, 1].flatten().A[0], (yMat-yMat_2).flatten().A[0], s=20, c='blue', alpha=.5)
    axs[5].scatter(xMat[:, 1].flatten().A[0], (yMat-yMat_3).flatten().A[0], s=20, c='blue', alpha=.5)
    
    axs0_title_text = axs[0].set_title(u'局部加权回归曲线,k=1.0', fontproperties=font)
    axs1_title_text = axs[1].set_title(u'局部加权回归曲线,k=0.01', fontproperties=font)
    axs2_title_text = axs[2].set_title(u'局部加权回归曲线,k=0.003', fontproperties=font)
    
    plt.setp(axs0_title_text, size=8, weight='bold', color='red')
    plt.setp(axs1_title_text, size=8, weight='bold', color='red')
    plt.setp(axs2_title_text, size=8, weight='bold', color='red')
    plt.xlabel('X')
    plt.show()
    
    
if __name__ == '__main__':
    plotlwlrRegression()

感知机perceptron

感知机perceptron是二分类的线性分类模型，输入是实例的特征向量，输出为实例的类别，取值一般为+1和-1二值，属于判别模型
西瓜书把这一部分放到了后面神经网络哪里，但是由于她也是线性模型，这里就一起学习了一下文章来源地址https://www.toymoban.com/news/detail-426156.html

实验代码

# -*- coding: utf-8 -*-


# 二维数据集决策边界可视化
from matplotlib.colors import ListedColormap
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

"""
类说明：构建感知机

Parameters:
    eta - 学习率(0,1]
    n_iter - 迭代次数
    w_ - 训练后的权重数组
    errors_ - 每轮训练后的误差
    
Returns:
    None

"""
class Perceptron(object):
    def __init__(self, eta=0.01, n_iter=10):
        self.eta = eta
        self.n_iter = n_iter
    
    """
    Fit training data
    Parameters
    X: {array-like}, shape=[n_samples, n_features]
       Trainig vectors, where n_samples is the number of samples and n_features is the number of features.
    y: array-like, shape = [n_samples]
       Target values.
    Returns
    self: object
    """
    def fit(self, X, y):        # 拟合训练数据
        # self.w_中的权值初始化为一个零向量R(m+1),其中m是数据集中维度(特征)的数量
        # 我们在此基础上增加一个0权重列(也就是阈值)
        self.w_ = np.zeros(1 + X.shape[1])  # X.shape[1]：特征数,self.w_[0]是b
        self.errors_ = []
        for _ in range(self.n_iter):
            errors = 0
            for xi, target in zip(X, y):

                update = self.eta * (target - self.predict(xi))/2

                # 更新 w b
                self.w_[1:] += update * xi
                self.w_[0] += update

                # 每轮中错分类样本的数量
                errors += int(update != 0.0)    
            self.errors_.append(errors)
        return self
    
    def net_input(self, X):         # 激活函数
        """Calculate net input"""
        # 计算X和w_的点积 
        return np.dot(X, self.w_[1:]) + self.w_[0]
    
    def predict(self, X):
        """Return class label after unit step"""
        return np.where(self.net_input(X) >= 0.0, 1, -1)


"""
函数说明：导入数据集

Parameters:
    None
    
Returns:
    X - 特征矩阵
    y - label列向量

Modify:
    2018-08-28
"""
def DataSet():
    # 使用pandas库直接从UCI机器学习库中将鸢尾花数据集转换为DataFrame对象并加载到内存中
    df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None)
    # 使用tail方法显示数据最后5行以保证数据正确加载
    df.tail()
    print(df)
    # 提取前100个类标，50个山鸢尾类标，50个变色鸢尾类标
    # iloc works on the positions in the index (so it only takes integers).
    y = df.iloc[0:100, 4].values
    # -1代表山鸢尾 1代表变色鸢尾，将label存到y中
    # np.where用法相当于C语言的 ? : 
    y = np.where(y == 'Iris-setosa', -1, 1) # 三元运算符，第一个参数是if的条件，第二个参数是if为真时的值，第三个参数是if为假时的值
    '''当只有一个参数时，返回的是每个符合condition条件元素的坐标,返回的是以元组的形式'''
    # 提取特征0和特征1 
    X = df.iloc[0:100, [0, 2]].values   # 切片[0,100）行，每行取第0和2列->iloc切面是前闭后开

    print("************")
    print(X)
    print("=============")
    print(y)

    # 绘制散点图
    plt.scatter(X[:50, 0], X[:50, 1], color='red', marker='o', label='setosa')
    plt.scatter(X[50:100, 0], X[50:100, 1], color='blue', marker='x', label='versicolor')
    # 花瓣长度
    plt.xlabel('petal length')
    # 萼片长度
    plt.ylabel('sepal length')
    plt.legend(loc='upper left')
    plt.show()
    # X为特征矩阵，y为label列向量（-1，1）
    return X, y


"""
函数说明：绘制迭代次数与误分点个数之间的关系

Parameters:
    None
    
Returns:
    None

Modify:
    2018-08-28
"""
def NumOfErrors():
    # 导入数据
    X, y = DataSet()
    # 实例化感知机
    ppn = Perceptron(eta=0.1, n_iter=10)
    # 训练模型
    ppn.fit(X, y)
    # 绘制迭代次数与误分点个数之间的关系
    plt.plot(range(1, len(ppn.errors_) + 1), ppn.errors_, marker='o')
    plt.xlabel('Epochs')
    plt.ylabel('Number of misclassifications')
    plt.show()
    

"""
函数说明：绘制决策区域图像

Parameters:
    X - 特征矩阵
    y - label列向量
    classifier - 分类器
    resolution - 采样间隔为0.02
    
Returns:
    None

Modify:
    2018-08-28
"""
def plot_decision_regions(X, y, classifier, resolution=0.02):
    # 散点样式
    markers = ('s', 'x', 'o', '^', 'v')
    # 颜色元组
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    # np.unique该函数是去除数组中的重复数字，并进行排序之后输出。
    # ListedColormap主要用于生成非渐变的颜色映射
    cmap = ListedColormap(colors[:len(np.unique(y))])
    # 横轴范围
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    # 纵轴范围
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    # meshgrid函数将最大值、最小值向量生成二维数组xx1和xx2
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), 
                           np.arange(x2_min, x2_max, resolution))
    z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    z = z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, z, alpha=0.4, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())
    # 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y==cl, 0], y=X[y==cl, 1], alpha=0.8, c=cmap(idx), marker=markers[idx], label=cl)
        

if __name__ == '__main__':
    # 导入数据
    X, y = DataSet()

    '''
    X：两个特征，图中以x[0]作横坐标，x[1]作纵坐标进行分类
    y：标签，1和-1
    '''

    # 实例化感知机
    ppn = Perceptron(eta=0.1, n_iter=10)
    # 训练模型
    ppn.fit(X, y)
    plot_decision_regions(X, y, classifier=ppn)
    # 萼片长度
    plt.xlabel('sepal length [cm]')
    # 花瓣长度
    plt.ylabel('petal length [cm]')
    plt.legend(loc='upper left')
    plt.show()
    NumOfErrors()

到了这里，关于[机器学习西瓜书]3.线性回归的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！