在独立于训练脚本的新脚本中部署用于推理的模型，需要构造一个模型类的对象，并将权重加载到模型中。操作流程为：定义模型--加载权重--在验证和测试数据集上部署模型。
import torch.nn as nn
import numpy as np
# 设置随机种子
np.random.seed(0)import torch.nn as nn
import torch.nn.functional as F
# 定义一个函数，用于计算卷积层的输出形状
def findConv2dOutShape(H_in,W_in,conv,pool=2):
# 获取卷积核的大小
kernel_size=conv.kernel_size
# 获取卷积的步长
stride=conv.stride
# 获取卷积的填充
padding=conv.padding
# 获取卷积的扩张
dilation=conv.dilation
# 计算卷积后的高度
H_out=np.floor((H_in+2*padding[0]-dilation[0]*(kernel_size[0]-1)-1)/stride[0]+1)
# 计算卷积后的宽度
W_out=np.floor((W_in+2*padding[1]-dilation[1]*(kernel_size[1]-1)-1)/stride[1]+1)
# 如果pool不为空
if pool:
# 将H_out除以pool
H_out/=pool
W_out/=pool
# 返回H_out和W_out的整数形式
return int(H_out),int(W_out)
class Net(nn.Module):
def __init__(self, params):
super(Net, self).__init__()
# 获取输入形状
C_in,H_in,W_in=params["input_shape"]
# 获取初始滤波器数量
init_f=params["initial_filters"]
# 获取第一个全连接层神经元数量
num_fc1=params["num_fc1"]
# 获取类别数量
num_classes=params["num_classes"]
# 获取模型的dropout率，是0到1间的浮点数
# Dropout是一种正则化技术，随机关闭部分神经元（输出设为0），防止过拟合，提高泛化能力
self.dropout_rate=params["dropout_rate"]
# 定义第一个卷积层
self.conv1 = nn.Conv2d(C_in, init_f, kernel_size=3)
# 计算第一个卷积层的输出形状
h,w=findConv2dOutShape(H_in,W_in,self.conv1)
self.conv2 = nn.Conv2d(init_f, 2*init_f, kernel_size=3)
h,w=findConv2dOutShape(h,w,self.conv2)
self.conv3 = nn.Conv2d(2*init_f, 4*init_f, kernel_size=3)
h,w=findConv2dOutShape(h,w,self.conv3)
self.conv4 = nn.Conv2d(4*init_f, 8*init_f, kernel_size=3)
h,w=findConv2dOutShape(h,w,self.conv4)
# 计算全连接层的输入形状
self.num_flatten=h*w*8*init_f
# 定义第一个全连接层
self.fc1 = nn.Linear(self.num_flatten, num_fc1)
self.fc2 = nn.Linear(num_fc1, num_classes)
# 定义前向传播函数，接收输入x
def forward(self, x):
# 第一个卷积层
x = F.relu(self.conv1(x))
# 第一个池化层
x = F.max_pool2d(x, 2, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2, 2)
x = F.relu(self.conv3(x))
x = F.max_pool2d(x, 2, 2)
x = F.relu(self.conv4(x))
x = F.max_pool2d(x, 2, 2)
# 将卷积层的输出展平
x = x.view(-1, self.num_flatten)
# 第一个全连接层
x = F.relu(self.fc1(x))
# Dropout层
x=F.dropout(x, self.dropout_rate)
# 第二个全连接层
x = self.fc2(x)
# 返回输入x应用对数软最大变换后的输出
# log-softmax对数软最大值函数，常用于计算交叉熵损失函数（cross-entropy loss），因为交叉熵损失函数需要计算概率的对数。
# dim参数指定了在哪个维度上应用log-softmax。例如，如果dim=1，则对每一行应用log-softmax。
return F.log_softmax(x, dim=1)
# 定义模型参数
params_model={
# 输入形状
"input_shape": (3,96,96),
# 初始过滤器数量
"initial_filters": 8,
# 全连接层1的神经元数量
"num_fc1": 100,
# Dropout率
"dropout_rate": 0.25,
# 类别数量
"num_classes": 2,
}
# 创建一个CNN模型，参数为params_model
cnn_model = Net(params_model)
import torch
# 权重文件路径
path2weights="./models/weights.pt"
# 加载权重文件
cnn_model.load_state_dict(torch.load(path2weights))
# 进入评估模式
cnn_model.eval()
# 移动模型至cuda设备
if torch.cuda.is_available():
device = torch.device("cuda")
cnn_model=cnn_model.to(device) import time
# 定义一个函数，用于部署模型
def deploy_model(model,dataset,device, num_classes=2,sanity_check=False):
# num_classes：类别数，默认为2
# sanity_check：是否进行完整性检查，默认为False
pass
# 获取数据集长度
len_data=len(dataset)
# 初始化输出张量
y_out=torch.zeros(len_data,num_classes)
# 初始化真实标签张量
y_gt=np.zeros((len_data),dtype="uint8")
# 将模型移动到指定设备
model=model.to(device)
# 存储每次推理的时间
elapsed_times=[]
# 在不计算梯度的情况下执行以下代码
with torch.no_grad():
for i in range(len_data):
# 获取数据集中的一个样本
x,y=dataset[i]
# 将真实标签存储到张量中
y_gt[i]=y
# 记录开始时间
start=time.time()
# 进行推理
y_out[i]=model(x.unsqueeze(0).to(device))
# 计算推理时间
elapsed=time.time()-start
# 将推理时间存储到列表中
elapsed_times.append(elapsed)
# 如果进行完整性检查，则只进行一次推理
if sanity_check is True:
break
# 计算平均推理时间
inference_time=np.mean(elapsed_times)*1000
# 打印平均推理时间
print("average inference time per image on %s: %.2f ms " %(device,inference_time))
# 返回推理结果和真实标签
return y_out.numpy(),y_gt
import torch
from PIL import Image
from torch.utils.data import Dataset
import pandas as pd
import torchvision.transforms as transforms
import os
# 设置随机种子，使得每次运行代码时生成的随机数相同
torch.manual_seed(0)
class histoCancerDataset(Dataset):
def __init__(self, data_dir, transform,data_type="train"):
# 获取数据目录
path2data=os.path.join(data_dir,data_type)
# 获取数据目录下的所有文件名
self.filenames = os.listdir(path2data)
# 获取数据目录下的所有文件的完整路径
self.full_filenames = [os.path.join(path2data, f) for f in self.filenames]
# 获取标签文件名
csv_filename=data_type+"_labels.csv"
# 获取标签文件的完整路径
path2csvLabels=os.path.join(data_dir,csv_filename)
# 读取标签文件
labels_df=pd.read_csv(path2csvLabels)
# 将标签文件的索引设置为文件名
labels_df.set_index("id", inplace=True)
# 获取每个文件的标签
self.labels = [labels_df.loc[filename[:-4]].values[0] for filename in self.filenames]
# 获取数据转换函数
self.transform = transform
def __len__(self):
# 返回数据集的长度
return len(self.full_filenames)
def __getitem__(self, idx):
# 根据索引获取图像
image = Image.open(self.full_filenames[idx])
# 对图像进行转换
image = self.transform(image)
# 返回图像和标签
return image, self.labels[idx]
import torchvision.transforms as transforms
# 创建一个数据转换器，将数据转换为张量
data_transformer = transforms.Compose([transforms.ToTensor()])
data_dir = "./data/"
# 传入数据目录、数据转换器和数据集类型
histo_dataset = histoCancerDataset(data_dir, data_transformer, "train")
# 打印数据集的长度
print(len(histo_dataset))
from torch.utils.data import random_split
# 获取数据集的长度
len_histo=len(histo_dataset)
# 训练集取数据集的80%
len_train=int(0.8*len_histo)
# 验证集取数据集的20%
len_val=len_histo-len_train
# 将数据集随机分割为训练集和验证集
train_ds,val_ds=random_split(histo_dataset,[len_train,len_val])
# 打印训练集和验证集的长度
print("train dataset length:", len(train_ds))
print("validation dataset length:", len(val_ds)) 
# 部署模型
y_out,y_gt=deploy_model(cnn_model,val_ds,device=device,sanity_check=False)
# 打印输出和真实值的形状
print(y_out.shape,y_gt.shape)
使用预测输出计算模型在验证数据集上的精度
from sklearn.metrics import accuracy_score
# 获取预测
y_pred = np.argmax(y_out,axis=1)
print(y_pred.shape,y_gt.shape)
# 计算精度
acc=accuracy_score(y_pred,y_gt)
print("accuracy: %.2f" %acc) 
# 部署在CPU上
device_cpu = torch.device("cpu")
y_out,y_gt=deploy_model(cnn_model,val_ds,device=device_cpu,sanity_check=False)
print(y_out.shape,y_gt.shape)
复制data文件夹中的sample_submission.csv文件并命名为test_labels.csv
path2csv="./data/test_labels.csv"
# 读取csv文件，并存储到DataFrame中
labels_df=pd.read_csv(path2csv)
# 显示DataFrame的前几行
labels_df.head()
data_dir = "./data/"
# 创建测试数据集
histo_test = histoCancerDataset(data_dir, data_transformer,data_type="test")
# 打印测试数据集的长度
print(len(histo_test)) 
# 用测试数据集部署
y_test_out,_=deploy_model(cnn_model,histo_test, device, sanity_check=False)
# 使用np.argmax函数对y_test_out进行操作，得到y_test_pred
y_test_pred=np.argmax(y_test_out,axis=1)
# 打印y_test_pred的形状
print(y_test_pred.shape)
from torchvision import utils
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
np.random.seed(0)
# 定义一个函数，用于显示图像和标签
def show(img,y,color=True):
# 将图像转换为numpy数组
npimg = img.numpy()
# 将图像的维度从（C,H,W）转换为（H,W,C）
npimg_tr=np.transpose(npimg, (1,2,0))
# 如果color为False，则将图像转换为灰度图像
if color==False:
npimg_tr=npimg_tr[:,:,0]
plt.imshow(npimg_tr,interpolation='nearest',cmap="gray")
else:
# 否则，直接显示图像
plt.imshow(npimg_tr,interpolation='nearest')
# 显示图像的标签
plt.title("label: "+str(y))
# 定义一个网格大小
grid_size=4
# 随机选择grid_size个图像的索引
rnd_inds=np.random.randint(0,len(histo_test),grid_size)
print("image indices:",rnd_inds)
# 从histo_test中获取grid_size个图像
x_grid_test=[histo_test[i][0] for i in range(grid_size)]
# 从y_test_pred中获取grid_size个标签
y_grid_test=[y_test_pred[i] for i in range(grid_size)]
# 将grid_size个图像组合成一个网格
x_grid_test=utils.make_grid(x_grid_test, nrow=4, padding=2)
print(x_grid_test.shape)
# 设置图像的大小
plt.rcParams['figure.figsize'] = (10.0, 5)
# 显示图像和标签
show(x_grid_test,y_grid_test)
1560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
