机器学习实战笔记7——逻辑回归

任务安排

1、机器学习导论       8、核方法
2、KNN及其实现       9、稀疏表示
3、K-means聚类      10、高斯混合模型
4、主成分分析          11、嵌入学习
5、线性判别分析      12、强化学习
6、贝叶斯方法          13、PageRank
7、逻辑回归              14、深度学习

逻辑回归（LR）

Ⅰ 最大似然估计

      后面的线性回归及逻辑回归均会用到最大似然估计，这里提前讲解，方便后续使用

似然函数：

                      设 $X$ 为离散随机变量，$\theta =({\theta }_1,...,{\theta }_k)$ 为待估计的多维参数向量，若随机变量 $x_1,...,x_n$ 相互独立且与 $X$ 同分布，
记$P(X_i=x_i)=p(x_i;\theta )$，则$$P(X_1=x_1,...,X_n=x_n)=\prod _{i=1}^{n}P(X_i=x_i)=\prod _{i=1}^{n}p(x_i;\theta )$$        称 $L(\theta )={\prod }_{i=1}^{n}p(x_i;\theta )$ 为似然函数（Likelihood function）

最大似然估计算法：

             ①写出似然函数：$$L({\theta }_1,...,{\theta }_k)=L(x_1,...,x_n;{\theta }_1,...,{\theta }_k)=\prod _{i=1}^{n}f(x_i;{\theta }_1,...,{\theta }_k)$$        $n$ 为样本数量，似然函数表示 $n$ 个样本（事件）同时发生的概率
             ②对似然函数取对数：$$\ln L({\theta }_1,...,{\theta }_k)=\sum _{i=1}^n\ln f(x_i;{\theta }_1,...,{\theta }_k)$$             ③将对数似然函数对各参数求偏导并令其为0，得到对数似然方程组
             ④求解方程组得到各个参数

Ⅱ 线性回归（Linear Regression）

模型介绍

      回归分析目的: 设法找出变量间的关联/依存（数量）关系，用函数关系式表达
      ①一元线性回归： $y_i=a+b{x}_i+e_i$
      其中：
               $a$ 是截距
               $b$ 是回归系数（回归直线的斜率）
               $e_i$ 是残差/损失（服从高斯分布）

      ②多元线性回归：$y_i=b_0+b_1{x}_{1i}+\dots +b_n{x}_{ni}+e_i$
      其中：
               $b_0$ 是常数项，是各变量都等于0时，因变量的估计值，也称本底值
               $b_i$ 是偏回归系数，其统计学意义是在其他所有自变量不变的情况下，某一自变量每变化一个单位，因变量平均变化的单位数

★目标函数

      ①目标函数求解
      线性回归假设特征和结果满足线性关系，得到预测模型（几何意义是一个拟合平面）$$h_{\theta }(x)={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2+\dots \dots =\sum _{i=1}^n{\theta }_i{x}_i=h_{\theta }(x)={\theta }^{T}x$$      $\theta$ 表示 $x$ 对预测值 $h_{\theta }(x)$ 的影响权重
      代入之前的模型，则得 $$y_i={\theta }^T{x}_i+{\epsilon }_i$$      ${\epsilon }_i$ 是每个样本点与预测值的差值（损失）

      现在的问题就变成，要利用最大似然估计，求解最合适的 ${\theta }^T$，使得 ${\epsilon }_i$ 最小，因为线性回归假设损失满足高斯分布，故得似然函数$$L(\theta )=\prod _{i=1}^{n}p(y_i|x_i;\theta )=\prod _{i=1}^n\frac{1}{\sqrt{2\pi }\sigma }{e}^{-\frac{(y_i-{\theta }^T{x}_i{)}^2}{2{\sigma }^2}}$$      对数似然函数$$\ln L(\theta )=\ln \prod _{i=1}^n\frac{1}{\sqrt{2\pi }\sigma }{e}^{-\frac{(y_i-{\theta }^T{x}_i{)}^2}{2{\sigma }^2}}$$      展开化简$$\sum _{i=1}^n\ln \frac{1}{\sqrt{2\pi }\sigma }{e}^{-\frac{(y_i-{\theta }^T{x}_i{)}^2}{2{\sigma }^2}}=n\ln \frac{1}{\sqrt{2\pi }\sigma }-\frac{1}{{\sigma }^2}\cdot \frac{1}{2}\sum _{i=1}^n(y_i-{\theta }^T{x}_i{)}^2$$
      把可以求得的常数去掉，得到目标函数(保留$\frac{1}{2}$为了得到最小二乘法公式)$$\min J(\theta )=\frac{1}{2}\sum _{i=1}^n(y_i-{\theta }^T{x}_i{)}^2$$
      ②目标函数优化（最小二乘法）
            $J(\theta )=\frac{1}{2}{\sum }_{i=1}^n(y_i-{\theta }^T{x}_i{)}^2=\frac{1}{2}(X\theta -y{)}^T(X\theta -y)$

       ${▽}_{\theta }J(\theta )={▽}_{\theta }(\frac{1}{2}(X\theta -y{)}^T(X\theta -y))$

                     $={▽}_{\theta }(\frac{1}{2}({\theta }^T{X}^T-y^T)(X\theta -y))$

                     $={▽}_{\theta }(\frac{1}{2}({\theta }^T{X}^{T}X\theta -{\theta }^T{X}^{T}y-y^{T}X\theta +y^{T}y))$

                     $=\frac{1}{2}(2X^{T}X\theta -X^{T}y-(y^{T}X{)}^T)$

                     $=X^{T}X\theta -X^{T}y$

令偏导 ${▽}_{\theta }J(\theta )=0$，则 $\theta =(X^{T}X{)}^{-1}{X}^{T}y$
最终，我们成功找到了使样本点到回归模型距离最短的线（面）

Ⅲ 逻辑回归（Logistic Regression）

线性回归与非线性回归

      学习了线性回归，我们已经能较好地解决符合线性特征的样本了，但是，如果样本是如下图一样非线性的，又该如何解决呢？——逻辑回归

      虽然线性回归和逻辑回归都属于监督学习范畴，但不同于线性回归的是，名字带有“回归”的逻辑回归，不属于回归，而属于分类，根本原因在于它以对数几率函数（Logistic function）作为激活函数（在人工神经网络的神经元上运行的函数，负责将神经元的输入映射到输出端），使其取值范围被限定在了 $[0,1]$，因此逻辑回归常常用来解决二分类、非线性问题（当然也可以通过设定多阈值来解决多分类问题）

对数几率函数（Logistic function）

      如图是 $Logistic$ 函数，是 $Sigmoid$ 函数（形状S型函数）的代表，其特点是自变量在0的附近时，因变量会迅速分离开来，因此对于二分类问题非常方便，其函数表达式为$$g(z)=\frac{1}{1+e^{-z}}$$

故可以得到逻辑回归预测函数 $$h_{\theta }(x)=g({\theta }^{T}x)=\frac{1}{1+e^{-}{\theta }^{T}x}$$
对上式变换，得到 $\ln \frac{h_{\theta }(x)}{1-h_{\theta }(x)}={\theta }^{T}x$，即对于输入 $x$，预测的分类结果有：$$P(y=1|x;\theta )=h_{\theta }(x)$$$$P(y=0|x;\theta )=1-h_{\theta }(x)$$

损失函数

      不同于线性回归假设损失满足高斯分布，逻辑回归假设损失满足伯努利分布（二项分布在试验次数n=1时的特例）
      类比之前用最大似然估计的求法，似然函数：$$L(\theta )=\prod _{i=1}^{m}p(y|x;\theta )=\prod _{i=1}^m{h}_{\theta }(x_i{)}^{y_i}(1-h_{\theta }(x_i){)}^{1-y_i}$$      取对数，对数似然函数：$$\ln L(\theta )=\sum _{i=1}^m{y}_i\ln h_{\theta }(x_i)+(1-y_i)\ln (1-h_{\theta }(x_i))$$      定义目标函数为：$$\min J(\theta )=-\frac{1}{m}[\sum _{i=1}^m{y}_i\ln h_{\theta }(x_i)+(1-y_i)\ln (1-h_{\theta }(x_i))]$$      该函数也叫交叉熵损失函数，在通信原理中常用

梯度下降法

      对于非线性问题，最小二乘法也可以使用，但是比起线性会复杂不少，故这里采用梯度下降（迭代）来求解参数
      参数更新公式：$${\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J(\theta )={\theta }_j-\alpha \frac{1}{m}\sum _{i=1}^m(h_{\theta }(x^{(i)}-y^{(i)})x_j^{(i)})$$
参考 线性回归
逻辑回归（Logistic Regression, LR）简介

今日任务

1.给定图像数据集，比较分类性能
2.给定图像数据集CIFAR10，比较分类性能

任务解决

1、老师还让我们也跑一下线性回归的，不难，写法和之前差不多

from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.model_selection import train_test_split
import numpy as np
import os
import cv2 as cv


def createDatabase(path):
    # 查看路径下所有文件
    TrainFiles = os.listdir(path)  # 遍历每个子文件夹
    # 计算有几个文件(图片命名都是以 序号.jpg方式)
    Train_Number = len(TrainFiles)  # 子文件夹个数
    X_train = []
    y_train = []
    # 把所有图片转为1维并存入X_train中
    for k in range(0, Train_Number):
        Trainneed = os.listdir(path + '/' + TrainFiles[k])  # 遍历每个子文件夹里的每张图片
        Trainneednumber = len(Trainneed)  # 每个子文件里的图片个数
        for i in range(0, Trainneednumber):
            image = cv.imread(path + '/' + TrainFiles[k] + '/' + Trainneed[i]).astype(np.float32)  # 数据类型转换
            image = cv.cvtColor(image, cv.COLOR_RGB2GRAY)  # RGB变成灰度图
            X_train.append(image)
            y_train.append(k)
    X_train = np.array(X_train)
    y_train = np.array(y_train)
    return X_train, y_train


# 逻辑回归分类器
def test_LR(*data):
    X_train, X_test, y_train, y_test = data
    lr = LogisticRegression(max_iter=10000)
    lr.fit(X_train, y_train)
    print('逻辑回归分类器')
    print('Testing Score: %.4f' % lr.score(X_test, y_test))
    return lr.score(X_test, y_test)


def test_Linear(*data):
    X_train, X_test, y_train, y_test = data
    linear = LinearRegression()
    linear.fit(X_train, y_train)
    print('线性回归分类器')
    print('Testing Score: %.4f' % linear.score(X_test, y_test))


path_face = 'C:/Users/1233/Desktop/Machine Learning/face_images/'
path_flower = 'C:/Users/1233/Desktop/Machine Learning/17flowers/'


X_train_flower, y_train_flower = createDatabase(path_flower)
X_train_flower = X_train_flower.reshape(X_train_flower.shape[0], 180*200)
X_train_flower, X_test_flower, y_train_flower, y_test_flower = \
    train_test_split(X_train_flower, y_train_flower, test_size=0.2, random_state=22)

digits = load_digits()
X_train_digits, X_test_digits, y_train_digits, y_test_digits = \
    train_test_split(digits.data, digits.target, test_size=0.2, random_state=22)

X_train_face, y_train_face = createDatabase(path_face)
X_train_face = X_train_face.reshape(X_train_face.shape[0], 180*200)
X_train_face, X_test_face, y_train_face, y_test_face = \
    train_test_split(X_train_face, y_train_face, test_size=0.2, random_state=22)

print('17flowers分类')
test_LR(X_train_flower, X_test_flower, y_train_flower, y_test_flower)
test_Linear(X_train_flower, X_test_flower, y_train_flower, y_test_flower)
print('Digits分类')
test_LR(X_train_digits, X_test_digits, y_train_digits, y_test_digits)
test_Linear(X_train_digits, X_test_digits, y_train_digits, y_test_digits)
print('Face images分类')
test_LR(X_train_face, X_test_face, y_train_face, y_test_face)
test_Linear(X_train_face, X_test_face, y_train_face, y_test_face)

效果图（可以看到，在比较复杂的数据集里，逻辑回归的性能会略好于别的分类方法，且线性回归性能随数据集复杂程度上升迅速下降）

      根据官方给的该 $score$ 函数返回值，是以决定系数（coefficient of determination）来判断回归方程拟合程度的
①平均值$$\bar{y}=\frac{1}{n}\sum _{i=1}^n{y}_i$$②总平方和（The total sum of squares）$$S{S}_{tot}=\sum (y_i-\bar{y}{)}^2$$③回归平方和（The regression sum of squares）$$S{S}_{reg}=\sum (f_i-\bar{y}{)}^2$$④决定系数（Coefficient of determination）$$R^2=1-\frac{S{S}_{reg}}{S{S}_{tot}}$$
所以 $score$ 函数返回值越接近1表示拟合程度越好，且有可能负数（这里和统计学里的可决系数定义不一样，统计学里的可决系数 $R^2\in [0,1]$）

2、CIFAR10在很多地方都有提供，老师让我们用 $PyTorch$ 里的，可以直接导入（$PyTorch$ 是一个开源的 Python 机器学习库（也有 C++，Java的库），基于 $Torch$，用于自然语言处理等应用程序）

      然而安装 $pytorch$ 前，$pip$又又又又又更新了，结果这次不知道什么原因，用机器学习实战笔记1——机器学习导论里原来记的命令行没更新成功，看了$site-package$ 里面有新版20.1的包，但是安装 $pytorch$ 就是叫我升级，升级了就报错，无奈之下，又找到了一个新的升级方法——在 $pycharm$ 的 $setting$里手动更新


双击 $Latest$  $version$ 一栏下方要更新的那个包

注意 左边 $Installto\dots \dots$ 和右边 $Specify$  $version$ 都要勾选
更新完成再用下面命令行安装 $pytorch$

pip install torch==1.3.1 -f https://download.pytorch.org/whl/torch_stable.html

pip install torchvision==0.4.1

上PyTorch官网根据他们给的命令行下载也可以，但是通常速度非常慢

安装完以后，终于是可以开始跑了，用PyTorch中文文档里给的python代码把数据集CIFAR10载下来即可

from torchvision.datasets import CIFAR10

CIFAR10(root=path, download=True)

当然，它是从官网上载的，非常慢，找到了一个前辈分享的CIFAR10百度云链接，下载以后解压出来，根据文档说的，把解压后的文件夹改成 “cifar-10-batches-py”，或者再用上面代码跑一遍，就会自动解压，输出

Files already downloaded and verified

即可

接下来是真的可以开始测试CIFAR10的分类性能了

import pickle
import numpy as np
from sklearn.linear_model import LogisticRegression
from myModule import clustering_performance
from sklearn.neighbors import KNeighborsClassifier
from sklearn import naive_bayes

path = 'C:/Users/1233/Desktop/Machine Learning/CIFAR10/cifar-10-batches-py/'


def unpickle(file):  # 官方给的例程
    with open(file, 'rb') as fo:
        cifar = pickle.load(fo, encoding='bytes')
    return cifar


def test_LR(*data):
    X_train, X_test, y_train, y_test = data
    lr = LogisticRegression(max_iter=10000)
    lr.fit(X_train, y_train)
    # ACC = lr.score(X_test, y_test)
    print('逻辑回归分类器')
    print('Testing Score: %.4f' % lr.score(X_test, y_test))
    # print('Testing Score: %.4f' % ACC)
    return lr.score(X_test, y_test)


def test_GaussianNB(*data):
    X_train, X_test, y_train, y_test = data
    cls = naive_bayes.GaussianNB()  # ['BernoulliNB', 'GaussianNB', 'MultinomialNB', 'ComplementNB','CategoricalNB']
    cls.fit(X_train, y_train)
    # print('高斯贝叶斯分类器')
    print('贝叶斯分类器')
    print('Testing Score: %.4f' % cls.score(X_test, y_test))
    return cls.score(X_test, y_test)


def test_KNN(*data):
    X_train, X_test, y_train, y_test = data
    knn = KNeighborsClassifier()
    knn.fit(X_train, y_train)
    y_sample = knn.predict(X_test)
    print('KNN分类器')
    ACC = clustering_performance.clusteringMetrics1(y_test, y_sample)
    print('Testing Score: %.4f' % ACC)
    return ACC


test_data = unpickle(path + 'test_batch')
for i in range(1, 4):
    train_data = unpickle(path + 'data_batch_' + str(i))
    X_train, y_train = train_data[b'data'][0:1234], np.array(train_data[b'labels'][0:1234])
    X_test, y_test = test_data[b'data'][0:1234], np.array(test_data[b'labels'][0:1234])
    print('data_batch_' + str(i))
    test_KNN(X_train, X_test, y_train, y_test)
    test_GaussianNB(X_train, X_test, y_train, y_test)
    test_LR(X_train, X_test, y_train, y_test)

效果图（训练集：测试集 = 1：1 只分别跑了batch1~3的前1234张，量实在是太大了，跑全部的时候电脑热得可怕，有电脑好的感兴趣的可以试试跑全部的效果，还可以试试线性回归分类，效果应该是非常不好的）