逻辑回归基本流程及鸢尾花项目实战

一、逻辑回归基本流程

1、逻辑回归

从一组样本的多个特征值中学习规律，建立模型（学习的模型抽象为一个公式f(x)），用这个模型来预测其他样本的结果。而逻辑回归是将预测结果分类。
逻辑回归步骤：
(1)将x的值归一化
(2)写权重函数z=w1x1+w2x2+…+wixi
(3)写激活函数a=σ(z)
(4)写损失函数L=-ylog(a)-(1-y)log(1-a)
(5)做梯度下降w=w-αdw
(6)用训练好的权重参数w做预测

2、激活函数

针对每个特征设权重wi，计算出的z=f(x)会有很多值，想把计算结果z归类到0和1之间，要用激活函数sigmoid:y=1/(1+e^(-z))，这时得到的就是预测值。
激活函数的特点：连续且可导、非线性变换。
激活函数有很多，如sigmoid(0,1)，tanh(-1,1)，Relu(z>0则=z;z<0则=0)

3、损失函数

损失函数的作用：
(1)建立真实值和预测值之间的一种联系，L=-ylog(a)-(1-y)log(1-a)
(2)能衡量真实值和预测值之间的差距，当y等于0时可以算出L的值，也就知道了差距
(3)通过a、y之间的差距能反推权重w和b

4、梯度下降与学习率

损失函数实质是L与W之间的函数，梯度下降能不断找到使损失函数取最小值的w。
学习率控制权重w每次迭代的步长。

5、归一化

(1)x’=(x-xmin)/(xmax-xmin)
(2)x’=(x-均值)/标准差
归一化的公式有很多，目的是加快模型收敛速度，防止模型训练走很多弯路。

二、鸢尾花实战

项目描述：根据鸢尾花花萼长度与宽度的特征数据统计，对其进行逻辑回归分类
数据特征：花萼长度、花萼宽度
类别标签：0-山鸢尾、1-杂色鸢尾、2-维吉尼亚鸢尾
第一步：导入numpy，matplotlib，数据集

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris

第二步：可视化数据，分析数据

iris = load_iris()
iris.feature_names,
iris.target_names
iris.data/#能看特征数据的具体信息
iris.target/#能看每行数据的标签的值
##取100个样本，取前两列特征，花萼长度和宽度
x=iris.data[0:100,0:2]
y=iris.target[0:100]
##分别取前两类样本，0和1
samples_0 = x[y==0, :]#把y=0的样本取出来
samples_1 = x[y==1, :]
#散点图可视化
plt.scatter(samples_0[:,0],samples_0[:,1],marker='o',color='r')
plt.scatter(samples_1[:,0],samples_1[:,1],marker='x',color='b')
plt.xlabel('X')
plt.ylabel('Y')

第三步：分拆数据，80个训练数据，20个测试数据

x_train=np.vstack([x[:40,:],x[60:100,:]])#取前40和后40的数据
y_train=np.concatenate([y[:40],y[60:100]])
x_test=x[40:60,:]
y_test=y[40:60]

第四步：逻辑回归算法的实现

class Logistic_Regression():
    def __init__(self):
        self.w=None
    def sigmoid(self,z):
        a=1/(1+ np.exp(-z))
        return a
    def output(self,x):
        z=np.dot(self.w,x.T)
        a=self.sigmoid(z)
        return a
    def compute_loss(self,x,y):
        num_train=x.shape[0]
        a=self.output(x)
        loss=np.sum(-y*np.log(a)-(1-y)*np.log(1-a))/num_train
        dw=np.dot((a-y),x)/num_train
        return loss,dw
    def train(self,x,y,learning_rate=0.01,num_iterations=10000):
        num_train,num_features=x.shape
        self.w=0.001*np.random.randn(1,num_features)
        loss=[]
        for i in range(num_iterations):
            error,dw=self.compute_loss(x,y)
            loss.append(error)
            self.w-=learning_rate*dw
            if i%200==0:
                print('steps:[%d/%d],loss:%f'%(i,num_iterations,error))
        return loss
    def predict(self,x):
        a=self.output(x)
        y_pred=np.where(a>=0.5,1,0)
        return y_pred

第五步：创建lr实例，训练模型

lr=Logistic_Regression()
loss=lr.train(x_train,y_train)
plt.plot(loss)
##决策边界可视化
plt.scatter(samples_0[:,0],samples_0[:,1],marker='o',color='r')
plt.scatter(samples_1[:,0],samples_1[:,1],marker='x',color='b')
plt.xlabel('x')
plt.ylabel('y')
x1=np.arange(4,7.5,0.05)
x2=(-lr.w[0][0]*x1)/lr.w[0][1]
#sigmoid=1/(1+np.exp(-x))
#x1*w1+x2*w2=0
plt.plot(x1,x2,'-',color='black')

第六步：测试集上预测

num_test=x_test.shape[0]
prediction=lr.predict(x_test)
accuracy=np.sum(prediction==y_test)/num_test
print(r'the accuracy of prediction is :', accuracy)