目录
1 ： 事先准备 。
2 ： 代码阅读。
2.1: 数据读取
2.2： 模型载入
3 训练过程：
4 测试过程：
5 ：线性验证
6 ： 用自己数据集进行对比学习。
第一： 改数据集 ：
2 改变batch_size和图片大小。
写在前面的话 CSDN真的是'sb'中的'sb'软件， 辛辛苦苦写半天 我复制个东西过来 他就把前面的刷没了 还要我重头写？？？？？？？？？？？？神经并b
------------------------------------------------------------------------------------------------------------------------------
2022李宏毅作业HW3 是食物的分类 ，但是我怎么尝试 再监督学习的模式下 准确率都达不到百分之60 .。半监督也感觉效果不明显。 所以 这次就想着对比学习能不能用来解决这个问题呢 。？看了一圈，感觉simsiam是对比学习里比较简单的一种方法，好像效果也不错。 所以来看一看这个东西是怎么玩的。
simsaim 是对比学习很新的文章了。 他的训练方式简单来说就是 ，一张图片 ，用不同的方式去增广后形成图片对 。 然后用一张去预测另一张。 不懂得可以看朱老师的视频。
1 ： 事先准备 。
代码地址 ：
下载解压。
直接在main函数的 运行 编辑配置中输入
--data_dir ../Data/ --log_dir ../logs/ -c configs/simsiam_cifar.yaml --ckpt_dir ~/.cache/ --hide_progress --download
os.environ['CUDA_VISIBLE_DEVICES']='0'
注意 ： 第二次运行可以删掉download
2 ： 代码阅读。神经网络的一个基本的框架就是 ： 数据读取 ， 模型载入， 训练，测试。 我们接下来根据这四块来看。
2.1: 数据读取运行main文件 。
main(device=args.device, args=args)进入main 函数 。
是三个数据集的读取。
train_loader ，， memory_loader 和 test_loader。 train和memory 都是训练集的数据 他们的不同之处在于， 数据增广的方式不同。 train的增广是用来训练的 memory和test的增广都是用来测试的。由于在对比学习里， 数据增广是很重要的 ，所以这里看下数据增广的方式。
dataset=get_dataset(
transform=get_aug(train=True, **args.aug_kwargs),
train=True,
**args.dataset_kwargs),**args.aug_kwargs 里规定了图片大小是32. 以及这次用的是simsaim。
这里两个train 。 只有训练集的第一个train是true。 而训练集的增广方式如下
class SimSiamTransform():
def __init__(self, image_size, mean_std=imagenet_mean_std):
image_size = 224 if image_size is None else image_size # by default simsiam use image size 224
p_blur = 0.5 if image_size > 32 else 0 # exclude cifar
# the paper didn't specify this, feel free to change this value
# I use the setting from simclr which is 50% chance applying the gaussian blur
# the 32 is prepared for cifar training where they disabled gaussian blur
self.transform = T.Compose([
T.RandomResizedCrop(image_size, scale=(0.2, 1.0)),
T.RandomHorizontalFlip(),
T.RandomApply([T.ColorJitter(0.4,0.4,0.4,0.1)], p=0.8),
T.RandomGrayscale(p=0.2),
T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=p_blur),
T.ToTensor(),
T.Normalize(*mean_std)
])
def __call__(self, x):
x1 = self.transform(x)
x2 = self.transform(x)
return x1, x2 增广方式可以参考 官网
这里依次是 ： 随机resize 然后剪切为输入大小， 也就是会随机取图片里的一块。
随机水平变换
0.8的概率调节亮度对比度和饱和度。
0.2概率灰度化
对于32的照片 不做高斯模糊。
转化为张量并标准化。
然后 对于一个输入 这里会做两次transform call可以让这个类像函数那样被调用。
对于 测试用的训练集 。也就是memory 是下面的增广方式。 而test也是下面的增广方式 。
else:
self.transform = transforms.Compose([
transforms.Resize(int(image_size*(8/7)), interpolation=Image.BICUBIC), # 224 -> 256
transforms.CenterCrop(image_size),
transforms.ToTensor(),
transforms.Normalize(*normalize)
])如果输入是 224 就 先放大到256，然后中心裁剪224，之后标准化。
如果输入是32 就放大到36 再中心裁剪32 .后标准化。
用的是cifar10的数据。 其实也就相当于很普通的 读图片 然后增广， 加标签。
我们只要看getitem取出来的数据是什么就好 。
img, target = self.data[index], self.targets[index]
# doing this so that it is consistent with all other datasets
# to return a PIL Image
img = Image.fromarray(img)
if self.transform is not None:
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
return img, target
注意 如果是训练集 在trans时会返回两张图片 ，所以返回的是一个元组。 而测试时 ，img就是单独的一张图片。 target也就是标签。
总结：数据部分 我们需要做一个数据集， 然后训练集的增广要返回两个结果。 当读取数据时，返回的是图片数据和标签数据。
2.2： 模型载入
这一部分我们来看模型 ，我们可以根据下面的伪代码来看模型长什么样子。 伪代码非常容易看懂。 aug就是增广嘛。 f来提特征，然后两个预测。 算loss 回传。
model = get_model(args.model).to(device)这句来获得模型。
if model_cfg.name == 'simsiam':
model = SimSiam(get_backbone(model_cfg.backbone))backbone就是普通的res18 这里不需要预训练的模型 只需要初始模型 。
class SimSiam(nn.Module):
def __init__(self, backbone=resnet50()):
super().__init__()
self.backbone = backbone
self.projector = projection_MLP(backbone.output_dim)
self.encoder = nn.Sequential( # f encoder
self.backbone,
self.projector
)
self.predictor = prediction_MLP()
def forward(self, x1, x2):
f, h = self.encoder, self.predictor
z1, z2 = f(x1), f(x2)
p1, p2 = h(z1), h(z2)
L = D(p1, z2) / 2 + D(p2, z1) / 2
return {'loss': L}
这个就是simsam的模型了 。 projector 是个三层的普通mlp 。 encoder 就是伪代码里的f了 而predictor就是伪代码里的h了 。 我们具体来看下loss 。
def D(p, z, version='simplified'): # negative cosine similarity
if version == 'original':
z = z.detach() # stop gradient
p = F.normalize(p, dim=1) # l2-normalize
z = F.normalize(z, dim=1) # l2-normalize
return -(p*z).sum(dim=1).mean()
elif version == 'simplified':# same thing, much faster. Scroll down, speed test in __main__
return - F.cosine_similarity(p, z.detach(), dim=-1).mean()
else:
raise Exception传说 simsaim的精髓就在于这个loss， 在于这个z.detach 也就是传说中的stop gradiant。 有了这个梯度停止， simsaim才能够训练的起来。 这时的simsaim就和k-means算法有点类似了。 说法很多 大家可以搜搜看。
其实我们可以看出来一点东西，在算loss时， p是预测值， z是标签，如果标签也要算梯度，两边就都在变了，参考我们平时的label都是不变的，确实z也不应该算梯度。
那么什么是stop gradiant呢 就是不算梯度的意思。比如
x = 2 y = 2**2 z = y+x z.grad = 5 y.detach() z.grad = 1
本来y是x的平方 求导等于4 所以z对x求导是5 然后不算y的梯度了 那么就只剩1了 。
这就是模型的全部了 ，输入两张图片 ，然后抽特征 预测 分别算loss
3 训练过程：
训练是非常普通的训练。
for idx, ((images1, images2), labels) in tqdm(enumerate(local_progress)):
model.zero_grad()
data_dict = model.forward(images1.to(device, non_blocking=True), images2.to(device, non_blocking=True))
loss = data_dict['loss'].mean() # ddp
loss.backward()
optimizer.step()
lr_scheduler.step()
data_dict.update({'lr':lr_scheduler.get_lr()})
local_progress.set_postfix(data_dict)
# logger.update_scalers(data_dict)从测试集中抽loader 注意抽出的是两张图片 由不同transformers形成的。 之后过模型得到loss，梯度回传。 这里日志一直报错 我直接屏蔽了。
4 测试过程：
测试过程比较的关键。
这里是用knn算法进行测试的 ，关于knn 可以看
简单的说， 就是从众。 在一个大平面上有很多的点， 然后你就看离自己最近的k个点，他们的标签是啥， 然后选最多的那个当自己的标签。
accuracy = knn_monitor(model.module.backbone, memory_loader, test_loader, device, k=min(args.train.knn_k, len(memory_loader.dataset)), hide_progress=args.hide_progress) def knn_monitor(net, memory_data_loader, test_data_loader, epoch, k=200, t=0.1, hide_progress=False):
net.eval()
classes = len(memory_data_loader.dataset.classes)
total_top1, total_top5, total_num, feature_bank = 0.0, 0.0, 0, []
with torch.no_grad():
# generate feature bank
for data, target in tqdm(memory_data_loader, desc='Feature extracting', leave=False, disable=hide_progress):
feature = net(data.cuda(non_blocking=True))
feature = F.normalize(feature, dim=1)
feature_bank.append(feature)
# [D, N]
feature_bank = torch.cat(feature_bank, dim=0).t().contiguous()
# [N]
feature_labels = torch.tensor(memory_data_loader.dataset.targets, device=feature_bank.device)
# loop test data to predict the label by weighted knn search
test_bar = tqdm(test_data_loader, desc='kNN', disable=hide_progress)
for data, target in test_bar:
data, target = data.cuda(non_blocking=True), target.cuda(non_blocking=True)
feature = net(data)
feature = F.normalize(feature, dim=1)
pred_labels = knn_predict(feature, feature_bank, feature_labels, classes, k, t)
total_num += data.size(0)
total_top1 += (pred_labels[:, 0] == target).float().sum().item()
test_bar.set_postfix({'Accuracy':total_top1 / total_num * 100})
return total_top1 / total_num * 100注意 这里的net 只是backbone 也就是resnet 而 memory 就是训练数据 不过增广方式不一样 。还有训练数据 和k值 取200.
net.eval()
classes = len(memory_data_loader.dataset.classes)
total_top1, total_top5, total_num, feature_bank = 0.0, 0.0, 0, []一些初始化和获取类别数。
with torch.no_grad():
# generate feature bank
for data, target in tqdm(memory_data_loader, desc='Feature extracting', leave=False, disable=hide_progress):
feature = net(data.cuda(non_blocking=True))
feature = F.normalize(feature, dim=1)
feature_bank.append(feature)
# [D, N]
feature_bank = torch.cat(feature_bank, dim=0).t().contiguous()
feature_labels = torch.tensor(memory_data_loader.dataset.targets, device=feature_bank.device)获取大平面上的点。 从训练集抽数据， 然后获取他们的特征。
最后的feature_bank大小是49664*512 也就是将近50000条数据 每个数据都有512 维的特征。 然后做了一个转置。
for data, target in test_bar:
data, target = data.cuda(non_blocking=True), target.cuda(non_blocking=True)
feature = net(data)
feature = F.normalize(feature, dim=1)抽取测试集的特征。
pred_labels = knn_predict(feature, feature_bank, feature_labels, classes, k, t)def knn_predict(feature, feature_bank, feature_labels, classes, knn_k, knn_t):
# compute cos similarity between each feature vector and feature bank ---> [B, N]
sim_matrix = torch.mm(feature, feature_bank)
# [B, K]
sim_weight, sim_indices = sim_matrix.topk(k=knn_k, dim=-1) #求出最大的knn_k个值
# [B, K]
sim_labels = torch.gather(feature_labels.expand(feature.size(0), -1), dim=-1, index=sim_indices)
sim_weight = (sim_weight / knn_t).exp()
# counts for each class
one_hot_label = torch.zeros(feature.size(0) * knn_k, classes, device=sim_labels.device)
# [B*K, C]
one_hot_label = one_hot_label.scatter(dim=-1, index=sim_labels.view(-1, 1), value=1.0)
# weighted score ---> [B, C]
pred_scores = torch.sum(one_hot_label.view(feature.size(0), -1, classes) * sim_weight.unsqueeze(dim=-1), dim=1)
pred_labels = pred_scores.argsort(dim=-1, descending=True)
return pred_labels
我们来看 knn是如果计算相似度的 ，也就是距离的。torch.mm表示矩阵的乘法。 我举个例子。
下面只是例子 ，真实数据需要归一化
a = [[1,2,3],
[4,5,6]]
b = [[1,2,3],
[2,4,6],
[3,6,9],
[4,8,1]]
a有2个样本， b有4个样本。 他们的特征都是3维。 现在求a[0] 和b中哪些样本最相似。
就要让a[0]和b中每一个样本点乘 得到 14, 28, 42, 23。数越大表示越相似，也就越近。 所以我们让a和b的转置相乘，得到：
tensor([[14, 28, 42, 23],
[32, 64, 96, 62]])
我们发现第一排 就是a[0]的相似度， 每一列都是与b中样本的点乘结果。
sim_matrix = torch.mm(feature, feature_bank)所以这里的sim_matrix 就是一个512 * 49664大小的矩阵。 512 表示有512个样本， 49664 表示每个样本和所有点的乘积。
sim_weight, sim_indices = sim_matrix.topk(k=knn_k, dim=-1) topk 表示取最大的值，和他们下标 这里取200个 我们就得到了离每一个样本，最近的那些点，他们的下标是多少。
sim_labels = torch.gather(feature_labels.expand(feature.size(0), -1), dim=-1, index=sim_indices)feature_labels.expand(feature.size(0), -1) 之前的文章说过 ，是一个复制扩充。 -1表示不改变维度。 feature是50000维 扩充后变成512 *50000 （注意label和49664不相等，是因为loader舍弃了最后的一部分，但是没关系 ， 本来就取不到这部分值）。
torch.gather 是按下标取值。
我们对标签按下标取值，得到了512 *200的矩阵， 每一行都表示这个样本距离最近的200个样本的标签。
sim_weight = (sim_weight / knn_t).exp()看到后面就知道这个knn_t的作用了 。 作用就是 控制相似度的权重。 比如 一个更相似的 他的标签可以一个顶好几个不相似的。 那么顶几个呢 ？ 就是t控制的了 。
# counts for each class
one_hot_label = torch.zeros(feature.size(0) * knn_k, classes, device=sim_labels.device)
# [B*K, C]
one_hot_label = one_hot_label.scatter(dim=-1, index=sim_labels.view(-1, 1), value=1.0)我们需要先搞懂scatter函数 。说实话着实有点难。因为官网的scatter都很难理解了 ，何况这个和官网不一样
我们可以看到 官网的第三个参数是src 也就是数据源，而这里是value 。。。真是奇怪。
对于tensor.scatter函数 可以看 这篇
相信大家对scatter 都有了理解。 我们回来。
这里先创建一个 长是512 *200 = 102400 宽是10的向量。
而sim_labels的大小是 （102400，1） 这个scatter做了什么呢 ？ 如下
one_hot = torch.tensor
([[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0]])
sim_label = torch.tensor([[3],[4]])
print(one_hot.scatter(-1,sim_label,value=1))tensor([[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0]])也就是把每行标签对应得数字那一列变为1 ，如果这行特征得标签是1 就把第一个数变为1，这样子。 类似的有102400行。 得到onehot后 按我得想法， 就统计200行中哪一列的1最多呗。 比如前200行里 第3列的1对多， 就说明第一个样本最近的200个里，最多的标签是2 ，。我们看看他们怎么做的。
pred_scores = torch.sum(one_hot_label.view(feature.size(0), -1, classes) * sim_weight.unsqueeze(dim=-1), dim=1)one_hot_label.view(feature.size(0), -1, classes)
这句可以理解。 变回512 *200*10 这样就可以统计各自的两百个了。
sim_weight.unsqueeze(dim=-1)
sim_weight 虽然在上面做了一点变换，但是我们其实不用管他，因为上面只是一种归一化的方式，我们依然可以把它看作最近 当前样本特征和两百个点特征的乘积。unsqueeze 表示扩充一维 在最后， sim_weight就变成了 512 *200 *1。 我们如何理解这个pred_score呢？ 我们不要看512个样本。 我们只看一个样本。 对于一个样本。他的one_label是200*10 而sim_weight就是200 *1 特征的点乘结果，也就是200个相似度分数 。 从两行 看两百行 很显然 就是让各行的标签1 乘上那个相似度分数。 之后再对200这个维度求和，就得到了各个标签相似的分数的和。 维度1*10
c = one_hot.scatter(-1,sim_label,value=1)
d = torch.tensor([[3],[4]])
print(c*d)
#################
tensor([[0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0]])
tensor([[0, 0, 0, 3, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 4, 0, 0, 0, 0, 0]])
print(torch.sum(c*d,dim=0))
#########
tensor([0, 0, 0, 3, 4, 0, 0, 0, 0, 0])看到这里我们明白了 。 这里的knn并不是简单的从众，他还要看影响力。 更相似的样本，他的标签对我们的结果的影响力更大。 这里相当于对标签做了一个加权求和。
回到512维 我们得到了512*10的矩阵 表示512个样本的各个标签的相似度分数 我们只要argsort就可以得到最大值的下标啦。 np.argsort这个函数可以对向量排序 然后返回他们原来的下标 des 表示可以降序。
pred_labels = pred_scores.argsort(dim=-1, descending=True)
return pred_labels得到标签 ， 回到原来的knn
total_num += data.size(0)
total_top1 += (pred_labels[:, 0] == target).float().sum().item()
test_bar.set_postfix({'Accuracy':total_top1 / total_num * 100})
return total_top1 / total_num * 100这里是计算top1 我估计如果计算top5 估计就是 target in labels[:,4]了 得到预测标签后准确率久很好算了。
5 ：线性验证
继续跟着主函数走 。 可以看到一堆保存的步骤。 然后进入linear_eval函数。 我猜测是用backbone抽特征然后直接预测结果的函数。
train_loader = torch.utils.data.DataLoader(
dataset=get_dataset(
transform=get_aug(train=False, train_classifier=True, **args.aug_kwargs),
train=True,
**args.dataset_kwargs
),
batch_size=args.eval.batch_size,
shuffle=True,
**args.dataloader_kwargs
)
test_loader = torch.utils.data.DataLoader(
dataset=get_dataset(
transform=get_aug(train=False, train_classifier=False, **args.aug_kwargs),
train=False,
**args.dataset_kwargs
),
batch_size=args.eval.batch_size,
shuffle=False,
**args.dataloader_kwargs
)
model = get_backbone(args.model.backbone)
classifier = nn.Linear(in_features=model.output_dim, out_features=10, bias=True).to(args.device)
先读取训练集和测试集， 然后 model是resnet 一个分类器是 一个全连接。 我好奇的是为什么不直接把backbone最后一层的恒等映射改为这个分类器呢 ？
msg = model.load_state_dict({k[9:]:v for k, v in save_dict['state_dict'].items() if k.startswith('backbone.')}, strict=True)
载入模型 
k长这个样子 取出那些以backb开头的层 就是resnet的层。 然后去掉前面9个字母 就是resnet的名字。
classifier = torch.nn.DataParallel(classifier)
# define optimizer
optimizer = get_optimizer(
args.eval.optimizer.name, classifier,
lr=args.eval.base_lr*args.eval.batch_size/256,
momentum=args.eval.optimizer.momentum,
weight_decay=args.eval.optimizer.weight_decay)
# define lr scheduler
lr_scheduler = LR_Scheduler(
optimizer,
args.eval.warmup_epochs, args.eval.warmup_lr*args.eval.batch_size/256,
args.eval.num_epochs, args.eval.base_lr*args.eval.batch_size/256, args.eval.final_lr*args.eval.batch_size/256,
len(train_loader),
)
loss_meter = AverageMeter(name='Loss')
acc_meter = AverageMeter(name='Accuracy')定义优化器和loss 最下面这个averagemeter是啥呀
查了一下 就是一个类似于队列这种的 数据结构。 然后可以更新 关键是可以求平均。
for epoch in global_progress:
loss_meter.reset()
model.eval()
classifier.train()
local_progress = tqdm(train_loader, desc=f'Epoch {epoch}/{args.eval.num_epochs}', disable=True)
for idx, (images, labels) in enumerate(local_progress):
classifier.zero_grad()
with torch.no_grad():
feature = model(images.to(args.device))
preds = classifier(feature)
loss = F.cross_entropy(preds, labels.to(args.device))
loss.backward()
optimizer.step()
loss_meter.update(loss.item())
lr = lr_scheduler.step()
local_progress.set_postfix({'lr':lr, "loss":loss_meter.val, 'loss_avg':loss_meter.avg})
然后定义好后 就是一个普通的训练过程了 。 值得注意的是 model是eval模型 也就是他是冻住的，参数不改变。而classfier是可以改变的， 梯度回传也只回传分类头的梯度， 这里就只训练分类器。
classifier.eval()
correct, total = 0, 0
acc_meter.reset()
for idx, (images, labels) in enumerate(test_loader):
with torch.no_grad():
feature = model(images.to(args.device))
preds = classifier(feature).argmax(dim=1)
correct = (preds == labels.to(args.device)).sum().item()
acc_meter.update(correct/preds.shape[0])
print(f'Accuracy = {acc_meter.avg*100:.2f}')普通的测试。
6 ： 用自己数据集进行对比学习。
路走远了，别忘了开始的方向。 我们是用对比学习解决食物分类的问题的。
我们要做的有几件事情。
第一： 改数据集 ： 
把它原来的三个数据集全#了。
然后 加入自己的数据集。 使用他的增广方式。 但在增广前 需要在 dataset的get里加 topil 因为他的增广里没有这个。
hw3食物分类有三个数据集：
一个有标签训练集 我用来当memory
一个无标签训练集 我用来当train
一个验证集 我用来测试。
pil_trans = transforms.ToPILImage()
filepath = '/home/lhy/hw3/food-11'
train_loader = getDataLoader(filepath, 'train_unl', True, args.train.batch_size, transform=get_aug(train=True, train_classifier=False, **args.aug_kwargs))
memory_loader = getDataLoader(filepath, 'train', False,args.train.batch_size, transform=get_aug(train=False, train_classifier=False, **args.aug_kwargs))
test_loader = getDataLoader(filepath, 'val', False,args.train.batch_size, transform=get_aug(train=False, train_classifier=False, **args.aug_kwargs))
2 改变batch_size和图片大小。
在这个文件里改batch 你会发现这个对比学习的模型 出奇的占内存，当我图片大小为224时，我的batch只能设置为32.
main函数里改imagesize 为自己的。
点运行。O了 。 然后发现效果并不是很好。。。。。