机器学习日记-Logistic回归二分类python实现Demo

﹏ヽ暗。殇╰゛Y 2023-06-30 02:46 1阅读 0赞

# -*- coding: utf-8 -*-
    
    import numpy as np
    
    '''
    模型
    '''
    class LogisticRegression(object):
        #初始化 学习率0.1   迭代次数100
        def __init__(self, learning_rate=0.1, max_iter=100, seed=None):
            self.seed = seed
            self.lr = learning_rate
            self.max_iter = max_iter
    
        def fit(self, x, y):
            np.random.seed(self.seed)
            #矩阵w高斯初始化
            self.w = np.random.normal(loc=0.0, scale=1.0, size=x.shape[1])
            #bias
            self.b = np.random.normal(loc=0.0, scale=1.0)
            self.x = x
            self.y = y
            for i in range(self.max_iter):
                self._update_step()
                # print('loss: \t{}'.format(self.loss()))
                # print('score: \t{}'.format(self.score()))
                # print('w: \t{}'.format(self.w))
                # print('b: \t{}'.format(self.b))
    
        def _sigmoid(self, z):
            return 1.0 / (1.0 + np.exp(-z))
        
        def _f(self, x, w, b):#线性回归函数 z=wX+b
            z = x.dot(w) + b
            return self._sigmoid(z)
    
        def predict_proba(self, x=None):#预测概率
            if x is None:
                x = self.x
            y_pred = self._f(x, self.w, self.b)
            return y_pred
    
        def predict(self, x=None):#预测值
            if x is None:
                x = self.x
            y_pred_proba = self._f(x, self.w, self.b)#概率值
            #y_pred 预测值
            y_pred = np.array([0 if y_pred_proba[i] < 0.5 else 1 for i in range(len(y_pred_proba))])
            return y_pred
    
        def score(self, y_true=None, y_pred=None):#真值和预测值比较  
            if y_true is None or y_pred is None:
                y_true = self.y
                y_pred = self.predict()
            acc = np.mean([1 if y_true[i] == y_pred[i] else 0 for i in range(len(y_true))])
            return acc #准确率 精度
    
        def loss(self, y_true=None, y_pred_proba=None):
            if y_true is None or y_pred_proba is None:
                y_true = self.y
                y_pred_proba = self.predict_proba()
            #代入损失函数公式
            return np.mean(-1.0 * (y_true * np.log(y_pred_proba) + (1.0 - y_true) * np.log(1.0 - y_pred_proba)))
    
        def _calc_gradient(self):#梯度计算
            y_pred = self.predict()
            d_w = (y_pred - self.y).dot(self.x) / len(self.y)
            d_b = np.mean(y_pred - self.y)
            return d_w, d_b
    
        def _update_step(self):#更新w b
            d_w, d_b = self._calc_gradient()
            self.w = self.w - self.lr * d_w
            self.b = self.b - self.lr * d_b
            return self.w, self.b

# -*- coding: utf-8 -*-
    
    import numpy as np
    
    '''
    数据准备
    '''
    def generate_data(seed):
        np.random.seed(seed)
        #定义2簇样本
        data_size_1 = 300
        x1_1 = np.random.normal(loc=5.0, scale=1.0, size=data_size_1)
        x2_1 = np.random.normal(loc=4.0, scale=1.0, size=data_size_1)
        y_1 = [0 for _ in range(data_size_1)]#label 0
        data_size_2 = 400
        x1_2 = np.random.normal(loc=10.0, scale=2.0, size=data_size_2)
        x2_2 = np.random.normal(loc=8.0, scale=2.0, size=data_size_2)
        y_2 = [1 for _ in range(data_size_2)]#label 1
        #合并2类样本
        x1 = np.concatenate((x1_1, x1_2), axis=0)
        x2 = np.concatenate((x2_1, x2_2), axis=0)
        x = np.hstack((x1.reshape(-1,1), x2.reshape(-1,1)))
        y = np.concatenate((y_1, y_2), axis=0)
        #总样本数
        data_size_all = data_size_1+data_size_2
        #数据打乱
        shuffled_index = np.random.permutation(data_size_all)
        x = x[shuffled_index]
        y = y[shuffled_index]
        return x, y
    def train_test_split(x, y):
        split_index = int(len(y)*0.7)
        #样本的0.7做训练
        x_train = x[:split_index]
        y_train = y[:split_index]
        #0.3做测试
        x_test = x[split_index:]
        y_test = y[split_index:]
        return x_train, y_train, x_test, y_test

# -*- coding: utf-8 -*-
    
    import numpy as np
    
    import matplotlib.pyplot as plt
    
    '''
    训练
    '''
    
    #import data_helper
    
    #from logistic_regression import *
    
    # data generation
    
    x, y = generate_data(seed=272)
    x_train, y_train, x_test, y_test = train_test_split(x, y)
    
    # visualize data
    # plt.scatter(x_train[:,0], x_train[:,1], c=y_train, marker='.')
    # plt.show()
    # plt.scatter(x_test[:,0], x_test[:,1], c=y_test, marker='.')
    # plt.show()
    
    # data normalization 归一化 （正则化）
    x_train = (x_train - np.min(x_train, axis=0)) / (np.max(x_train, axis=0) - np.min(x_train, axis=0))
    x_test = (x_test - np.min(x_test, axis=0)) / (np.max(x_test, axis=0) - np.min(x_test, axis=0))
    
    # Logistic regression classifier   给模型填数据
    clf = LogisticRegression(learning_rate=0.1, max_iter=500, seed=272)
    clf.fit(x_train, y_train)
    '''
    画图
    '''
    # plot the result
    split_boundary_func = lambda x: (-clf.b - clf.w[0] * x) / clf.w[1]#分割线
    xx = np.arange(0.1, 0.6, 0.1)#坐标轴
    cValue = ['g','b'] #点的颜色
    plt.scatter(x_train[:,0], x_train[:,1], c=[cValue[i] for i in y_train], marker='o')
    plt.plot(xx, split_boundary_func(xx), c='red')
    plt.show()
    '''
    预测结果
    '''
    # loss on test set
    y_test_pred = clf.predict(x_test)
    y_test_pred_proba = clf.predict_proba(x_test)
    print(clf.score(y_test, y_test_pred))
    print(clf.loss(y_test, y_test_pred_proba))
    # print(y_test_pred_proba)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neXVuZmVpeHl6_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neXVuZmVpeHl6_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020011417292830.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neXVuZmVpeHl6,size_16,color_FFFFFF,t_70