How Microsoft AI for Beginners Lessons Are Structured with Dual TensorFlow and PyTorch Frameworks

Microsoft's AI for Beginners curriculum uses a dual-framework approach where each hands-on lesson provides paired Python scripts—one prefixed with tf for TensorFlow and one with pytorch for PyTorch—allowing learners to master the same concepts in both dominant deep-learning ecosystems.

The AI-For-Beginners repository by Microsoft organizes its educational content into topic-focused lesson folders, with a distinctive pedagogical design that eliminates framework lock-in. Rather than forcing beginners to choose between TensorFlow and PyTorch, the curriculum enables direct comparison of syntax, debugging workflows, and performance characteristics through parallel implementations.

Folder Structure and Naming Conventions

All instructional content lives under lessons/<topic>/, with each module containing a README, optional assignments, and framework-specific code files.

• Example path: lessons/4-ComputerVision/07-ConvNets/
• TensorFlow files: Prefixed with tf (e.g., tfcv.py)
• PyTorch files: Prefixed with pytorch (e.g., pytorchcv.py)

Both scripts implement identical model architectures, data loading patterns, and training loops. Only the library-specific API calls differ, creating a controlled environment for learners to translate knowledge between frameworks.

Convolutional Neural Networks: Framework Comparison

The ConvNets lesson demonstrates this dual-framework structure clearly. Both scripts build the same CNN architecture for image classification on 28×28 grayscale inputs.

TensorFlow Implementation (tfcv.py)

import tensorflow as tf
from tensorflow.keras import layers, models

# Build a simple CNN

model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

Source: [lessons/4-ComputerVision/07-ConvNets/tfcv.py](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/tfcv.py)

PyTorch Implementation (pytorchcv.py)

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
        self.pool  = nn.MaxPool2d(2, 2)
        self.fc1   = nn.Linear(32 * 13 * 13, 64)
        self.fc2   = nn.Linear(64, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(x)
        x = x.view(-1, 32 * 13 * 13)
        x = F.relu(self.fc1(x))
        return self.fc2(x)

Source: [lessons/4-ComputerVision/07-ConvNets/pytorchcv.py](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/pytorchcv.py)

Notice how TensorFlow uses a declarative Sequential API with layer stacking, while PyTorch requires an explicit nn.Module class with a forward() method. The dual-framework design makes these paradigm differences immediately visible.

Transfer Learning: Freezing Pretrained Models

The transfer learning lesson extends this pattern to practical workflows using MobileNetV2.

TensorFlow Transfer Learning (tfcv.py)

base_model = tf.keras.applications.MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,
    weights='imagenet'
)
base_model.trainable = False          # Freeze the base

global_avg = tf.keras.layers.GlobalAveragePooling2D()
prediction = tf.keras.layers.Dense(5, activation='softmax')
model = tf.keras.Sequential([base_model, global_avg, prediction])

Source: [lessons/4-ComputerVision/08-TransferLearning/tfcv.py](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/tfcv.py)

PyTorch Transfer Learning (pytorchcv.py)

import torchvision.models as models

base_model = models.mobilenet_v2(pretrained=True)
for param in base_model.parameters():
    param.requires_grad = False          # Freeze the base

num_ftrs = base_model.classifier[1].in_features
base_model.classifier[1] = nn.Linear(num_ftrs, 5)   # Replace head

Source: [lessons/4-ComputerVision/08-TransferLearning/pytorchcv.py](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/pytorchcv.py)

Both scripts accomplish the same three objectives: load pretrained ImageNet weights, freeze feature extraction layers, and attach a custom classification head for 5 classes. The dual-framework consistency ensures learners recognize transferable concepts regardless of syntax differences.

NLP and Other Topics

The dual-framework pattern appears across the curriculum, though implementation details vary by topic complexity.

• Computer Vision lessons: Always provide paired tfcv.py and pytorchcv.py scripts
• NLP lessons: PyTorch implementations use torchnlp.py (e.g., in lessons/5-NLP/18-Transformers/torchnlp.py), while TensorFlow concepts often appear in notebook form using Keras APIs

For natural language processing, the torchnlp.py script demonstrates tokenization, model definition, and training with torchtext, maintaining the same architectural approach as vision counterparts.

Pedagogical Benefits of the Dual-Framework Approach

Microsoft's design choice delivers three concrete advantages for beginners:

1. Framework flexibility — Learners aren't locked into one ecosystem early in their education
2. Direct comparability — Side-by-side study reveals how high-level concepts (layers, optimizers, loss functions) map to different APIs
3. Career readiness — Exposure to both TensorFlow and PyTorch prepares students for diverse industry codebases

The consistent file naming convention and parallel folder structure make it trivial to locate corresponding implementations when switching between frameworks.

Summary

• Microsoft AI-For-Beginners structures lessons under lessons/<topic>/ with READMEs, assignments, and code files
• Dual-framework pairing provides tf*.py (TensorFlow/Keras) and pytorch*.py (PyTorch) scripts for core modules
• Both implementations share identical architectures, data pipelines, and training objectives
• Examples in lessons/4-ComputerVision/ demonstrate ConvNets and transfer learning with MobileNetV2 in both frameworks
• The design enables direct syntax comparison while reinforcing transferable deep-learning concepts

Frequently Asked Questions

Does every AI for Beginners lesson include both TensorFlow and PyTorch code?

Not every lesson. Computer Vision modules consistently provide paired scripts (tfcv.py and pytorchcv.py), while some NLP lessons use notebook-based TensorFlow/Keras examples alongside dedicated PyTorch files like torchnlp.py. The repository prioritizes dual-framework coverage for fundamental architecture lessons where API differences are most instructive.

How do the TensorFlow and PyTorch implementations differ in the Microsoft AI curriculum?

They differ only in library-specific syntax, not in architecture or learning objectives. Both use the same layer configurations, activation functions, and training procedures. TensorFlow scripts leverage Keras's Sequential or Functional APIs, while PyTorch scripts define custom nn.Module classes with explicit forward() methods.

Why does Microsoft use a dual-framework approach for teaching AI?

According to the repository structure, this approach eliminates framework bias and mirrors real-world machine learning engineering, where teams frequently work with both TensorFlow and PyTorch. It also accelerates framework translation skills—critical when adapting research code or collaborating across organizations.

Where can I find the paired framework files in the repository?

Navigate to specific lesson folders under lessons/. For example, the ConvNets lesson stores its dual implementations at lessons/4-ComputerVision/07-ConvNets/tfcv.py and lessons/4-ComputerVision/07-ConvNets/pytorchcv.py. The tf and pytorch prefixes make corresponding files instantly identifiable.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}