李宏毅机器学习作业2-使用逻辑回归对人员按收入分类

说明

本代码实现尚有很大不足，最终分类的正确率仅能达到78.25%，且迭代次数过多（100次） 或 不对数据进行任何处理 或 将所有特征均用minmax的方法归一化 的情况下，都会导致测试集的所有分类均为0，原因尚不明，恳请读者指正。
另外，本代码未划分验证集，等有新思路再一并修改。

代码

# -*- coding:utf-8 -*-
import numpy as np
import pandas as pd


def data_processing():
    dfx = pd.read_csv('X_train.csv')
    dfy = pd.read_csv('Y_train.csv')
    x_data = np.array(dfx, dtype='float')
    x_data[:, 1] /= np.mean(x_data[:, 1])

    y_data = np.array(dfy)
    return x_data, y_data


def sigmoid(x, bias, weight):
    return 1.0/(1.0+np.exp(-bias-x.dot(weight.T)))


def gradient_descent(x_data, y_data):
    epoch = 10
    lr = 1
    bias = 0.0
    weight = np.zeros(len(x_data[0]))
    sum_b, sum_w = 0.0, 0.0

    for i in range(epoch):
        grad_b = 0.0
        grad_w = np.zeros(len(x_data[0]))
        for j in range(len(x_data)):
            grad_b += (y_data[j]-sigmoid(x_data[j], bias, weight))*(-1)
            grad_w += (y_data[j]-sigmoid(x_data[j], bias, weight))*(-x_data[j])
        # 取平均，防止计算溢出
        grad_w /= len(x_data)
        grad_b /= len(x_data)
        # adagraad
        sum_b += grad_b**2
        sum_w += grad_w.dot(grad_w.T)
        bias -= lr/np.sqrt(sum_b) * grad_b
        weight -= lr/np.sqrt(sum_w) * grad_w
    return bias, weight


def test_model(bias, weight):
    df = pd.read_csv('X_test.csv')
    # df = pd.read_csv('X_train.csv')
    res = []
    x_test = np.array(df)
    for i in range(len(x_test)):
        if sigmoid(x_test[i], bias, weight) >= 0.5:
            res.append(1)
        else:
            res.append(0)
    return res


def count_precision(res):
    df = pd.read_csv('correct_answer.csv', usecols=[1])
    # df = pd.read_csv('Y_train.csv')
    temp = np.array(df)
    sum = 0.0
    for i in range(len(temp)):
        sum += np.abs(res[i]-temp[i])
    print('total loss: ', float(sum/len(temp)))
    print('model precision: ', float(1-sum/len(temp)))


if __name__ == '__main__':
    x_data, y_data = data_processing()
    bias, weight = gradient_descent(x_data, y_data)
    res = test_model(bias, weight)
    count_precision(res)

另外，附上逻辑回归实现与运算/或运算的代码

# -*- coding:utf-8 -*-
import numpy as np


def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-z))


if __name__ == '__main__':
    x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
    # 单层神经网络实现逻辑或运算
    y = np.array([[0], [1], [1], [1]])
    # 如果实现的是与运算，将上面改为 y = np.array([[0], [0], [0], [1]])

    epochs = 1000
    learning_rate = 1.0
    w = np.ones(2)
    b = 0.0
    sum_w, sum_b = 0.0, 0.0
    for i in range(epochs):
        w_grad = np.zeros(2)
        b_grad = 0.0
        for j in range(len(x)):
            w_grad += (y[j] - sigmoid(w.dot(x[j])+b)) * (-x[j])
            b_grad += (y[j] - sigmoid(w.dot(x[j])+b)) * (-1)
        w_grad /= len(x)
        b_grad /= len(x)
        # adagrad
        sum_w += w_grad**2
        sum_b += b_grad**2
        w -= learning_rate/np.sqrt(sum_w) * w_grad
        b -= learning_rate/np.sqrt(sum_b) * b_grad

    # test
    res = []
    for i in range(len(x)):
        t = sigmoid(w.dot(x[i])+b)
        flag = 1
        if t < 0.5:
            flag = 0
            t = 1 - t
        print('input:', x[i], ' output:', flag, 'probability:%.6f'% float(t))

结果：