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

> Explore how Microsoft AI for Beginners lessons structure content with dual TensorFlow and PyTorch frameworks. Learn AI concepts using paired Python scripts for both dominant deep-learning ecosystems.

- Repository: [Microsoft/AI-For-Beginners](https://github.com/microsoft/AI-For-Beginners)
- Tags: architecture
- Published: 2026-08-21

---

**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`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py))
- **PyTorch files**: Prefixed with **`pytorch`** (e.g., [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/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`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py))

```python
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)](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/tfcv.py)

### PyTorch Implementation ([`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py))

```python
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)](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`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py))

```python
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)](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/08-TransferLearning/tfcv.py)

### PyTorch Transfer Learning ([`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py))

```python
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)](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`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py) and [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py) scripts
- **NLP lessons**: PyTorch implementations use [`torchnlp.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/torchnlp.py) (e.g., in [`lessons/5-NLP/18-Transformers/torchnlp.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/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`](https://github.com/microsoft/AI-For-Beginners/blob/main/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`](https://github.com/microsoft/AI-For-Beginners/blob/main/tfcv.py) and [`pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/pytorchcv.py)), while some NLP lessons use notebook-based TensorFlow/Keras examples alongside dedicated PyTorch files like [`torchnlp.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/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`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/tfcv.py) and [`lessons/4-ComputerVision/07-ConvNets/pytorchcv.py`](https://github.com/microsoft/AI-For-Beginners/blob/main/lessons/4-ComputerVision/07-ConvNets/pytorchcv.py). The `tf` and `pytorch` prefixes make corresponding files instantly identifiable.