任务描述
本关任务：通过二分类，确定一个人是否年收入超过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：
- 对于train.csv中离散的特征属性（例如work_class,education...）------使用onehot编码来处理
- 对于train.csv中连续的特征属性（例如age,capital_gain...）------则是直接用数据集中的原值
- 在X_train, X_test中 : 每行包含一个表示样本的106-维特性
- 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加载数据集： 给出加载训练集示例：
mport numpy as npX_train_fpath = 'data/X_train'X_train = np.genfromtxt(X_train_fpath,delimiter = ',',skip_header = 1)
数据标准化
这里给出两种标准化的选择，给出了第一种实现范例，请使用第二种正态分布的规格化。并且可以自行选择对哪些列进行规格化，例如[0,1,3,4,5,7,10,12,25,26,27,28]。
- 将所有输入数据规范化为0和1，必须指定训练或测试。 在现实世界中，我们不知道测试数据是什么样的。我们只能用输入数据分布对测试数据进行归一化。因此，在测试时，请输入相应的归一化超参数。 如下：
zi=max(x)−min(x)xi−min(x)
即代码示例：
def _normalize_column(X, train=True, specified_column=None, X_min=None, X_max=None):# 归一化，将指定列的数据每一列进行归一化if train:if specified_column == None:# 如果没有指定列，则对全部列进行归一化处理specified_column = np.arange(X.shape[1])length = len(specified_column)X_max = np.reshape(np.max(X[:, specified_column], 0), (1, length))X_min = np.reshape(np.min(X[:, specified_column], 0), (1, length))X[:, specified_column] = np.divide(np.subtract(X[:, specified_column], X_min),np.subtract(X_max,X_min))return X, X_max, X_min
- 将指定列规格化为正态分布。你可以尝试不同类型的规范化，以使模型更容易地了解数据分布。 对于正态分布，可以通过下面方法来进行标准化：
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）
当数据量不足时，使用交叉验证，可以一定上提高训练效果。
示例数据分割成两部分一部分训练集，一部分验证集：分割值具体自己设置。
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]
训练过程
在这里设置：（也可以自己设置，查看效果）
max_iter = 40 # 最大迭代次数batch_size = 32 # 每一次迭代训练的数据量learning_rate = 0.01 # 学习率
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、bw = w - learning_rate / np.square(step) * w_gradb = b - learning_rate / np.square(step) * b_gradstep = step + 1
并且在每个epoch训练中记录下训练误差 以及验证集中的误差用于画图数据:(示例训练集误差)
# 计算训练集的误差和准确率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)
准确度函数如下：
def accuracy(y_pre, y):acc = np.sum(y_pre == y) / len(y_pre)return acc
画图函数
导入画图函数包：
import matplotlib.pyplot as plt%matplotlib inline
画出训练集以及验证集中loss 以及 准确率 的对比图形：
测试数据的使用预测二分类
通过读入测试集数据X_test数据，利用训练好的模型，来完成年薪的预测，并且将结果输入到output.csv文件中。
X_test_fpath='data/X_test'output_fpath='output.csv'
result=infer(X_test,v,b)with open(output_fpath,'v') as f:f.write("id,label\n")for i,v in enumerate(result):f.write("%d,%d\n"%(i+1,v))
以下方法可以查看各个特征项对预测结果的贡献度如下:
# 输出贡献最大的10个特征ind = np.argsort(np.abs(w))[::-1]with open(X_test_fpath) as f:content=f.readline().rstrip("\n")features=np.array([x for x in content.split(',')])for i in ind[0:10]:print(features[i], w[i])
编程要求
根据提示，在右侧编辑器 / Begin / 到 / End / 处补充代码。
测试说明
数据集在：/data/workspace/myshixun/step1/train.csv;/data/workspace/myshixun/step1/test.csv
完成加载数据和网络的编写，结果具有随机性，图片展示结果也会具有一定的差异性，本关是通过检查保存文件验证是否通关。
平台会对你编写的代码进行测试：
预期输出：
id, label1 , 0.02 , 0.03 , 0.04 , 0.05 , 0.06 , 0.07 , 0.08 , 1.09 , 0.010 , 0.016282id,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')