{"id":36673,"date":"2024-11-01T09:50:28","date_gmt":"2024-11-01T09:50:28","guid":{"rendered":"http:\/\/atmokpo.com\/w\/?p=36673"},"modified":"2024-11-01T11:52:16","modified_gmt":"2024-11-01T11:52:16","slug":"deep-learning-pytorch-course-introduction-to-convolutional-neural-networks","status":"publish","type":"post","link":"https:\/\/atmokpo.com\/w\/36673\/","title":{"rendered":"Deep Learning PyTorch Course, Introduction to Convolutional Neural Networks"},"content":{"rendered":"

<\/p>\n

\n Deep learning has established itself as a dominant methodology in the fields of artificial intelligence and machine learning in recent years. Today, we will take a look at Convolutional Neural Networks (CNNs). CNNs are particularly effective for image recognition and processing, and they are widely used across various industries.\n<\/p>\n

What is a Convolutional Neural Network?<\/h2>\n

\n A Convolutional Neural Network is a type of neural network specialized in recognizing visual patterns in given data, such as photos or videos. CNNs are fundamentally composed of convolutional layers, pooling layers, and fully connected layers.\n<\/p>\n

Convolutional Layer<\/h3>\n

\n The convolutional layer is responsible for extracting features from the input data. This layer uses small filters (kernels) to perform operations on specific parts of the input image to generate output. The resulting feature map contains only the useful information from the input data.\n<\/p>\n

Pooling Layer<\/h3>\n

\n The pooling layer is used to reduce the size of the feature map. This helps to reduce model complexity and computational load, preventing overfitting. The most common method is max pooling, which reduces the size of the feature map by selecting the largest value from a given area.\n<\/p>\n

Fully Connected Layer<\/h3>\n

\n At the end of the neural network, there is a fully connected layer. This layer makes the final predictions based on the information obtained from the previous layers. Since all neurons are connected to the previous layer, it can make complex decisions regarding the input data.\n<\/p>\n

Implementing CNN with PyTorch<\/h2>\n

\n Now, let\u2019s implement a simple CNN model using PyTorch. We will create a model to classify handwritten digits using the MNIST dataset.\n<\/p>\n

Preparation<\/h3>\n

\n First, we will install the necessary libraries and download the dataset. The following libraries are required:\n<\/p>\n

pip install torch torchvision\n<\/code><\/pre>\n
Preparing the Dataset<\/h3>\n
\n    We will download and load the MNIST dataset. You can use the code below to prepare the training and testing datasets.\n<\/p>\n
\nimport torch\nimport torchvision\nimport torchvision.transforms as transforms\n\n# Define data transformations\ntransform = transforms.Compose(\n    [transforms.ToTensor(), \n     transforms.Normalize((0.5,), (0.5,))])  # Normalization using mean and standard deviation\n\n# Training dataset\ntrainset = torchvision.datasets.MNIST(root='.\/data', train=True, download=True, transform=transform)\ntrainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)\n\n# Testing dataset\ntestset = torchvision.datasets.MNIST(root='.\/data', train=False, download=True, transform=transform)\ntestloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)\n<\/code><\/pre>\n
Defining the Model<\/h3>\n
\n    Now, let’s define the convolutional neural network model. CNN models are typically designed with a structure that combines convolutional layers and pooling layers.\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)  # Input channels 1, output channels 32\n        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)  # Max pooling\n        self.conv2 = nn.Conv2d(32, 64, kernel_size=3)  # Input channels 32, output channels 64\n        self.fc1 = nn.Linear(64 * 6 * 6, 128)  # Fully connected layer, 64x6x6 is the output size\n        self.fc2 = nn.Linear(128, 10)  # Final output 10 classes (0-9)\n\n    def forward(self, x):\n        x = self.pool(F.relu(self.conv1(x)))  # First convolution and pooling\n        x = self.pool(F.relu(self.conv2(x)))  # Second convolution and pooling\n        x = x.view(-1, 64 * 6 * 6)  # Change tensor shape\n        x = F.relu(self.fc1(x))  # First fully connected layer\n        x = self.fc2(x)  # Second fully connected layer\n        return x\n<\/code><\/pre>\n
Training the Model<\/h3>\n
\n    To train the model, we need to define a loss function and an optimizer, and iteratively train on the data.\n<\/p>\n
\n# Initialize the model\ncnn = CNN()\ncriterion = nn.CrossEntropyLoss()  # Loss function\noptimizer = torch.optim.SGD(cnn.parameters(), lr=0.01)  # Stochastic Gradient Descent\n\n# Model training\nfor epoch in range(5):  # Number of epochs\n    running_loss = 0.0\n    for i, data in enumerate(trainloader, 0):\n        inputs, labels = data\n        optimizer.zero_grad()  # Zero the gradients\n        outputs = cnn(inputs)  # Prediction\n        loss = criterion(outputs, labels)  # Loss calculation\n        loss.backward()  # Gradient calculation\n        optimizer.step()  # Parameter update\n        running_loss += loss.item()\n    print(f'Epoch {epoch + 1}, Loss: {running_loss \/ len(trainloader)}')\n<\/code><\/pre>\n
Evaluating the Model<\/h3>\n
\n    After training is complete, we evaluate the model’s performance using the test dataset.\n<\/p>\n
\ncorrect = 0\ntotal = 0\n\nwith torch.no_grad():  # Disable gradient calculation\n    for data in testloader:\n        images, labels = data\n        outputs = cnn(images)\n        _, predicted = torch.max(outputs.data, 1)\n        total += labels.size(0)\n        correct += (predicted == labels).sum().item()\n\nprint(f'Accuracy on the test set: {100 * correct \/ total} %')\n<\/code><\/pre>\n
Conclusion<\/h2>\n
\n    We have now experienced the process of constructing a simple convolutional neural network using PyTorch and training and evaluating it on a real dataset. We hope this tutorial has helped you understand the basic structure of deep learning and practical implementation using Python. Challenge yourself to tackle more complex models and diverse datasets in the future!\n<\/p>\n
References<\/h2>\n