本文主要是介绍实现卷积神经网络：吴恩达Course 4-卷积神经网络-week1作业 pytorch版，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
注意事项
和老师用tensorflow写的结果不同，不过测试集准度更高了，以下几点原因：
1.没用Xaiver初始化，使用了pytorch默认的初始化方式
2.pytorch和tensorflow的padding机制不同，没有特意去还原tensorflow的方式，pytorch的padding设置值不可以比卷积核的宽度一半大，所以当步长大，用默认方式“SAME”不了
3.全连接层的线性函数输出神经元老师用的是6个，这里用了20个（因为第2点，加上ReLU，用6个神经元会梯度消失，100步以内不收敛）
吐槽一句pytorch的padding方式不太友好，要自己算，tensorflow直接padding="SAME"就行了
资料下载
相关文件可在【tensorflow版大佬】下载
备注
week1作业有两个：
第一部分：用numpy还原卷积神经网络的实现过程
第二部分：用框架实现卷积神经网络
这里只包含第二部分的内容
载入库
import torch
from torch.utils.data import DataLoader, TensorDataset
from torch import nn
import numpy as np
from matplotlib import pyplot as plt
from cnn_utils import load_dataset
数据预处理
# 设置随机种子
torch.manual_seed(1)# 载入数据
X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = load_dataset()# 可视化一个样本
index = 6
plt.imshow(X_train_orig[index])
print('y=' + str(np.squeeze(Y_train_orig[:, index])))
plt.show()# 归一化数据集
X_train = np.transpose(X_train_orig, (0, 3, 1, 2))/255 # 将维度转为(1080, 3, 64, 64)
X_test = np.transpose(X_test_orig, (0, 3, 1, 2))/255 # 将维度转为(120, 3, 64, 64)
# 转置y
Y_train = Y_train_orig.T # (1080, 1)
Y_test = Y_test_orig.T # (120, 1)print('number of training examples = ' + str(X_train.shape[0]))
print('number of test examples = ' + str(X_test.shape[0]))
print('X_train shape: ' + str(X_train.shape))
print('Y_train shape: ' + str(Y_train.shape))
print('X_test shape: ' + str(X_test.shape))
print('Y_test shape: ' + str(Y_test.shape))
可视化一个样本：
打印维度：
number of training examples = 1080
number of test examples = 120
X_train shape: (1080, 3, 64, 64)
Y_train shape: (1080, 1)
X_test shape: (120, 3, 64, 64)
Y_test shape: (120, 1)
建模部分
# 创建数据接口
def data_loader(X_train, Y_train, batch_size=64):train_db = TensorDataset(torch.from_numpy(X_train).float(), torch.squeeze(torch.from_numpy(Y_train)))train_loader = DataLoader(train_db, batch_size=batch_size, shuffle=True)return train_loader# 构建模型
class CNN(nn.Module):def __init__(self):# 继承模块super(CNN, self).__init__()self.conv1 = nn.Sequential(nn.Conv2d( # input shape (3, 64, 64)in_channels=3, # input通道数out_channels=8, # output通道数kernel_size=4, # 卷积核的边长fstride=1, # 步长padding=1 # padding模式为SAME，=[(s-1)n-s+f]/2，这里算出来不是整数，向下取整了),nn.ReLU(),nn.MaxPool2d(kernel_size=8, stride=8, padding=4))self.conv2 = nn.Sequential( # input shape (8, 64, 64)nn.Conv2d(8, 16, 2, 1, 1),nn.ReLU(),nn.MaxPool2d(kernel_size=4, stride=4, padding=2))self.fullconnect = nn.Sequential(nn.Linear(16 * 3 * 3, 20),nn.ReLU())self.classifier = nn.LogSoftmax(dim=1)def forward(self, x):x = self.conv1(x)x = self.conv2(x)# 展平x = x.view(x.size(0), -1)x = self.fullconnect(x)output = self.classifier(x)return outputdef weigth_init(m):if isinstance(m, nn.Conv2d):nn.init.xavier_uniform_(m.weight.data)nn.init.constant_(m.bias.data, 0)elif isinstance(m, nn.Linear):nn.init.xavier_uniform_(m.weight.data)nn.init.constant_(m.bias.data, 0)def model(X_train, Y_train, X_test, Y_test, learning_rate=0.009, num_epochs=100, minibatch_size=64, print_cost=True,is_plot=True):train_loader = data_loader(X_train, Y_train, minibatch_size)cnn = CNN()# cnn.apply(weigth_init)cost_func = nn.NLLLoss()optimizer = torch.optim.Adam(cnn.parameters(), lr=learning_rate, betas=(0.9, 0.999))# 保存每次迭代的cost的列表costs = []# 批次数量m = X_train.shape[0]num_batch = m / minibatch_sizefor epoch in range(num_epochs):epoch_cost = 0for step, (batch_x, batch_y) in enumerate(train_loader):# 前向传播output = cnn(batch_x)# 计算成本cost = cost_func(output, batch_y)epoch_cost += cost.data.numpy() / num_batch# 梯度归零optimizer.zero_grad()# 反向传播cost.backward()# 更新参数optimizer.step()if print_cost and epoch % 5 == 0:costs.append(epoch_cost)print('Cost after epoch %i : %f' % (epoch, epoch_cost))# 画学习曲线if is_plot:plt.plot(costs)plt.xlabel('iterations per 5')plt.ylabel('cost')plt.show()# 保存学习后的参数torch.save(cnn.state_dict(), 'net_params.pkl')print('参数已保存到本地pkl文件。')# 预测训练集cnn.load_state_dict(torch.load('net_params.pkl'))output_train = cnn(torch.from_numpy(X_train).float())pred_Y_train = torch.max(output_train, dim=1)[1].data.numpy()# 预测测试集output_test = cnn(torch.from_numpy(X_test).float())pred_Y_test= torch.max(output_test, dim=1)[1].data.numpy()# 训练集准确率print('Train Accuracy: %.2f %%' % float(np.sum(np.squeeze(Y_train) == pred_Y_train)/m*100))# 测试集准确率print('Test Accuracy: %.2f %%' % float(np.sum(np.squeeze(Y_test) == pred_Y_test)/X_test.shape[0]*100))return cnnmodel(X_train, Y_train, X_test, Y_test)
迭代过程：
Cost after epoch 0 : 2.401703
Cost after epoch 5 : 1.341189
Cost after epoch 10 : 0.801924
Cost after epoch 15 : 0.567850
Cost after epoch 20 : 0.446336
Cost after epoch 25 : 0.342109
Cost after epoch 30 : 0.278837
Cost after epoch 35 : 0.182508
Cost after epoch 40 : 0.152718
Cost after epoch 45 : 0.124633
Cost after epoch 50 : 0.103368
Cost after epoch 55 : 0.099265
Cost after epoch 60 : 0.092497
Cost after epoch 65 : 0.067059
Cost after epoch 70 : 0.080446
Cost after epoch 75 : 0.101512
Cost after epoch 80 : 0.051409
Cost after epoch 85 : 0.021475
Cost after epoch 90 : 0.017657
Cost after epoch 95 : 0.010164
学习曲线：
训练准确率与测试准确率：
Train Accuracy: 100.00 %
Test Accuracy: 90.83 %
到这就完成啦~
这篇关于实现卷积神经网络：吴恩达Course 4-卷积神经网络-week1作业 pytorch版的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
