How to Set Up Your Machine Learning Environment in 2026 (Beginner Guide)

# macOS — install via Homebrew (recommended)
brew install python@3.12
# Verify
python3.12 --version
# Expected: Python 3.12.x

# macOS/Linux — alternatively install via pyenv for multi-version management
curl https://pyenv.run | bash
# Add to shell profile (~/.zshrc or ~/.bashrc):
# export PATH="$HOME/.pyenv/bin:$PATH"
# eval "$(pyenv init -)"
pyenv install 3.12.3
pyenv global 3.12.3
python --version
# Expected: Python 3.12.3

# Windows — download from python.org/downloads
# Check 'Add Python to PATH' during installation
# Verify in PowerShell:
python --version
# Expected: Python 3.12.x

# Verify pip is installed and up to date
python3.12 -m pip install --upgrade pip
pip --version
# Expected: pip 24.x from .../python3.12/site-packages/pip

# Option A: venv (built into Python — recommended for most users)
# Create a named environment directory outside the project so it is never committed
python3.12 -m venv ~/ml_envs/ml_2026

# Activate on macOS/Linux
source ~/ml_envs/ml_2026/bin/activate

# Activate on Windows (PowerShell)
# ~/ml_envs/ml_2026/Scripts/Activate.ps1

# Verify you are in the virtual environment — path must point to ml_2026
which python
# Expected: ~/ml_envs/ml_2026/bin/python

which pip
# Expected: ~/ml_envs/ml_2026/bin/pip

# Upgrade pip, setuptools, and wheel inside the environment before installing anything else
pip install --upgrade pip setuptools wheel

# When you are done working
deactivate

# ---

# Option B: conda (from Anaconda or Miniconda)
# Create conda environment with Python version pinned
conda create -n ml_2026 python=3.12 -y

# Activate
conda activate ml_2026

# Verify — path must point to the conda environment
which python
conda list | head -20

# Deactivate
conda deactivate

# ---

# Add this to .gitignore to ensure the environment is never committed
echo 'ml_env/' >> .gitignore
echo '__pycache__/' >> .gitignore
echo '*.pyc' >> .gitignore
echo '.env' >> .gitignore

# Always activate your virtual environment first — verify with 'which python'
source ~/ml_envs/ml_2026/bin/activate

# Step 1: Upgrade pip before installing anything
pip install --upgrade pip setuptools wheel

# Step 2: Install core data science stack — order matters
pip install numpy==1.26.4
pip install pandas==2.2.2
pip install matplotlib==3.9.0
pip install seaborn==0.13.2

# Step 3: Install scikit-learn and gradient boosting libraries
pip install scikit-learn==1.5.0
pip install xgboost==2.0.3
pip install lightgbm==4.3.0

# Step 4: Install Jupyter support
pip install jupyter==1.0.0 ipykernel==6.29.4
# Register this environment as a Jupyter kernel
python -m ipykernel install --user --name ml_2026 --display-name "ML 2026 (Python 3.12)"

# Step 5: Install experiment tracking
pip install mlflow==2.13.0

# Step 6: Install LLM API SDKs — baseline in 2026
pip install openai==1.30.1
pip install anthropic==0.28.0
pip install python-dotenv==1.0.1

# Step 7: Install ONE deep learning library
# Option A: PyTorch — recommended for beginners and researchers in 2026
# CPU-only version (fast to install, no GPU required for learning)
pip install torch==2.3.0 torchvision==0.18.0 torchaudio==2.3.0 --index-url https://download.pytorch.org/whl/cpu
# GPU version — get the exact command from pytorch.org/get-started/locally
# pip install torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cu121

# Option B: TensorFlow — if your team uses it
# pip install tensorflow==2.16.1

# Do not install both in the same environment without explicit version pinning and testing

# Step 8: Verify every import — catch silent failures before they surface in a notebook
python -c "
import numpy as np; print(f'NumPy {np.__version__}')
import pandas as pd; print(f'pandas {pd.__version__}')
import sklearn; print(f'scikit-learn {sklearn.__version__}')
import matplotlib; print(f'matplotlib {matplotlib.__version__}')
import xgboost; print(f'XGBoost {xgboost.__version__}')
import mlflow; print(f'MLflow {mlflow.__version__}')
import openai; print(f'openai {openai.__version__}')
import torch; print(f'PyTorch {torch.__version__}')
print('All imports successful')
"

# Step 9: Freeze requirements with exact version pins
pip freeze > requirements.txt
echo "requirements.txt generated with $(wc -l < requirements.txt) packages"

{
  "python.defaultInterpreterPath": "~/ml_envs/ml_2026/bin/python",

  "jupyter.askForKernelRestart": false,
  "jupyter.alwaysTrustNotebooks": true,
  "notebook.cellToolbarLocation": {
    "default": "right",
    "jupyter-notebook": "left"
  },
  "notebook.output.scrolling": true,
  "notebook.cellExecutionTimeout": 600000,

  "[python]": {
    "editor.defaultFormatter": "ms-python.black-formatter",
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
      "source.organizeImports": "explicit"
    }
  },

  "python.analysis.typeCheckingMode": "basic",
  "python.analysis.autoImportCompletions": true,

  "files.exclude": {
    "**/__pycache__": true,
    "**/*.pyc": true,
    "**/.ipynb_checkpoints": true,
    "**/ml_env": true
  },
  "search.exclude": {
    "**/data/**/*.csv": true,
    "**/data/**/*.parquet": true,
    "**/*.pkl": true,
    "**/*.pt": true
  },

  "git.ignoreLimitWarning": true,
  "editor.rulers": [88],
  "editor.tabSize": 4
}

# Step 1: Verify NVIDIA GPU is detected by the system
lspci | grep -i nvidia
# On Windows: Device Manager > Display Adapters

# Step 2: Check installed NVIDIA driver and supported CUDA version
nvidia-smi
# Top-right corner shows maximum supported CUDA version
# Example: CUDA Version: 12.4 means your driver supports CUDA up to 12.4

# Step 3: Match PyTorch CUDA build to your driver's supported CUDA version
# Get the exact install command from: https://pytorch.org/get-started/locally/
# Example for CUDA 12.1:
pip install torch==2.3.0 torchvision==0.18.0 --index-url https://download.pytorch.org/whl/cu121

# Step 4: Verify CUDA is detected by PyTorch
python -c "
import torch
print(f'PyTorch version: {torch.__version__}')
print(f'CUDA available: {torch.cuda.is_available()}')
if torch.cuda.is_available():
    print(f'CUDA version: {torch.version.cuda}')
    print(f'GPU count: {torch.cuda.device_count()}')
    print(f'GPU name: {torch.cuda.get_device_name(0)}')
    print(f'GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB')
else:
    print('No CUDA GPU detected — running on CPU')
    print('Tip: install the CPU-only PyTorch build if you do not have a GPU')
"

# Step 5: Benchmark CPU vs GPU to confirm GPU is being used
python -c "
import torch
import time

size = 4096
a_cpu = torch.randn(size, size)
b_cpu = torch.randn(size, size)

start = time.time()
_ = torch.matmul(a_cpu, b_cpu)
cpu_time = time.time() - start
print(f'CPU matrix multiply ({size}x{size}): {cpu_time:.3f}s')

if torch.cuda.is_available():
    a_gpu = a_cpu.cuda()
    b_gpu = b_cpu.cuda()
    # Warm up the GPU
    torch.matmul(a_gpu, b_gpu)
    torch.cuda.synchronize()
    start = time.time()
    _ = torch.matmul(a_gpu, b_gpu)
    torch.cuda.synchronize()
    gpu_time = time.time() - start
    print(f'GPU matrix multiply ({size}x{size}): {gpu_time:.3f}s')
    print(f'Speedup: {cpu_time / gpu_time:.1f}x')
else:
    print('GPU not available — using CPU only')
    print('For learning, Google Colab provides free GPU: colab.research.google.com')
"

my_ml_project/
├── README.md                    # Problem statement, setup instructions, results
├── requirements.txt             # Pinned dependencies — pip freeze output
├── setup.sh                     # One-command environment setup script
├── .env.example                 # Template for required environment variables (no real keys)
├── .gitignore                   # Excludes: data/, models/, .env, __pycache__, *.pkl, *.pt
├── .pre-commit-config.yaml      # Black formatting + detect-secrets hook
├── .vscode/
│   └── settings.json            # Project-level VS Code configuration
├── data/
│   ├── raw/                     # Original unmodified source data — never edit these
│   ├── processed/               # Cleaned and transformed data ready for modeling
│   └── .gitkeep                 # Preserves directory structure in Git without committing data
├── notebooks/
│   ├── 01_eda.ipynb             # Exploratory data analysis
│   ├── 02_feature_engineering.ipynb
│   └── 03_modeling.ipynb        # Training, evaluation, model selection
├── src/
│   ├── __init__.py
│   ├── data/
│   │   ├── __init__.py
│   │   ├── load.py              # Data loading — reads from data/raw/
│   │   └── preprocess.py        # Cleaning and transformation pipeline
│   ├── features/
│   │   ├── __init__.py
│   │   └── build_features.py    # Feature engineering functions
│   ├── models/
│   │   ├── __init__.py
│   │   ├── train.py             # Training script with MLflow logging
│   │   └── predict.py           # Inference logic — used by API and tests
│   └── visualization/
│       ├── __init__.py
│       └── visualize.py
├── models/                      # Saved model artifacts — tracked with DVC, not Git
│   └── .gitkeep
├── tests/
│   ├── test_data.py             # Validate data loading and preprocessing
│   ├── test_features.py
│   └── test_models.py           # Smoke tests for prediction output shape and type
├── api/
│   ├── app.py                   # FastAPI prediction endpoint
│   ├── Dockerfile               # Container definition for deployment
│   └── docker-compose.yml       # Local API + MLflow server orchestration
└── mlruns/                      # MLflow experiment tracking (add to .gitignore for large teams)