基于 Logistic Regression 逻辑斯蒂回归对鸢尾花分类

    1. import numpy as np
    2. import pandas as pd
    1. data = pd.read_csv(r"dataset/iris.arff.csv", header=0)
    2. # data.drop(["Id"], axis=1, inplace=True)
    3. data.drop_duplicates(inplace=True)
    4. # data["class"].drop_duplicates()
    5. # Iris-setosa Iris-versicolor Iris-virginica
    6. # 名称映射为数字
    7. data["class"] = data["class"].map({"Iris-setosa":0, "Iris-versicolor":1, "Iris-virginica":2})
    8. # 筛选数据，只选择0和1
    9. data = data[data["class"]!=2]
    1. class LogisticRegression:
    2.     '''逻辑回归算法实现'''
    3.     def __init__(self, learning_rate, times):
    4.         '''初始化
    6.         parameters
    7.         -----
    8.         learning_rate: float
    9.         times: int
    10.         '''
    11.         self.learning_rate = learning_rate
    12.         self.times = times
    13.     def sigmoid(self, z):
    14.         ''' sigmoid实现
    16.         parameters:
    17.         -----
    18.         z: float  自变量： z=w.T*x
    20.         Returns
    21.         -----
    22.         p: float, 属于[0,1]区间。s>=0.5(z>0)时，类别为1，否则为
    23.         '''
    24.         return 1.0 / ( 1.0 + np.exp(-z) )
    25.     def fit(self, X, y):
    26.         '''训练
    27.         Parameters:
    28.         X: 特征矩阵，可以是List也可以是Ndarray，形状为： [样本数量,特征数量]
    29.         y: 标签数组
    30.         '''
    31.         X = np.asarray(X)
    32.         y = np.asarray(y)
    33.         # 创建权重向量，初始化为0.多出来的1是截距
    34.         self.w_ = np.zeros(1 + X.shape[1]) # shape[0]为样本数量，shape[1]为特征数量
    35.         # 创建损失列表，保存每次迭代后的损失值
    36.         self.loss_ = []
    37.         for i in range(self.times):
    38.             z = np.dot(X, self.w_[1:]) + self.w_[0]
    39.             # 计算概率值(判定为1的概率值)
    40.             p = self.sigmoid(z)
    41.             # 根据逻辑回归的代价函数（目标函数或叫损失函数）计算损失值
    42.             # 逻辑回归的代价函数（目标函数或叫损失函数）：
    43.             # J(W) = - sum(yi * log(s(zi))+(1-yi)log(1-s(zi)))  
    44.             cost = - np.sum(y * np.log(p) + (1 - y) * np.log(1 - p))
    45.             self.loss_.append(cost)
    46.             # *****************************************************
    47.             # *******************重点：权重更新********************
    48.             # *****************************************************
    49.             # 调整权重值，根据公式 权重(j列) = 权重(j列) + 学习率 * sum( y - s(z)) * x(j列)
    50.             self.w_[0] += self.learning_rate * np.sum(y - p) * 1
    51.             self.w_[1:] += self.learning_rate * np.dot(X.T, y - p)
    52.     def predict_proba(self, X):
    53.         '''根据参数传递的样本，对样本数据进行预测属于某一个类别的概率
    55.         Parameters
    56.         -----
    57.         X: 类数组类型 [ 样本数量, 特征数量]
    59.         Return
    60.         -----
    61.         result：预测（概率值）
    62.         '''
    63.         X = np.asarray(X)
    64.         z = np.dot(X, self.w_[1:]) + self.w_[0]
    65.         p = self.sigmoid(z)
    66.         # 将预测结果转换为二位数组，方便后续拼接
    67.         p = p.reshape(-1,1)
    68.         # 将两个数组拼接，方向是横向拼接
    69.         return np.concatenate([1-p, p], axis=1) #横向拼接为为1
    70.     def predict(self, X):
    71.         '''根据参数预测样本属于哪个类别
    73.         Parameters
    74.         -----
    75.         X: 类数组类型： [样本数量，特征数量]. 带预测样本特征
    77.         Return
    78.         -----
    79.         返回属于哪个类别
    80.         '''
    81.         return np.argmax(self.predict_proba(X), axis=1)
    1. t1 = data[data["class"]==0]
    2. t2 = data[data["class"]==1]
    3. t1 = t1.sample(len(t1), random_state=0)
    4. t2 = t2.sample(len(t2), random_state=0)
    5. train_X = pd.concat([t1.iloc[:40,:-1], t2.iloc[:40,:-1]], axis=0)
    6. train_y = pd.concat([t1.iloc[:40,-1], t2.iloc[:40,-1]], axis=0)
    7. test_X = pd.concat([t1.iloc[40:,:-1], t2.iloc[40:,:-1]], axis=0)
    8. test_y = pd.concat([t1.iloc[40:,-1], t2.iloc[40:,-1]], axis=0)
    10. # 鸢尾花的特征列都在同一个数量级，我们可以不用标准化处理
    11. lr = LogisticRegression(learning_rate=0.01, times=20)
    12. lr.fit(train_X, train_y)
    13. # lr.predict_proba(test_X)
    14. result = lr.predict(test_X)
    15. # 计算准确性
    16. accuracy = np.sum(result==test_y) / len(test_y)
    17. display(accuracy)

    1.0

    1. import matplotlib as mpl
    2. import matplotlib.pyplot as plt
    3. mpl.rcParams['font.family'] = 'SimHei'
    4. mpl.rcParams['axes.unicode_minus'] = False
    1. # 绘制预测值
    2. plt.plot(result, 'ro',ms=15, label="预测值") # ms指定圆圈大小
    3. plt.plot(test_y.values, 'go', label="预测值") # pandas读取时serise类型，我们需要转为ndarray
    4. plt.title('逻辑回归预测')
    5. plt.xlabel('样本序号')
    6. plt.ylabel('预测值')
    7. plt.show()

    image.png

    1. # 绘制目标函数的损失值
    2. plt.plot(range(1,lr.times+1), lr.loss_, 'go-')
    3. plt.xlabel('迭代次数')
    4. plt.ylabel('损失值loss')

    Text(0, 0.5, ‘损失值loss’)

    image.png