{"id":36683,"date":"2024-11-01T09:50:34","date_gmt":"2024-11-01T09:50:34","guid":{"rendered":"http:\/\/atmokpo.com\/w\/?p=36683"},"modified":"2024-11-01T11:52:13","modified_gmt":"2024-11-01T11:52:13","slug":"deep-learning-pytorch-course-training-evaluation","status":"publish","type":"post","link":"https:\/\/atmokpo.com\/w\/36683\/","title":{"rendered":"Deep Learning PyTorch Course, Training Evaluation"},"content":{"rendered":"

<\/p>\n

Deep learning is a branch of artificial intelligence that is used to extract features from complex data and find patterns. PyTorch is a widely used Python library for implementing such deep learning models. In this course, we will learn about training and evaluating deep learning models using PyTorch.<\/p>\n

1. Overview of Training Deep Learning Models<\/h2>\n

The training process for deep learning models can be broadly divided into three stages:<\/p>\n

    \n
  1. Model Definition: Define a neural network structure suitable for the data to be used.<\/li>\n
  2. Training: Optimize the model to fit the given data.<\/li>\n
  3. Evaluation: Validate the performance of the trained model.<\/li>\n<\/ol>\n

    2. Installing Required Libraries<\/h2>\n

    First, we need to install PyTorch. If you are using Anaconda, you can install it with the following command:<\/p>\n

    conda install pytorch torchvision torchaudio -c pytorch<\/code><\/pre>\n
    3. Preparing the Dataset<\/h2>\n
    For this example, we will use the MNIST dataset. MNIST is a dataset of handwritten digit images that is frequently used for training deep learning models.<\/p>\n
    3.1. Loading and Preprocessing the Dataset<\/h3>\n
    We can easily load the MNIST dataset using PyTorch’s torchvision library. Here is the code to load and preprocess the data:<\/p>\n
    \nimport torch\nfrom torchvision import datasets, transforms\n\n# Data preprocessing: Resize images and normalize them.\ntransform = transforms.Compose([\n    transforms.Resize((28, 28)),\n    transforms.ToTensor(),\n    transforms.Normalize((0.5,), (0.5,))\n])\n\n# Download and load the dataset\ntrain_dataset = datasets.MNIST(root='.\/data', train=True, download=True, transform=transform)\ntest_dataset = datasets.MNIST(root='.\/data', train=False, download=True, transform=transform)\n\n# Create data loaders\ntrain_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\ntest_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n    <\/code><\/pre>\n
    4. Defining the Model<\/h2>\n
    Now, let’s define a neural network model. We will use a simple fully connected neural network. The following code defines the model:<\/p>\n
    \nimport torch.nn as nn\nimport torch.nn.functional as F\n\nclass SimpleNN(nn.Module):\n    def __init__(self):\n        super(SimpleNN, self).__init__()\n        self.fc1 = nn.Linear(28 * 28, 128)  # First hidden layer\n        self.fc2 = nn.Linear(128, 64)        # Second hidden layer\n        self.fc3 = nn.Linear(64, 10)         # Output layer\n        \n    def forward(self, x):\n        x = x.view(-1, 28 * 28)  # Convert to 1D tensor\n        x = F.relu(self.fc1(x))  # Apply activation function\n        x = F.relu(self.fc2(x))\n        x = self.fc3(x)           # Final output\n        return x\n    <\/code><\/pre>\n
    5. Training the Model<\/h2>\n
    To train the model, we need to define a loss function and an optimizer. We will use CrossEntropyLoss and the Adam optimizer. Here is the code to implement the training process:<\/p>\n
    \n# Initialize model, loss function, and optimizer\nmodel = SimpleNN()\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n\n# Training loop\nnum_epochs = 5\n\nfor epoch in range(num_epochs):\n    for i, (images, labels) in enumerate(train_loader):\n        # Forward pass\n        outputs = model(images)\n        loss = criterion(outputs, labels)\n\n        # Backward pass and optimization\n        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n\n        if (i+1) % 100 == 0:\n            print(f'Epoch [{epoch+1}\/{num_epochs}], Step [{i+1}\/{len(train_loader)}], Loss: {loss.item():.4f}')\n    <\/code><\/pre>\n
    6. Evaluating the Model<\/h2>\n
    To evaluate the trained model, we will use the test dataset to calculate the model’s accuracy. Here is the code for model evaluation:<\/p>\n
    \n# Evaluating the model\nmodel.eval()  # Set to evaluation mode\nwith torch.no_grad():\n    correct = 0\n    total = 0\n    for images, labels in test_loader:\n        outputs = model(images)\n        _, predicted = torch.max(outputs.data, 1)\n        total += labels.size(0)\n        correct += (predicted == labels).sum().item()\n\n    print(f'Accuracy of the model on the 10000 test images: {100 * correct \/ total:.2f}%')\n    <\/code><\/pre>\n
    7. Analyzing Results<\/h2>\n
    The evaluation results of the model show the accuracy on the test dataset. Additionally, various techniques can be applied to achieve better performance. For example:<\/p>\n