新手小白的pytorch学习第十四弹------十一、十二、十三弹卷积神经网络CNN的习题

习题编号目录

No 1
No 2
No 3
No 4
No 5
No 6
No 7
No 8
No 9
No 10
No 11
No 12
No 13

练习题主要就是 写代码，所以这篇文章大部分是代码哟~

No 1

What are 3 areas in industry where computer vision is currently being used?

No 2

工业异常检测，目标检测

Search “what is overfitting in machine learning” and write down a sentence about what you find.

“overfitting”,就是过拟合，学的特征太多了，太细节了。
举个例子：
一个模型需要学习树叶，来分辨这个图片是不是树叶，但我们的数据比较有特点，是锯齿状的树叶，模型学到了锯齿状，于是就判定圆形的树叶不是树叶啦，这就是过拟合。
很明显过拟合会影响模型的泛化性能。

No 3

Search “ways to prevent overfitting in machine learning”, write down 3 of the things you find and a sentence about each. Note: there are lots of these, so don’t worry too much about all of them, just pick 3 and start with those.

数据集扩充：通过增加训练数据集的样本数量来减少模型对训练数据的过度拟合，从而提高模型的泛化性能。eg：生成一些类似但不完全相同的样本来扩充训练集。这些类似但不完全相同的样本可以通过对原始数据集进行一些变换操作得到，比如图像数据可以进行翻转、旋转、缩放等操作。
正则化：可以通过在模型的损失函数中加入一项正则化项，对模型进行约束，使其在学习过程中对训练数据的拟合程度受到一定程度的限制。正则化的思想是通过对模型的参数进行惩罚，使得模型的权重变得更小，从而降低模型的复杂度，提高泛化能力。
数据降维：将高维数据映射到低维空间，可以减少特征之间的冗余信息，从而提高模型的泛化能力。有两种方法：特征选择和特征提取。特征选择是指从原始特征中选择最相关的特征，从而达到降低数据维度的目的。而特征提取则是通过某种算法将原始特征转化为新的特征，从而达到降低数据维度的目的。

No 4

Spend 20-minutes reading and clicking through the CNN Explainer website.
* Upload your own example image using the “upload” button and see what happens in each layer of a CNN as your image passes through it.

No 5

Load the torchvision.datasets.MNIST() train and test datasets.

import torchvision
import torchvision.datasets as datasets
from torchvision.transforms import ToTensortrain_data = datasets.MNIST(root='data',train=True,download=True,transform=ToTensor(),target_transform=None)
test_data = datasets.MNIST(root='data',train=False,download=True,transform=ToTensor(),target_transform=None)

No 6

Visualize at least 5 different samples of the MNIST training dataset.

image, label = train_data[0]
image, label

(tensor([[[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000, 0.0000, 0.0000, 0.0000],
[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000, 0.0000, 0.0000, 0.0000, 0.0118, 0.0706, 0.0706, 0.0706,
0.4941, 0.5333, 0.6863, 0.1020, 0.6510, 1.0000, 0.9686, 0.4980,
0.0000, 0.0000, 0.0000, 0.0000],
[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
…
[0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,
0.0000, 0.0000, 0.0000, 0.0000]]]),
5)
Output is truncated. View as a scrollable element or open in a text editor. Adjust cell output settings…

class_names = train_data.classes
class_names

[‘0 - zero’,
‘1 - one’,
‘2 - two’,
‘3 - three’,
‘4 - four’,
‘5 - five’,
‘6 - six’,
‘7 - seven’,
‘8 - eight’,
‘9 - nine’]

train_data

Dataset MNIST
Number of datapoints: 60000
Root location: data
Split: Train
StandardTransform
Transform: ToTensor()

import matplotlib.pyplot as plt
image, label = train_data[0]
plt.imshow(image.squeeze(), cmap="gray")
plt.title(class_names[label])

在这里插入图片描述

import random
train_samples = []
train_labels = []
for sample, label in random.sample(list(train_data), k=5):train_samples.append(sample)train_labels.append(label)train_samples[0].shape

torch.Size([1, 28, 28])

import torch
import matplotlib.pyplot as plttorch.manual_seed(42)
plt.figure(figsize=(10, 5))
nrows = 1
ncols = 5
for i, sample in enumerate(train_samples):plt.subplot(nrows, ncols, i+1)plt.imshow(sample.squeeze(), cmap="gray")plt.axis(False)# plt.title(class_names[train_label])

在这里插入图片描述

No 7

Turn the MNIST train and test datasets into dataloaders using torch.utils.data.DataLoader, set the batch_size=32.

from torch.utils.data import DataLoaderBATCH_SIZE=32train_dataloader = DataLoader(dataset=train_data,shuffle=True,batch_size=BATCH_SIZE)
test_dataloader = DataLoader(dataset=test_data,batch_size=BATCH_SIZE,shuffle=False)

train_dataloader, test_dataloader

(<torch.utils.data.dataloader.DataLoader at 0x1f4d79a95e0>,
<torch.utils.data.dataloader.DataLoader at 0x1f4df3b0e50>)

No 8

Recreate model_2 used in this notebook (the same model from the CNN Explainer website, also known as TinyVGG) capable of fitting on the MNIST dataset.

# 设备无关代码
device = "cuda" if torch.cuda.is_available() else "cpu"
device

‘cuda’

创建模型

import torch.nn as nn
# 创建 CNN 模型
class MNISTModelV0(nn.Module):def __init__(self, input_shape:int, hidden_units:int, output_shape:int):super().__init__()self.conv_block_1 = nn.Sequential(nn.Conv2d(in_channels=input_shape,out_channels=hidden_units,kernel_size=(3, 3),stride=1,padding=1),nn.ReLU(),nn.Conv2d(in_channels=hidden_units,out_channels=hidden_units,kernel_size=(3, 3),stride=1,padding=1),nn.ReLU(),nn.MaxPool2d(kernel_size=(2, 2)))self.conv_block_2 = nn.Sequential(nn.Conv2d(in_channels=hidden_units,out_channels=hidden_units,kernel_size=(3, 3),stride=1,padding=1),nn.ReLU(),nn.Conv2d(in_channels=hidden_units,out_channels=hidden_units,kernel_size=(3, 3),stride=1,padding=1),nn.ReLU(),nn.MaxPool2d(kernel_size=(2, 2)))self.classifier = nn.Sequential(nn.Flatten(),nn.Linear(in_features=hidden_units*7*7,out_features=output_shape))def forward(self, x):x = self.conv_block_1(x)# print(f"Output shape of conv_block_1:{x.shape}")x = self.conv_block_2(x)# print(f"Output shape of conv_block_2:{x.shape}")x = self.classifier(x)# print(f"Output shape of classifier:{x.shape}")return x

# 实例化模型
model_0 = MNISTModelV0(input_shape=1,hidden_units=10,output_shape=len(class_names))
model_0.to(device)

MNISTModelV0(
(conv_block_1): Sequential(
(0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
)
(conv_block_2): Sequential(
(0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU()
(2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU()
(4): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
)
(classifier): Sequential(
(0): Flatten(start_dim=1, end_dim=-1)
(1): Linear(in_features=490, out_features=10, bias=True)
)
)

先搞个测试数据传一下，后面报错了，我们来找找是什么原因这个方法真的好用！！！

random_image_tensor = torch.randn(size=(1, 28, 28))
random_image_tensor.shape

torch.Size([1, 28, 28])

# 把这个测试数据传递给模型看看会不会报错
model_0.to(device)
model_0(random_image_tensor.unsqueeze(0).to(device))

tensor([[ 0.0366, -0.0940, 0.0686, -0.0485, 0.0068, 0.0290, 0.0132, 0.0084,
-0.0030, -0.0185]], device=‘cuda:0’, grad_fn=< AddmmBackward0>)

通过print方法，知道是模型中传递给网络的输入输出有问题

No 9

Train the model you built in exercise 8. on CPU and GPU and see how long it takes on each.

image, label  = train_data[0]
image.shape

torch.Size([1, 28, 28])

BB，这些函数都是我们之前学习过的喔喔喔

# 损失函数和优化器
import torch.optim as optim
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(params=model_0.parameters(),lr=0.1)

# 训练函数
def train_step(model:nn.Module,dataloader:DataLoader,loss_fn:nn.Module,optimizer:torch.optim.Optimizer,accuracy_fn,device:torch.device = device):# 设置循环周期train_loss, train_acc = 0, 0model.train()for batch, (X, y) in enumerate(dataloader):# 将数据放到统一的设备上X, y = X.to(device), y.to(device)y_pred = model(X)loss = loss_fn(y_pred,y)train_loss += losstrain_acc += accuracy_fn(y_true=y,y_pred=y_pred.argmax(dim=1))optimizer.zero_grad()loss.backward()optimizer.step()train_loss /= len(dataloader)train_acc /= len(dataloader)print(f"Train Loss:{train_loss:.4f} | Train Acc:{train_acc:.2f}%")

# 测试函数
def test_step(model:nn.Module,dataloader:DataLoader,loss_fn:nn.Module,accuracy_fn,device:torch.device=device):"""Peroforms a testing loop step on model going over data_loader"""test_loss, test_acc = 0, 0model.eval()with torch.inference_mode():for X, y in dataloader:X, y = X.to(device), y.to(device)y_pred = model(X)test_loss += loss_fn(y_pred, y)test_acc += accuracy_fn(y_true=y,y_pred=y_pred.argmax(dim=1))test_loss /= len(dataloader)test_acc /= len(dataloader)print(f"Test Loss:{test_loss:.4f} | Test Acc:{test_acc:.2f}%\n")

# 评估函数
def eval_model(model:nn.Module,dataloader:DataLoader,loss_fn:nn.Module,accuracy_fn,device=device):"""Returns a dictionary containing the results of model predicting on data_loader..."""loss, acc = 0, 0model.eval()with torch.inference_mode():for X, y in dataloader:X, y = X.to(device), y.to(device)y_pred = model(X)loss += loss_fn(y_pred, y)acc += accuracy_fn(y_true=y,y_pred=y_pred.argmax(dim=1))loss /= len(dataloader)acc /= len(dataloader)return {"model_name":model.__class__.__name__,"model_loss":loss.item(),"model_acc":acc}

from timeit import default_timer as timer
def print_train_time(start:float,end:float,device:torch.device=None):"""Prints difference between start and end time."""total_time = end - startprint(f"Train time on {device}:{total_time:.3f} seconds")return total_time

# Calculate accuracy (a classification metric)
def accuracy_fn(y_true, y_pred):"""Calculates accuracy between truth labels and predictions.Args:y_true (torch.Tensor): Truth labels for predictions.y_pred (torch.Tensor): Predictions to be compared to predictions.Returns:[torch.float]: Accuracy value between y_true and y_pred, e.g. 78.45"""correct = torch.eq(y_true, y_pred).sum().item()acc = (correct / len(y_pred)) * 100return acc

训练模型

from tqdm.auto import tqdmfrom helper_functions import accuracy_fn
# train and test on GPU
train_start_time_on_gpu = timer()epochs=3for epoch in tqdm(range(epochs)):print(f"Epoch:{epoch}\n")train_step(model=model_0,dataloader=train_dataloader,loss_fn=loss_fn,optimizer=optimizer,accuracy_fn=accuracy_fn,device=device)test_step(model=model_0,dataloader=test_dataloader,loss_fn=loss_fn,accuracy_fn=accuracy_fn,device=device)train_end_time_on_gpu = timer()
total_time_on_gpu = print_train_time(start=train_start_time_on_gpu,end=train_end_time_on_gpu,device=device)

在这里插入图片描述
我简直了，我都不敢信，这准确率是多少！
来，Ada，张开你的卡姿兰大眼睛看看这个数字，到底是多少
啊啊啊啊啊，98%啊，天哪噜，98%，震惊！
喔霍霍，妈呀，好好好

model_0_result = eval_model(model=model_0,dataloader=test_dataloader,loss_fn=loss_fn,accuracy_fn=accuracy_fn,device=device)
model_0_result

{‘model_name’: ‘MNISTModelV0’,
‘model_loss’: 0.05393431708216667,
‘model_acc’: 98.10303514376997}

No 10

Make predictions using your trained model and visualize at least 5 of them comparing the prediciton to the target label.

def make_prediction(model:nn.Module,data: list,device:torch.device=device):pred_probs=[]model.to(device)model.eval()with torch.inference_mode():for sample in data:sample = torch.unsqueeze(sample, dim=0).to(device)pred_logit = model(sample)pred_prob = torch.softmax(pred_logit.squeeze(),dim=0)pred_probs.append(pred_prob.cpu())# Stack the pred_probs to turn list into a tensorreturn torch.stack(pred_probs)

import random
test_samples = []
test_labels = []
for sample, label in random.sample(list(test_data),k=9):test_samples.append(sample)test_labels.append(label)

# make predictions
pred_probs = make_prediction(model=model_0,data=test_samples,device=device)
pred_probs

tensor([[1.0177e-07, 9.6744e-08, 9.0552e-05, 4.1145e-07, 3.1134e-09, 9.2933e-08,
1.0455e-07, 8.3808e-07, 9.9990e-01, 1.0561e-05],
[7.0788e-10, 1.9963e-08, 1.1445e-07, 7.4835e-07, 1.0650e-04, 1.4251e-06,
2.5626e-12, 5.2849e-06, 8.3278e-06, 9.9988e-01],
[2.0574e-11, 2.7979e-05, 9.9959e-01, 3.6853e-04, 1.0323e-13, 1.5242e-13,
1.8023e-12, 9.5447e-06, 5.1182e-07, 4.4869e-12],
[2.2204e-10, 6.1201e-10, 4.8230e-05, 1.4246e-06, 3.8657e-12, 6.7251e-07,
9.1211e-10, 1.9719e-08, 9.9995e-01, 4.0643e-07],
[2.1181e-15, 8.9004e-13, 4.7079e-13, 3.2457e-08, 5.5606e-11, 1.0000e+00,
9.1563e-09, 4.4056e-17, 3.3977e-08, 3.1905e-08],
[1.4000e-05, 5.6517e-10, 1.0992e-05, 4.6077e-11, 9.9994e-01, 5.4655e-09,
4.8744e-06, 8.1010e-06, 7.0937e-08, 2.0188e-05],
[9.9992e-01, 6.8991e-11, 7.1014e-05, 6.2839e-11, 3.7751e-11, 2.0786e-07,
7.2334e-07, 9.5343e-10, 4.6806e-06, 7.3413e-08],
[7.6309e-13, 3.0353e-10, 7.0295e-10, 4.9777e-07, 2.5954e-14, 8.0768e-12,
9.5778e-17, 1.0000e+00, 1.0831e-10, 1.9796e-08],
[1.4944e-11, 7.4691e-13, 2.8261e-12, 6.1482e-08, 1.7732e-11, 1.0000e+00,
4.6807e-09, 2.5018e-11, 1.3533e-07, 2.7457e-06]])

pred_classes = pred_probs.argmax(dim=1)
pred_classes

tensor([8, 9, 2, 8, 5, 4, 0, 7, 5])

# plot predictions
plt.figure(figsize=(9,9))
nrows = 3
ncols = 3
for i, sample in enumerate(test_samples):plt.subplot(nrows, ncols, i+1)plt.imshow(sample.squeeze(), cmap="gray")pred_label = class_names[pred_classes[i]]truth_label = class_names[test_labels[i]]title_text = f"Pred:{pred_label} | Truth:{truth_label}"# 预测正确是绿色的title， 预测错误是红色的titleif pred_label == truth_label:plt.title(title_text, fontsize=10, c="g")else:plt.title(title_text, fontsize=10, c="r")plt.axis(False);

在这里插入图片描述

No 11

Plot a confusion matrix comparing your model’s predictions to the truth labels.

from tqdm.auto import tqdm# 1 在测试数据上使用我们训练好的模型
y_preds = []
model_0.eval()
with torch.inference_mode():for X, y in test_dataloader:X, y = X.to(device), y.to(device)y_logit = model_0(X)y_pred = torch.softmax(y_logit.squeeze(), dim=0).argmax(dim=1)y_preds.append(y_pred.cpu())# Concatenate list of predictions into a tensor
y_pred_tensor = torch.cat(y_preds)
y_pred_tensor

tensor([7, 2, 1, …, 4, 5, 6])

from torchmetrics import ConfusionMatrix
from mlxtend.plotting import plot_confusion_matrix# 2 制作confusion实例，将预测和标签进行比较
confmat = ConfusionMatrix(num_classes=len(class_names),task='multiclass')
confmat_tensor = confmat(preds = y_pred_tensor,target = test_data.targets)# 3 plot the confusion matrix
fig, ax = plot_confusion_matrix(conf_mat=confmat_tensor.numpy(), # matplotlib likes working with numpyclass_names = class_names,figsize=(10, 7)
)

在这里插入图片描述

No 12

Create a random tensor of shape [1, 3, 64, 64] and pass it through a nn.Conv2d() layer with various hyperparameter settings (these can be any settings you choose), what do you notice if the kernel_size parameter goes up and down?

import random
random_tensor = torch.randn(size=(1, 3, 64, 64))
random_tensor

tensor([[[[-0.6684, 0.4637, -0.3516, …, -0.6252, 0.6887, 0.2075],
[-1.1143, -1.2353, 0.3464, …, -0.7403, 0.3211, 0.2074],
[-0.1284, -1.0946, 0.4482, …, 0.7574, -0.2992, -0.0710],
…,
[ 1.5077, 0.2374, 0.2925, …, -0.2159, -0.6532, -1.2062],
[ 1.9584, 0.8458, 0.3636, …, 0.3946, 0.1667, -1.6578],
[ 1.1362, 1.9202, 1.0445, …, -0.4046, 0.9407, -0.3916]],
[-0.8766, -0.2172, 0.5522, …, -0.0553, -0.6218, 0.3710],
…,
[ 1.8482, -0.2374, 1.4276, …, -0.2379, 0.7371, -1.8488],
[-0.6760, 1.0012, -0.3990, …, -1.4388, -2.0143, -0.9468],
[-0.7640, 0.7572, 0.8566, …, -0.8063, -1.2623, -0.0394]]]])

conv_layer = nn.Conv2d(in_channels=3,out_channels=2,kernel_size=(3, 3),stride=1,padding=1)

# 将随机生成的数据放到 conv_layer 中
random_tensor_through_conv = conv_layer(random_tensor)
random_tensor_through_conv.shape

torch.Size([1, 2, 64, 64])

conv_layer = nn.Conv2d(in_channels=3,out_channels=2,kernel_size=(5,5),stride=1,padding=1)# 将随机生成的数据放到 conv_layer 中
random_tensor_through_conv = conv_layer(random_tensor)
random_tensor_through_conv.shape

torch.Size([1, 2, 62, 62])

conv_layer = nn.Conv2d(in_channels=3,out_channels=2,kernel_size=(10, 10),stride=1,padding=1)# 将随机生成的数据放到 conv_layer 中
random_tensor_through_conv = conv_layer(random_tensor)
random_tensor_through_conv.shape

torch.Size([1, 2, 57, 57])

conv_layer = nn.Conv2d(in_channels=3,out_channels=2,kernel_size=(30, 30),stride=1,padding=1)# 将随机生成的数据放到 conv_layer 中
random_tensor_through_conv = conv_layer(random_tensor)
random_tensor_through_conv.shape

torch.Size([1, 2, 37, 37])

conv_layer = nn.Conv2d(in_channels=3,out_channels=2,kernel_size=(64, 64),stride=1,padding=1)# 将随机生成的数据放到 conv_layer 中
random_tensor_through_conv = conv_layer(random_tensor)
random_tensor_through_conv.shape

torch.Size([1, 2, 3, 3])

conv_layer = nn.Conv2d(in_channels=3,out_channels=2,kernel_size=(65, 65),stride=1,padding=1)# 将随机生成的数据放到 conv_layer 中
random_tensor_through_conv = conv_layer(random_tensor)
random_tensor_through_conv.shape

torch.Size([1, 2, 2, 2])

conv_layer = nn.Conv2d(in_channels=3,out_channels=2,kernel_size=(66, 66),stride=1,padding=1)# 将随机生成的数据放到 conv_layer 中
random_tensor_through_conv = conv_layer(random_tensor)
random_tensor_through_conv.shape

torch.Size([1, 2, 1, 1])

卷积核的大小，padding，stride都影响降低维度的量，比如我的padding是1，那我的kernel_size就可以达到66，而不是刚开始的64，就可以将维度降为1

No 13

Use a model similar to the trained model_2 from this notebook to make predictions on the test torchvision.datasets.FashionMNIST dataset.
* Then plot some predictions where the model was wrong alongside what the label of the image should’ve been.
* After visualing these predictions do you think it’s more of a modelling error or a data error?
* As in, could the model do better or are the labels of the data too close to each other (e.g. a “Shirt” label is too close to “T-shirt/top”)?

fashion_train_data = datasets.FashionMNIST(root='data',train=True,transform=ToTensor(),download=True,target_transform=None)
fashion_test_data = datasets.FashionMNIST(root='data',train=False,download=True,transform=ToTensor(),target_transform=None)

fashion_train_data,fashion_test_data

(Dataset FashionMNIST
Number of datapoints: 60000
Root location: data
Split: Train
StandardTransform
Transform: ToTensor(),
Dataset FashionMNIST
Number of datapoints: 10000
Root location: data
Split: Test
StandardTransform
Transform: ToTensor())

fashion_train_dataloader = DataLoader(dataset=fashion_train_data,batch_size=BATCH_SIZE,shuffle=True)
fashion_test_dataloader = DataLoader(dataset=fashion_test_data,batch_size=BATCH_SIZE,shuffle=True)

len(fashion_train_dataloader),len(fashion_test_dataloader)

使用我们创建的模型来训练一下这个FashionMNIST数据集

train_start_time_on_fashion = timer()epochs = 3
for epoch in tqdm(range(epochs)):print(f"Epoch:{epoch}\n======================")train_step(model=model_0,dataloader=fashion_train_dataloader,loss_fn=loss_fn,optimizer=optimizer,device=device,accuracy_fn=accuracy_fn)test_step(model=model_0,dataloader=fashion_test_dataloader,loss_fn=loss_fn,accuracy_fn=accuracy_fn,device=device)train_end_time_on_fashion = timer()
total_time_on_fashion = print_train_time(start=train_start_time_on_fashion,end=train_end_time_on_fashion,device=device)

在这里插入图片描述

model_0_result_fashion = eval_model(model=model_0,dataloader=fashion_test_dataloader,loss_fn=loss_fn,accuracy_fn=accuracy_fn,device=device)
model_0_result_fashion

{‘model_name’: ‘MNISTModelV0’,
‘model_loss’: 0.31344807147979736,
‘model_acc’: 89.12739616613419}

model_0_result

{‘model_name’: ‘MNISTModelV0’,
‘model_loss’: 0.05393431708216667,
‘model_acc’: 98.10303514376997}

import pandas as pd
compare_results = pd.DataFrame([model_0_result,model_0_result_fashion])
compare_results

在这里插入图片描述

compare_results["training_time"] = [total_time_on_gpu,total_time_on_fashion]
compare_results

在这里插入图片描述

compare_results["dataset"] = ["MNIST","FashionMNIST"]
compare_results

在这里插入图片描述

compare_results.set_index("dataset")["model_acc"].plot(kind="barh")
plt.ylabel("dataset")
plt.xlabel("accuracy(%)");

在这里插入图片描述

import random
test_samples = []
test_labels = []
for sample, label in random.sample(list(fashion_test_data), k=9):test_samples.append(sample)test_labels.append(label)#查看第一个样本的形状
test_samples[0].shape

torch.Size([1, 28, 28])

# make predictions
pred_probs = make_prediction(model=model_0,data=test_samples,device=device)
pred_classes = pred_probs.argmax(dim=1)# plot predictions
plt.figure(figsize=(9,9))
nrows = 3
ncols = 3
for i, sample in enumerate(test_samples):plt.subplot(nrows, ncols, i+1)plt.imshow(sample.squeeze(), cmap="gray")pred_label = class_names[pred_classes[i]]truth_label = class_names[test_labels[i]]title_text = f"Pred:{pred_label} | Truth:{truth_label}"# 预测正确是绿色的title， 预测错误是红色的titleif pred_label == truth_label:plt.title(title_text, fontsize=10, c="g")else:plt.title(title_text, fontsize=10, c="r")plt.axis(False);