datawhalechina/team-learning-data-mining
逻辑回归模型：
树模型：
集成模型
基于bagging思想的集成模型
基于boosting思想的集成模型
Adaboost模型
‣
XGBoost模型
LightGBM模型
CatBoost模型
Baggin和Boosting的区别总结如下：
超参数调优
模型对比与性能评估：
对于模型来说，其在训练集上面的误差我们称之为训练误差或者经验误差，而在测试集上的误差称之为测试误差。
对于我们来说，我们更关心的是模型对于新样本的学习能力，即我们希望通过对已有样本的学习，尽可能的将所有潜在样本的普遍规律学到手，而如果模型对训练样本学的太好，则有可能把训练样本自身所具有的一些特点当做所有潜在样本的普遍特点，这时候我们就会出现过拟合的问题。
因此我们通常将已有的数据集划分为训练集和测试集两部分，其中训练集用来训练模型，而测试集则是用来评估模型对于新样本的判别能力。
①留出法
留出法是直接将数据集D划分为两个互斥的集合，其中一个集合作为训练集S，另一个作为测试集T。需要注意的是在划分的时候要尽可能保证数据分布的一致性，即避免因数据划分过程引入额外的偏差而对最终结果产生影响。为了保证数据分布的一致性，通常我们采用分层采样的方式来对数据进行采样。
Tips： 通常，会将数据集D中大约2/3~4/5的样本作为训练集，其余的作为测试集。
import torch
from torchvision import datasets, transforms
batch_size = 200
"""读取训练集和测试集"""
train_db = datasets.MNIST('../data', train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
test_db = datasets.MNIST('../data', train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
"""刚读取进来的"""
print('train:', len(train_db), 'test:', len(test_db))
"""将训练集划分为训练集和验证集"""
train_db, val_db = torch.utils.data.random_split(train_db, [50000, 10000])
print('train:', len(train_db), 'validation:', len(val_db))
'''
这一步是将torch.utils.data.dataset.Subset
转换成torch.utils.data.dataloader.DataLoader
根据batch_size让它多出了一个 批编号 的维度
'''
# 训练集
train_loader = torch.utils.data.DataLoader(
train_db,
batch_size=batch_size, shuffle=True)
# 验证集
val_loader = torch.utils.data.DataLoader(
val_db,
batch_size=batch_size, shuffle=True)
# 测试集
test_loader = torch.utils.data.DataLoader(
test_db,
batch_size=batch_size, shuffle=True)
②交叉验证法
k折交叉验证通常将数据集D分为k份，其中k-1份作为训练集，剩余的一份作为测试集，这样就可以获得k组训练/测试集，可以进行k次训练与测试，最终返回的是k个测试结果的均值。交叉验证中数据集的划分依然是依据分层采样的方式来进行。
对于交叉验证法，其k值的选取往往决定了评估结果的稳定性和保真性，通常k值选取10。
当k=1的时候，我们称之为留一法
import torch
import torch.nn as nn
from torch.utils.data import DataLoader,Dataset
import torch.nn.functional as F
from torch.autograd import Variable
#####构造的训练集####
x = torch.rand(100,28,28)
y = torch.randn(100,28,28)
x = torch.cat((x,y),dim=0)
label =[1] *100 + [0]*100
label = torch.tensor(label,dtype=torch.long)
######网络结构##########
class Net(nn.Module):
#定义Net
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(28*28, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 2)
def forward(self, x):
x = x.view(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:]
num_features = 1
for s in size:
num_features *= s
return num_features
##########定义dataset##########
class TraindataSet(Dataset):
def __init__(self,train_features,train_labels):
self.x_data = train_features
self.y_data = train_labels
self.len = len(train_labels)
def __getitem__(self,index):
return self.x_data[index],self.y_data[index]
def __len__(self):
return self.len
########k折划分############
def get_k_fold_data(k, i, X, y): ###此过程主要是步骤（1）
# 返回第i折交叉验证时所需要的训练和验证数据，分开放，X_train为训练数据，X_valid为验证数据
assert k > 1
fold_size = X.shape[0] // k # 每份的个数:数据总条数/折数（组数）
X_train, y_train = None, None
for j in range(k):
idx = slice(j * fold_size, (j + 1) * fold_size) #slice(start,end,step)切片函数
##idx 为每组 valid
X_part, y_part = X[idx, :], y[idx]
if j == i: ###第i折作valid
X_valid, y_valid = X_part, y_part
elif X_train is None:
X_train, y_train = X_part, y_part
else:
X_train = torch.cat((X_train, X_part), dim=0) #dim=0增加行数，竖着连接
y_train = torch.cat((y_train, y_part), dim=0)
#print(X_train.size(),X_valid.size())
return X_train, y_train, X_valid,y_valid
def k_fold(k, X_train, y_train, num_epochs=3,learning_rate=0.001, weight_decay=0.1, batch_size=5):
train_loss_sum, valid_loss_sum = 0, 0
train_acc_sum ,valid_acc_sum = 0,0
for i in range(k):
data = get_k_fold_data(k, i, X_train, y_train) # 获取k折交叉验证的训练和验证数据
net = Net() ### 实例化模型
### 每份数据进行训练,体现步骤三####
train_ls, valid_ls = train(net, *data, num_epochs, learning_rate,\\
weight_decay, batch_size)
print('*'*25,'第',i+1,'折','*'*25)
print('train_loss:%.6f'%train_ls[-1][0],'train_acc:%.4f\\n'%valid_ls[-1][1],\\
'valid loss:%.6f'%valid_ls[-1][0],'valid_acc:%.4f'%valid_ls[-1][1])
train_loss_sum += train_ls[-1][0]
valid_loss_sum += valid_ls[-1][0]
train_acc_sum += train_ls[-1][1]
valid_acc_sum += valid_ls[-1][1]
print('#'*10,'最终k折交叉验证结果','#'*10)
####体现步骤四#####
print('train_loss_sum:%.4f'%(train_loss_sum/k),'train_acc_sum:%.4f\\n'%(train_acc_sum/k),\\
'valid_loss_sum:%.4f'%(valid_loss_sum/k),'valid_acc_sum:%.4f'%(valid_acc_sum/k))
#########训练函数##########
def train(net, train_features, train_labels, test_features, test_labels, num_epochs, learning_rate,weight_decay, batch_size):
train_ls, test_ls = [], [] ##存储train_loss,test_loss
dataset = TraindataSet(train_features, train_labels)
train_iter = DataLoader(dataset, batch_size, shuffle=True)
### 将数据封装成 Dataloder 对应步骤（2）
#这里使用了Adam优化算法
optimizer = torch.optim.Adam(params=net.parameters(), lr= learning_rate, weight_decay=weight_decay)
for epoch in range(num_epochs):
for X, y in train_iter: ###分批训练
output = net(X)
loss = loss_func(output,y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
### 得到每个epoch的 loss 和 accuracy
train_ls.append(log_rmse(0,net, train_features, train_labels))
if test_labels is not None:
test_ls.append(log_rmse(1,net, test_features, test_labels))
#print(train_ls,test_ls)
return train_ls, test_ls
def log_rmse(flag,net,x,y):
if flag == 1: ### valid 数据集
net.eval()
output = net(x)
result = torch.max(output,1)[1].view(y.size())
corrects = (result.data == y.data).sum().item()
accuracy = corrects*100.0/len(y) #### 5 是 batch_size
loss = loss_func(output,y)
net.train()
return (loss.data.item(),accuracy)
loss_func = nn.CrossEntropyLoss()
k_fold(10,x,label) ### k=10,十折交叉验证
③自助法
我们每次从数据集D中取一个样本作为训练集中的元素，然后把该样本放回，重复该行为m次，这样我们就可以得到大小为m的训练集，在这里面有的样本重复出现，有的样本则没有出现过，我们把那些没有出现过的样本作为测试集。
进行这样采样的原因是因为在D中约有36.8%的数据没有在训练集中出现过。留出法与交叉验证法都是使用分层采样的方式进行数据采样与划分，而自助法则是使用有放回重复采样的方式进行数据采样
代码示例