Python for Machine Learning

A NumPy array is a grid of numbers that all share one type, stored together in memory. That layout is why maths on an array is fast: one operation runs across every element at once — called a vectorised operation — instead of you writing a Python loop.

Two words you'll meet constantly: a 1D array is a vector (a single row of values), and a 2D array is a matrix (a table where rows are samples and columns are features). The array's .shape tells you how many of each.

Worked example — read the comments, every line states its result:

import numpy as np

# A NumPy array is a fast, fixed-type grid of numbers. It is the
# container every ML library passes data around in.

prices = np.array([10.0, 20.0, 30.0, 40.0])   # 1D array (a "vector")
print(prices)            # Expected output: [10. 20. 30. 40.]
print(prices.shape)      # Expected output: (4,)   <- 4 elements, 1 axis

# Vectorised math: one operation applies to EVERY element, no loop.
print(prices * 1.2)      # Expected output: [12. 24. 36. 48.]
print(prices.mean())     # Expected output: 25.0

# A 2D array is a matrix: rows = samples, columns = features.
X = np.array([[1, 2],
              [3, 4],
              [5, 6]])
print(X.shape)           # Expected output: (3, 2)   <- 3 samples, 2 features
print(X.sum(axis=0))     # Expected output: [9 12]   <- sum down each column

Real data rarely arrives as a tidy grid of one type — it has named columns like age, city, and price, mixing numbers, text, and true/false. A DataFrame is pandas' answer: a labelled table you can program, like a spreadsheet with code.

The move you'll repeat in every project is splitting that table into X (the feature columns the model learns from) and y (the single target column it learns to predict). Everything after this lesson assumes you can do that split.

Worked example:

import pandas as pd

# A DataFrame is a labelled table: named columns + indexed rows.
# Think of it as a spreadsheet you can program.

df = pd.DataFrame({
    "city":   ["London", "Paris", "Berlin", "Rome"],
    "temp_c": [12, 16, 9, 18],
    "rain":   [True, False, True, False],
})

print(df.shape)              # Expected output: (4, 3)   <- 4 rows, 3 columns
print(df["temp_c"].mean())   # Expected output: 13.75

# Filter rows with a boolean condition (this is the workhorse of pandas):
warm = df[df["temp_c"] > 12]
print(warm["city"].tolist())  # Expected output: ['Paris', 'Rome']

# Split into features (X) and the label/target (y) for ML:
X = df[["temp_c", "rain"]]    # the inputs the model learns FROM
y = df["city"]                # the answer the model learns to predict
print(X.shape, y.shape)       # Expected output: (4, 2) (4,)

Notice df[df["temp_c"] > 12]: you build a column of True/False values, then use it to keep only the matching rows. That boolean-filter trick is the single most-used pandas operation.

scikit-learn's superpower is consistency: a decision tree, a linear model, and a support-vector machine all expose the same three methods. Learn them once and you can drive any model.

• .fit(X, y) — train: learn the patterns linking features X to labels y.
• .predict(X) — use: guess labels for new, unseen rows.
• .score(X, y) — check: for a classifier, the fraction of predictions that were correct (accuracy).

Two supporting pieces make those three honest. train_test_split holds back a slice of data the model never trains on, so the score is earned, not memorised. A Pipeline glues a transformer (something that reshapes the data, like a scaler that re-scales features) to the model, so the transformer is fitted on the training data only — never on the test data.

Worked example — the full pattern in one place:

from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

# Every scikit-learn model speaks the SAME three verbs:
#   .fit(X, y)   -> learn from labelled data
#   .predict(X)  -> guess labels for new data
#   .score(X, y) -> how often it was right (accuracy, 0.0-1.0)

# 1) Split FIRST so the test set stays unseen during training.
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 2) A Pipeline chains a transformer + a model into one object, so the
#    scaler is fitted on TRAIN ONLY and reused on test — no leakage.
model = make_pipeline(
    StandardScaler(),          # transformer: re-scales features
    LogisticRegression(),      # estimator: makes the prediction
)

model.fit(X_train, y_train)              # learn
preds = model.predict(X_test)            # predict
print(model.score(X_test, y_test))       # Expected output: 0.97  (example)

# .score() just compares preds to the true labels — exactly what you will
# compute by hand in the runnable exercise below.

np.dot and .score sound advanced, but underneath they are plain arithmetic you can write without any library. Seeing that demystifies the whole stack — and it runs in the editor right now.

A single linear prediction is a dot product: multiply each feature by its weight, sum the results, and add a constant bias. That's all np.dot(features, weights) + bias does.

Worked example — a dot product by hand:

# What does numpy actually DO under the hood? A model prediction is mostly
# a "dot product": multiply each feature by its weight, then add them up.
# Here it is in plain Python so you can see there is no magic.

features = [2.0, 3.0, 1.0]    # one sample: 3 feature values
weights  = [0.5, 1.0, 2.0]    # what the model "learned" for each feature
bias     = 1.0                # a constant added at the end

total = bias
for f, w in zip(features, weights):
    total += f * w            # accumulate
...

These four trip up almost every beginner. Spotting them early saves hours.

scaler.fit(X)                    # ❌ sees the test rows too
X_train, X_test = train_test_split(X)

X_train, X_test = train_test_split(X)
scaler.fit(X_train)              # ✅ test set stays unseen

model.fit(X, y)
model.score(X, y)    # ❌ ~1.0 — it just memorised the answers

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model.fit(X_train, y_train)
model.score(X_test, y_test)   # ✅ an honest score

model.fit(X, y)   # ❌ X has 100 rows, y has 90

print(X.shape, y.shape)   # must share the same first number
X = X.reshape(-1, 1)      # ✅ make one feature column 2D

scaler.fit(X_train); X_train = scaler.transform(X_train)
X_test = scaler.fit_transform(X_test)   # ❌ refits on test

scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test  = scaler.transform(X_test)   # ✅ same parameters, no leakage