Virtual Environments

Why Do We Need Virtual Environments?

Imagine you have two Python projects.

Project A needs one version of a package:

Project A
numpy 1.x

But Project B needs another version:

Project B
numpy 2.x

If both projects use the same global Python environment, package versions can conflict with each other.

This is especially common in AI projects because AI applications use many packages such as NumPy, Pandas, PyTorch, TensorFlow, and other libraries.

Simple Real-World Example

Think about two kitchens.

Kitchen A
├── Ingredients for Project A
└── Tools for Project A


Kitchen B
├── Ingredients for Project B
└── Tools for Project B

The kitchens are separate, so changing something in Kitchen A does not affect Kitchen B.

A Python virtual environment works in a similar way. Each project gets its own isolated set of packages.

Create a Virtual Environment

Python provides the venv module for creating virtual environments.

First create a project directory:

mkdir ai-project

cd ai-project

Now create a virtual environment:

python -m venv venv

This creates a directory called venv.

ai-project/
│
└── venv/

The environment contains its own Python executable and package installation area.

Activate the Environment

On Linux or macOS, activate the environment with:

source venv/bin/activate

After activation, your terminal usually shows the environment name:

(venv) user@computer:~/ai-project$

The (venv) tells you that the virtual environment is currently active.

Activate on Windows

On Windows Command Prompt:

venv\Scripts\activate

On Windows PowerShell:

venv\Scripts\Activate.ps1

After activation, you should see (venv) in the terminal.

Install Packages Inside the Environment

Once the environment is activated, install packages using pip.

pip install numpy

You can install multiple packages:

pip install numpy pandas matplotlib

These packages are installed into the active virtual environment rather than being added to your project independently of the environment.

Check Installed Packages

You can see the packages installed in the current environment using:

pip list

You can also check a specific package:

pip show numpy

This can show information such as the installed version and installation location.

requirements.txt

A project often needs a list of the packages it depends on. Python projects commonly store this information in a file called requirements.txt.

Create it using:

pip freeze > requirements.txt

The file might contain:

numpy==2.x.x
pandas==2.x.x
matplotlib==3.x.x

Another developer can then install those dependencies with:

pip install -r requirements.txt

This makes it much easier to recreate the same project environment.

Deactivate the Environment

When you finish working on the project, you can leave the virtual environment using:

deactivate

The (venv) indicator will disappear from your terminal.

Complete Virtual Environment Workflow

A typical Python AI project can follow this workflow:

# 1. Create project
mkdir ai-project

# 2. Enter project
cd ai-project

# 3. Create environment
python -m venv venv

# 4. Activate environment
source venv/bin/activate

# 5. Install packages
pip install numpy pandas

# 6. Save dependencies
pip freeze > requirements.txt

# 7. Work on your project

# 8. Leave environment
deactivate

Virtual Environments in AI Projects

AI projects usually depend on many libraries. For example:

ai-project/
│
├── venv/
│
├── models/
│   └── model.py
│
├── data/
│   └── data.csv
│
├── main.py
│
└── requirements.txt

The venv directory contains the isolated environment, while your actual application code lives in files such as main.py and the models directory.

In a real project, you normally do not commit the entire venv directory to Git. Instead, you commit files such as requirements.txt so another developer can recreate the environment.

Why Virtual Environments Matter for AI

AI projects can have complicated dependencies. Different projects may require different versions of the same library.