2022年11月27日 Logistic Regression

​ 学逻辑回归的时候，发现逻辑回归虽然是分类问题，但是和回归问题的几种算法还是非常的相似的。他们的常规步骤都是寻找回归函数，然后构造损失函数，求损失函数最小来得到回归参数。如果出现过拟合，则可以利用前面学的正则化方法来消除。

​ sklearn库里面有很多常用机器学习回归和分类函数。使用方式是先调用函数模型，然后利用fit拟合，最后用predict预测。我们学习机器学习过程中，就是先学算法思路，然后利用高级语言把思路实现，封装成这几个方法，如果能够自己封装出来，从头到尾实现，才说明自己各个方面理解的比较深刻。

​ 逻辑函数利用sigmod函数来作为回归函数，因为他可以将连续的量映射成0-1内的数，然后可以通过人为假定的阈值加以分类。
这一部分CSDN资料特别多，多看几篇代码思路推导就能理解了，具体细节方面理解涉及到数学的功底

---

Sklearn demo

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer # 乳腺癌数据集
from sklearn.model_selection import train_test_split
if __name__ == '__main__':
    data=load_breast_cancer() #加载数据集
    X =data['data'] #数据
    Y = data['target'] #标签
    X_train,X_test,Y_train,Y_test = train_test_split(X,Y,test_size=0.3,random_state=1) #划分测试集和训练集
    l1 = LogisticRegression(penalty="l1",C=0.5,solver="liblinear") #配置逻辑回归，penalty为正则化，solver为求解w的方法
    l1.fit(X_train,Y_train)
    score =  l1.score(X_test,Y_test)
    print(score)

完整的domo过程，但是我还不知道如何预测，python的语法基础不够扎实。

import numpy as np
import pandas as pd

data = pd.read_csv('Dry_Bean_Dataset.csv')
df = pd.DataFrame(data)
label = []
for i in df['Class'][0:3349]:
    if i == 'SEKER':
        label.append(0)
    else:
        label.append(1)
x1 = df['MajorAxisLength'][0:3349]
x2 = df['MinorAxisLength'][0:3349]
train_data = list(zip(x1, x2, label)) # zip 打包为元组的列表


class Logistic_Regression:
    def __init__(self, traindata, alpha=0.001, circle=100, batchlength=40):
        self.traindata = traindata  # 训练数据集
        self.alpha = alpha  # 学习率
        self.circle = circle  # 学习次数
        self.batchlength = batchlength  # 把3349个数据分成多个部分，每个部分有batchlength个数据
        self.w = np.random.normal(size=(3, 1))  # 随机初始化参数w

    def data_process(self):
        '''做随机梯度下降，打乱数据顺序，并把所有数据分成若干个batch'''
        np.random.shuffle(self.traindata)
        data = [self.traindata[i:i + self.batchlength]
                for i in range(0, len(self.traindata), self.batchlength)]
        return data

    def train1(self):
        '''根据损失函数（1）来进行梯度下降，这里采用随机梯度下降'''
        for i in range(self.circle):
            batches = self.data_process()
            print('the {} epoch'.format(i))  # 程序运行时显示执行次数
            for batch in batches:
                d_w = np.zeros(shape=(3, 1))  # 用来累计w导数值
                for j in batch:  # 取batch中每一组数据
                    x0 = np.r_[j[0:2], 1]  # 把数据中指标取出，后面补1
                    x = np.mat(x0).T  # 转化成列向量
                    y = j[2]  # 标签
                    dw = (self.sigmoid(self.w.T * x) - y)[0, 0] * x
                    d_w += dw
                self.w -= self.alpha * d_w / self.batchlength

    def train2(self):
        '''用均方损失函数来进行梯度下降求解'''
        for i in range(self.circle):
            batches = self.data_process()
            print('the {} epoch'.format(i))  # 程序运行时显示执行次数
            for batch in batches:
                d_w = np.zeros(shape=(3, 1))  # 用来累计w导数值
                for j in batch:  # 取batch中每一组数据
                    x0 = np.r_[j[0:2], 1]  # 把数据中指标取出，后面补1
                    x = np.mat(x0).T  # 转化成列向量
                    y = j[2]  # 标签
                    dw = \
                    ((self.sigmoid(self.w.T * x) - y) * self.sigmoid(self.w.T * x) * (1 - self.sigmoid(self.w.T * x)))[
                        0, 0] * x
                    d_w += dw
                self.w -= self.alpha * d_w / self.batchlength

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def predict(self, x):
        '''测试新数据属于哪一类，x是2维列向量'''
        s = self.sigmoid(self.w.T * x)
        if s >= 0.5:
            return 1
        elif s < 0.5:
            return 0



regr = Logistic_Regression(traindata=train_data)
regr.train1()  # 采用1的方式进行训练

[demo](