What Are the Dependencies for AI For Beginners? Complete Setup Guide

The AI For Beginners curriculum depends on two primary specification files—environment.yml for Conda packages and requirements.txt for PyPI libraries—to provide TensorFlow, PyTorch, Jupyter, and domain-specific tools for machine learning, computer vision, and NLP.

The Microsoft AI For Beginners repository requires a carefully curated Python environment to run its educational notebooks covering symbolic AI through modern transformers. According to the source code, the project uses a dual-layer dependency system that separates base environment configuration from specific package versions. Understanding these dependencies ensures reproducible execution across local workstations, cloud instances, and containerized development environments.

Core Dependency Specification Files

The repository root contains two canonical files that define the entire software stack:

Conda Environment Definition

The environment.yml file establishes the base Anaconda environment with core scientific computing packages and channels. This file specifies the Python interpreter version and Conda-forge packages for system-level dependencies like OpenCV.

Key entries in environment.yml include:

• python – Core interpreter targeting the latest stable release
• numpy 1.26 – Fundamental numerical arrays for all tensor operations
• matplotlib 3.9 – Visualization of training curves and data distributions
• scipy 1.13 – Scientific computing utilities complementing NumPy
• scikit-learn – Classical machine learning algorithms and evaluation metrics
• opencv (conda-forge channel) – Image preprocessing for computer vision lessons
• jupyter, ipykernel, ipywidgets – Notebook runtime and interactive widgets
• pytorch, torchvision, torchtext, torchdata (pytorch channel) – Deep learning framework and domain libraries
• requests 2.32 – HTTP client for downloading datasets
• pip – Enables installation of the secondary requirements file

Python Package Requirements

The requirements.txt file enumerates exact PyPI versions for deep learning frameworks and specialized AI libraries used across the curriculum:

• tensorflow 2.17.0 – Core deep learning framework
• keras 3.13.2 – High-level neural network API
• tensorboard 2.17.1 – Experiment tracking and visualization
• torchinfo 1.8.0 – PyTorch model architecture summaries
• pandas 2.2.2 – Tabular data manipulation
• nltk 3.10.0 – Natural language processing utilities
• gensim 4.3.3 – Word embeddings and topic modeling
• huggingface 0.0.1 – Wrapper for Hugging Face Hub access
• tokenizers 0.20.0 – Fast text tokenization for transformers
• gym 0.26.2 – Reinforcement learning environments
• pygame 2.6.0 – Interactive graphics for RL demos
• scikit-image 0.24.0 – Advanced image processing
• pillow 12.2.0 – Image manipulation alongside OpenCV
• seaborn 0.13.2 – Statistical visualization enhancements
• tqdm 4.66.5 – Progress bars for training loops
• smart-open 7.0.4 – Streaming remote datasets from cloud storage

Domain-Specific Dependency Groups

The curriculum organizes dependencies by AI discipline to support modular learning paths.

Deep Learning Frameworks

The repository uniquely supports both major frameworks side-by-side:

• PyTorch ecosystem (torch, torchvision, torchtext, torchdata) powers the neural network fundamentals, CNN, and RNN lessons
• TensorFlow ecosystem (tensorflow, keras, tensorflow-datasets, tensorflow-hub) supports alternative implementations and production-oriented examples

Computer Vision Libraries

Vision lessons require image I/O and processing capabilities:

• opencv – High-performance image loading and transformation
• imageio 2.35.0 – Simple image I/O for dataset loading
• scikit-image 0.24.0 – Morphological operations and filters
• pillow 12.2.0 – Format conversion and basic manipulation

Natural Language Processing Tools

Text processing dependencies enable transformer and classical NLP examples:

• nltk 3.10.0 – Tokenization, stemming, and corpora access
• gensim 4.3.3 – Word2Vec and LDA topic models
• tokenizers 0.20.0 – Byte-Pair Encoding for modern LLMs
• huggingface 0.0.1 – Model hub integration for pretrained transformers

Reinforcement Learning Environment

RL-specific modules provide interactive training environments:

• gym 0.26.2 – Standardized environment interface (OpenAI Gym)
• pygame 2.6.0 – Rendering engine for custom environment visualization

Installation and Environment Setup

To reproduce the exact environment specified in the Microsoft repository, execute these commands from the repository root:

Create the base Conda environment:

conda env create -f environment.yml
conda activate ai4beg

Install the PyPI-specific dependencies:

pip install -r requirements.txt

Verify the installation by importing core libraries in a Python interpreter or notebook cell:

import numpy as np
import torch
import tensorflow as tf
import matplotlib.pyplot as plt

print(f"NumPy: {np.__version__}")
print(f"PyTorch: {torch.__version__}")
print(f"TensorFlow: {tf.__version__}")
print("All core dependencies loaded successfully!")

Alternative Environment Configurations

The repository provides variant specifications for different deployment targets:

• binder/environment.yml – Trimmed version optimized for Binder cloud notebooks, removing heavy local-only dependencies
• binder/requirements.txt – Mirrors the root requirements for Binder's isolated execution environment
• .devcontainer/environment.yml – Identical to the root Conda specification, enabling VS Code Dev Containers for reproducible development without local environment conflicts

These variants ensure consistent execution whether running locally, on GitHub Codespaces, or through mybinder.org.

Summary

• The AI For Beginners dependencies are split between environment.yml (Conda packages) and requirements.txt (PyPI libraries).
• Core scientific stack includes NumPy 1.26, SciPy 1.13, Pandas 2.2.2, and Matplotlib 3.9.
• Deep learning support requires both TensorFlow 2.17.0/Keras 3.13.2 and PyTorch with companion libraries.
• Domain-specific tools cover computer vision (OpenCV, scikit-image), NLP (NLTK, Gensim, tokenizers), and reinforcement learning (Gym).
• Alternative configurations exist for Binder (binder/) and VS Code Dev Containers (.devcontainer/).

Frequently Asked Questions

What Python version does AI For Beginners require?

The environment.yml specifies the latest stable Python release available in the Conda channels at environment creation time. The curriculum targets Python 3.10+ compatibility to support modern type hints and TensorFlow 2.17 requirements.

Can I use pip instead of Conda to install all dependencies?

While the requirements.txt contains most Python packages, system-level dependencies like OpenCV and the specific PyTorch CUDA builds are best managed through Conda. The recommended workflow uses conda env create first, then pip install -r requirements.txt for the remaining packages.

Why does the repository include both TensorFlow and PyTorch?

The curriculum demonstrates concepts using both frameworks to provide pedagogical flexibility. Early neural network lessons often use PyTorch for clarity, while production-deployment examples leverage TensorFlow and Keras. Having both installed allows students to compare implementations directly.

How do I verify that all dependencies installed correctly?

After activating the ai4beg environment, run the import verification script provided in the repository README or execute jupyter notebook and open any lesson notebook. Successful kernel startup without ModuleNotFoundError indicates proper installation. For comprehensive validation, run the notebook cells in lessons/0-Setup/dependency_check.ipynb if available.

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