Python for AI

The dimensions lesson: axes, ndim, and reading .shape as a tuple, so 'expected 2D, got 1D' never scares you again.

Rearrange the same numbers into a new grid with reshape, the -1 wildcard, flatten/ravel, and transpose.

Reach into arrays: 1D index/slice/step, 2D m[row, col], whole rows and columns, and the views-vs-copy gotcha.

Boil an array down with sum/mean/std/min/max/median and argmax/argmin, then control the sweep direction on 2D arrays with the axis parameter.

Use a boolean mask to select, count, and edit array elements; combine conditions with & and |, and branch with np.where.

Mixed read-and-predict reps that combine everything from Module 1: create, reshape, slice, vectorize, aggregate along an axis, and mask.

The pandas Series: a 1D labelled array where every value carries an index label.

The DataFrame: a 2D labelled table made of Series that share one index.

Load a CSV and run the first-look toolkit: head, tail, info, describe, shape, sample.

Pick columns (Series vs DataFrame) and rows with loc (label) vs iloc (position).

Boolean filtering with & and |, isin, .str, query, and sort_values.

Column aggregations and groupby: split-apply-combine for per-group answers.

Multi-aggregation .agg, value_counts, pivot_table cross-tabs, and method chaining.

Read-and-predict reps combining select, filter, sort, groupby, and value_counts.

What NaN is, why it's contagious, and how to find every hole with isna().

Drop or fill? dropna, fillna with a constant/mean/median, ffill, and when to pick each.

Rename columns, fix dtypes with astype, parse dates with to_datetime, and the category dtype.

The .str accessor: strip, lower/upper/title, replace, contains, split — so your groups stop fracturing.

Build columns with vectorized math and boolean logic, then apply() for per-value and per-row custom logic.

Find and drop duplicate rows, then clean up the gappy index with reset_index(drop=True).

No new concepts — walk one messy dataset end to end: detect, fill, retype, scrub, derive, dedupe, reindex.

Meet matplotlib and the figure/axes model by building your first line chart.

Compare categories with bar charts and reveal relationships with scatter plots.

Use histograms to see the shape (distribution) of a single numeric column.

Meet seaborn, a DataFrame-friendly layer on matplotlib, and read a box plot.

Measure how columns move together with correlation and visualize it as a heatmap.

Mixed reps across the whole module: pick the right chart, read a chart, and fill the plotting call.

What a Jupyter Notebook is, the code and markdown cells you work in, the kernel that remembers your variables, and how to launch it — the tool data science actually runs on.

The #1 thing that makes notebooks reproducible: cell execution order and hidden state, the Restart & Run All habit, the execution-count markers, essential shortcuts, and magic commands.

The repeatable EDA ritual you run on every new dataset in a notebook — load, first look, missing audit, distributions, correlations, then answer real questions — assembled from everything in Modules 1-4.

Pure practice for Module 5 — predict cell output, spot the out-of-order execution bug, order the EDA steps, and read info/describe output — then wrap up the module.

Where machine-learning data comes from, how to load scikit-learn's built-in datasets, and the exploration checklist every project starts with — including the class-balance check.

The split every supervised dataset has: features (X) are the input clues you learn from, the target (y) is the answer you predict — and why sklearn expects X to be 2D.

Why you must evaluate a model on data it never saw: overfitting, holding out a test set with train_test_split, and what random_state does.

Models do math, so text categories must become numbers: label encoding (only for ordered categories) vs one-hot encoding (for unordered ones), and the fake-ordering trap.

Putting numeric columns on a comparable range with StandardScaler and MinMaxScaler — and the critical rule: fit on the training set ONLY, or you cause data leakage.

Assemble encoding, scaling, and the train/test split into the one correct end-to-end order — and see how the wrong order silently leaks data.

Meet scikit-learn's estimator API: every model learns with model.fit(X, y) and predicts with model.predict(X) — the same two methods, every time.

Why accuracy lies on imbalanced data, and the metrics that tell the truth: precision, recall, F1, and the confusion matrix.

Pure reps through the full machine-learning pipeline: X vs y, splitting, spotting data leakage, encoding choices, fit/predict order, and reading a confusion matrix.

Build analyze.py, a reusable command-line tool that profiles any CSV file and saves distribution and correlation charts — folding six modules of skills into one program.

Build an end-to-end machine-learning notebook: load a dataset, run full EDA, preprocess, train a RandomForest, and evaluate it — every cell annotated with the module that taught the technique.

Walk one complete, annotated machine-learning pipeline end to end — clean, split into X/y, split-then-scale, train a RandomForest, and read a confusion matrix — with every stage tracing back to the module that taught it.