[Medical AI with Python : P3/G2.3] Python and Deep Learning for Beginners: Building a Neural Network

Difficulty: ★★☆☆☆

💡In this third chapter, let’s leverage the knowledge from Chapters 1 and 2 to actually build a neural network and classify the MNIST handwritten digit data. We will implement the entire basic cycle of deep learning, from model definition and training to accuracy evaluation and visualization of misclassifications.

By getting your hands dirty, you should be able to grasp concepts like “What is learning?” and “How is backpropagation used?” in a concrete way. Before we dive into the full-scale implementation of generative AI models, let’s confirm the principles of learning with a simple neural network.

For those who want to conceptually understand or review the series of processes in deep learning, we recommend reading our past article: “【Medical AI Classroom: Vol.7】Tracing Errors Backward?! The Learning Process of ‘Deep Learning’“!

1. What is the MNIST Dataset?

MNIST is a famous benchmark dataset created by a research institute under the U.S. Department of Commerce, containing 70,000 images (60,000 for training + 10,000 for testing) of handwritten digits (0-9) at 28×28 pixels.

• Monochrome 1-channel images
• Pixel values are normalized from the 0-255 range to 0-1 or -1 to 1
• Widely used as the “go-to dataset for machine learning beginners”

In PyTorch, you can use torchvision.datasets.MNIST to automatically download and easily handle it. It’s a very accessible example for understanding the structure of neural networks.

---

2. Steps to Try it on Google Colab

1. Access Google Colab and create a new notebook.
2. In the top menu, go to “Runtime” → “Change runtime type” → change “Hardware accelerator” to GPU (it also works on CPU, but GPU is faster).
3. Paste all the following code blocks into the same notebook and run them in order from the top.

---

3. Training Code Example

Here, we will implement multi-class classification with a neural network using MNIST.

• Data Preparation
• Displaying Sample Images
• Model Definition
• Training Loop (with loss transition graph)
• Test Evaluation (displaying misclassifications, confusion matrix)

Copy and paste the code from each cell into a Google Colab notebook in order, run it, and check the output.

(1) Install & Import Libraries

# --- What are Libraries? ---
# They are like "toolboxes" that come pre-packaged with convenient functions frequently used in programming 
# (e.g., mathematical calculations, image display, AI training).
# They allow for efficient development because you don't have to build everything from scratch.

# 1) Install Libraries (for Google Colab)
!pip install torch torchvision scikit-learn seaborn

# 2) Import necessary libraries
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
from sklearn.metrics import confusion_matrix

# Check if a GPU is available in PyTorch and use it if possible
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Using device:", device)

---

(2) Prepare Dataset and DataLoader

graph TD
    A["Step 1: Define Preprocessing Pipeline
(transform)"]
    B["Step 2: Create Dataset
(train_dataset)
Applies the pipeline to each image"]
    C["Step 3: Create DataLoader
(train_loader)
Groups the dataset into shuffled batches"]
    D["Output: Ready for Model Training"]

    A --> B --> C --> D

# 3) Define data preprocessing transforms
# In deep learning, we convert image data to a format suitable for the model (a tensor) 
# and "normalize" it to make learning easier.
transform = transforms.Compose([
    # Convert image to a Tensor (PyTorch's numerical array) and normalize to a 0-1 range
    transforms.ToTensor(),              
    # Further normalize with mean 0.5 and std dev 0.5 (scaling to a -1 to 1 range)
    transforms.Normalize((0.5,), (0.5,))    
])

# 4) Create the MNIST training dataset
# This prepares the MNIST (handwritten digit images) dataset included in torchvision.
train_dataset = torchvision.datasets.MNIST(
    # Folder to save the data (created automatically if it doesn't exist)
    root='./data',            
    # Specify whether it's training data (True) or test data (False)
    train=True,               
    # Apply the image preprocessing defined above
    transform=transform,      
    # Automatically download the data from the internet if it's not available
    download=True             
)

# 5) Set the batch size and create a DataLoader
# A DataLoader is a mechanism for feeding data to the model in small batches.
train_loader = torch.utils.data.DataLoader(
    # Use the dataset created above
    train_dataset,            
    # The number of data points to use in one training iteration (batch size)
    batch_size=64,            
    # Shuffle the order of the data each time to prevent training bias
    shuffle=True              
)

# Displays the total number of downloaded training data points (60,000) for confirmation.
print("Number of training data:", len(train_dataset))

---

(3) Visualize Sample Images

graph TD
    A["Input: train_loader
(Contains all data batches)"]
    B["Step 1: Fetch the first batch of data
(e.g., 64 images and their labels)"]
    C["Step 2: Loop through the first 9 images
in the fetched batch"]
    D["Step 3: For each image, display it in a 3x3 grid
with its corresponding label as the title"]
    E["Output: A window showing the 3x3 grid of
sample images with their correct labels"]

    A --> B --> C --> D --> E

# 6) Get the first batch from the DataLoader and display the images

# Get a mechanism called an "iterator" that allows retrieving data one batch at a time.
data_iter = iter(train_loader)
# Get the first batch (images and their corresponding labels).
images, labels = next(data_iter)

# Convert the PyTorch Tensor format to NumPy format for displaying images.
# Note: .numpy() will error on a GPU tensor. Use .cpu().numpy() when using a GPU.
images_np = images.numpy()

# Create a figure for drawing. The size is 8x8 inches.
fig = plt.figure(figsize=(8, 8))

# Loop through the first 9 images and display them.
for i in range(9):
    # Prepare to arrange the images one by one in a 3-row by 3-column grid.
    ax = fig.add_subplot(3, 3, i + 1)

    # Display the image in black and white (reversed grayscale).
    # np.squeeze() removes unnecessary dimensions of the image.
    ax.imshow(np.squeeze(images_np[i]), cmap='gray_r')

    # Display the correct label as the title above the image.
    ax.set_title(f"Label: {labels[i].item()}")

    # Hide the axes (borders) around the image.
    ax.axis('off')

# Add a title to the entire figure.
plt.suptitle("MNIST Sample Images", fontsize=16)
# Output the images to the display window.
plt.show()

---

(4) Neural Network Definition

# 7) Neural Network Definition
class SimpleNet(nn.Module):
    # Define our custom network "SimpleNet" by inheriting from PyTorch's nn.Module.
    # nn.Module is like a "template" for building neural networks.
    def __init__(self):
        # Call the initializer of the parent class (nn.Module). It won't work correctly without this.
        super(SimpleNet, self).__init__()

        # A "fully connected layer" that transforms the 784 pixels into a 128-dimensional vector.
        self.fc1 = nn.Linear(28*28, 128)

        # The output layer that classifies the 128-dimensional features into 10 classes (0-9).
        self.fc2 = nn.Linear(128, 10)

    # This function defines the "forward pass" - the flow from input to output.
    def forward(self, x):
        # Flatten the 2D image (e.g., 1x28x28) to a 1D vector (784).
        x = x.view(-1, 28*28)

        # Pass input through the first layer and apply the ReLU activation function.
        # ReLU introduces non-linearity, allowing the model to learn complex patterns.
        x = F.relu(self.fc1(x))

        # Pass through the second layer to get the final scores (logits) for each class.
        x = self.fc2(x)

        # The output (logits) can be directly passed to a loss function.
        return x

# Instantiate the model and move it to the configured device (CPU or GPU).
model = SimpleNet().to(device)
# Print the model's structure to check it.
print(model)

---

(5) Loss Function & Optimizer

# 8) Loss Function & Optimizer

# Defines the "Cross-Entropy Loss function," which is common for classification problems.
# It quantifies the "gap" between the model's output (logits) and the correct labels.
criterion = nn.CrossEntropyLoss()

# Sets up the "Adam optimization algorithm" to update model parameters.
# model.parameters() specifies all parameters that should be learned.
# lr=0.001 is the "learning rate," which controls how quickly the model learns.
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 💡Note: The loss function (criterion) measures "how wrong the model is."
# The optimizer (optimizer) determines "how to correct the parameters."

💡What is Cross-Entropy Loss?

It’s a metric that evaluates “how confidently the model predicted the correct answer.”

For example, for an image where the correct answer is “3”, if the model predicts “3” with high probability, the loss will be small. Conversely, if it gets it wrong, the loss will be large.

In terms of a formula:

Loss = -log(probability of the correct class)

In other words, for the correct data, a higher predicted probability for the correct answer means a smaller loss.

In PyTorch, this one line is all you need:

criterion = nn.CrossEntropyLoss()

During training, the model is designed to be corrected based on this loss, “by the amount it was wrong.”

---

(6) Training Loop and Loss Curve Graph

# 9) Execute the training loop

# Specifies the total number of training iterations (epochs).
# An epoch is one full pass of training on the entire dataset.
num_epochs = 5
# Prepare a list to save the average loss for each epoch.
epoch_losses = []

for epoch in range(num_epochs):
    running_loss = 0.0   # Accumulated loss within one epoch
    total_batch = 0      # Batch counter

    # Get one batch of images and labels from the data loader.
    for images, labels in train_loader:
        # Transfer images and labels to the GPU or CPU.
        images = images.to(device)
        labels = labels.to(device)

        # Reset the gradients from the previous batch.
        optimizer.zero_grad()

        # Input the images into the model to get the output (logits).
        outputs = model(images)

        # Calculate the error between the output and the correct labels.
        loss = criterion(outputs, labels)

        # Automatically calculate the gradients for each parameter (backpropagation).
        loss.backward()

        # Update the model's parameters based on the gradients.
        optimizer.step()

        # Add up the loss value from that batch.
        running_loss += loss.item()

        # Increment the batch count by one.
        total_batch += 1

    # Calculate the average loss for one epoch.
    avg_loss = running_loss / total_batch
    # Record the average loss to be used for the graph later.
    epoch_losses.append(avg_loss)

    # After each epoch, display the loss to check the training progress.
    print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}")

print("Training completed!")

# 10) Plot the loss curve
# Create a figure for the graph.
plt.figure(figsize=(6, 4))
# Display the loss trend for each epoch as a line graph.
plt.plot(range(1, num_epochs + 1), epoch_losses, marker='o')
# Add graph decorations.
plt.title("Training Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.grid(True)
# Display the graph.
plt.show()

• (a) Reset Gradients → (b) Forward Pass → (c) Calculate Loss → (d) Backward Pass → (e) Update Parameters
• As training progresses, the Loss gradually decreases

---

(7) Test Data Evaluation & Visualization of Misclassifications

# 11) Create DataLoader for test data
test_dataset = torchvision.datasets.MNIST(
    root='./data',
    train=False,
    transform=transform,
    download=True
)
test_loader = torch.utils.data.DataLoader(
    test_dataset,
    batch_size=64,
    shuffle=False
)
print("Number of test data:", len(test_dataset))

# 12) Calculate accuracy using the test data
# Switch the model to "evaluation mode". This is important for layers like Dropout.
model.eval()

# Counters for correct predictions and total samples.
correct = 0
total = 0

# Lists to save misclassified examples for visualization.
misclassified_images = []
misclassified_true = []
misclassified_pred = []

# Disable gradient calculation to save memory and computations.
with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)

        # Get model predictions.
        outputs = model(images)

        # Get the index of the max log-probability (the predicted class).
        _, predicted = torch.max(outputs.data, 1)

        # Update total and correct counts.
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

        # Store up to 9 misclassified images.
        for i in range(len(labels)):
            if predicted[i] != labels[i] and len(misclassified_images) < 9:
                misclassified_images.append(images[i].cpu().numpy())
                misclassified_true.append(labels[i].cpu().item())
                misclassified_pred.append(predicted[i].cpu().item())

# Calculate and print the final accuracy.
accuracy = correct / total
print(f"Accuracy on test data: {accuracy*100:.2f}%")

# 13) Visualize the misclassified images
if misclassified_images:
    fig = plt.figure(figsize=(8, 8))
    for i in range(len(misclassified_images)):
        ax = fig.add_subplot(3, 3, i + 1)
        ax.imshow(np.squeeze(misclassified_images[i]), cmap='gray_r')
        ax.set_title(f"True: {misclassified_true[i]}, Pred: {misclassified_pred[i]}")
        ax.axis('off')
    plt.suptitle("Misclassified Samples", fontsize=16)
    plt.show()
else:
    print("There were no misclassifications to display. High accuracy!")

• model.eval() : Puts the model in inference mode.
• torch.no_grad() : Disables gradient tracking to reduce computational load.
• Checking a few misclassified examples makes it easier to understand how the model is making mistakes.

---

(8) (Optional) Plotting the Confusion Matrix

# 14) Visualize the Confusion Matrix

# Prepare lists to save all true and predicted labels.
y_true = []
y_pred = []

# Set model to evaluation mode.
model.eval()

# Iterate through test data without calculating gradients.
with torch.no_grad():
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs, 1)
        # Append batch results to the lists.
        y_true.extend(labels.cpu().numpy())
        y_pred.extend(predicted.cpu().numpy())

# Create the confusion matrix using scikit-learn.
cm = confusion_matrix(y_true, y_pred)

# Create a figure for the plot.
plt.figure(figsize=(8, 6))

# Visualize the confusion matrix as a heatmap using Seaborn.
# annot=True: Display numbers in each cell.
# fmt='d': Display as integers.
# cmap='Blues': Use a blue color map.
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')

# Add titles and labels.
plt.title("Confusion Matrix (MNIST)")
plt.xlabel("Predicted Label")
plt.ylabel("True Label")
plt.show()

• The distribution of misclassifications for classes 0-9 is visible at a glance.
• The more entries on the diagonal, the more correct the identifications are.

---

4. Execution Results

When you run all the cells, the following logs, graphs, and images will be output.

1. Sample images before training
   • You can see how the handwritten digits are represented as data.
2. Loss display & curve graph
   • Shows the loss decreasing with each epoch.
3. Accuracy on test data
   • Even with a simple fully connected network, it’s common to get over 90-95% accuracy in 5 epochs.
4. Misclassification examples
   • Visualizes cases where the model made a mistake, such as “True: 9, Pred: 4”.
5. Confusion Matrix (optional)
   • Provides a high-level view of misclassifications between classes.

---

5. Summary and Next Steps

MNIST is a dataset of monochrome images (28×28) of handwritten digits 0-9. Using PyTorch, we experienced the training flow through the following steps.

1. Batch splitting with DataLoader
2. Input to the model → Forward Pass
3. Loss Calculation
4. Backward Pass (Backpropagation)
5. Parameter Update

The basic structure is the same for medical images and data in other fields.

Application to Medical AI

• For X-rays, CT scans, and pathology images, larger models like CNNs/Transformers and transfer learning are effective.
• Even if the amount of data or number of channels differs, the mechanism of the training loop is the same.
• In real-world applications, aspects like patient information protection and ethical reviews are extremely important.

Basics of Data Preparation and Preprocessing (Handling Medical Data)

• Cleaning and format conversion for text, images, and audio
• Anonymization of patient data, ethical reviews, and compliance with laws like the Personal Information Protection Act and HIPAA
• Data splitting and strategies to prevent overfitting (Train/Validation/Test)

In medical AI projects, the “quality of the data” greatly influences the outcome. Please look forward to it!

Next Chapter Preview: More Python and Intermediate Deep Learning

In Chapter 4 and beyond of the second part, we plan to delve into more technical topics mentioned in the previous chapter, such as “computation graphs,” “loss functions,” and “backpropagation,” in the intermediate Python and deep learning section.

---

Reference Links

• Google Colab
• VS Code Official Site
• Anaconda Official Site / Miniconda
• PyTorch Official Documentation
• Python venv Documentation (Official)
• scikit-learn confusion_matrix

---

Caution

• The content of this article is current as of the time of writing. There may be changes depending on the environment and version.
• When actually handling patient information, please ensure thorough privacy protection and legal compliance.
• Especially for patient images and medical records, handle them appropriately after following organizational guidelines and Institutional Review Board (IRB) procedures.

This concludes the explanation of “Building a Simple Neural Network with MNIST.” Please try running it on Colab, visualize the learning process and misclassifications, and deepen your understanding of neural networks.

---

参考文献

• LeCun, Y., Bottou, L., Bengio, Y. and Haffner, P. (1998). Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11), pp.2278-2324.
• Goodfellow, I., Bengio, Y. and Courville, A. (2016). Deep Learning. MIT Press.

※本記事は情報提供を目的としたものであり、特定の治療法を推奨するものではありません。健康に関するご懸念やご相談は、必ず専門の医療機関にご相談ください。

---

ご利用規約（免責事項）

当サイト（以下「本サイト」といいます）をご利用になる前に、本ご利用規約（以下「本規約」といいます）をよくお読みください。本サイトを利用された時点で、利用者は本規約の全ての条項に同意したものとみなします。

第1条（目的と情報の性質）

1. 本サイトは、医療分野におけるAI技術に関する一般的な情報提供および技術的な学習機会の提供を唯一の目的とします。
2. 本サイトで提供されるすべてのコンテンツ（文章、図表、コード、データセットの紹介等を含みますが、これらに限定されません）は、一般的な学習参考用であり、いかなる場合も医学的な助言、診断、治療、またはこれらに準ずる行為（以下「医行為等」といいます）を提供するものではありません。
3. 本サイトのコンテンツは、特定の製品、技術、または治療法の有効性、安全性を保証、推奨、または広告・販売促進するものではありません。紹介する技術には研究開発段階のものが含まれており、その臨床応用には、さらなる研究と国内外の規制当局による正式な承認が別途必要です。
4. 本サイトは、情報提供を目的としたものであり、特定の治療法を推奨するものではありません。健康に関するご懸念やご相談は、必ず専門の医療機関にご相談ください。

第2条（法令等の遵守）
利用者は、本サイトの利用にあたり、医師法、医薬品、医療機器等の品質、有効性及び安全性の確保等に関する法律（薬機法）、個人情報の保護に関する法律、医療法、医療広告ガイドライン、その他関連する国内外の全ての法令、条例、規則、および各省庁・学会等が定める最新のガイドライン等を、自らの責任において遵守するものとします。これらの適用判断についても、利用者が自ら関係各所に確認するものとし、本サイトは一切の責任を負いません。

第3条（医療行為における責任）

1. 本サイトで紹介するAI技術・手法は、あくまで研究段階の技術的解説であり、実際の臨床現場での診断・治療を代替、補助、または推奨するものでは一切ありません。
2. 医行為等に関する最終的な判断、決定、およびそれに伴う一切の責任は、必ず法律上その資格を認められた医療専門家（医師、歯科医師等）が負うものとします。AIによる出力を、資格を有する専門家による独立した検証および判断を経ずに利用することを固く禁じます。
3. 本サイトの情報に基づくいかなる行為によって利用者または第三者に損害が生じた場合も、本サイト運営者は一切の責任を負いません。実際の臨床判断に際しては、必ず担当の医療専門家にご相談ください。本サイトの利用によって、利用者と本サイト運営者の間に、医師と患者の関係、またはその他いかなる専門的な関係も成立するものではありません。

第4条（情報の正確性・完全性・有用性）

1. 本サイトは、掲載する情報（数値、事例、ソースコード、ライブラリのバージョン等）の正確性、完全性、網羅性、有用性、特定目的への適合性、その他一切の事項について、何ら保証するものではありません。
2. 掲載情報は執筆時点のものであり、予告なく変更または削除されることがあります。また、技術の進展、ライブラリの更新等により、情報は古くなる可能性があります。利用者は、必ず自身で公式ドキュメント等の最新情報を確認し、自らの責任で情報を利用するものとします。

第5条（AI生成コンテンツに関する注意事項）
本サイトのコンテンツには、AIによる提案を基に作成された部分が含まれる場合がありますが、公開にあたっては人間による監修・編集を経ています。利用者が生成AI等を用いる際は、ハルシネーション（事実に基づかない情報の生成）やバイアスのリスクが内在することを十分に理解し、その出力を鵜呑みにすることなく、必ず専門家による検証を行うものとします。

第6条（知的財産権）

1. 本サイトを構成するすべてのコンテンツに関する著作権、商標権、その他一切の知的財産権は、本サイト運営者または正当な権利を有する第三者に帰属します。
2. 本サイトのコンテンツを引用、転載、複製、改変、その他の二次利用を行う場合は、著作権法その他関連法規を遵守し、必ず出典を明記するとともに、権利者の許諾を得るなど、適切な手続きを自らの責任で行うものとします。

第7条（プライバシー・倫理）
本サイトで紹介または言及されるデータセット等を利用する場合、利用者は当該データセットに付随するライセンス条件および研究倫理指針を厳格に遵守し、個人情報の匿名化や同意取得の確認など、適用される法規制に基づき必要とされるすべての措置を、自らの責任において講じるものとします。

第8条（利用環境）
本サイトで紹介するソースコードやライブラリは、執筆時点で特定のバージョンおよび実行環境（OS、ハードウェア、依存パッケージ等）を前提としています。利用者の環境における動作を保証するものではなく、互換性の問題等に起因するいかなる不利益・損害についても、本サイト運営者は責任を負いません。

第9条（免責事項）

1. 本サイト運営者は、利用者が本サイトを利用したこと、または利用できなかったことによって生じる一切の損害（直接損害、間接損害、付随的損害、特別損害、懲罰的損害、逸失利益、データの消失、プログラムの毀損等を含みますが、これらに限定されません）について、その原因の如何を問わず、一切の法的責任を負わないものとします。
2. 本サイトの利用は、学習および研究目的に限定されるものとし、それ以外の目的での利用はご遠慮ください。
3. 本サイトの利用に関連して、利用者と第三者との間で紛争が生じた場合、利用者は自らの費用と責任においてこれを解決するものとし、本サイト運営者に一切の迷惑または損害を与えないものとします。
4. 本サイト運営者は、いつでも予告なく本サイトの運営を中断、中止、または内容を変更できるものとし、これによって利用者に生じたいかなる損害についても責任を負いません。

第10条（規約の変更）
本サイト運営者は、必要と判断した場合、利用者の承諾を得ることなく、いつでも本規約を変更することができます。変更後の規約は、本サイト上に掲載された時点で効力を生じるものとし、利用者は変更後の規約に拘束されるものとします。

第11条（準拠法および合意管轄）
本規約の解釈にあたっては、日本法を準拠法とします。本サイトの利用および本規約に関連して生じる一切の紛争については、東京地方裁判所を第一審の専属的合意管轄裁判所とします。

---

For J³, may joy follow you.