一、代码慢慢阅读理解+总结内化：
1.关于torch.nn.covd2d()的参数含义、具体用法、功能：
（1）参数含义：
注意，里面的"padding"参数：《both》side所以是上下左右《四》边都会加一个padding数量的0列:
证明如下：
import torch
x = 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 torch
x = 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 = a
self.b = b
def __len__(self):
return self.b - self.a + 1 #（2）定义len函数，返回b-a+1
def __getitem__(self, index): #（3）定义getitem函数，有一个参数index,一般都是返回这个index位置的那一行数据
assert self.a-1 <= index <= self.b-1
return 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等
这个文章里面讲述得还算比较清晰，不过需要下载CIFAR-10的数据集
5.利用matplotlib中的plt.imread读取(同一个文件夹下)，plt.imshow和plt.show打印输出图像
import matplotlib.pyplot as plt
test = 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*32
nn.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时，出现了突破：
之后的结果就之后再说。。。