Introduction

Before writing Machine Learning code, you need a reliable development environment. The environment includes Python, installed libraries, a code editor or notebook application, project files, and the computing resources used to execute the code.

A correctly configured environment helps prevent package conflicts, missing dependencies, inconsistent results, and confusion about which Python installation is executing a program.

This lesson presents two practical setup paths. You can configure a local environment on your computer or use Google Colab through a web browser. Local development provides greater control, while Colab can be convenient for learning, notebooks, and optional accelerator access.

Learning Objectives

Prerequisites

Environment Components

Choose a Setup Path

Install Python

Install a supported Python 3 version from an official or approved source. During installation, ensure that the Python command can be accessed from your terminal when the installer provides that option.

After installation, open a new terminal and verify Python:

python --version

On some systems, the Python 3 command may be:

python3 --version

Verify the package installer:

python -m pip --version

If your system uses python3, use:

python3 -m pip --version

Create a Project Directory

Keep each major Machine Learning project in its own directory. This makes environment isolation, version control, documentation, and cleanup easier.

mkdir ml-environment-check
cd ml-environment-check

A useful starter structure is:

ml-environment-check/
|
|-- README.md
|-- requirements.txt
|-- notebooks/
|-- src/
|   `-- environment_check.py
|-- tests/
|-- data/
|-- models/
`-- reports/

What Is a Virtual Environment?

A virtual environment is an isolated Python environment created for a particular project. It has its own interpreter reference and installed package collection.

Suppose one project requires one version of a library while another project requires a different version. Separate virtual environments help prevent the packages of one project from interfering with the packages of another.

Create a Virtual Environment

Run the following command from the project directory:

python -m venv .venv

If your system uses python3, run:

python3 -m venv .venv

The .venv directory contains the isolated environment. The leading dot is a naming convention and does not change the environment's purpose.

Activate the Virtual Environment

Windows Command Prompt

.venv\Scripts\activate

Windows PowerShell

.venv\Scripts\Activate.ps1

Linux or macOS

source .venv/bin/activate

After activation, the terminal prompt commonly displays the environment name. Verify the active interpreter:

python -c "import sys; print(sys.executable)"

Verify that pip belongs to the same environment:

python -m pip --version

Install the Core Course Packages

Upgrade the package installer inside the active environment:

python -m pip install --upgrade pip

Install the foundational data and Machine Learning packages:

python -m pip install numpy pandas matplotlib seaborn scikit-learn jupyterlab

Inspect Installed Packages

Display the installed packages:

python -m pip list

Display information about a particular package:

python -m pip show scikit-learn

Verify the core imports:

python -c "import numpy, pandas, sklearn; print('Core packages are available')"

Record Project Dependencies

A dependency file records the libraries required to recreate the environment.

One option is to export the current environment:

python -m pip freeze > requirements.txt

Review the generated file before committing it. Recreate an environment from that file using:

python -m pip install -r requirements.txt

Deactivate the Environment

When you finish working in the project environment, deactivate it:

deactivate

Deactivation returns the terminal to its previous Python environment. It does not delete packages or project files.

Install and Configure an IDE

An Integrated Development Environment, commonly called an IDE, provides tools for writing, running, navigating, testing, and debugging code. A lighter code editor can provide similar features through extensions.

Visual Studio Code Setup

Start JupyterLab

Activate the project environment and start JupyterLab:

jupyter lab

JupyterLab normally opens in a web browser. Create a Python notebook and select the kernel associated with the current virtual environment.

Verify the Notebook Kernel

import sys

print(sys.executable)
print(sys.version)

The executable path should point to the intended environment.

Add the Environment to Git Ignore Rules

The virtual environment contains generated and machine-specific files. It should not normally be committed to Git.

Add these patterns to the project .gitignore file:

# Python virtual environments
.venv/
venv/
env/

# Python-generated files
__pycache__/
*.py[cod]

# Notebook temporary data
.ipynb_checkpoints/

# Local secrets and environment variables
.env
.env.*
!.env.example

# Generated datasets and models
data/raw/*
data/processed/*
models/*

# Keep documentation placeholders
!data/raw/README.md
!data/processed/README.md
!models/README.md

Verify the Local ML Environment

Create src/environment_check.py with the following content:

import sys

import matplotlib
import numpy as np
import pandas as pd
import sklearn

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score


print("Python:", sys.version.split()[0])
print("Python executable:", sys.executable)
print("NumPy:", np.__version__)
print("pandas:", pd.__version__)
print("Matplotlib:", matplotlib.__version__)
print("scikit-learn:", sklearn.__version__)

dataset = load_iris(as_frame=True)

X = dataset.data
y = dataset.target

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.20,
    random_state=42,
    stratify=y
)

model = DecisionTreeClassifier(
    max_depth=3,
    random_state=42
)

model.fit(X_train, y_train)

predictions = model.predict(X_test)

accuracy = accuracy_score(
    y_test,
    predictions
)

print(f"Environment test accuracy: {accuracy:.3f}")
print("Machine Learning environment is working.")

Run the file from the project directory:

python src/environment_check.py

Google Colab Setup

Google Colab provides a hosted notebook environment that runs through a web browser. It can be useful when you do not want to configure a complete local setup or when an available accelerator runtime is suitable for the lesson.

import platform
import sys

print("Python:", sys.version)
print("Platform:", platform.platform())

import numpy as np
import pandas as pd
import sklearn

print("NumPy:", np.__version__)
print("pandas:", pd.__version__)
print("scikit-learn:", sklearn.__version__)

Working with Files in Colab

Colab notebooks can work with uploaded files, generated files, and connected storage. Use only data that you are authorized to place in that environment.

CPU vs GPU

A CPU is suitable for Python programming, data preparation, SQL access, visualization, and many classical Machine Learning algorithms. A GPU can accelerate supported highly parallel numerical calculations, especially certain Deep Learning workloads.

Enable an Accelerator in Colab

When a Deep Learning lesson requires an accelerator, open the notebook's runtime settings and select an available hardware accelerator. Availability and usage limits depend on the current Colab environment and account.

After changing the runtime type, the runtime may restart. Run the notebook setup and import cells again.

General NVIDIA Runtime Check

nvidia-smi

If a compatible NVIDIA runtime is available, the command can display information about the GPU and driver environment.

Verify GPU Access with PyTorch

If PyTorch is installed in the environment, use:

import torch

print("PyTorch version:", torch.__version__)
print("CUDA available:", torch.cuda.is_available())

if torch.cuda.is_available():
    print("GPU:", torch.cuda.get_device_name(0))
else:
    print("PyTorch is using the CPU.")

Select the execution device in a reusable way:

import torch

device = torch.device(
    "cuda"
    if torch.cuda.is_available()
    else "cpu"
)

print("Selected device:", device)

Verify GPU Access with TensorFlow

If TensorFlow is installed in a supported environment, inspect the detected GPU devices:

import tensorflow as tf

print("TensorFlow version:", tf.__version__)

gpu_devices = tf.config.list_physical_devices(
    "GPU"
)

print("Detected GPU devices:", gpu_devices)

if gpu_devices:
    print("TensorFlow can detect at least one GPU.")
else:
    print("TensorFlow is using the available CPU environment.")

Understand GPU Memory Limits

A GPU has its own memory. A model, its parameters, input batches, activations, gradients, and temporary calculations may all use GPU memory during training.

Environment Security

Development environments may contain credentials, database connections, datasets, model artifacts, notebook outputs, and external-service access. These resources must be protected.

API_TOKEN = "real-secret-token"
DATABASE_PASSWORD = "real-password"

import os

api_token = os.environ["API_TOKEN"]
database_password = os.environ[
    "DATABASE_PASSWORD"
]

Common Setup Problems

Environment Diagnostic Commands

Use these commands to inspect the active environment:

python --version
python -m pip --version
python -m pip list
python -c "import sys; print(sys.executable)"
python -c "import sys; print(sys.path)"
python -c "import numpy; print(numpy.__version__)"

Inside Python or a notebook:

import os
import platform
import sys

print("Python version:", sys.version)
print("Interpreter:", sys.executable)
print("Operating system:", platform.platform())
print("Working directory:", os.getcwd())

Recreate an Environment

If an environment becomes difficult to repair, it may be safer to recreate it from documented dependencies.

deactivate

python -m venv .venv

python -m pip install -r requirements.txt

Setup Verification Checklist

Hands-On Setup Activity

Common Setup Mistakes

Knowledge Check

Lesson Summary