学习笔记（三）逻辑回归

《机器学习实战》学习笔记（三）Logistic 回归

1. 什么是逻辑回归

线性回归和逻辑回归其实没有多大的区别，就是逻辑回归多了一个Sigmoid函数，使样本能映射到[0,1]之间的数值，用来做分类问题。

1. 线性回归：线性指输入变量是一次的，回归即拟合，线性回归即：确定唯一的因变量（需要预测的值）和一个或多个数值型的自变量（预测变量）之间的关系。即：求出W，b的值 $y=f(X)=WX+b$
   其中：W,X均为向量
2. 逻辑回归：逻辑回归即是在线性回归函数的输出结果中加了一个Sigmoid函数，将结果映射到了[0,1]上，从而实现分类。

2. Sigmoid函数

1. Sigmoid函数:
   $Sigmoid(x) = \frac{1}{1+e^{-x}}$
   

3. 代码实现

样本数据链接：链接：https://pan.baidu.com/s/1L-iR8zQR7l3rrNL0WcZSvQ
提取码：yuma

# -*- coding: utf-8 -*-
"""
Created on Thu Feb 28 15:10:27 2019

@author: xinglin
"""

import matplotlib.pyplot as plt
import numpy as np

class MyLogisticRegression:
    def __init__(self):
        pass

    def  sigmoid(self,x):
        return 1.0 / (1.0 + np.exp(-x))
    # 展示sigmoid
    def show_sigmoid(self):
        x = np.linspace(-10, 10)
        y = self.sigmoid(x)
        plt.plot(x,y)
        plt.show()
    # 加载数据
    def loadDataSet(self):
        '''
        return---np array
        trainDataSet:带常数项的数据
        dataSet:原始数据
        dataLabel：标签，类别列表
        
        '''
        data = np.loadtxt('Logistic Regression/data1.txt', delimiter=',')
        dataSet = data[:,0:2]
        #为了便于进行矩阵运算，每个样本增加一列 1 ，表示常数项
        b = np.ones((dataSet.shape[0],1))
        trainDataSet = np.concatenate([dataSet,b],axis = 1)  
        dataLabel = data[:,2]
        return trainDataSet,dataSet,dataLabel
    def showData(self):
        dataMat,data,labelMat = self.loadDataSet()  # 加载数据集
        pos = np.where(labelMat == 1)
        neg = np.where(labelMat == 0)

        plt.scatter(dataMat[pos, 0], dataMat[pos, 1], marker='o', c='b')
        plt.scatter(dataMat[neg, 0], dataMat[neg, 1], marker='x', c='r')
        plt.show()

    def gradAscent(self):
        dataMatIn,orgData,classLabels = self.loadDataSet()
        dataMatrix = np.mat(dataMatIn)                            #转换成numpy的mat
        labelMat = np.mat(classLabels).transpose()                #转换成numpy的mat,并进行转置
        m, n = np.shape(dataMatrix)                               #返回dataMatrix的大小。m为行数,n为列数。
        alpha = 0.01                                              #学习速率,控制更新的幅度。
        maxCycles = 1000000                                      #迭代次数
        weights = np.ones((n,1))
        wList = []
        for k in iter(range(maxCycles)):
            h = self.sigmoid(dataMatrix * weights)                #梯度上升矢量化公式
            error = labelMat - h
            weights = weights + alpha * dataMatrix.transpose() * error
        return weights.getA()                                     #将矩阵转换为数组，返回权重数组

    def plotBestFit(self,weights):
        dataMat,data,labelMat = self.loadDataSet()  # 加载数据集

        pos = np.where(labelMat == 1)
        neg = np.where(labelMat == 0)

        plt.scatter(dataMat[pos, 0], dataMat[pos, 1], marker='o', c='b')
        plt.scatter(dataMat[neg, 0], dataMat[neg, 1], marker='x', c='r')
        x = np.arange(0, 100, 0.1)
        y = (-weights[0] * x - weights[2]) / weights[1]
        plt.plot(x,y)
        plt.show()


if __name__ == '__main__':
    Model = MyLogisticRegression()
    # Model.show_sigmoid()
    weights = Model.gradAscent()
    print(weights)
    Model.showData()
    Model.plotBestFit(weights)

运行效果：

4. 总结

1. 这里简单的实现了逻辑回归的基本原理，效果不是很好，所得的权重值不稳定，没有结束条件，完全靠指定的次数结束。难以拟合。
2. 想要更好的效果可以采用随机梯度上升算法，或者支持向量机（SVM），支持向量机，它被认为是目前最好的现成的算法之一。