Python: 利用logstic逻辑回归实现手写数字识别

比眉伴天荒 2023-02-11 12:24 9阅读 0赞

> 之前实现手写数字识别都是用的框架，就很快写好了，这次ML作业要求用原理来写，在网上看了看资料，感觉比较少。

--------------------

### 文章目录 ###

*   *   *   *  1. 逻辑回归的简单介绍
             *  2. 逻辑回归的Python实现

#### 1. 逻辑回归的简单介绍 ####

> logistic一般用于二分类，就利用sigmoid函数进行激励即可。若要想利用实现多分类，则需要多次使用逻辑回归。就好比手写数字识别，一共有十个类别，对于数字0来说，需要判断是0还是非0这个二分类，对于1也是如此，所以需要使用十次逻辑回归。

逻辑回归总的来说就是需要求得参数`w`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1ODk2MTM2_size_16_color_FFFFFF_t_70]

#### 2. 逻辑回归的Python实现 ####

import torch  # import some related modules
    import torchvision
    import scipy.optimize as op
    import matplotlib.pyplot as plt
    import numpy as np
    
    
    def sigmoid(x):  #motivation function
        return 1 / (1 + np.exp(-x))
    
    
    
    def loss(theta, x_data, y_data, lr):  # computing loss function
        m, n = x_data.shape
        theta = theta.reshape((-1, 1))
        y_data = y_data.reshape((-1, 1))
        hx = sigmoid(np.dot(x_data, theta))
        ln_h = np.log(hx)
        part1 = -np.dot(ln_h.T, y_data) / m
        ln_1h = np.log(1 - hx)
        part2 = -np.dot(ln_1h.T, 1 - y_data) / m
        # don't do that : theta[0, 0] = 0 # don't penalize theta0
        reg = lr * np.dot(theta[1:, :].T, theta[1:, :]) / (2 * m)  # add regularization
        return (part1 + part2 + reg).flatten()
    
    
    def grad(theta, x_data, y_data, lr):  # computing thhe grade
        m, n = x_data.shape
        theta_tempt = theta.reshape((-1, 1)).copy()
        y_data = y_data.reshape((-1, 1))
        hx = sigmoid(np.dot(x_data, theta_tempt))
        theta_tempt[0, 0] = 0  # don't penalize theta0
        part1 = np.dot(x_data.T, hx - y_data)
        part2 = lr * theta_tempt
        return ((part1 + part2) / m).flatten()
    
    
    def find_w(theta, x_data, y_data, l, num_labels):  # optimize the parameter
        for i in range(num_labels):  # num_labels次求解
            y_tempt = y_data.copy() 
            # pre-treat
            pos = np.where(y_data == i)
            neg = np.where(y_data != i)
            y_tempt[pos] = 1
            y_tempt[neg] = 0
    
            # for j in range(200): # iteration
            # diff = grad(theta[i,:], x_data, y_data, lr)
            # theta[i,:] = theta[i,:]-l*diff
    
            result = op.minimize(loss, theta[i, :].T, args=(x_data, y_tempt, l), method="TNC", jac=grad)
            # print("{} : {}".format(i, result.success))
            theta[i, :] = result.x  # 将更新参数进行返回
        return theta
    
    
    def one_vs_all(x_data, y_data, lr, num_labels):  # obtain the updated parameter
        # initialize some params
        m, n = x_data.shape
        x_data = np.column_stack((np.ones((m, 1)), x_data))
        # initialize initial_theta
        initial_thata = np.zeros((num_labels, n + 1))
        theta = find_w(initial_thata, x_data, y_data, lr, num_labels)
        return theta
    
    
    def pred_lr(theta, x_data):  # predict the result
        m, n = x_data.shape
        x_data = np.column_stack((np.ones((m, 1)), x_data))
        result = sigmoid(np.dot(x_data, theta.T))
        predict = np.argmax(result, 1)
        return predict
    
    
    def main():
        # load train data
        train_data = torchvision.datasets.MNIST(
            root='./mnist/',
            train=True,
            transform=torchvision.transforms.ToTensor(),  # （0,1）预处理路数据
            download=False,
        )
        data = train_data.data.reshape(train_data.data.size(0), -1)  # 每个样本拉成一行
        x_data = data[:5000, :].numpy()/255.0  # extract examples
        y_data = train_data.targets[:5000].numpy()  # 
    
        # load test data
        test_data = torchvision.datasets.MNIST(
            root='./mnist/',
            train=False,
            transform=torchvision.transforms.ToTensor(),  # （0,1）预处理路数据
            download=False,
        )
        data = test_data.data.reshape(test_data.data.size(0), -1)
        test_x = data[:2000].numpy()/255.0  # normalization
        test_y = test_data.targets[:2000].numpy()
    
        num_labels = 10
        lr = 0.03  
    
        theta = one_vs_all(x_data, y_data, lr, num_labels)  # updated parameter
    
        result = pred_lr(theta, test_x)  # predict result
        print("this number is {}".format(result))  # output
        acc = sum(result == test_y) / float(test_y.shape[0])
        print(acc)
    if __name__ == '__main__':
        main()

但写的时候有个小问题，在**find\_w**函数中，为什么被注释掉的**iteration** 的代码不能用呢，就是简单的梯度下降迭代呀，如果有大佬发现了希望能解决一下Hhh.

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