Create a Python Virtual Environment for ML

# Day 1: Create a Python Virtual Environment for ML

🎯 Objective

Create an isolated Python virtual environment for a Machine Learning project and install the essential ML libraries.

In this task, we will:

🧠 Concept

A Python virtual environment provides an isolated environment for a Python project.

Instead of installing packages globally:

System Python
├── numpy
├── pandas
├── scikit-learn
└── matplotlib

we create a project-specific environment:

Project
│
├── ml-env/
│   ├── Python
│   └── Packages
│
└── requirements.txt

This prevents dependencies from different projects from conflicting with each other.

For example:

Project A
└── numpy 1.x

Project B
└── numpy 2.x

Each project can maintain its own package versions.

📂 Step 1: Check Current Directory

Check the current working directory:

pwd

pwd stands for:

Print Working Directory

Example:

/root/code

This tells us where the virtual environment will be created.

🐍 Step 2: Check Python Version

Verify that Python 3 is installed:

python3 --version

Example:

Python 3.x.x

This confirms that Python is available before creating the environment.

📦 Step 3: Create the Virtual Environment

Create a virtual environment called:

ml-env

Run:

python3 -m venv ml-env

Command Breakdown

python3

Runs Python 3.

-m

Runs a Python module as a command.

venv

Python's built-in virtual environment module.

ml-env

The directory/name of the new environment.

The structure becomes:

/root/code/
│
└── ml-env/
    ├── bin/
    ├── include/
    ├── lib/
    └── pyvenv.cfg

🔍 Step 4: Verify the Environment

List files in the current directory:

ls -lah

You should see:

ml-env

Then inspect the environment:

ls ml-env

Typical contents:

bin
include
lib
lib64
pyvenv.cfg

The exact directories can vary slightly depending on the operating system and Python installation.

🚀 Step 5: Activate the Virtual Environment

Activate the environment:

source /root/code/ml-env/bin/activate

If you're already inside /root/code, you can simply use:

source ml-env/bin/activate

After activation, the terminal usually changes to something like:

(ml-env) root@server:/root/code#

The (ml-env) prefix indicates that the virtual environment is active.

🧠 What Activation Does

Before activation:

python
  ↓
System Python

pip
  ↓
System packages

After activation:

python
  ↓
ml-env/bin/python

pip
  ↓
ml-env/bin/pip

This means packages installed using pip will belong to this environment rather than the global Python installation.

You can verify this with:

which python

and:

which pip

They should point somewhere under:

/root/code/ml-env/bin/

🤖 Step 6: Install ML Libraries

Install the required Machine Learning libraries:

pip install numpy pandas scikit-learn matplotlib

This installs four commonly used Python data science and ML packages.

NumPy

numpy

Used for:

Example:

import numpy as np

Pandas

pandas

Used for:

Example:

import pandas as pd

Scikit-learn

scikit-learn

Used for traditional Machine Learning tasks such as:

Python imports it using:

import sklearn

Matplotlib

matplotlib

Used for:

Common import:

import matplotlib.pyplot as plt

📦 Step 7: Check Installed Packages

You can inspect the packages installed in the environment:

pip list

You should find packages including:

numpy
pandas
scikit-learn
matplotlib

Additional dependencies will also appear because these libraries depend on other Python packages.

📝 Step 8: Generate requirements.txt

Save the installed dependencies:

pip freeze > requirements.txt

How It Works

pip freeze
     │
     │ installed package versions
     ▼
requirements.txt

The > operator redirects the output into the file.

Instead of printing:

numpy==...
pandas==...
scikit-learn==...
matplotlib==...

to the terminal, it saves it to:

requirements.txt

🔍 Step 9: Check requirements.txt

Display the contents:

cat requirements.txt

You should see package versions similar to:

matplotlib==...
numpy==...
pandas==...
scikit-learn==...

There will normally be additional packages because pip freeze records the environment's installed dependencies.

🔄 Recreate the Environment

One major advantage of requirements.txt is reproducibility.

Another developer can create a virtual environment:

python3 -m venv ml-env

Activate it:

source ml-env/bin/activate

Then install the same dependencies:

pip install -r requirements.txt

The flow becomes:

requirements.txt
      │
      │ pip install -r
      ▼
Python Virtual Environment
      │
      ├── numpy
      ├── pandas
      ├── scikit-learn
      └── matplotlib

📴 Deactivate the Environment

When finished working inside the environment:

deactivate

The (ml-env) prefix will disappear from the terminal.

This returns you to the system Python environment.

🕘 Check Command History

To review previously executed shell commands:

history

This is useful for:

⚙️ Complete Workflow

pwd

python3 --version

python3 -m venv ml-env

ls -lah

ls ml-env

source /root/code/ml-env/bin/activate

pip install numpy pandas scikit-learn matplotlib

pip freeze > requirements.txt

cat requirements.txt

history

⚠️ Important Notes

For Git projects, add it to .gitignore:

ml-env/

The files you normally keep are:

project/
├── .gitignore
├── requirements.txt
└── source code

rather than committing the entire virtual environment.

🧪 Validation Checklist

📌 Summary

Create the environment:

python3 -m venv ml-env

Activate it:

source /root/code/ml-env/bin/activate

Install the Machine Learning packages:

pip install numpy pandas scikit-learn matplotlib

Save dependencies:

pip freeze > requirements.txt

The complete concept is:

Python Project
      │
      │ python3 -m venv
      ▼
   ml-env
      │
      │ activate
      ▼
Isolated Python Environment
      │
      │ pip install
      ▼
┌─────────────────────┐
│ numpy               │
│ pandas              │
│ scikit-learn        │
│ matplotlib          │
└─────────────────────┘
      │
      │ pip freeze
      ▼
requirements.txt

The key takeaway is:

> A Python virtual environment isolates project dependencies, while requirements.txt records those dependencies so the environment can be reproduced consistently.