# How to Swap Between Different ML Frameworks in ML-For-Beginners Lessons

> Easily swap between ML frameworks like TensorFlow PyTorch and scikit-learn in the ML-For-Beginners curriculum. Learn how with framework-specific notebooks.

- Repository: [Microsoft/ML-For-Beginners](https://github.com/microsoft/ML-For-Beginners)
- Tags: how-to-guide
- Published: 2026-02-28

---

**You swap between ML frameworks in the ML-For-Beginners curriculum by opening the framework-specific notebook that corresponds to your desired library, as each lesson contains separate notebooks for TensorFlow, PyTorch, scikit-learn, and others that share identical data loading and evaluation logic.**

The Microsoft ML-For-Beginners repository provides a modular curriculum where every lesson is implemented across multiple machine-learning frameworks. This architecture allows you to swap between different ML frameworks in lessons simply by selecting the notebook that targets your preferred library, ensuring the educational narrative remains consistent while the API implementation changes.

## Repository Architecture for Multi-Framework Lessons

The repository organizes content into self-contained Jupyter notebooks that follow a strict naming convention. Each lesson resides in a dedicated directory containing framework-specific variants of the same instructional content.

According to the source code structure, the key components include:

- **Framework-Specific Notebooks**: Separate files implementing identical algorithms with different libraries. All notebooks in a lesson share the same base filename, differing only by the framework suffix (e.g., `03-Regression-TensorFlow.ipynb`, `03-Regression-PyTorch.ipynb`, `03-Regression-ScikitLearn.ipynb`).
- **Shared Utilities**: The `utils/` directory contains framework-agnostic helper functions for data loading, preprocessing, and visualization that every notebook imports.
- **Requirements Files**: [`requirements.txt`](https://github.com/microsoft/ML-For-Beginners/blob/main/requirements.txt) lists common dependencies, while framework-specific packages (like `tensorflow` or `torch`) are installed separately as needed.

This design ensures that when you swap frameworks, only the import statements and API calls change; the surrounding lesson narrative, data paths, and evaluation metrics remain identical.

## Steps to Swap Between Frameworks in a Lesson

Follow this workflow to switch from one machine-learning library to another within the same lesson:

1. **Locate the Lesson Index** – Open the top-level [`README.md`](https://github.com/microsoft/ML-For-Beginners/blob/main/README.md) to find the lesson you want to study. The index lists every framework available for that specific topic.

2. **Select the Framework-Specific Notebook** – Navigate to the lesson folder and open the notebook whose filename ends with your desired framework:
   - **TensorFlow** ⇒ `…-TensorFlow.ipynb`
   - **PyTorch** ⇒ `…-PyTorch.ipynb`
   - **scikit-learn** ⇒ `…-ScikitLearn.ipynb`

3. **Install Dependencies** – Set up the environment using the provided [`requirements.txt`](https://github.com/microsoft/ML-For-Beginners/blob/main/requirements.txt) and add the framework-specific package. For example:

   ```bash
   pip install -r requirements.txt
   pip install tensorflow==2.14
   # or

   pip install torch torchvision
   ```

4. **Execute the Notebook** – Run all cells. Because data loading and evaluation logic are abstracted into the `utils` module, you will see identical results across frameworks, allowing you to compare API ergonomics and performance directly.

5. **Optional: Convert Models** – If you need to export a model to a different format (e.g., TensorFlow to ONNX), look for notebooks with "Export" or "Convert" in the title, such as `01-Introduction/03-Deep Learning/03-2-Deep Learning - ONNX Export.ipynb`.

## Framework-Specific Implementation Examples

The following snippets demonstrate how the same linear regression task is implemented in three different frameworks. These examples are taken from the `02-Regression/03-Regression/` directory.

### TensorFlow Implementation

In `02-Regression/03-Regression/03-Regression-TensorFlow.ipynb`, the model is built using `tf.keras.Sequential`:

```python
import tensorflow as tf
from utils import load_data, plot_results

X_train, y_train, X_test, y_test = load_data()

model = tf.keras.Sequential([
    tf.keras.layers.Dense(1, input_shape=(X_train.shape[1],))
])
model.compile(optimizer='adam', loss='mse')
model.fit(X_train, y_train, epochs=100, verbose=0)

preds = model.predict(X_test)
plot_results(y_test, preds, title="TensorFlow Linear Regression")

```

### PyTorch Implementation

The PyTorch variant in `02-Regression/03-Regression/03-Regression-PyTorch.ipynb` uses `nn.Linear` and explicit training loops:

```python
import torch
import torch.nn as nn
from utils import load_data, plot_results

X_train, y_train, X_test, y_test = load_data()
X_train = torch.from_numpy(X_train).float()
y_train = torch.from_numpy(y_train).float()

model = nn.Linear(X_train.shape[1], 1)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(100):
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs.squeeze(), y_train)
    loss.backward()
    optimizer.step()

preds = model(torch.from_numpy(X_test).float()).detach().numpy()
plot_results(y_test, preds, title="PyTorch Linear Regression")

```

### scikit-learn Implementation

The scikit-learn version in `02-Regression/03-Regression/03-Regression-ScikitLearn.ipynb` provides the most concise implementation:

```python
from sklearn.linear_model import LinearRegression
from utils import load_data, plot_results

X_train, y_train, X_test, y_test = load_data()

model = LinearRegression()
model.fit(X_train, y_train)

preds = model.predict(X_test)
plot_results(y_test, preds, title="scikit-learn Linear Regression")

```

## Key Files for Framework Management

| File | Description | Path |
|------|-------------|------|
| [`README.md`](https://github.com/microsoft/ML-For-Beginners/blob/main/README.md) | Master index listing all lessons and supported frameworks. | [`README.md`](https://github.com/microsoft/ML-For-Beginners/blob/main/README.md) |
| `utils/` | Shared helper functions for data loading and visualization. | `utils/` |
| [`requirements.txt`](https://github.com/microsoft/ML-For-Beginners/blob/main/requirements.txt) | Common Python dependencies for all lessons. | [`requirements.txt`](https://github.com/microsoft/ML-For-Beginners/blob/main/requirements.txt) |
| `03-2-Deep Learning - TensorFlow.ipynb` | Example TensorFlow deep learning notebook. | `01-Introduction/03-Deep Learning/03-2-Deep Learning - TensorFlow.ipynb` |
| `03-2-Deep Learning - PyTorch.ipynb` | Equivalent PyTorch implementation. | `01-Introduction/03-Deep Learning/03-2-Deep Learning - PyTorch.ipynb` |

## Summary

- The ML-For-Beginners curriculum uses **framework-specific notebooks** that share a common naming convention, allowing you to swap between TensorFlow, PyTorch, and scikit-learn by simply opening the corresponding file.
- All notebooks import **shared utility functions** from the `utils/` directory, ensuring that data loading, preprocessing, and evaluation remain identical across frameworks.
- To switch frameworks, install the specific requirements (e.g., `pip install tensorflow`), open the appropriately suffixed notebook (e.g., `…-TensorFlow.ipynb`), and execute the cells to compare API implementations side-by-side.

## Frequently Asked Questions

### How do I know which frameworks are supported in a specific lesson?

Check the top-level [`README.md`](https://github.com/microsoft/ML-For-Beginners/blob/main/README.md) or the lesson folder's index. Each lesson entry lists all available framework implementations, and the notebook files follow a strict naming pattern where the framework name appears as a suffix (e.g., `-TensorFlow.ipynb`, `-PyTorch.ipynb`, `-ScikitLearn.ipynb`).

### Can I mix frameworks within the same lesson?

While each notebook is self-contained and uses only one framework, you can run multiple notebooks from the same lesson sequentially. Because all variants import the same `load_data` and `plot_results` functions from `utils/`, you can compare outputs across TensorFlow, PyTorch, and scikit-learn without data inconsistencies.

### Do I need to reinstall dependencies every time I switch frameworks?

You only need to install a framework's specific packages once per environment. The base [`requirements.txt`](https://github.com/microsoft/ML-For-Beginners/blob/main/requirements.txt) covers common dependencies like `numpy` and `pandas`, while framework-specific packages (e.g., `tensorflow`, `torch`) are installed separately. Once installed, you can switch between notebooks freely without reinstallation.

### How do I convert a trained model from one framework to another?

The repository includes advanced lessons demonstrating cross-framework conversion. Look for notebooks with "Export" or "Convert" in the title, such as `01-Introduction/03-Deep Learning/03-2-Deep Learning - ONNX Export.ipynb`, which shows how to export a TensorFlow model to ONNX format for interoperability with other frameworks.