\n
\n
\n
\n Here, \\(Y\\) is the output, \\(X\\) is the input image, \\(K\\) is the filter, and \\(M\\) and \\(N\\) are the dimensions of the filter.\n <\/p>\n
\n Deep learning technology has achieved innovative results in computer vision, natural language processing, and various fields. In this course, we will take an in-depth look at Convolutional Neural Networks (CNN) and Deconvolutional Neural Networks (or Transpose Convolutional Networks) using PyTorch.\n <\/p>\n
\n Convolutional Neural Networks (CNN) are a deep learning technology that demonstrates superior performance primarily in image recognition and processing. CNNs use specialized layers known as convolutional layers to process input images. These layers extract features by leveraging the spatial structure of the images.\n <\/p>\n
\n Convolutional layers perform convolution operations with filters (or kernels) over the input image. Filters are small matrices that detect specific features in images, and multiple filters are used to extract various features. Typically, filters are updated during the learning process.\n <\/p>\n
\n The convolution operation is performed by sliding the filter over the input image. It can be expressed by the following formula:
\n
\n
\n
\n Here, \\(Y\\) is the output, \\(X\\) is the input image, \\(K\\) is the filter, and \\(M\\) and \\(N\\) are the dimensions of the filter.\n <\/p>\n
\n After the convolution operation, an activation function is applied to introduce non-linearity. The ReLU (Rectified Linear Unit) function is primarily used:
\n
\n\n<\/p>\n
\n Now, let\u2019s explore how to implement a CNN using PyTorch. Below is an example of a basic CNN structure.\n <\/p>\n
\n We will use the MNIST dataset. MNIST is a dataset consisting of handwritten digit images, which is suitable for testing basic image processing models.\n <\/p>\n
\nimport torch\nimport torchvision\nimport torchvision.transforms as transforms\n\n# Data preprocessing\ntransform = transforms.Compose(\n [transforms.ToTensor(),\n transforms.Normalize((0.5,), (0.5,))])\n\n# Download MNIST dataset\ntrainset = torchvision.datasets.MNIST(root='.\/data', train=True,\n download=True, transform=transform)\ntrainloader = torch.utils.data.DataLoader(trainset, batch_size=64,\n shuffle=True)\ntestset = torchvision.datasets.MNIST(root='.\/data', train=False,\n download=True, transform=transform)\ntestloader = torch.utils.data.DataLoader(testset, batch_size=64,\n shuffle=False)\n <\/code><\/pre>\n2.2 Defining the CNN Model<\/h3>\n
\n The code for defining the CNN structure is as follows. It includes convolutional layers, fully connected layers, and activation functions.\n <\/p>\n
\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nclass CNN(nn.Module):\n def __init__(self):\n super(CNN, self).__init__()\n self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1) # First convolution layer\n self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0) # Max pooling layer\n self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1) # Second convolution layer\n self.fc1 = nn.Linear(64 * 7 * 7, 128) # First fully connected layer\n self.fc2 = nn.Linear(128, 10) # Second fully connected layer\n\n def forward(self, x):\n x = self.pool(F.relu(self.conv1(x))) # Convolution -> Activation -> Pooling\n x = self.pool(F.relu(self.conv2(x))) # Convolution -> Activation -> Pooling\n x = x.view(-1, 64 * 7 * 7) # Reshape tensor\n x = F.relu(self.fc1(x)) # Fully connected -> Activation\n x = self.fc2(x) # Output layer\n return x\n <\/code><\/pre>\n2.3 Training the Model<\/h3>\n
\n To train the model, we will define the loss function and optimizer.\n <\/p>\n
\nimport torch.optim as optim\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel = CNN().to(device)\ncriterion = nn.CrossEntropyLoss() # Loss function\noptimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9) # SGD optimizer\n\n# Training the model\nfor epoch in range(10): # 10 epochs\n running_loss = 0.0\n for i, data in enumerate(trainloader, 0):\n inputs, labels = data[0].to(device), data[1].to(device)\n \n # Zero the gradients\n optimizer.zero_grad()\n \n # Forward pass + backward pass + optimization\n outputs = model(inputs)\n loss = criterion(outputs, labels)\n loss.backward()\n optimizer.step()\n \n running_loss += loss.item()\n if i % 100 == 99: # Print every 100 batches\n print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss \/ 100:.3f}')\n running_loss = 0.0\n print(\"Epoch finished\")\n <\/code><\/pre>\n2.4 Evaluating the Model<\/h3>\n
\n We will evaluate the trained model and measure its accuracy.\n <\/p>\n
\ncorrect = 0\ntotal = 0\n\nwith torch.no_grad():\n for data in testloader:\n images, labels = data[0].to(device), data[1].to(device)\n outputs = model(images)\n _, predicted = torch.max(outputs.data, 1)\n total += labels.size(0)\n correct += (predicted == labels).sum().item()\n\nprint(f'Accuracy of the network on the 10000 test images: {100 * correct \/ total:.2f}%')\n <\/code><\/pre>\n3. Introduction to Deconvolutional Neural Networks<\/h2>\n
\n Deconvolutional Neural Networks, or Transpose Convolutional Networks, are structures that reconstruct images after feature extraction from Convolutional Neural Networks (CNN). They are mainly used in image generation tasks, especially in fields like Generative Adversarial Networks (GANs).\n <\/p>\n
3.1 How Deconvolutional Layers Work<\/h3>\n
\n Deconvolutional layers perform the inverse of the standard convolution functions in CNNs. They are used to convert low-resolution images into higher resolution images. Such layers are also known as “Transpose Convolution” or “Deconvolution”. This involves applying spatial linear transformations of the filters.\n <\/p>\n
3.2 Example of Deconvolution<\/h3>\n
\n Let’s look at an example of implementing a Deconvolutional Neural Network in PyTorch.\n <\/p>\n
\nclass DeconvNetwork(nn.Module):\n def __init__(self):\n super(DeconvNetwork, self).__init__()\n self.deconv1 = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1) # First deconvolution layer\n self.deconv2 = nn.ConvTranspose2d(32, 1, kernel_size=3, stride=2, padding=1) # Second deconvolution layer\n\n def forward(self, x):\n x = F.relu(self.deconv1(x)) # Activation\n x = torch.sigmoid(self.deconv2(x)) # Output layer\n return x\n <\/code><\/pre>\n3.3 Image Reconstruction via Deconvolution Networks<\/h3>\n
\n We can check the basic structure of image reconstruction using the model we have defined. This can be applied to solutions like GANs or Autoencoders.\n <\/p>\n
\ndeconv_model = DeconvNetwork().to(device)\n\n# Adding an image to the array\nimage = torch.randn(1, 64, 7, 7).to(device) # Random tensor\nreconstructed_image = deconv_model(image)\nprint(reconstructed_image.shape) # It can reconstruct to (1, 1, 28, 28)\n <\/code><\/pre>\n4. Conclusion<\/h2>\n
\n In this course, we learned about two core technologies of deep learning: Convolutional Neural Networks (CNN) and Deconvolutional Neural Networks. We explained how to build and train a CNN structure using the PyTorch framework, alongside the basic operation principles of Deconvolutional Networks. These technologies are foundational to many state-of-the-art deep learning models and continue to evolve.\n <\/p>\n
\n We hope this aids your deep learning journey, and may you continue to develop your models through deeper research and exploration!\n <\/p>\n
<\/body><\/p>\n","protected":false},"excerpt":{"rendered":"