零基础入门CV赛事-Task4 模型训练与验证

1. 分类算法之k-近邻

k-近邻算法采用测量不同特征值之间的距离来进行分类

优点：精度高、对异常值不敏感、无数据输入假定

缺点：计算复杂度高、空间复杂度高

使用数据范围：数值型和标称型

一个例子弄懂k-近邻
电影可以按照题材分类，每个题材又是如何定义的呢？那么假如两种类型的电影，动作片和爱情片。动作片有哪些公共的特征？那么爱情片又存在哪些明显的差别呢？我们发现动作片中打斗镜头的次数较多，而爱情片中接吻镜头相对更多。当然动作片中也有一些接吻镜头，爱情片中也会有一些打斗镜头。所以不能单纯通过是否存在打斗镜头或者接吻镜头来判断影片的类别。那么现在我们有6部影片已经明确了类别，也有打斗镜头和接吻镜头的次数，还有一部电影类型未知。

电影名称 打斗镜头 接吻镜头 电影类型
California Man 3 104 爱情片
He’s not Really into dues 2 100 爱情片
Beautiful Woman 1 81 爱情片
Kevin Longblade 101 10 动作片
Robo Slayer 3000 99 5 动作片
Amped II 98 2 动作片
? 18 90 未知
那么我们使用K-近邻算法来分类爱情片和动作片：存在一个样本数据集合，也叫训练样本集，样本个数M个，知道每一个数据特征与类别对应关系，然后存在未知类型数据集合1个，那么我们要选择一个测试样本数据中与训练样本中M个的距离，排序过后选出最近的K个，这个取值一般不大于20个。选择K个最相近数据中次数最多的分类。那么我们根据这个原则去判断未知电影的分类

电影名称 与未知电影的距离
California Man 20.5
He’s not Really into dues 18.7
Beautiful Woman 19.2
Kevin Longblade 115.3
Robo Slayer 3000 117.4
Amped II 118.9
我们假设K为3，那么排名前三个电影的类型都是爱情片，所以我们判定这个未知电影也是一个爱情片。那么计算距离是怎样计算的呢？

sklearn.neighbors
sklearn.neighbors提供监督的基于邻居的学习方法的功能，sklearn.neighbors.KNeighborsClassifier是一个最近邻居分类器。那么KNeighborsClassifier是一个类，我们看一下实例化时候的参数

class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=‘uniform’, algorithm=‘auto’, leaf_size=30, p=2, metric=‘minkowski’, metric_params=None, n_jobs=1, kwargs)
“”"
:param n_neighbors：int，可选（默认= 5），k_neighbors查询默认使用的邻居数

:param algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：'ball_tree’将会使用 BallTree，'kd_tree’将使用 KDTree，“野兽”将使用强力搜索。'auto’将尝试根据传递给fit方法的值来决定最合适的算法。

:param n_jobs：int，可选（默认= 1),用于邻居搜索的并行作业数。如果-1，则将作业数设置为CPU内核数。不影响fit方法。

“”"
import numpy as np
from sklearn.neighbors import KNeighborsClassifier

neigh = KNeighborsClassifier(n_neighbors=3)
Method
fit(X, y)

使用X作为训练数据拟合模型，y作为X的类别值。X，y为数组或者矩阵

X = np.array([[1,1],[1,1.1],[0,0],[0,0.1]])
y = np.array([1,1,0,0])
neigh.fit(X,y)
kneighbors(X=None, n_neighbors=None, return_distance=True)

找到指定点集X的n_neighbors个邻居，return_distance为False的话，不返回距离

neigh.kneighbors(np.array([[1.1,1.1]]),return_distance= False)

neigh.kneighbors(np.array([[1.1,1.1]]),return_distance= False,an_neighbors=2)
predict(X)

预测提供的数据的类标签

neigh.predict(np.array([[0.1,0.1],[1.1,1.1]]))
predict_proba(X)

返回测试数据X属于某一类别的概率估计

neigh.predict_proba(np.array([[1.1,1.1]]))

2.task4学习

构造训练集和验证集；
每轮进行训练和验证，并根据最优验证集精度保存模型。
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=10,
shuffle=True,
num_workers=10,
)

val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=10,
shuffle=False,
num_workers=10,
)

model = SVHN_Model1()
criterion = nn.CrossEntropyLoss (size_average=False)
optimizer = torch.optim.Adam(model.parameters(), 0.001)
best_loss = 1000.0
for epoch in range(20):
print('Epoch: ', epoch)

train(train_loader, model, criterion, optimizer, epoch)
val_loss = validate(val_loader, model, criterion)

# 记录下验证集精度
if val_loss < best_loss:
    best_loss = val_loss
    torch.save(model.state_dict(), './model.pt')

其中每个Epoch的训练代码如下：

def train(train_loader, model, criterion, optimizer, epoch):
# 切换模型为训练模式
model.train()

for i, (input, target) in enumerate(train_loader):
    c0, c1, c2, c3, c4, c5 = model(data[0])
    loss = criterion(c0, data[1][:, 0]) + \
            criterion(c1, data[1][:, 1]) + \
            criterion(c2, data[1][:, 2]) + \
            criterion(c3, data[1][:, 3]) + \
            criterion(c4, data[1][:, 4]) + \
            criterion(c5, data[1][:, 5])
    loss /= 6
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

其中每个Epoch的验证代码如下：

def validate(val_loader, model, criterion):
# 切换模型为预测模型
model.eval()
val_loss = []

# 不记录模型梯度信息
with torch.no_grad():
    for i, (input, target) in enumerate(val_loader):
        c0, c1, c2, c3, c4, c5 = model(data[0])
        loss = criterion(c0, data[1][:, 0]) + \
                criterion(c1, data[1][:, 1]) + \
                criterion(c2, data[1][:, 2]) + \
                criterion(c3, data[1][:, 3]) + \
                criterion(c4, data[1][:, 4]) + \
                criterion(c5, data[1][:, 5])
        loss /= 6
        val_loss.append(loss.item())
return np.mean(val_loss)

4.4 模型保存与加载
在Pytorch中模型的保存和加载非常简单，比较常见的做法是保存和加载模型参数：
torch.save(model_object.state_dict(), ‘model.pt’)
model.load_state_dict(torch.load(’ model.pt’))