【科学计算与数学建模】logistic回归预测二分类

草堂春睡足2024-03-24 13:46

任务描述

本关任务：通过二分类，确定一个人是否年收入超过5万美元。

相关知识

为了完成本关任务，你需要掌握：1. python 语言基础； 2. 机器学习。

数据集以及任务介绍
任务

二分类任务：确定一个人是否年收入超过5万美元。

数据集

贝克尔(Barry Becker)从1994年的人口普查数据库中提取的数据。利用以下条件提取出一组相当清晰的记录: ((AGE>16) && (AGI>100) && (AFNLWGT>1) && (HRSWK>0))

数据属性信息

总共是提供了两个数据集：train.csv，test.csv。并且一共是有以下属性： age, workclass, fnlwgt, education, education num, marital-status, occupation relationship, race, sex, capital-gain, capital-loss, hours-per-week, native-country, make over 50K a year or not（income） 更多信息可以自行查看数据文件。

提供的特征属性格式

对于数据集：X_train,Y_train,X_test：

  1. 对于train.csv中离散的特征属性（例如work_class,education...）------使用onehot编码来处理
  2. 对于train.csv中连续的特征属性（例如age,capital_gain...）------则是直接用数据集中的原值
  3. 在X_train, X_test中 : 每行包含一个表示样本的106-维特性
  4. Y_train: label = 0 表示 "<= 50K" 、 label = 1表示" >50K "

注意：所谓onehot编码，例如sex属性中只有male,female两类属性值，使用onehot编码则是，对于任意一行数据表示一个人的信息，那么如果这个人的sex信息为male，则编码为[1,0]。

提交的数据格式

请预测test.csv中16281资料。

结果输出到csv文件中：

第一行必须为id,label，从第二行开始为预测结果

每行分别为id以及预测的label，请以逗号分隔

如下图的展示格式。

实现方法---Logistic Regression
加载数据

首先通过numpy加载数据集： 给出加载训练集示例：

复制代码
  1. mport numpy as np
  2. X_train_fpath = 'data/X_train'
  3. X_train = np.genfromtxt(X_train_fpath,delimiter = ',',skip_header = 1)
数据标准化

这里给出两种标准化的选择，给出了第一种实现范例，请使用第二种正态分布的规格化。并且可以自行选择对哪些列进行规格化，例如[0,1,3,4,5,7,10,12,25,26,27,28]。

  1. 将所有输入数据规范化为0和1，必须指定训练或测试。 在现实世界中，我们不知道测试数据是什么样的。我们只能用输入数据分布对测试数据进行归一化。因此，在测试时，请输入相应的归一化超参数。 如下：
    zi=max(x)−min(x)xi−min(x)

即代码示例：

复制代码
  1. def _normalize_column(X, train=True, specified_column=None, X_min=None, X_max=None):
  2. # 归一化，将指定列的数据每一列进行归一化
  3. if train:
  4. if specified_column == None:
  5. # 如果没有指定列，则对全部列进行归一化处理
  6. specified_column = np.arange(X.shape[1])
  7. length = len(specified_column)
  8. X_max = np.reshape(np.max(X[:, specified_column], 0), (1, length))
  9. X_min = np.reshape(np.min(X[:, specified_column], 0), (1, length))
  10. X[:, specified_column] = np.divide(
  11. np.subtract(X[:, specified_column], X_min),np.subtract(X_max,X_min))
  12. return X, X_max, X_min
  1. 将指定列规格化为正态分布。你可以尝试不同类型的规范化，以使模型更容易地了解数据分布。 对于正态分布，可以通过下面方法来进行标准化：

Z=σX−μ​

代码示例：
X[:,specified_column] = np.divide(np.subtract(X[:,specified_column],X_mean), X_std)

逻辑回归模型

从算法描述，我们实现:

  • _sigmoid: 来计算输入的sigmoid. 使用np.clip来避免溢出，将数据夹在[ 1e-6 ,1-1e-6]之间。
    示例：np.clip(1 / (1.0 + np.exp(-z)), 1e-6, 1-1e-6)
  • get_prob: 在给定权重和偏差的情况下，找出模型预测输出1的概率
    示例：_sigmoid(np.add(np.matmul(X, w), b))
  • infer: 如果概率>为0.5，则输出1，否则输出0。
    示例： np.round(get_prob(X, w, b))
  • _crossentropy: 计算模型输出和真实标签之间的交叉熵。
    L(f)=∑nC(f(xn),yn)
  • _computeLoss : 计算输入为X, Y, w的损失函数L(w)
    可以适当加上正则化：
    示例：_cross_entropy(y_pred, Y_label) + lamda * np.sum(np.square(w))
  • gradient : 通过数学推导损失函数，各个参数的梯度为:
    各个权重w的梯度和如下：
    ∑n​−(yn−fw,b(xn))xin​
    即：参数w梯度求平均，如下：
    `w_grad = -np.mean(np.multiply(pred_error.T, X.T), 1)`

若是考虑正则化,那么： w_grad = -np.mean(np.multiply(pred_error.T, X.T), 1)+lamda*w

各个偏置b的参数如下：
∑n​−(yn−fw,b​(xn))

即，参数b梯度求平均，如下：
b_grad = -np.mean(pred_error)

验证集的使用（Validation set）

当数据量不足时，使用交叉验证，可以一定上提高训练效果。

示例数据分割成两部分一部分训练集，一部分验证集：分割值具体自己设置。

复制代码
  1. def train_dev_split(X, y, dev_size=0.25):
  2. # 按照dev_size比例分割数据，用于交叉验证
  3. train_len = int(round(len(X) * (1-dev_size)))
  4. return X[0:train_len], y[0:train_len], X[train_len:], y[train_len:]

打乱顺序的函数：

复制代码
  1. def _shuffle(X, y):
  2. # 打乱数据顺序
  3. randomize = np.arange(len(X))
  4. np.random.shuffle(randomize)
  5. return X[randomize], y[randomize]
训练过程

在这里设置：（也可以自己设置，查看效果）

复制代码
  1. max_iter = 40 # 最大迭代次数
  2. batch_size = 32 # 每一次迭代训练的数据量
  3. learning_rate = 0.01 # 学习率
复制代码
  1. for epoch in range(max_iter):
  2. X_train, y_train = _shuffle(X_train, y_train)
  3. step = 1 # 更新学习率
  4. # 逻辑回归
  5. for i in range(int(np.floor(len(y_train) / batch_size))):
  6. X = X_train[i*batch_size:(i+1)*batch_size]
  7. y = y_train[i*batch_size:(i+1)*batch_size]
  8. # 计算梯度
  9. w_grad, b_grad = gradient_regularization(X, y, w, b, lamda)
  10. # 更新w、b
  11. w = w - learning_rate / np.square(step) * w_grad
  12. b = b - learning_rate / np.square(step) * b_grad
  13. step = step + 1

并且在每个epoch训练中记录下训练误差 以及验证集中的误差用于画图数据:(示例训练集误差)

复制代码
  1. # 计算训练集的误差和准确率
  2. y_train_pre = get_prob(X_train, w, b)
  3. acc_train.append(accuracy(np.round(y_train_pre), y_train))
  4. loss_train.append(compute_loss(
  5. y_train, y_train_pre, lamda, w) / num_train)

准确度函数如下：

复制代码
  1. def accuracy(y_pre, y):
  2. acc = np.sum(y_pre == y) / len(y_pre)
  3. return acc
画图函数

导入画图函数包：

复制代码
  1. import matplotlib.pyplot as plt
  2. %matplotlib inline

画出训练集以及验证集中loss 以及 准确率 的对比图形：

测试数据的使用预测二分类

通过读入测试集数据X_test数据，利用训练好的模型，来完成年薪的预测，并且将结果输入到output.csv文件中。

复制代码
  1. X_test_fpath='data/X_test'
  2. output_fpath='output.csv'
复制代码
  1. result=infer(X_test,v,b)
  2. with open(output_fpath,'v') as f:
  3. f.write("id,label\n")
  4. for i,v in enumerate(result):
  5. f.write("%d,%d\n"%(i+1,v))

以下方法可以查看各个特征项对预测结果的贡献度如下:

复制代码
  1. # 输出贡献最大的10个特征
  2. ind = np.argsort(np.abs(w))[::-1]
  3. with open(X_test_fpath) as f:
  4. content=f.readline().rstrip("\n")
  5. features=np.array([x for x in content.split(',')])
  6. for i in ind[0:10]:
  7. print(features[i], w[i])

编程要求

根据提示，在右侧编辑器 / Begin / 到 / End / 处补充代码。

测试说明

数据集在：/data/workspace/myshixun/step1/train.csv;/data/workspace/myshixun/step1/test.csv

完成加载数据和网络的编写，结果具有随机性，图片展示结果也会具有一定的差异性，本关是通过检查保存文件验证是否通关。

平台会对你编写的代码进行测试：

预期输出：

复制代码
  1. id, label
  2. 1 , 0.0
  3. 2 , 0.0
  4. 3 , 0.0
  5. 4 , 0.0
  6. 5 , 0.0
  7. 6 , 0.0
  8. 7 , 0.0
  9. 8 , 1.0
  10. 9 , 0.0
  11. 10 , 0.0
  12. 16282
  13. id,label

开始你的任务吧，祝你成功！

代码部分

python 复制代码 
import csv
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


def dataProcess_X(data):
    # income和sex列的值可以直接使用1位二进制码表示，不需要进行one-hot编码
    if "income" in data.columns:
        Data = data.drop(["income", "sex"], axis=1)
    else:
        Data = data.drop(["sex"], axis=1)

    # 离散属性列
    listObjectData = [
        col for col in Data.columns if Data[col].dtypes == "object"]
    # 连续属性列
    listNonObjectData = [
        col for col in Data.columns if col not in listObjectData]

    ObjectData = Data[listObjectData]
    NonObjectData = Data[listNonObjectData]

    # 插入sex列，0代表male，1代表female
    NonObjectData.insert(0, "sex", (data["sex"] == " Female").astype(np.int))
    ObjectData = pd.get_dummies(ObjectData)  # one-hot编码

    Data = pd.concat([NonObjectData, ObjectData], axis=1)  # 合并离散属性和连续属性
    Data = Data.astype("int64")

    Data = (Data - Data.mean()) / Data.std()  # 标准化
    return Data


def dataProcess_Y(data):
    # income属性，0代表小于等于50K，1代表大于50K
    return (data["income"] == " >50K").astype(np.int)


def normalize_column(X, train=True, specified_column=None, X_mean=True, X_std=True):
    # 归一化，将指定列的数据归一到0附近，且符合正态分布
    if train:
        if specified_column == None:
            # 如果没有指定列，则对全部列进行归一化处理
            specified_column = np.arange(X.shape[1])
        length = len(specified_column)
        X_mean = np.reshape(np.mean(X[:, specified_column], 0), (1, length))
        X_std = np.reshape(np.std(X[:, specified_column], 0), (1, length))

        X[:, specified_column] = np.divide(
            np.subtract(X[:, specified_column], X_mean), X_std)

    return X, X_mean, X_std


def _sigmoid(z):
    return np.clip(1 / (1.0 + np.exp(-z)), 1e-6, 1-1e-6)


def get_prob(X, w, b):
    return _sigmoid(np.add(np.matmul(X, w), b))


def infer(X, w, b):
    return np.round(get_prob(X, w, b))


def gradient(X, y, w, b):
    # 梯度计算
    y_pre = get_prob(X, w, b)
    pre_error = y - y_pre
    w_grad = -np.sum(np.multiply(pre_error, X.T), 1)
    b_grad = -np.sum(pre_error)
    return w_grad, b_grad


def gradient_regularization(X, y, w, b, lamda):
    # 进行正则化的梯度计算
    y_pre = get_prob(X, w, b)
    pre_error = y - y_pre
    w_grad = -np.sum(np.multiply(pre_error, X.T), 1) + lamda * w
    b_grad = -np.sum(pre_error)
    return w_grad, b_grad


def _cross_entropy(y, y_pre):
    cross_entropy = -np.dot(y, np.log(y_pre)) - \
        np.dot((1 - y), np.log(1 - y_pre))
    return cross_entropy


def compute_loss(y, y_pre, lamda, w):
    return _cross_entropy(y, y_pre) + lamda * np.sum(np.square(w))


def train_dev_split(X, y, dev_size=0.25):
    # 按照dev_size比例分割数据，用于交叉验证
    train_len = int(round(len(X) * (1-dev_size)))
    return X[0:train_len], y[0:train_len], X[train_len:], y[train_len:]


def _shuffle(X, y):
    # 打乱数据顺序
    randomize = np.arange(len(X))
    np.random.shuffle(randomize)
    return X[randomize], y[randomize]


def accuracy(y_pre, y):
    acc = np.sum(y_pre == y) / len(y_pre)
    return acc


# --------------- Begin --------------- #
# 加载训练数据集
# train_data = 
train_data = pd.read_csv("/data/workspace/myshixun/step1/train.csv")
test_data = pd.read_csv("/data/workspace/myshixun/step1/test.csv")
X_train_fpath = '/data/workspace/myshixun/step1/train.csv'
X_train = np.genfromtxt(X_train_fpath,delimiter = ',',skip_header = 1)
# --------------- End --------------- #

# 训练数据将107维降为106维，以适应测试数据
X_train = dataProcess_X(train_data).drop(
    ['native_country_ Holand-Netherlands'], axis=1).values
y_train = dataProcess_Y(train_data).values

col = [0, 1, 3, 4, 5, 7, 10, 12, 25, 26, 27, 28]
X_train, X_mean, X_std = normalize_column(X_train, specified_column=col)

# 分割数据为训练集和验证集
X_train, y_train, X_dev, y_dev = train_dev_split(X_train, y_train)
num_train = len(y_train)  # 训练集大小
num_dev = len(y_dev)  # 验证集大小

max_iter = 40  # 最大迭代次数
batch_size = 32  # 每一次迭代训练的数据量
learning_rate = 0.01  # 学习率

loss_train = []  # 训练误差
loss_validation = []  # 验证误差
acc_train = []  # 训练准确率
acc_validation = []  # 验证准确率

w = np.zeros((X_train.shape[1],))
b = np.zeros((1,))

# 正则化
regularize = True
if regularize:
    lamda = 0.01
else:
    lamda = 0

# --------------- Begin --------------- #
# 完善二分类模型
for epoch in range(max_iter):
    X_train, y_train = _shuffle(X_train, y_train)

    step = 1  # 更新学习率
    # 逻辑回归
    for i in range(int(np.floor(len(y_train) / batch_size))):
        X = X_train[i*batch_size:(i+1)*batch_size]
        y = y_train[i*batch_size:(i+1)*batch_size]

        # 计算梯度
        w_grad, b_grad = gradient_regularization(X, y, w, b, lamda)

        # 更新w、b
        w = w - learning_rate / np.square(step) * w_grad
        b = b - learning_rate / np.square(step) * b_grad

        step = step + 1

    # 计算训练集的误差和准确率
    y_train_pre = get_prob(X_train, w, b)
    acc_train.append(accuracy(np.round(y_train_pre), y_train))
    loss_train.append(compute_loss(
        y_train, y_train_pre, lamda, w) / num_train)

    # 计算验证集的误差和准确率
    y_dev_pre = get_prob(X_dev, w, b)
    acc_validation.append(accuracy(np.round(y_dev_pre), y_dev))
    loss_validation.append(compute_loss(
        y_dev, y_dev_pre, lamda, w) / num_dev)
# --------------- End --------------- #

test_data = pd.read_csv("/data/workspace/myshixun/step1/test.csv")
X_test = dataProcess_X(test_data)
features = X_test.columns.values
X_test = X_test.values

X_test, _, _ = normalize_column(
    X_test, train=False, specified_column=col, X_mean=X_mean, X_std=X_std)

result = infer(X_test, w, b)

# 输出贡献最大的10个特征
ind = np.argsort(np.abs(w))[::-1]
for i in ind[0:10]:
    print(features[i], w[i])

with open("/data/workspace/myshixun/step1/predict_test.csv", "w+") as csvfile:
    csvfile.write("id,label\n")
    print("id, label")
    for i, label in enumerate(result):
        csvfile.write("%d,%d\n" % (i+1, label))
        if i < 10:
            print(i+1, ", ", label)

plt.plot(loss_train)
plt.plot(loss_validation)
plt.legend(['train', 'validation'])
plt.savefig('/data/workspace/myshixun/step1/img1/test.jpg')

plt.plot(acc_train)
plt.plot(acc_validation)
plt.legend(['train', 'validation'])
plt.savefig('/data/workspace/myshixun/step1/img1/test2.jpg')
相关推荐
我感觉。2 天前
【机器学习chp6】对数几率回归
算法·机器学习·逻辑回归·分类模型·对数几率回归
孤单网愈云4 天前
11.19机器学习_逻辑回归
人工智能·机器学习·逻辑回归
cuisidong19974 天前
逻辑回归LR(Logistic Regression)原理以及代码实践
算法·机器学习·逻辑回归
乘风而来的思绪4 天前
【西瓜书】对数几率回归（逻辑回归）的概念与表示
机器学习·分类·逻辑回归
Seeklike4 天前
11.19 机器学习-岭回归+拉索回归+逻辑回归
机器学习·回归·逻辑回归
谢眠4 天前
机器学习day7-线性回归3、逻辑回归、聚类、SVC
机器学习·逻辑回归·线性回归
蒙娜丽宁6 天前
【人工智能】从零开始用Python实现逻辑回归模型：深入理解逻辑回归的原理与应用
人工智能·python·逻辑回归
醉昭酒6 天前
【第4章 | 分类与逻辑回归】(python机器学习）
机器学习·分类·逻辑回归
爱学习的uu6 天前
机器学习实战笔记30-31：逻辑回归及对应调参实验代码
人工智能·笔记·算法·机器学习·逻辑回归
小馒头学python10 天前
【机器学习】突破分类瓶颈：用逻辑回归与Softmax回归解锁多分类世界
人工智能·python·算法·机器学习·分类·回归·逻辑回归
热门推荐
01ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07IT专业入门，高考假期预习指南08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10Docker 夺命连环 15 问