Coding¶

Environments¶

Two virtual environments: code for Python/PyTorch scripts, jupyter for notebook kernels.

Code / PyTorch (code/.venv)¶

cd code
uv venv .venv
source .venv/bin/activate
uv sync --extra pytorch          # PyTorch and computer vision
uv sync --extra llm --extra agents   # LLM and agent scripts

See code/SUBJECTS.md for subject folder mapping.

Jupyter (jupyter/.venv)¶

cd jupyter
uv venv .venv
source .venv/bin/activate
uv sync --extra deep-learning     # optional: Keras/TensorFlow notebooks
uv run python -m ipykernel install --user --name ml-studies-jupyter

Notebooks live under code/<subject>/ but use the jupyter kernel.

uv (Recommended)¶

uv is a fast Python package and project manager written in Rust. It replaces pip, pip-tools, pipx, poetry, pyenv, virtualenv, and more.

Installation:

# macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# or via Homebrew
brew install uv

Project setup:

# Code environment (scripts, PyTorch, LLM)
cd code && uv venv .venv && uv sync --extra pytorch

# Jupyter environment (notebooks under code/<subject>/)
cd jupyter && uv venv .venv && uv sync

Quick commands:

uv run python script.py
uv run jupyter lab

Subject folders are documented in code/SUBJECTS.md.

Legacy per-folder setup (deprecated)¶

Each project folder contains a pyproject.toml for dependency management.

VSCode¶

Jupyter Notebook¶

• To select an environment, use the Python: Select Interpreter command from the Command Palette (⇧⌘P)
• Use Create: New Jupyter Notebook from command Palette
• Select a kernel using the kernel picker in the top right.
• Within a Python Notebook, it's possible to view, inspect, sort, and filter the variables within the current Jupyter session, using Variables in toolbar.
• We can offload intensive computation in a Jupyter Notebook to other computers by connecting to a remote Jupyter server. Use server URL with security token.

Run Kaggle image¶

As an alternate Kaggle has a more complete docker image to start with.

# CPU based
docker run --rm -v $(pwd):/home -it gcr.io/kaggle-images/python /bin/bash
# GPU based
docker run -v $(pwd):/home --runtime nvidia --rm -it gcr.io/kaggle-gpu-images/python /bin/bash

Important Python Libraries¶

numpy¶

• Array computing in Python. Numpy official quickstar.t

• NumPy dimensions are called axes.

  import numpy as np
  a = np.array([2, 3, 4])
  b = np.ones((2, 3, 4), dtype=np.int16)
  c = np.zeros((3, 4))
  

• Create a sequence of number: np.arange(10, 30, 5)

• Matrix product: using .dot or @

  A = np.array([[1, 1], [0, 1]])
  B = np.array([[2, 0], [3, 4]])
  A @ B
  A.dot(B)
  

scipy¶

SciPy is a collection of mathematical algorithms and convenience functions built on top of NumPy. See product documentation.

• Get a normal distribution function: use the probability density function (pdf)

  from scipy.stats import norm
  x = np.arange(-3, 3, 0.01)
  y=norm.pdf(x)
  

MatPlotLib¶

Persent figure among multiple axes, from the data for human analysis.

• Classic import

  import matplotlib.pyplot as plt
  import numpy as np
  
  import matplotlib as mpl
  

• See Notebook

Seaborn¶

Seaborn provides a high-level interface for drawing attractive and informative statistical graphics. Based on top of MatPlotLib and integrated with Pandas.

See the introduction for different examples

import matplotlib.pyplot as plt
import seaborn as sns
sns.set_theme()
sns.relplot(
    data=masses_data,
    x="age", y="shape", 
    hue="density", size="density"
)
plt.show()

PyTorch¶

Via conda or pip, install pytorch torchvision torchaudio.

Example of getting started code in code/deep-learning/fundamentals/.

Summary of the library and deeper studies

Code Samples¶

Code is organized by subject under code/: scripts and notebooks live together per topic. See SUBJECTS.md. End-to-end demos remain in e2e-demos/.

Perceptron¶

Located in code/perceptron/:

Classification¶

Located in code/classification/:

Regression¶

Located in code/regression/:

PyTorch Deep Learning¶

Located in code/deep-learning/ and code/computer-vision/:

LangChain and LLM Integration¶

Located in code/LLM/langchain/:

RAG Implementations¶

Located in code/LLM/langchain/rag/:

LangGraph Agent Patterns¶

Located in code/agents/langgraph/:

Ollama Local LLM¶

Located in code/LLM/ollama/:

End-to-End Demos¶

Located in e2e-demos/:

UI Frameworks¶

Located in techno/:

Jupyter Notebooks by subject¶

Notebooks live under code/<subject>/. Use the jupyter environment kernel.