Chapter 3 — Python Tools for AI¶

import numpy as np
from numpy.typing import NDArray

# Creating arrays
zeros: NDArray[np.float32] = np.zeros((3, 4), dtype=np.float32)
ones:  NDArray[np.float64] = np.ones((2, 5))
rng = np.random.default_rng(seed=42)
rand: NDArray[np.float64] = rng.standard_normal((100, 10))
arange: NDArray[np.int64] = np.arange(0, 20, 2)       # [0, 2, 4, ..., 18]
linspace: NDArray[np.float64] = np.linspace(0, 1, 50)  # 50 evenly spaced points

print(f"rand shape: {rand.shape}, dtype: {rand.dtype}")  # (100, 10), float64
print(f"Memory (MB): {rand.nbytes / 1e6:.4f}")          # 0.008 MB

# dtype matters for memory and GPU transfer
x_f64 = np.ones((1000, 1000), dtype=np.float64)  # 8 MB
x_f32 = np.ones((1000, 1000), dtype=np.float32)  # 4 MB
print(f"float64: {x_f64.nbytes // 1_000_000} MB, float32: {x_f32.nbytes // 1_000_000} MB")

import numpy as np
from numpy.typing import NDArray

# Subtract per-feature mean from a (n_samples, n_features) matrix
X: NDArray[np.float64] = np.random.randn(100, 10)
mu: NDArray[np.float64] = X.mean(axis=0)  # shape (10,)
X_centred: NDArray[np.float64] = X - mu   # broadcasting: (100, 10) - (10,) → (100, 10)

# Add a bias vector to each row in a batch
W: NDArray[np.float64] = np.random.randn(5, 3)   # (5, 3)
b: NDArray[np.float64] = np.array([1.0, 2.0, 3.0])   # (3,)
out: NDArray[np.float64] = W + b  # (5, 3) + (3,) → (5, 3)

# Outer product via broadcast
u = np.array([[1], [2], [3]])    # (3, 1)
v = np.array([[4, 5, 6]])        # (1, 3)
outer = u * v                     # (3, 3)
print(outer)
# [[4  5  6]
#  [8 10 12]
#  [12 15 18]]

import numpy as np
import time
from numpy.typing import NDArray

N = 10_000_000
x: NDArray[np.float64] = np.random.rand(N)

# Loop — slow (Python interpreter)
start = time.perf_counter()
total = 0.0
for v in x:
    total += v * v
loop_time = time.perf_counter() - start

# Vectorised — fast (C/BLAS/SIMD)
start = time.perf_counter()
total_vec = np.dot(x, x)  # or (x ** 2).sum()
vec_time = time.perf_counter() - start

print(f"Loop:       {loop_time:.3f}s")    # e.g., 3.2s
print(f"Vectorised: {vec_time:.4f}s")     # e.g., 0.012s
print(f"Speedup:    {loop_time / vec_time:.0f}x")

import pandas as pd
import numpy as np

# Creating a DataFrame
df = pd.DataFrame({
    "name":   ["Alice", "Bob", "Charlie", "Diana"],
    "age":    [29, 34, 22, 41],
    "salary": [95_000.0, 120_000.0, 72_000.0, 145_000.0],
    "dept":   ["eng", "eng", "sales", "eng"],
})

print(df.dtypes)
# name       object
# age         int64
# salary    float64
# dept       object

# A Series is a single column — 1-D with an index
ages: pd.Series = df["age"]
print(ages.mean(), ages.std())

# Basic info
print(df.shape)        # (4, 4)
print(df.describe())   # summary statistics for numeric columns

import pandas as pd

# CSV
df_csv = pd.read_csv(
    "data/train.csv",
    dtype={"user_id": "int32", "amount": "float32"},
    parse_dates=["timestamp"],
    na_values=["N/A", "null", ""],
)

# JSON (records orient)
df_json = pd.read_json("data/events.json", orient="records", lines=True)

# Parquet — columnar format, much faster for large datasets
df_parquet = pd.read_parquet("data/features.parquet", engine="pyarrow")

# Reading only specific columns (large files)
df_cols = pd.read_csv("data/big.csv", usecols=["id", "label", "feature_1"])

import pandas as pd

df = pd.DataFrame({
    "val": [10, 20, 30, 40, 50],
}, index=["a", "b", "c", "d", "e"])

# loc: label-based (inclusive on both ends)
print(df.loc["b":"d"])    # rows b, c, d

# iloc: position-based (exclusive end)
print(df.iloc[1:4])       # positions 1, 2, 3 → rows b, c, d

# Boolean mask (works with both)
mask = df["val"] > 25
print(df.loc[mask])       # c, d, e

# Setting values — always use loc/iloc to avoid SettingWithCopyWarning
df.loc[df["val"] > 40, "val"] = 999

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "age":    [25.0, np.nan, 30.0, np.nan, 45.0],
    "income": [50_000.0, 60_000.0, np.nan, 80_000.0, np.nan],
    "city":   ["NYC", None, "LA", "NYC", None],
})

# Detect
print(df.isna().sum())        # count missing per column
print(df.isna().mean())       # fraction missing

# Drop rows with any NaN
df_dropped = df.dropna()

# Drop columns with > 30 % missing
threshold = 0.30
df_filtered = df.loc[:, df.isna().mean() < threshold]

# Fill — different strategies per column
df_filled = df.copy()
df_filled["age"]    = df["age"].fillna(df["age"].median())
df_filled["income"] = df["income"].fillna(df["income"].mean())
df_filled["city"]   = df["city"].fillna("Unknown")

# Forward fill (time-series)
df_ffill = df.ffill()

print(df_filled.isna().sum())  # all zeros

import matplotlib.pyplot as plt
import numpy as np

fig, ax = plt.subplots(figsize=(8, 4))

x = np.linspace(0, 4 * np.pi, 300)
ax.plot(x, np.sin(x), label="sin(x)", color="#2563EB", linewidth=2)
ax.plot(x, np.cos(x), label="cos(x)", color="#DC2626", linewidth=2, linestyle="--")

ax.set_xlabel("x", fontsize=13)
ax.set_ylabel("Amplitude", fontsize=13)
ax.set_title("Trigonometric Functions", fontsize=15, fontweight="bold")
ax.legend(fontsize=12)
ax.grid(alpha=0.3)

fig.tight_layout()
fig.savefig("trig.png", dpi=150, bbox_inches="tight")
plt.close(fig)  # release memory — always close in scripts

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

# Global style settings — set once at the top of a script
mpl.rcParams.update({
    "font.family":       "DejaVu Sans",
    "font.size":         12,
    "axes.spines.top":   False,
    "axes.spines.right": False,
    "axes.grid":         True,
    "grid.alpha":        0.3,
    "figure.dpi":        150,
})

fig, ax = plt.subplots(figsize=(6, 4))
x = np.linspace(0, 1, 100)
ax.plot(x, x**2, lw=2, label=r"$y = x^2$")
ax.set_xlabel("x"); ax.set_ylabel("y")
ax.legend()
ax.set_title("Publication-Ready Figure")

# PNG for web/notebooks (raster)
fig.savefig("figure.png", dpi=300, bbox_inches="tight")

# PDF/SVG for papers (vector)
fig.savefig("figure.pdf", bbox_inches="tight")
fig.savefig("figure.svg", bbox_inches="tight")

plt.close(fig)

# Cell 1: imports and seeds — always the same, always first
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pathlib import Path

rng = np.random.default_rng(seed=42)
DATA_DIR = Path("../data")
OUT_DIR  = Path("../outputs")
OUT_DIR.mkdir(parents=True, exist_ok=True)

print("Environment ready.")