Gnothi AI

OCDevel

Understand the machine learning behind a prediction, then learn to build and run the system that makes it. This AI course is for programmers who want a rigorous, practical education, starting with the field's basic ideas and progressing toward production systems. Concepts, mathematics, code and engineering develop together: use a model on real data, examine why it works, and return to the idea at greater depth. Probability, statistics and Bayesian inference receive sustained attention alongside linear algebra, calculus and optimization. The curriculum moves through classical machine learning, neural networks and PyTorch, then opens up transformers and large language models. Later lessons cover retrieval-augmented generation, fine-tuning, AI agents and MLOps, including evaluation, deployment and monitoring on AWS and Google Cloud. Worked examples connect an intuition to a derivation, a piece of Python or a system design, giving you material to practice beyond the audio. AI news connects new research and product releases to the fundamentals that explain them. General programming fluency is assumed; prior machine learning study is not. This show's audio is narrated by AI-generated synthetic voices.

Episodes

  1. 2d ago

    10. Twenty Questions About Pixels

    A decision tree picks yes-or-no pixel questions by measuring how much each cut reduces Gini impurity or entropy, shown with a hand-worked example. The chapter then covers how greedy splitting limits it, how tree depth drives overfitting on MNIST, and why tree probabilities and structure need caution. It closes with a Gemini 4 Carbon announcement and a fraud-detection paper on calibration. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website How a tree picks its questions A decision tree reduces the training images to a short series of yes-or-no questions about pixels, then discards the images. This is the opposite of k-nearest neighbors, which keeps every image and works when a new one arrives. The chapter asks how a tree chooses its first question and how it knows when to stop. Gini impurity and entropy Two numbers measure how mixed a group is. Gini impurity is one minus the sum of squared class shares. Entropy, in bits, is the negative sum of each share times the base-two log of that share. For six sevens and four ones, Gini is 0.48 and entropy is about 0.97 bits. A pure group scores zero on both. The two usually choose the same split. Choosing a cut by hand Candidate thresholds are midpoints between neighboring sorted values, and a hand calculation needs only those where the label changes. In the worked ten-image example, cut A lowers weighted impurity by about 0.31, cut B by about 0.16 and cut C by 0.32, so C wins. The tree then repeats the process on each side. The limit of greedy splitting Each split is chosen for its immediate gain. An XOR pattern across two pixels shows no gain from either pixel alone, so a greedy tree can miss it. Finding the truly best tree is NP-complete, so trees are built one step at a time. Growing a tree on MNIST The chapter uses DecisionTreeClassifier with criterion, max_depth, min_samples_leaf and random_state. It fits on the first fifty thousand training images, validates on the next ten thousand, and leaves the test set sealed. Sweeping max_depth upward, both scores rise at first. An unlimited tree reaches 100 percent training accuracy by memorizing, while validation flattens or dips. min_samples_leaf attacks overfitting by forbidding tiny leaves. Reading and trusting the tree feature_importances_ reshaped to 28 by 28 shows bright pixels near the center and near zero at the border. predict_proba on a tree is just leaf class counts, so deep trees give mostly zero or one and are poorly calibrated. Trees are also unstable: refitting after dropping a random five percent of the data can change the top split and everything below it. That instability motivates random forests, which come next. The exercise is a sweep of max_depth against min_samples_leaf on validation only. News Google DeepMind announced Gemini 4 Carbon on October 28, 2026, aimed at cybersecurity and engineering. A paper on fraud detection under operating limits, arXiv 2610.39556, uses chronological holdouts with XGBoost and LightGBM. On PaySim data, Platt calibration cut the Brier score from 0.1141 to 0.0245. Alerting on only the top one percent of scores cut false-positive investigations from 192 to 117, while recall fell from 0.4236 to 0.2122. These results hold for that dataset and setup only.

  2. 2d ago

    9. Classifying by the Closest Examples

    Generating… This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website A model that stores instead of learning k-nearest neighbors keeps every labeled training image. It does its work only when a new image arrives: it measures the distance to each stored example, takes the k closest, and lets them vote. A hand-worked example uses two classes on a flat page with one stray point near the wrong cluster. The same new point is labeled B at k of one, A at k of three, and B at k of seven. Small k chases oddities. Large k lets the bigger class win. Good values are found on held-out data. What "close" means for pixels On MNIST, each image becomes a point with 784 coordinates, and Euclidean distance rewards ink in the same pixels. A seven shifted by one pixel can look farther away than a different digit drawn in the same spot. Dividing pixels by 255 shrinks every distance equally, so accuracy does not change. StandardScaler inflates near-empty border pixels, and reported results show it costs accuracy. Logistic regression could give those pixels small weights. kNN has no weights, so the scale it receives sets how much each pixel counts. Results, cost and diagnostics Using scikit-learn's KNeighborsClassifier on the existing validation split, the scikit-learn KNeighborsClassifier reference explains the defaults: n_neighbors, weights, Minkowski metric with p, algorithm, and n_jobs. Tree searches save almost nothing in 784 dimensions. Reported accuracy on raw pixels is roughly 96.8 to 97.2 percent, as in this MNIST classifier at about 97 percent, against about 92 percent for logistic regression. Fitting is instant. Prediction takes minutes because it compares every validation image with every stored one, and memory grows with the training set. The chapter suggests comparing confusion matrices against logistic regression. It warns that predict_proba values come in steps of 1/k, so ROC curves turn coarse and the scores are not calibrated. A sixteen-run experiment varies k, weighting and scaling on a 2,000-image subset. It includes: a written guess before each run a noise estimate of about four tenths of a point an identity check at k of one the expectation that timing stays flat across settings Decision trees come next. PyTorch on TPUs, and version 2.15 Google and Meta announced the open-source TorchTPU, which brings eager-mode PyTorch to TPUs. It covers about 450 core operations and connects to torch.compile, vLLM, SGLang and TorchTitan. The chapter cautions that this coverage does not guarantee support for every model, and that speed depends on the workload. PyTorch 2.15 brings FSDP2 upgrades and newer AMD and Intel support. On an M3 Ultra, mixture-of-experts decoding ran about a third faster through Metal, a result measured only for that setup. Nothing needs to change yet. Once PyTorch is added, pin the version and rerun a saved experiment around each upgrade.

  3. Oct 23

    8. Ranking Every Threshold at Once

    How ROC curves and AUC measure a model's ranking rather than a single threshold, worked by hand and then on MNIST in scikit-learn. It also covers when precision-recall and average precision reveal what ROC hides, plus notes on pandas 3.1.0 and a seed-related change in scikit-learn's development branch. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website From a single cut to a whole ranking Precision, recall and F1 describe one threshold, but a logistic-regression model on MNIST hands back scores. Sort the validation images by how seven-like the model thinks they are and you get a ranking. Any threshold is one cut through that ranking. The ROC curve and its area, AUC, grade the ranking itself. To get a yes-or-no question, the ten digits are reduced to one-vs-rest: sevens against everything else, roughly one positive for every nine negatives. Eight images, fourteen pairs out of fifteen A worked example with three sevens and five non-sevens sweeps the cut from high to low. Each positive let in is a step up and each negative is a step right. The one ranking mistake, a non-seven at 0.70 above a seven at 0.60, gives an area of fourteen fifteenths. Counting positive-negative pairs gives the same figure: AUC is the chance that a random positive outscores a random negative. It ignores thresholds and exact score values, so it says nothing about where to cut or whether a 0.8 means eighty percent. That second property is calibration, and it has to be checked separately. Running it on MNIST The chapter covers roc_curve on a single probability column, and roc_auc_score with multi_class="ovr", labels set to classes_, and average=None for per-digit values. Plotting uses RocCurveDisplay.from_predictions. Macro AUC near 0.99 alongside roughly 92% accuracy has two causes. Ranking is easier than picking the single right digit, and the many easy negatives dilute the false positive rate. When precision-recall tells more At one-in-a-thousand rarity, the same one percent false positive rate buries real hits under false alarms, while the ROC curve looks unchanged. precision_recall_curve ignores true negatives. average_precision_score sums precision weighted by each rise in recall. Its random floor is the positive rate, which PrecisionRecallDisplay can draw with plot_chance_level=True. The exercise asks you to predict, then rank, all ten digits by AUC, AP and F1 on validation only, and to explain where the rankings disagree. pandas 3.1.0 and the scikit-learn development branch pandas 3.1.0 shipped on October 22. It changes nothing in this workflow. Check your pinned version with uv tree and upgrade between experiments, not during one. scikit-learn's unreleased 1.10 dev branch changes feature subsampling in histogram gradient boosting. As a result, the same random_state can now produce different trees. The suggested check is to rerun one saved experiment on the old and new lock files and compare validation metrics. A large shift from the upgrade alone suggests the result leaned on luck.

  4. Oct 16

    7. Where the Ninety-Two Percent Goes Wrong

    How a confusion matrix, precision, recall and F1 expose which mistakes a handwritten-digit classifier makes, why accuracy alone can mislead, and how moving a decision threshold trades precision against recall. Also covers the final release of Python 3.15 and how to check a project against it. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website What accuracy hides A logistic-regression model that gets about nine digits in ten right still tells you nothing about the tenth. Which images does it miss, and what does it call them instead? Everything here is computed on a validation split: fit on the first fifty thousand training images, predict on the last ten thousand. The test set stays shut, so that looking hard at mistakes doesn't shape the final score. Reading a confusion matrix A worked example uses a tiny three-digit classifier (one, seven, nine) on twelve images. Its accuracy is 75%, but that figure hides that every one was found, sevens were the weak spot, and sevens and nines were confused in both directions. A confusion matrix keeps all of this. Rows are truth, columns are predictions. The diagonal holds the correct answers, and each off-diagonal cell is a specific mistake. Mirror cells show whether a confusion runs one way or both. Precision, recall and F1 Precision looks down a column: of everything called a seven, how many were sevens? Recall looks along a row: of the real sevens, how many were found? F1 is their harmonic mean. It is pulled down hard by the weaker number, so a model that is excellent on one and hopeless on the other can't score well. A model that says seven only once, correctly, out of fifty real sevens averages 51 but gets an F1 of about 0.04. The ten-by-ten grid on MNIST scikit-learn's confusion matrix function and ConfusionMatrixDisplay draw the grid as a heat map. ConfusionMatrixDisplay replaces the removed plot confusion matrix function. Normalising by row makes each diagonal cell that digit's recall, and normalising by column makes it precision. Pairs worth checking include 4/9, 3/5, 7/9 and 2/8. The classification report The report lists per-digit precision, recall, F1 and support, plus accuracy, a macro average and a weighted average. On near-balanced MNIST the two averages sit close together. On imbalanced data they split, and a good weighted average can hide a rare class the model has nearly given up on. When accuracy misleads, and moving the threshold A detector that always says "negative" on data with 1% positives scores 99% accuracy and finds nothing. Using predict proba with a one-versus-rest cutoff for eight, lowering the threshold raises recall and lowers precision, and raising it does the reverse. Where to set it depends on what each kind of mistake costs. That choice is made on validation data and written down. Exercise Guess the worst-recall digit, check it against the report, plot ten to twenty of its errors, and write one sentence on what they share. Python 3.15 ships After a third release candidate, the final release is out. It adds opt-in lazy imports (PEP 810), UTF-8 as the default file encoding, a built-in frozendict, and the Tachyon sampling profiler. The suggested check is to rerun the project on 3.15 in a copy and compare classification reports with the 3.14 run.

  5. Oct 9

    6. The First Model That Actually Learns

    Linear regression is fitted by hand to show least squares, then logistic regression with softmax and log loss is trained on MNIST, reaching about 92 percent. A short news segment covers the one-week delay of Python 3.15 and the release of Polars 2.0. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website Least squares on four points A model of this kind is a weighted sum of features plus a rule for choosing the weights. Four invented points (hours studied against quiz score) are fitted by hand. Each error is squared so misses can't cancel and big misses cost more. The line that minimises the sum of squared errors comes out as prediction = 1.4x + 0.5, with squared errors totalling two tenths. scikit-learn's LinearRegression returns the same coef_ and intercept_. It needs x as a four-by-one column, because the library always expects a two-dimensional feature table. Squaring is flagged as a choice that suits symmetric noise with rare large misses. A later chapter gives that assumption a precise form. From a line to class probabilities A line can't name a digit. An output of 4.6 is no class, and nothing keeps predictions in range. Logistic regression keeps the weighted sum but changes what is done with it. A sigmoid squashes the sum into a yes-or-no probability. Softmax turns ten per-digit scores into ten probabilities that add to one. Scoring switches to log loss. It charges about a tenth for giving the right digit 0.9, about 0.7 for 0.5, and about 4.6 for 0.01. Log loss has no closed-form solution, so the solver improves the weights step by step. Ninety-two percent on MNIST LogisticRegression goes inside a pipeline after StandardScaler. That way the scaler learns averages from training images only. Scaling evens out the loss surface so the lbfgs solver converges faster. The default max_iter of 100 triggers a ConvergenceWarning on MNIST, so the chapter uses 1,000. The deprecated multi_class parameter should be left out. The test score lands around 92–93 percent, against the 11.35 percent baseline. Per-digit accuracy is uneven, and listeners are told to read their own numbers. Reshaping the coefficient row for zero to 28×28 shows a rough ring of positive weight with a negative centre. That template shows both what the model learned and its limit with shifted strokes. The exercise compares scaling choices and iteration limits on a validation split, never on the test set. Python 3.15 delayed a week Blocking bugs in the lazy-import feature (PEP 810) pushed the final release from October 1 to October 9. Release manager Hugo van Kemenade issued a third release candidate on October 2. pandas 3.0.6 and scikit-learn 1.9.1 already ship prebuilt packages for 3.15, in standard and free-threaded builds. Once 3.15 final is out, the suggested check is to pin a copy of the project to it with uv, confirm the library versions, and rerun the notebook. Polars 2.0.0 makes streaming the default for lazy queries. Its joins and group-bys no longer preserve row order unless maintain_order is set, which can silently misalign positional splits.

  6. Oct 2

    5. The Number Every Model Must Beat

    Using the MNIST arrays, this chapter inspects the data with NumPy and pandas, seals off the test set, and measures an honest floor of about 11.35 percent with a model that ignores the pixels. It closes with what Python 3.15's release candidate means for a project pinned to 3.14. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website Reading the arrays before any model X.shape prints (70000, 784): seventy thousand images, one per row, and one pixel position per column. y.shape prints (70000,), a flat list with one label per row of X. Checking dtype shows pixel values from 0 to 255 and labels stored as text strings, the character "5" rather than the number five. Slicing at row sixty thousand gives a 60,000-image training set and a 10,000-image test set with no overlap. Reshaping one row to 28 by 28 shows the stroke of a handwritten five. pandas is used only for inspection. value_counts shows the classes are close to balanced. Ones are the most common class at about eleven percent. A small per-pixel table shows that corner pixels are almost always zero, so some features carry almost no information. The model still trains on the raw NumPy array, not on this table. Keeping the test set shut The test slice is set aside before any modeling choice and scored once, at the end. Checking it repeatedly while tuning means the final number measures fit to those ten thousand images, not to new handwriting. Slicing by position works for MNIST because the dataset was built with this split in mind. Most datasets have no such guarantee. The general tool is a shuffled, stratified split with a fixed random seed, as described in the train_test_split reference. A random split can still leak information through repeat writers, duplicate rows or repeated customers. The fix is to split by the unit that has to stay separate. A model that ignores the pixels DummyClassifier with most_frequent looks only at the labels and predicts "1" for every image. Its test accuracy is 1,135 correct out of 10,000, about 11.35 percent. Broken down by digit, it is perfect on ones and gets every other digit wrong, a pattern the single accuracy figure hides. An exercise compares this with the stratified and uniform strategies. Both should land near ten percent and spread their errors evenly across the digits. most_frequent wins on accuracy and is also the most lopsided. Linear and logistic regression come next, and their scores are to be read against this floor. Python 3.15 and a pinned project Python 3.15 reached its second release candidate, with the final release scheduled for 1 October 2026. The release notes list lazy imports, the Tachyon profiler and a built-in frozendict. UTF-8 also becomes the default encoding for open(), which could change how a CSV file reads on Windows. NumPy has prebuilt wheels for 3.15. pandas and scikit-learn wheels were still pending, so the advice is to stay on 3.14 for this course. Test 3.15 in a throwaway environment, and upgrade the lockfile only once those wheels exist. After upgrading, confirm the baseline still prints 11.35 percent.

  7. Sep 25

    4. A Workspace Someone Else Can Rerun

    This chapter builds a machine-learning workspace that someone else can rerun, using uv, a lock file, git and a documented MNIST download. It also covers what a random seed can and cannot guarantee, and how uv 0.12 changes the project that uv init creates. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website Why "it worked on my machine" happens A notebook that runs on one laptop and fails on another usually has one of four ordinary causes: a different Python version, library versions that drift, hidden notebook state left in the kernel, or data fetched from somewhere nobody wrote down. From this point the course starts making claims about models, and each claim assumes someone else could rerun the work and get the same answer. A workspace that another person can rebuild Each cause gets its own fix. uv, from Astral, manages the Python version, an isolated environment and pinned dependencies. uv init creates the project and its pyproject file. uv add numpy matplotlib scikit-learn records the dependencies, builds the private .venv and writes uv.lock, which stores exact versions, hashes and sources. Jupyter tools are added as dev dependencies, and uv run jupyter lab opens a notebook inside the project environment. That setup follows uv's guide to using Jupyter. Git tracks everything that describes and rebuilds the project. A .gitignore keeps out the environment, data files, checkpoints, caches and any .env secrets. First contact with MNIST The data loads through one documented route, scikit-learn's fetch_openml, as mnist_784 version 1 (ID 554). The arrays come back as 70,000 × 784 images and 70,000 labels. The labels are text, not numbers. The standard split keeps the first 60,000 images for training and the last 10,000 for testing. The first image is displayed next to its label, a five, as a check that the two agree. The class counts are uneven: ones are the most common at just under 7,000, and fives the least at just over 5,400. A text cell in the notebook records where the data came from. Proving it reruns "Restart and run all" catches hidden state. The stronger test is a clean clone followed by uv sync. A fixed random seed makes a single run repeatable. It does not guarantee the same results across library versions or hardware, and it does not show whether a result is typical. The milestone is a written learning-problem statement for MNIST. Its baseline always predicts "1" and scores about 11% on the test set. A useful result must clearly beat that baseline on the held-out test images, and training accuracy does not count. A repository that describes a clean clone is not proof that one happened, so the exercise is to actually do it and compare the outputs line by line. uv 0.12 changes the project uv init creates Since 0.12.0, uv init sets up a packaged project with a src layout by default. Adding --no-package skips that structure. The release also refuses MD5 digests and strictly enforces required hashes. Later patch releases added a check command and support for downloading Python 3.15 release candidates. Python 3.15 is still a release candidate, and the stable line is 3.14 (see Python's release versions).

  8. Sep 18

    3. What Signal the Machine Actually Gets

    A walk through the four learning settings — supervised, unsupervised, reinforcement, self-supervised — organised around what feedback the world actually returns and when, with MNIST, tic-tac-toe and next-word prediction as the worked cases. Closes with the GLM-5.3 release read as an example of reward-driven training. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website The one question behind four names Supervised, unsupervised, reinforcement, self-supervised are not four families of algorithms. They are four answers to one question: what does the system get told, and when. Everything here follows from that. Answers already written down MNIST as the worked case: pixels paired with a digit a person chose. The correct answer sits beside every guess, which makes the feedback immediate — and paid for in human labour. Sixty thousand images means sixty thousand decisions, and the price climbs when the judgment is a chest X-ray two radiologists may read differently, an email that is angry or merely brisk, or a cyclist boxed frame by frame. Throw the labels away The same pile of pixels with nothing attached. What remains is structure: which images resemble each other, and how much of the seven hundred eighty-four dimensions is redundant. The awkward part gets stated plainly — with no answer key there is no clean test. Six customer groups or eight? Nothing in the data holds an opinion, so you judge by downstream usefulness or by whether someone who knows the domain recognises the groups. A number that arrives at the end Tic-tac-toe as Sutton and Barto set it up in Reinforcement Learning: An Introduction: pick a free square, receive nothing, and after three to five of your own moves one number arrives. It says how things went, not what you should have done — the credit assignment problem. Values propagate backward along the path actually walked, one step at a time. And because the learner only sees consequences of moves it chose, it must sometimes act against its own current judgment to find out. Targets hidden in the data Cover a word and ask for it. A five-hundred-word page becomes roughly five hundred examples, and nobody annotated anything. It uses supervised machinery on invented targets, and it usually is not the last step — pretraining is followed by fine-tuning on far fewer real labels. What you have, not what sounds advanced Loan repayment records, uncategorised support transcripts, and a home-screen recommender that can be read either way. The four settings are not a ranking. GLM-5.3, read through its reward Z.ai's GLM-5.3 release keeps GLM-5.2's 743-billion-parameter base with no further pretraining and scales the reinforcement learning: verified multi-step environments. Reported jumps on Terminal-Bench 3.0 and DeepSWE are evidence about those benchmarks and nothing else. The open weights were held back around two weeks after cyber capability scaled faster than expected.

  9. Sep 11

    2. What Each Era of AI Tried, and Why It Stalled

    This chapter traces artificial intelligence from Turing's 1950 test through the Dartmouth meeting, two funding collapses, expert systems, statistical learning, and the deep learning and transformer breakthroughs, then applies the same evidentiary habits to a newly released AI model. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website A seventy-five-year argument about who supplies the rule The line drawn last time — between problems where a rule can be written down and problems where only examples can reveal it — turns out to be the entire history of artificial intelligence. Alan Turing opened it in 1950 by replacing "can a machine think" with a checkable game of blind interrogation, laid out in his original paper in Mind. Six years later the Dartmouth proposal bet that any feature of intelligence could be described precisely enough for a machine to simulate it, and the first decade delivered real wins in search, games, and Frank Rosenblatt's perceptron — a machine that adjusted its own weights from wrong answers. Then came the reckoning. Search exploded combinatorially on real problems, a single layer of weights proved unable to solve exclusive-or, and government reviews on both sides of the Atlantic — most bluntly the Lighthill Report — found promises with nothing measured behind them, and funding stopped. The next era hand-wrote expert knowledge instead, and it worked: XCON cut computer-configuration errors from over thirty percent to under two, saving Digital Equipment Corporation tens of millions a year, a story traced in the history of configuration technologies. It still collapsed under its own maintenance — half the rule base rewritten every year — because rules interact in ways nobody can see once the pile grows large enough. What replaced hand-written knowledge was counting from data: speech and statistical machine translation learned their structure from text rather than grammar books. Layered networks returned in 2012 when AlexNet beat hand-designed image features by eleven points on ImageNet, and in 2017 attention mechanisms let every position in a sequence look directly at every other, becoming the transformer behind today's large models. The chapter closes on what scaling has actually proven versus only claimed, and on five ideas — weight adjustment, held-out evaluation, learned probabilities, learned features, and attention — that survived every collapse along the way. Reading a release without the hype A current example puts that habit to work: Google's Gemini 3.6 Flash cuts output tokens by roughly seventeen percent and resolves about half of real software issues on one benchmark, yet an independent vision evaluation found its object-localization accuracy got worse — one release, improving on one measure while sliding on another.

  10. Sep 10

    1. Learning Rules From Examples Instead of Writing Them

    This chapter contrasts problems with hand-writable rules against problems like spam filtering and digit recognition where only examples work, sorts out five commonly confused terms in the field, and walks a vague "reduce churn" request into a fully specified, checkable prediction problem. This episode is narrated by AI-generated synthetic voices. Episode page & show notes Visit website When rules fail and examples work The chapter opens with two small programs that look equally simple but aren't. Withholding tax from a paycheck is a rule someone already wrote down — you code it in six lines and check it by hand. Spam filtering looks the same size but collapses: every fix (bad spelling, hidden HTML, image text, padding with harmless prose) is immediately worked around, and the rules start fighting each other until nobody can say what the filter does. Yet a person can still sort spam from real mail in seconds. That gap — recognizable but not describable, with plenty of examples on hand — is where learning from data belongs instead of hand-written logic, a distinction laid out clearly by pieces comparing rule-based and machine learning approaches to language tasks and when to choose one system over the other. Handwritten digit recognition tells the same story without any adversary involved: loops that don't close, sevens with and without a bar, forced the field toward systems like MNIST that learn the rule from labelled pixels instead of hand-coded shape logic. From there the chapter separates five words people use loosely and interchangeably — artificial intelligence, machine learning, deep learning, statistics, and data science — giving each one a problem it actually owns, from shortest-path search to A/B test confidence intervals to the messy plumbing of real datasets. It rejects the idea that these sit on a ladder with deep learning at the top, pointing out that a hand-written rule, a plain average, or a significance test is frequently the correct and more honest answer. Turning a wish into a stated problem The back half works a single example end to end: a vague request to "reduce churn" gets turned into a fully specified prediction problem — one subscriber, one month, features known before the fact (with a live demonstration of leakage via a cancellation-reason field filled in only after someone leaves), a yes/no target, historical labels drawn straight from billing records, and a baseline ("always say no," 96% accurate and useless) that any real model has to beat. It closes by turning to MNIST itself — sixty thousand labelled digit images reduced to raw pixel brightness with no notion of a line or curve — as the plainest way to see what a model is actually handed before it learns anything.

  • 10 Episodes

About

Understand the machine learning behind a prediction, then learn to build and run the system that makes it. This AI course is for programmers who want a rigorous, practical education, starting with the field's basic ideas and progressing toward production systems. Concepts, mathematics, code and engineering develop together: use a model on real data, examine why it works, and return to the idea at greater depth. Probability, statistics and Bayesian inference receive sustained attention alongside linear algebra, calculus and optimization. The curriculum moves through classical machine learning, neural networks and PyTorch, then opens up transformers and large language models. Later lessons cover retrieval-augmented generation, fine-tuning, AI agents and MLOps, including evaluation, deployment and monitoring on AWS and Google Cloud. Worked examples connect an intuition to a derivation, a piece of Python or a system design, giving you material to practice beyond the audio. AI news connects new research and product releases to the fundamentals that explain them. General programming fluency is assumed; prior machine learning study is not. This show's audio is narrated by AI-generated synthetic voices.

Information

  • Creator
    OCDevel
  • Years Active
    2026
  • Episodes
    10
  • Rating
    Clean
  • Copyright
    © All rights reserved 2026, OCDevel
  • Show Website
    Gnothi AI