一、代码慢慢阅读理解+总结内化：

1.关于torch.nn.covd2d()的参数含义、具体用法、功能：

（1）参数含义：

注意，里面的“padding”参数：《both》side所以是上下左右《四》边都会加一个padding数量的0列:

证明如下：

import torchx = torch.randn(3,1,5,4)
print(x)conv = torch.nn.Conv2d(1,4,3,1,1)
res = conv(x)print(res.shape)    # torch.Size([3, 4, 5, 4])
#所以说，很明显，只要padding的参数设置为1 + filter大小为3*3，那么输出的图像高、宽==输入的高、宽

运行结果：torch.Size([3, 4, 5, 4]

(2)具体用法：

import torchx = torch.randn(3,1,5,4)
print(x)conv = torch.nn.Conv2d(1,4,(2,3))
res = conv(x)print(res.shape)    # torch.Size([3, 4, 4, 2])

输入：x[ batch_size, channels, height_1, width_1 ]
batch_size，一个batch中样本的个数 3
channels，通道数，也就是当前层的深度 1
height_1， 图片的高 5
width_1， 图片的宽 4

卷积操作：Conv2d[ channels, output, height_2, width_2 ]
channels，通道数，和上面保持一致，也就是当前层的深度 1
output ，输出的深度 4【需要4个filter】
height_2，卷积核的高 2
width_2，卷积核的宽 3

输出：res[ batch_size,output, height_3, width_3 ]
batch_size,，一个batch中样例的个数，同上 3
output， 输出的深度 4
height_3， 卷积结果的高度 4
width_3，卷积结果的宽度 2

（3）功能：

里面实现的功能,应该就是实现利用自己设定数量的filters，进行按照自己设定的stride、padding的方式对整个图像进行二维卷积，得到一个新的channel的图像,

新的channels的数目 == filters的数目,

至于输出的图像的size，需要自己进行计算一下！！！

2.torch.nn.BatchNorm2d()的参数含义、用法、功能作用：

（1）参数含义:

（2）用法示例：

里面看到的randn()

输入：x[ batch_size, channels, height_1, width_1 ]
batch_size，一个batch中样本的个数 2，也就是有2个tensor张量，后面3是张量的厚、高、宽

channel的大小是3

高、宽都是2

import torch.nn as nn
import torch
if __name__ == '__main__':bn = nn.BatchNorm2d(3)ip = torch.randn(2, 3, 2, 2)print(ip)output = bn(ip)print(output)

（3）功能作用：

BatchNorm为什么NB呢，关键还是效果好。①不仅仅极大提升了训练速度，收敛过程大大加快；②还能增加分类效果，一种解释是这是类似于Dropout的一种防止过拟合的正则化表达方式，所以不用Dropout也能达到相当的效果；③另外调参过程也简单多了，对于初始化要求没那么高，而且可以使用大的学习率等。总而言之，经过这么简单的变换，带来的好处多得很，这也是为何现在BN这么快流行起来的原因。

具体参见这一篇文章：白话详细解读（七）----- Batch Normalization_底层研究生的博客-CSDN博客

3.torch.nn.MaxPool2d()最大池化（pooling）函数：

(1)参数含义：

nn.MaxPool2d(2, 2, 0), #但是pooling会改变图像的大小,图像会变成64*（128/2）*(128/2)

第一个“2”： 代表kernel_size,也就是窗口的大小，这里只有1个数值，那就是正方形的了

第二个“2”：代表stride，这里只有1个数值，那么就是向右的时候2个，向下的时候，也是2个

第三个“0”：代表在4个边加padding层的层数

（2）用法示例：

torch.nn.MaxPool2d详解_Medlen的博客-CSDN博客

具体可以参见这一篇博客，每个参数的用法讲述得非常详细

（3）作用：

主要是为了减少图像的高、宽size，和图像压缩的思想一致，也是利用了对于“下采样”的话，人眼对图像的感知是不会发生改变的

4.DataLoader的使用-初探：

（1）一个最基础的实例：

import torch
from torch.utils.data import Dataset, DataLoader
#下面逐步分析如下创建Dataset 和 DataLoader的示例代码#1.从已经定义好的Dataset基类中继承得到Plus1Dataset类
class Plus1Dataset(Dataset):def __init__(self, a=0, b=1): #（1）定义这个类的构造函数，self是固定的要求，a,b是自己设置的变量super(Dataset, self).__init__()#继承得到积累的构造函数assert a <= b #需要a<=b,否则终断开(断言语法)self.a = aself.b = bdef __len__(self):return self.b - self.a + 1 #（2）定义len函数，返回b-a+1def __getitem__(self, index): #（3）定义getitem函数，有一个参数index,一般都是返回这个index位置的那一行数据assert self.a-1 <= index <= self.b-1return index, index+1
#2.实例化创建Plus1Dataset和DataLoader的对象
data_train = Plus1Dataset(a=1,b=16)
data_train_loader = DataLoader(data_train, batch_size=4, shuffle=True)
print(len(data_train))  

从这个实例可以看出，

Dataset只是一个数据的容器，它是Loader的一部分

但是呢，DataLoader里面不仅有数据，还有对数据进行处理的方法，比如batch_size的大小，是否shuffle等

(2)http://t.csdn.cn/6H0LG

这个文章里面讲述得还算比较清晰，不过需要下载CIFAR-10的数据集

5.利用matplotlib中的plt.imread读取(同一个文件夹下)，plt.imshow和plt.show打印输出图像

import matplotlib.pyplot as plttest = plt.imread("./00000000.png")plt.imshow(test)
plt.axis('off')  # 关闭坐标轴
plt.show()

6.使用PIL库中的Image进行操作图像：

from PIL import Image# Load the image
image = Image.open("image.jpg")# Save the image with a new name and format
output_path = "output.png"
image.save(output_path, "PNG")# Show the output path
print("Image saved at:", output_path)

通过Image.open打开的对象可以直接作为transforms的参数，它可以和numpy.array进行转换，上面用plt打开的方式其实得到的是numpy.array对象，不能直接transform

7.torchvision.transforms模块-初探：

慢慢阅读学习+自己实践一下是否可以对一个图像进行这样的处理

import matplotlib.pyplot as plt
from PIL import Image
test = plt.imread("./00000000.png")
test2 = Image.open("00000000.png")#plt.imshow(test)
#plt.axis('off')#plt.show()
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]import torchvision.transforms as transforms
train_transforms =transforms.Compose([transforms.Resize((500,500)), #这个函数可以将图像转变为统一的500*500的大小#transforms.CenterCrop(300), #这个就是从中心裁剪300*300的大小的图片，原来其他部分都不要了#transforms.RandomCrop(300), #随机裁剪出一个300*300部分#transforms.RandomHorizontalFlip(0.5),#以0.5个概率进行水平翻转#transforms.RandomRotation(degrees=45),#在不超过45度的范围内进行随机旋转#transforms.Normalize(mean = mean,std=std) #反正就是 归一化，没什么好说的#transforms.ToTensor(),#这个用得挺多的，就是将图像转换为tensor的数据类型#transforms.ColorJitter(brightness=0.5,contrast=0.5,saturation=0.5,hue=0.5),#分别设置亮度，对比度，饱和度，色调的偏差范围[随机]#transforms.Grayscale(), #将图像转变为channel==1的灰度图])img1 = train_transforms(test2)#下面是存储一个Image类型的图片放到该目录下的方式
save_path = "test_output.png"
img1.save(save_path,"PNG")
print("Image as below:",save_path)img1.show() #似乎Image只有这个函数可以显示图像，而且是用默认图像查看器打开的，算了，就这样吧
#和上面的plt有些不同plt是在下面输出显示绘制

8.torch.nn.Softmax()函数讲解：

Pytorch nn.Softmax(dim=?) - 知乎 (zhihu.com)

这篇文章中详细讲解了 Softmax函数中的dim参数的用法：

这篇文章描述得非常清晰，比chatGPT讲的好多了

9.防止梯度爆炸的函数utils.clip_grad_norm(,)的用法：

10.调用argmax函数，在最后一个维度中的每一组的抽取出max值的位置索引组成一个向量，用于和label中的数据进行比较，从而计算accuracy：

二、定义的基本classifier模型：

class Classifier(nn.Module): #这里定义了这个CNN食物图像分类的nuaral network结构def __init__(self):super(Classifier, self).__init__()# The arguments for commonly used modules:# torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)# torch.nn.MaxPool2d(kernel_size, stride, padding)# input image size: [3, 128, 128]#需要我进一步进行慢慢学习的是：#（1）这个Convd函数的参数的意义？以及具体的实现是什么？#答：里面实现的功能,应该就是实现利用自己设定数量的filters，进行按照自己设定的stride、padding的方式对整个图像进行二维卷积，得到一个新的channel的图像#...具体见csdn#（2）这个BatchNorm2d函数的参数的意义？以及实现的功能是什么#（3）这里特别需要注意的是，这次用的数据是图像，最开始有对图像进行transform.resize(128,128),所以图像的pixel大小应该是3*128*128#所以，这个图像数据到底经历了什么？self.cnn_layers = nn.Sequential(nn.Conv2d(3, 64, 3, 1, 1), #通过我的计算，输出的大小应该是64[厚]*128[高]*128[宽]nn.BatchNorm2d(64), #参数是channels（filters）的数量，只会改变数据分布，不会改变数据形状nn.ReLU(), #先通过BN,再使用ReLU是真的香，这样就可以最大化的利用BN得到的（0，1）正太分布了nn.MaxPool2d(2, 2, 0),#但是pooling会改变图像的大小,图像会变成64*（128/2）*(128/2)nn.Conv2d(64, 128, 3, 1, 1),nn.BatchNorm2d(128),nn.ReLU(),nn.MaxPool2d(2, 2, 0),#图像大小128*32*32nn.Conv2d(128, 256, 3, 1, 1),nn.BatchNorm2d(256),nn.ReLU(),nn.MaxPool2d(4, 4, 0),#图像大小256*8*8)self.fc_layers = nn.Sequential(nn.Linear(256 * 8 * 8, 256),nn.ReLU(),nn.Linear(256, 256),nn.ReLU(),nn.Linear(256, 11))def forward(self, x):# input (x): [batch_size, 3, 128, 128]# output: [batch_size, 11]# Extract features by convolutional layers.x = self.cnn_layers(x)# The extracted feature map must be flatten before going to fully-connected layers.x = x.flatten(1) #需要展平之后，才能调用Linear()层# The features are transformed by fully-connected layers to obtain the final logits.x = self.fc_layers(x)return x

三、定义get_pseudo_labels函数:

这个函数，就是为了使用哪些没有label的数据，从而实现semi-unsupervised的训练方式，这里暂时先不考虑

def get_pseudo_labels(dataset, model, threshold=0.65): #参数是dataset,model和门槛# This functions generates pseudo-labels of a dataset using given model.# It returns an instance of DatasetFolder containing images whose prediction confidences exceed a given threshold.# You are NOT allowed to use any models trained on external data for pseudo-labeling.device = "cuda" if torch.cuda.is_available() else "cpu"#设备选择# Construct a data loader.data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=False) #创建一个data_loader# Make sure the model is in eval mode.model.eval()# Define softmax function.softmax = nn.Softmax(dim=-1)# Iterate over the dataset by batches.for batch in tqdm(data_loader):img, _ = batch# Forward the data# Using torch.no_grad() accelerates the forward process.with torch.no_grad():logits = model(img.to(device))# Obtain the probability distributions by applying softmax on logits.probs = softmax(logits)# ---------- TODO ----------# Filter the data and construct a new dataset.# # Turn off the eval mode.model.train()return dataset

四、train部分：

# ---------- Training ----------# Make sure the model is in train mode before training.model.train() #开启train模式# These are used to record information in training.train_loss = [] #准备好记录train过程中的loss数值和accuracy的数值train_accs = []# Iterate the training set by batches.for batch in tqdm(train_loader): #每一个batch中进行的操作# A batch consists of image data and corresponding labels.imgs, labels = batch #从这个batch中获取到imgs数据数组 和 labels数据数组# Forward the data. (Make sure data and model are on the same device.)logits = model(imgs.to(device)) #计算出这一个batch的logits# Calculate the cross-entropy loss.# We don't need to apply softmax before computing cross-entropy as it is done automatically.loss = criterion(logits, labels.to(device)) #计算logits和labels之间的loss# Gradients stored in the parameters in the previous step should be cleared out first.optimizer.zero_grad() #清空之前的grad# Compute the gradients for parameters.loss.backward()# Clip the gradient norms for stable training.grad_norm = nn.utils.clip_grad_norm_(model.parameters(), max_norm=10)# Update the parameters with computed gradients.optimizer.step() #调用backward+step进行常规化的模型更新 + clip_grad_norm防止梯度爆炸# Compute the accuracy for current batch.acc = (logits.argmax(dim=-1) == labels.to(device)).float().mean()# Record the loss and accuracy.train_loss.append(loss.item()) #将这个batch的loss放到数组中train_accs.append(acc)     #将这个batch的acc放到数组中#一个epoch完成，接下来就是计算这一次的均值，然后进行打印输出# The average loss and accuracy of the training set is the average of the recorded values.train_loss = sum(train_loss) / len(train_loss) train_acc = sum(train_accs) / len(train_accs)# Print the information.print(f"[ Train | {epoch + 1:03d}/{n_epochs:03d} ] loss = {train_loss:.5f}, acc = {train_acc:.5f}")

五、validation部分：

 #validtion部分和train部分基本一样，处理backward+step哪里不需要了# ---------- Validation ----------# Make sure the model is in eval mode so that some modules like dropout are disabled and work normally.model.eval()# These are used to record information in validation.valid_loss = []valid_accs = []# Iterate the validation set by batches.for batch in tqdm(valid_loader):# A batch consists of image data and corresponding labels.imgs, labels = batch# We don't need gradient in validation.# Using torch.no_grad() accelerates the forward process.with torch.no_grad():logits = model(imgs.to(device))# We can still compute the loss (but not the gradient).loss = criterion(logits, labels.to(device))# Compute the accuracy for current batch.acc = (logits.argmax(dim=-1) == labels.to(device)).float().mean()# Record the loss and accuracy.valid_loss.append(loss.item())valid_accs.append(acc)# The average loss and accuracy for entire validation set is the average of the recorded values.valid_loss = sum(valid_loss) / len(valid_loss)valid_acc = sum(valid_accs) / len(valid_accs)# Print the information.print(f"[ Valid | {epoch + 1:03d}/{n_epochs:03d} ] loss = {valid_loss:.5f}, acc = {valid_acc:.5f}")

六、test部分：

# Make sure the model is in eval mode.
# Some modules like Dropout or BatchNorm affect if the model is in training mode.
model.eval()# Initialize a list to store the predictions.
predictions = [] #开启eval()模式后，设置一个pred数组，用于存储通过model计算得到的预测结果，之后用于和labels进行比较# Iterate the testing set by batches.
for batch in tqdm(test_loader): #还是利用tqdm进行迭代,一个个的batch进行处理# A batch consists of image data and corresponding labels.# But here the variable "labels" is useless since we do not have the ground-truth.# If printing out the labels, you will find that it is always 0.# This is because the wrapper (DatasetFolder) returns images and labels for each batch,# so we have to create fake labels to make it work normally.imgs, labels = batch #获取图像数据# We don't need gradient in testing, and we don't even have labels to compute loss.# Using torch.no_grad() accelerates the forward process.with torch.no_grad():logits = model(imgs.to(device)) #计算得到预测的结果# Take the class with greatest logit as prediction and record it.predictions.extend(logits.argmax(dim=-1).cpu().numpy().tolist()) #直接将预测的logits转换为preditions里面一些one-hot vec

七、创建predict.csv文件，并且将prediction数组中的结果进行写入:

# Save predictions into the file.
with open("predict.csv", "w") as f: #创建一个predict.csv文件# The first row must be "Id, Category"f.write("Id,Category\n")  #第一行是:Id, Category# For the rest of the rows, each image id corresponds to a predicted class.for i, pred in  enumerate(predictions): #将predictions中的结果逐个写入到这个文件中f.write(f"{i},{pred}\n")

训练的结果，就算是sample的代码用T4,也要跑25分钟才能跑完80个epoch

(1)这是用sample代码跑34个epoch时的 accuracy，在train上面已经很好了，但是在valid上面还是处于50%左右

(2)在第40个epoch时，出现了突破：

之后的结果就之后再说。。。