一、代码慢慢阅读理解+总结内化:
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等
(2)http://t.csdn.cn/6H0LG
这个文章里面讲述得还算比较清晰,不过需要下载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时,出现了突破:
文章来源:https://www.toymoban.com/news/detail-704256.html
之后的结果就之后再说。。。文章来源地址https://www.toymoban.com/news/detail-704256.html
到了这里,关于李宏毅-21-hw3:对11种食物进行分类-CNN的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!