文章目录
前言
入坑2年后,重新梳理之前的知识,发现其实需要一个自己的深度学习的模板pipeline。他需要:
- 数据集切分
- dataset的功能
- dataloader的功能
- train的过程中print 每个epoch的训练集 测试集的准确率,loss
在这个过程中,我会从自我实现的角度一步步进化,已经说明为什么需要这样做。
用一个多层感知机为因子搭建一个pipeline
读取数据和处理异常数据用pandas
训练用torch 的tensor是一个好习惯。
计算用numpy
1数据相关
1.1 数据初探
根据15个特征预测员工是否会离职的问题, 很明显是个分类问题,输出是否会离职的概率做分类。
data = pd.read_csv("dataset/HR.csv")
data.head()
看一下都有哪些职位:
data.salary.unique()
array(['sales', 'accounting', 'hr', 'technical', 'support', 'management',
'IT', 'product_mng', 'marketing', 'RandD'], dtype=object)
工资等级:
data.salary.unique()
array(['low', 'medium', 'high'], dtype=object)
pandas 的group by 功能用一下:按工资和部门分组查询。
data.groupby(["salary","part"]).size()
1.2.数据处理
需要把工资的等级:high low ,…
部门分类:销售 技术 财务 …
转成onehot编码
pd.get_dummies(data.salary)
data = data.join(pd.get_dummies(data.salary))
del data["salary"]
data = data.join(pd.get_dummies(data.part))
del data["part"]
data.left.value_counts()
问题1:所以为啥需要做One-hot编码?
对于属性是不具备序列性、不能比较大小的属性,通常我们不能用简单的数值来粗暴替换。因为属性的数值大小会影响到权重矩阵的计算,不存在大小关系的属性,其权重也不应该发生相应的变化,那么我们就需要用到One-hot编码(也有人称独热编码)这种特殊的编码方式了。
来看一个简单的例子:假设我们有一个特征是自有房和无自有房,样本情况如下:
data = [['自有房',40,50000],
['无自有房',22,13000],
['自有房',30,30000]]
编码后的样本矩阵变为:
data = [[1,0,40,50000],
[0,1,22,13000],
[1,0,30,30000]]
问题2:One-hot编码适用算法,(但是我们这个算法就是逻辑回归在使用的,这块存疑吧)
有大神说,现在的经验,one-hot用在GBDT、XGBoost这些模型里面都挺好的,但是用在逻辑回归里不行。因为逻辑回归要求变量间相互独立,如果你只有一个属性需要做one-hot编码还好,如果你有多个属性需要做one-ont编码,那么当某个样本的多个one-hot属性同时为1时,这两个属性就完全相关了,必然会导致singular error,也就是非奇异矩阵不能求解唯一解,得不出唯一的模型,但是你又不可能把同一个属性的某一个one-hot延伸变量删除。
如果在逻辑回归中入模标称属性,可以直接替换成数值,然后做woe变换,用每个类别的woe值来代替原来的数值,这样既能够避免生成相关性强的变量,又能避开类别间大小无法比较的问题。
1.3 数据变形
构建X_data 和 Y_data
转成torch.tensor 并同意数据到torch.float32
2 定义网络,优化函数
因为是二分类问题,所以最终需要将线性计算结果,拟合到0,1之间,用sigmoid函数。
因为20个特征,所以选择20,输出的是0,1之间的概率,就是1个特征
二元交叉熵,二分类 当然用二元交叉熵
loss_fn = nn.BCELoss()
class Model(nn.Module):
def __init__(self):
super().__init__()
self.liner_1 = nn.Linear(20, 64)
self.liner_2 = nn.Linear(64, 64)
self.liner_3 = nn.Linear(64,1)
self.sigmoid = nn.Sigmoid()
def forward(self, input):
x = self.liner_1(input)
x = F.relu(x)
x = self.liner_2(x)
x = F.relu(x)
x = self.liner_3(x)
x = self.sigmoid(x)
return x
3. 训练
3.1 可用版本
这里有个关键问题,with no grad 加在哪来的问题,
我们是为了看每一批次后的训练状态,它的梯度是不需要积累的,所以用 with no grad 包起来
for epoch in range(epochs):
for i in range(no_of_batches):
start = i * batch
end = start + batch
x = X[start: end]
y = Y[start: end]
y_pred = model(x)
loss = loss_fn(y_pred, y)
# 将model.parameters()
optim.zero_grad()
loss.backward()
optim.step()
with torch.no_grad():
print("epoch:",epoch,"loss:",loss_fn(model(X),Y).data.item())
优点:简单可用
缺点:
- 切片送入模型的过程是手动完成
- 没有构建训练集和测试集,
- 只能按epoch 看到 整体的loss 而无法看到test accuracy 和loss,也就是说无法验证数据的欠拟合和过拟合
3.2. 优化
基于以上两个缺点,我们会迭代修改它。
3.2.1 使用dataset类进行重构
X ndarray 类型的所有 特征值集合
Y ndarray类型的所有labels 集合
from torch.utils.data import TensorDataset
HRdataset = TensorDataset(X, Y)
HRdataset
可以看到 HRdataset 返回两个数据,x是特征,y是对应的labels
这样以来,我们就优化了,它的切片。
for epoch in range(epochs):
for i in range(no_of_batches):
x, y = HRdataset[i*batch: i*batch+batch]
y_pred = model(x)
loss = loss_fn(y_pred, y)
optim.zero_grad()
loss.backward()
optim.step()
with torch.no_grad():
print('epoch: ', epoch, 'loss: ', loss_fn(model(X), Y).data.item())
3.2.2 使用dataloader类进一步优化
3.2.1 简化了切片的处理过程,对批次数据的获取产生了优化。但是有一个问题,我们无法shuffle 送入模型的顺序,这样可以避免它基于顺序的过拟合。
这个时候需要一个shuffle函数,把batch_size 当入参传进来了。
from torch.utils.data import DataLoader
HR_ds = TensorDataset(X, Y)
HR_dl = DataLoader(HR_ds, batch_size=batch, shuffle=True)
model, optim = get_model()
for epoch in range(epochs):
for x, y in HR_dl:
y_pred = model(x)
loss = loss_fn(y_pred, y)
optim.zero_grad()
loss.backward()
optim.step()
with torch.no_grad():
print('epoch: ', epoch, 'loss: ', loss_fn(model(X), Y).data.item())
3.2.3 使用sklearn进一步优化
test数据集是不需要shuffle的,想一想为什么?
train_x, test_x, train_y, test_y = train_test_split(X_data, Y_data)
train_x = torch.from_numpy(train_x).type(torch.float32)
train_y = torch.from_numpy(train_y).type(torch.float32)
test_x = torch.from_numpy(test_x).type(torch.float32)
test_y = torch.from_numpy(test_y).type(torch.float32)
train_ds = TensorDataset(train_x, train_y)
train_dl = DataLoader(train_ds, batch_size=batch, shuffle=True)
test_ds = TensorDataset(test_x, test_y)
test_dl = DataLoader(test_ds, batch_size=batch)
计算正确率的代码
y_pred = (y_pred > 0.5).type(torch.int32)
(y_pred == labels).float().mean() # [True, Fasle, True]
封装成函数
def accuracy(y_pred, y_true):
y_pred = (y_pred > 0.5).type(torch.int32)
acc = (y_pred == y_true).float().mean()
return acc
model, optim = get_model()
最终的训练:
for epoch in range(epochs):
for x, y in train_dl:
y_pred = model(x)
loss = loss_fn(y_pred, y)
optim.zero_grad()
loss.backward()
optim.step()
with torch.no_grad():
epoch_accuracy = accuracy(model(train_x), train_y)
epoch_loss = loss_fn(model(train_x), train_y).data
epoch_test_accuracy = accuracy(model(test_x), test_y)
epoch_test_loss = loss_fn(model(test_x), test_y).data
print('epoch: ', epoch, 'loss: ', round(epoch_loss.item(), 3),
'accuracy:', round(epoch_accuracy.item(), 3),
'test_loss: ', round(epoch_test_loss.item(), 3),
'test_accuracy:', round(epoch_test_accuracy.item(), 3)
)
4.总结
一步步的,把从一个最简化版的深度学习模板打造的有模有样,这个时候,对于有监督的分类算法,不管是二分类还是多分批,只需要该自定义网络那块和损失函数,优化目标函数三个地方,别的地方不用动,是不是很酷啊!
一篇文章不能解决所有问题,后面一篇文章,我会加入tensorboard 看板的内容,并最终给出代码,敬请期待。另外,以后我可以指导学生,有偿,欢迎私信。