如何编写3d CNN的PyTorch教程
首先，我们需要简单解释一下什么是3d CNN，以及它与通用2d CNN的区别。然后，我们将逐步分析如何使用Pytorch实现3D卷积神经网络。
什么是3D卷积神经网络？
无论我们说的CNN与2d CNN非常相似，都保留3d CNN。区别在于以下几点（非详尽列表）：
3d卷积层
最初2d卷积层是输入与不同过滤器之间的逐项乘法运算，其中过滤器和输入是2d矩阵
在3d卷积层中，使用相同的操作。我们对多对二维矩阵进行这些操作。
填充选项和幻灯片步骤选项的工作方式相同。
3d MaxPool图层
2d Maxpool图层（2x2滤镜）大约要取一个我们从输入中划定的2x2小正方形的最大元素。
现在，在3d Maxpool（2x2x2）中，我们在宽度为2的立方体中查找最大元素。此多维数据集表示从输入以2x2x2区域分隔的空间。
请注意，运算数量（与2d CNN层相比）乘以使用的过滤器的大小（与Maxpool或卷积无关），也乘以输入本身的大小。
3d数据点看起来如何？
那么3D CNN的数据点看起来如何？
生动描述图片的一种方法是使用以下图片：
可用于CNN的其他现有数据集包括：
RGB-D设备：Google Tango，Microsoft Kinect等。 激光雷达从多个图像进行3D重建现在如何实施？
可以自己尝试使用我们正在使用的 Kaggle在该数据集上的代码。
整个笔记本中将使用多个库。这是它的列表。
<code># importing the libraries import pandas as pd import numpy as np from tqdm import tqdm import os # for reading and displaying images from skimage.io import imread import matplotlib.pyplot as plt # for creating validation set from sklearn.model_selection import train_test_split # for evaluating the model from sklearn.metrics import accuracy_score # PyTorch libraries and modules import torch from torch.autograd import Variable import torch.nn as nn import torch.nn.functional as F from torch.optim import * import h5py from plot3D import */<code>
首先，由于数据集是特定的，因此在将它们提供给网络之前，我们使用以下帮助函数来处理它们。
另外，数据集存储为h5文件，因此要提取实际数据点，我们需要从h5文件读取数据，并使用to_categorical函数将其转换为向量。在此步骤中，我们还准备进行交叉验证。
<code>def array_to_color(array, cmap="Oranges"): s_m = plt.cm.ScalarMappable(cmap=cmap) return s_m.to_rgba(array)[:,:-1] def rgb_data_transform(data): data_t = [] for i in range(data.shape[0]): data_t.append(array_to_color(data[i]).reshape(16, 16, 16, 3)) return np.asarray(data_t, dtype=np.float32)/<code>
假设变量X_train / X_test分别具有（10000，16，16，16，3）和（2000，16，16，16，3）的形状，而target_train / targets_test分别具有（10000，）（2000，）的形状。但是现在我们再次将所有这些转换为PyTorch张量格式。我们通过以下方式做到这一点。
<code>with h5py.File("./full_dataset_vectors.h5", "r") as hf: # Split the data into training/test features/targets X_train = hf["X_train"][:] targets_train = hf["y_train"][:] X_test = hf["X_test"][:] targets_test = hf["y_test"][:] # Determine sample shape sample_shape = (16, 16, 16, 3) # Reshape data into 3D format X_train = rgb_data_transform(X_train) X_test = rgb_data_transform(X_test) # Convert target vectors to categorical targets targets_train = to_categorical(targets_train).astype(np.integer) targets_test = to_categorical(targets_test).astype(np.integer)/<code>
<code>train_x = torch.from_numpy(X_train).float() train_y = torch.from_numpy(targets_train).long() test_x = torch.from_numpy(X_test).float() test_y = torch.from_numpy(targets_test).long() batch_size = 100 #We pick beforehand a batch_size that we will use for the training # Pytorch train and test sets train = torch.utils.data.TensorDataset(train_x,train_y) test = torch.utils.data.TensorDataset(test_x,test_y) # data loader train_loader = torch.utils.data.DataLoader(train, batch_size = batch_size, shuffle = False) test_loader = torch.utils.data.DataLoader(test, batch_size = batch_size, shuffle = False)/<code>
对于模型，这里是我们将使用的架构：
2套ConvMake：
· 两个集合的过滤器大小为（3x3x3），步幅为（1x1x1）的3d卷积层
· 泄漏的Relu激活功能
· 具有滤镜大小（2x2x2）和跨度（2x2x2）的3d MaxPool层
2个FC层，分别具有512和128个节点。
在第一个FC层之后有一个Dropout层。
然后将模型通过以下方式转换为代码：
<code>num_classes = 10 # Create CNN Model class CNNModel(nn.Module): def __init__(self): super(CNNModel, self).__init__() self.conv_layer1 = self._conv_layer_set(3, 32) self.conv_layer2 = self._conv_layer_set(32, 64) self.fc1 = nn.Linear(2**3*64, 128) self.fc2 = nn.Linear(128, num_classes) self.relu = nn.LeakyReLU() self.batch=nn.BatchNorm1d(128) self.drop=nn.Dropout(p=0.15) def _conv_layer_set(self, in_c, out_c): conv_layer = nn.Sequential( nn.Conv3d(in_c, out_c, kernel_size=(3, 3, 3), padding=0), nn.LeakyReLU(), nn.MaxPool3d((2, 2, 2)), ) return conv_layer def forward(self, x): # Set 1 out = self.conv_layer1(x) out = self.conv_layer2(out) out = out.view(out.size(0), -1) out = self.fc1(out) out = self.relu(out) out = self.batch(out) out = self.drop(out) out = self.fc2(out) return out #Definition of hyperparameters n_iters = 4500 num_epochs = n_iters / (len(train_x) / batch_size) num_epochs = int(num_epochs) # Create CNN model = CNNModel() #model.cuda() print(model) # Cross Entropy Loss error = nn.CrossEntropyLoss() # SGD Optimizer learning_rate = 0.001 optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)/<code>
在参数方面，请注意第一个完全卷积层上的输入节点数。我们的数据集的形状为（16,16,16,3），这就是我们获得大小为（2x2x2）的滤波输出的方式。
以下是训练代码。可以通过将优化器更改为Adam来进行优化，调整学习速度（有一定的动力）等等。
<code># CNN model training count = 0 loss_list = [] iteration_list = [] accuracy_list = [] for epoch in range(num_epochs): for i, (images, labels) in enumerate(train_loader): train = Variable(images.view(100,3,16,16,16)) labels = Variable(labels) # Clear gradients optimizer.zero_grad() # Forward propagation outputs = model(train) # Calculate softmax and ross entropy loss loss = error(outputs, labels) # Calculating gradients loss.backward() # Update parameters optimizer.step() count += 1 if count % 50 == 0: # Calculate Accuracy correct = 0 total = 0 # Iterate through test dataset for images, labels in test_loader: test = Variable(images.view(100,3,16,16,16)) # Forward propagation outputs = model(test) # Get predictions from the maximum value predicted = torch.max(outputs.data, 1)[1] # Total number of labels total += len(labels) correct += (predicted == labels).sum() accuracy = 100 * correct / float(total) # store loss and iteration loss_list.append(loss.data) iteration_list.append(count) accuracy_list.append(accuracy) if count % 500 == 0: # Print Loss print('Iteration: {} Loss: {} Accuracy: {} %'.format(count, loss.data, accuracy))/<code>
经过少量样本培训，我们得到了以下准确性和损失。