{ "cells": [ { "cell_type": "raw", "metadata": {}, "source": [ "---\n", "title: \"Notebook 12: AI, Machine Learning & Ethics — Opening the Oracle\"\n", "subtitle: \"COMP 1150 — Computer Science Concepts\"\n", "author: \"Brendan Shea, PhD\"\n", "date: last-modified\n", "---" ] }, { "cell_type": "markdown", "metadata": { "colab_header": true }, "source": [ "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/brendanpshea/computing_concepts_python/blob/main/v2/notebooks/COMP1150_NB12_AIMLEthics.ipynb) \n", "[Download .ipynb](https://raw.githubusercontent.com/brendanpshea/computing_concepts_python/main/v2/notebooks/COMP1150_NB12_AIMLEthics.ipynb) · [View on GitHub](https://github.com/brendanpshea/computing_concepts_python/blob/main/v2/notebooks/COMP1150_NB12_AIMLEthics.ipynb)\n" ] }, { "cell_type": "markdown", "id": "e4349659", "metadata": {}, "source": [ "## Learning Outcomes\n", "\n", "By the end of this notebook, you will be able to:\n", "\n", "- Explain how machine learning differs from ordinary programming, and distinguish supervised from unsupervised learning\n", "- Describe how a perceptron learns, and see a tiny one learn in code\n", "- Explain what a large language model does — tokenization, training, and next-token prediction — and what it is *not*\n", "- Show how bias enters a model through its data, and why hiding a variable doesn't remove it\n", "- Reason about the costs and accountability of AI systems: privacy, labor, environment, and who answers when they fail\n", "\n", "*Maps to course LOs: 10, 11*" ] }, { "cell_type": "markdown", "id": "797f1e3d", "metadata": {}, "source": [ "## The Oracle You Didn't Vote For\n", "\n", "All semester, an AI assistant has sat beside you — suggesting code, explaining errors, drafting text. You've used it, checked it, and sometimes caught it being confidently wrong. This notebook is where you finally open it up and see what it *is*.\n", "\n", "Meet **Athena**, who runs Athena Oversight, a firm that audits AI systems before they're unleashed on the public. This week five companies want to deploy powerful new systems across the city: a hiring tool, a loan scorer, a chatbot, a face recognizer, a \"risk\" predictor for the courts. Athena has been hired to inspect them all.\n", "\n", "Her philosophy is the whole notebook:\n", "\n", "> \"Everyone treats these systems as oracles — mysterious, all-knowing, not to be questioned. My job is to pry them open. An oracle you can inspect is just a machine. An oracle you *can't* inspect is just a god you never voted for. So we open every one.\"" ] }, { "cell_type": "markdown", "id": "7c2e1f37", "metadata": {}, "source": [ "This is the last notebook of the course, and it closes a loop. The very first notebook told the story of four algorithms, ending with ELIZA — a 1960s program that imitated a therapist and fooled people into pouring out their hearts. Everything since has built toward understanding the machines that now write, decide, and predict.\n", "\n", "Today we open five of them:\n", "\n", "1. **Learning from data** — how a machine \"learns\" a rule instead of being given one.\n", "2. **The perceptron** — the tiny artificial neuron underneath it all, learning in front of you.\n", "3. **Language models** — what the assistant you've used all semester actually does.\n", "4. **The mirror** — where bias comes from, and why it's so hard to remove.\n", "5. **The costs we don't see** — privacy, labor, environment, and the question under all of it: when an AI harms someone, who answers?\n", "\n", "By the end, you won't see an oracle. You'll see a machine — one you can question." ] }, { "cell_type": "markdown", "id": "e65d8c52", "metadata": {}, "source": [ "## 1. Learning From Data, Not Rules\n", "\n", "For eleven notebooks, *you* wrote the rules. To decide who gets a loan, you'd write `if income > 50000 and debt < 10000:` — you picked the numbers, you picked the logic. Every program in this course has worked that way.\n", "\n", "But some problems have no rule you could ever write down. How would you write instructions to recognize a cat in a photo? You can't list every possible arrangement of pixels — a cat can be orange or black, curled up or leaping, in sun or shadow. How would you write rules for \"what word comes next in this sentence\"? There are too many sentences, and no rulebook covers them.\n", "\n", "These aren't just *hard* problems. They're a different *kind* of problem — the kind humans solve from **experience**, not from rules anyone can state. You know a cat when you see one, but you can't write down how. That gap is exactly where ordinary programming stops." ] }, { "cell_type": "markdown", "id": "9a312c95", "metadata": {}, "source": [ "### The Flip: Learn From Examples\n", "\n", "**Machine learning** is the way around that wall. Instead of *writing* the rule, you *show the machine examples* — thousands of them — and let it work out the rule on its own.\n", "\n", "Think about how a small child learns the word \"dog.\" Nobody hands a toddler a definition (\"four legs, fur, a tail\" — so is a cat). Instead they see dog after dog after dog, hear \"dog\" each time, and eventually the pattern just *clicks*. They can spot a breed they've never seen before and still say \"dog.\"\n", "\n", "A machine-learning system learns the same way: not from a definition, but from piles of labeled examples until the pattern clicks. The thing it learns — the pattern — is called a **model**. Everything in this notebook is a version of this one idea." ] }, { "cell_type": "markdown", "id": "17675213", "metadata": {}, "source": [ "### Two Ways to Learn\n", "\n", "Machine learning comes in two main flavors, and the difference is simply *what you hand the machine*:\n", "\n", "- **Supervised learning** — you give it examples *with the answers attached*: \"these 1,000 emails are spam; these 1,000 are not.\" It learns to predict the answer for new cases. The answer attached to each example is its **label**.\n", "- **Unsupervised learning** — you give it data with *no answers* and ask it to find structure by itself: \"here are a million customers — put the similar ones together.\" No labels; it discovers the groupings." ] }, { "cell_type": "code", "execution_count": 1, "id": "2a60e4f1", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "\n", "sup\n", "\n", "Supervised\n", "examples WITH answers (labels)\n", "\n", "\n", "\n", "predict a label\\n(spam / not spam)\n", "\n", "predict a label\n", "(spam / not spam)\n", "\n", "\n", "\n", "sup->predict a label\\n(spam / not spam)\n", "\n", "\n", "\n", "\n", "\n", "uns\n", "\n", "Unsupervised\n", "examples with NO answers\n", "\n", "\n", "\n", "find groups\\n(cluster similar things)\n", "\n", "find groups\n", "(cluster similar things)\n", "\n", "\n", "\n", "uns->find groups\\n(cluster similar things)\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#| label: fig-learning\n", "#| fig-alt: \"Diagram contrasting supervised learning, which trains on examples that carry answers, with unsupervised learning, which trains on examples that carry none.\"\n", "import graphviz\n", "graphviz.Source(r\"\"\"digraph G {\n", " bgcolor=\"transparent\"; rankdir=TB;\n", " node [shape=box, style=\"rounded,filled\", fontname=\"Helvetica\", fontsize=10, fillcolor=\"#dde8f0\"];\n", " edge [fontname=\"Helvetica\", fontsize=9];\n", " sup [label=\"Supervised\\nexamples WITH answers (labels)\", fillcolor=\"#f3e9d8\"];\n", " uns [label=\"Unsupervised\\nexamples with NO answers\", fillcolor=\"#f3e9d8\"];\n", " sup -> \"predict a label\\n(spam / not spam)\";\n", " uns -> \"find groups\\n(cluster similar things)\";\n", "}\"\"\")" ] }, { "cell_type": "markdown", "id": "cbd696ea", "metadata": {}, "source": [ "**Reading it:** the split is about what you hand the machine. Labeled examples → it learns to *predict the label*. Unlabeled data → it learns to *find structure*. Almost everything called \"AI\" today is one of these two, and most of the headline systems — including the ones we open next — are supervised." ] }, { "cell_type": "markdown", "id": "69f219c6", "metadata": {}, "source": [ "### Watching a Machine Find a Rule\n", "\n", "Let's make \"learning from examples\" concrete and small enough to see all of it. **Cassandra**, who runs a prediction company, won't hand-pick a loan cutoff. She has past data — each applicant's income, and whether they repaid — and lets the machine find the dividing line itself.\n", "\n", "The machine's whole strategy: *try every possible cutoff, and keep the one that fits the past best.* That's it. The next cell does exactly that." ] }, { "cell_type": "code", "execution_count": 2, "id": "c0b50f7f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The machine learned the rule: approve if income >= 35k\n", "(That rule fits 7 of 7 past cases.)\n" ] } ], "source": [ "# Past loans: (income in $1000s, repaid?). The machine will find the cutoff itself.\n", "loans = [(20, 0), (25, 0), (30, 0), (35, 1), (45, 1), (55, 1), (60, 1)]\n", "\n", "best_cutoff, best_score = 0, 0\n", "for cutoff in range(20, 61, 5):\n", " correct = sum((1 if income >= cutoff else 0) == repaid for income, repaid in loans)\n", " if correct > best_score:\n", " best_score, best_cutoff = correct, cutoff\n", "\n", "print(f\"The machine learned the rule: approve if income >= {best_cutoff}k\")\n", "print(f\"(That rule fits {best_score} of {len(loans)} past cases.)\")" ] }, { "cell_type": "markdown", "id": "26aae003", "metadata": {}, "source": [ "Nobody told the program that 35 was the magic number. It *tried* the options and kept the rule that best matched the examples. That is machine learning stripped to its bones: no human wrote the threshold; the data chose it.\n", "\n", "Real systems do this with millions of examples and thousands of variables at once, and they can't just \"try every cutoff\" — the search is far too big. So they need a smarter way to *search* for a good rule. That smarter way is the subject of the next section, and it's the engine inside almost all modern AI." ] }, { "cell_type": "markdown", "id": "f7bd6b7b", "metadata": {}, "source": [ "### 💭 Think About It — Rules vs. Examples\n", "\n", "Think of two things you can do: one you learned from a *rule* someone told you (\"i before e except after c\"), and one you learned from *examples* until you just got a feel for it (recognizing a friend's face, knowing when a joke will land).\n", "\n", "Which kind is easier to *explain* to someone else? Machine-learned skills are usually the second kind: the machine can *do* it but can't say *why*. Hold onto that thought — it comes back when we ask whether these systems are fair." ] }, { "cell_type": "markdown", "id": "e61b777a", "metadata": {}, "source": [ "## 2. Inside the Black Box: The Perceptron\n", "\n", "**Daedalus**, the city's master engineer, builds the automated systems everyone else treats as magic. He'll tell you there's no magic — just a tiny part, repeated. That part, invented in 1958, is called a **perceptron**, and it is the seed of every neural network alive today. Understand this one small thing and you understand the shape of all of it.\n", "\n", "A perceptron is a single decision-maker. Picture a judge weighing evidence for a yes-or-no verdict. Each piece of evidence is an **input**. The judge trusts some evidence more than others — that trust is a **weight**. The judge adds up the evidence, each piece scaled by how much it's trusted, and returns *yes* if the total clears a bar, *no* if it doesn't." ] }, { "cell_type": "code", "execution_count": 3, "id": "ed1e90f5", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "\n", "\n", "in1\n", "\n", "income\n", "\n", "\n", "\n", "sum\n", "\n", "add up\n", "(weighted)\n", "\n", "\n", "\n", "in1->sum\n", "\n", "\n", " x weight 1\n", "\n", "\n", "\n", "in2\n", "\n", "debt\n", "\n", "\n", "\n", "in2->sum\n", "\n", "\n", " x weight 2\n", "\n", "\n", "\n", "out\n", "\n", "over the bar?\n", "yes = approve\n", "no = deny\n", "\n", "\n", "\n", "sum->out\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#| label: fig-neuron\n", "#| fig-alt: \"Diagram of a single artificial neuron: income and debt inputs are each multiplied by a weight, added together, and compared against a threshold that approves or denies.\"\n", "import graphviz\n", "graphviz.Source(r\"\"\"digraph G {\n", " bgcolor=\"transparent\"; rankdir=LR;\n", " node [fontname=\"Helvetica\", fontsize=10];\n", " node [shape=box, style=\"rounded,filled\", fillcolor=\"#dde8f0\"];\n", " in1 [label=\"income\"]; in2 [label=\"debt\"];\n", " node [shape=circle, style=\"filled\", fillcolor=\"#f3e9d8\", width=1.1, fixedsize=true];\n", " sum [label=\"add up\\n(weighted)\"];\n", " node [shape=box, style=\"rounded,filled\", fillcolor=\"#e3efe1\"];\n", " out [label=\"over the bar?\\nyes = approve\\nno = deny\"];\n", " in1 -> sum [label=\" x weight 1\"];\n", " in2 -> sum [label=\" x weight 2\"];\n", " sum -> out;\n", "}\"\"\")" ] }, { "cell_type": "markdown", "id": "ce03b653", "metadata": {}, "source": [ "**Reading it:** the two inputs (income, debt) each get multiplied by a weight, the results are added up, and if the total clears a bar the perceptron says \"approve.\" In numbers, that's just three steps:\n", "\n", "```\n", "total = weight1 * input1 + weight2 * input2 + bias\n", "output = 1 if total > 0 else 0\n", "```\n", "\n", "The **bias** is simply where the bar sits. The whole cleverness is in the weights — get them right and the perceptron makes good decisions. So the real question is: where do the right weights come from?" ] }, { "cell_type": "markdown", "id": "32867cee", "metadata": {}, "source": [ "### How It Learns: Guess, Check, Nudge\n", "\n", "Nobody sets the weights by hand. The perceptron *learns* them, and its method is one you already use.\n", "\n", "Think about learning to throw a ball at a target. You throw, you see how far off you were, you adjust, you throw again. Guess, check, nudge — over and over — until you're hitting it. The perceptron learns weights exactly this way:\n", "\n", "1. **Guess** — make a prediction with the current weights.\n", "2. **Check** — compare the guess to the known right answer. Off by how much? That gap is the **error**.\n", "3. **Nudge** — shift each weight a little in the direction that would have reduced the error.\n", "\n", "If the guess was already right, the error is zero and nothing changes. Only mistakes cause learning. Let's watch one single nudge happen, by hand, before turning it loose." ] }, { "cell_type": "markdown", "id": "e4ef7d36", "metadata": {}, "source": [ "### One Lesson, in Slow Motion\n", "\n", "The perceptron starts knowing *nothing*: both weights are 0, and the bias is 0. Here comes its first example — an applicant with **income 6, debt 1**, who we know was **approved** (the right answer is 1).\n", "\n", "- **Guess:** total = (0 × 6) + (0 × 1) + 0 = **0**. Is 0 above the bar (0)? No. So it guesses **0 — deny.**\n", "- **Check:** the right answer was 1 (approve). Error = 1 − 0 = **+1**. It was wrong, and the error is positive — it guessed too low.\n", "- **Nudge:** shift each weight by `learning rate × error × input`. With a learning rate of 0.1: income's weight becomes 0 + (0.1 × 1 × 6) = **0.6**; debt's weight becomes 0 + (0.1 × 1 × 1) = **0.1**; the bias becomes **0.1**.\n", "\n", "In one step it learned a little: income now counts *for* approval. It hasn't learned that debt should count *against* approval yet — that comes from the examples where high debt led to denial. Run through all the examples a few times, and the weights settle into place. The next cell does exactly that." ] }, { "cell_type": "code", "execution_count": 4, "id": "30c46739", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final learned weights: [0.4, -0.4] bias: 0.0\n" ] } ], "source": [ "# Each example: [income, debt] -> 1 approve, 0 deny\n", "data = [([6,1],1), ([7,2],1), ([8,1],1), ([5,0],1),\n", " ([2,5],0), ([1,4],0), ([3,6],0), ([2,3],0)]\n", "\n", "w = [0.0, 0.0] # weights start at zero: the perceptron knows nothing\n", "b = 0.0\n", "rate = 0.1\n", "\n", "for training_pass in range(20): # go through all the examples 20 times\n", " for x, target in data:\n", " total = w[0]*x[0] + w[1]*x[1] + b\n", " guess = 1 if total > 0 else 0\n", " error = target - guess # 0 if right; +1 or -1 if wrong\n", " w[0] += rate * error * x[0] # nudge each weight (only when wrong)\n", " w[1] += rate * error * x[1]\n", " b += rate * error\n", "\n", "print(\"Final learned weights:\", [round(v, 2) for v in w], \" bias:\", round(b, 2))" ] }, { "cell_type": "markdown", "id": "6e131ba0", "metadata": {}, "source": [ "### Understanding the Code\n", "\n", "- It starts at zero and loops through the examples 20 times, doing guess-check-nudge on each.\n", "- `error` is 0 when the guess is right — so correct answers change nothing. **Only mistakes teach it.**\n", "- It ends with a **positive** weight for income (+0.4) and a **negative** weight for debt (−0.4): it taught itself that income is good and debt is bad, from nothing but examples.\n", "\n", "But numbers like `[0.4, -0.4]` don't show what the machine really *did*. The clearest way to see it is to draw it." ] }, { "cell_type": "code", "execution_count": 5, "id": "17165995", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 429, "width": 576 } }, "output_type": "display_data" } ], "source": [ "#| label: fig-boundary\n", "#| fig-alt: \"Scatter plot of applicants by income and debt, with a straight decision boundary separating the approved points from the denied ones.\"\n", "import matplotlib.pyplot as plt\n", "\n", "approve = [(6,1),(7,2),(8,1),(5,0)]\n", "deny = [(2,5),(1,4),(3,6),(2,3)]\n", "plt.scatter([p[0] for p in approve], [p[1] for p in approve], color=\"#2a78d6\", s=90, label=\"approved\")\n", "plt.scatter([p[0] for p in deny], [p[1] for p in deny], color=\"#e34948\", s=90, marker=\"s\", label=\"denied\")\n", "plt.plot([0,9], [0,9], color=\"#52514e\", lw=2, ls=\"--\", label=\"the line it learned\")\n", "plt.xlabel(\"income\"); plt.ylabel(\"debt\"); plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "1d6cfaae", "metadata": {}, "source": [ "**Reading it:** each dot is an applicant — blue circles approved, red squares denied. The dashed line is the rule the perceptron *discovered*: approve everyone above it, deny everyone below. It landed on \"approve when income is greater than debt.\" Nobody drew that line or programmed that rule. The neuron found it, from examples alone, by nudging two numbers. *That* is what \"learning\" means here." ] }, { "cell_type": "markdown", "id": "874b01e2", "metadata": {}, "source": [ "### From One Neuron to a Brain\n", "\n", "A single perceptron can only ever draw one straight line. That's enough to separate income from debt, but the world is rarely so tidy — no straight line separates photos of cats from photos of dogs.\n", "\n", "The power comes from wiring many perceptrons together in **layers**: the outputs of one layer become the inputs of the next. This is a **neural network**." ] }, { "cell_type": "code", "execution_count": 6, "id": "3f39bb93", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "G\n", "inputs        →     hidden layer     →   output\n", "\n", "\n", "i1\n", "\n", "\n", "\n", "\n", "h1\n", "\n", "\n", "\n", "\n", "i1->h1\n", "\n", "\n", "\n", "\n", "\n", "h2\n", "\n", "\n", "\n", "\n", "i1->h2\n", "\n", "\n", "\n", "\n", "\n", "h3\n", "\n", "\n", "\n", "\n", "i1->h3\n", "\n", "\n", "\n", "\n", "\n", "h4\n", "\n", "\n", "\n", "\n", "i1->h4\n", "\n", "\n", "\n", "\n", "\n", "i2\n", "\n", "\n", "\n", "\n", "i2->h1\n", "\n", "\n", "\n", "\n", "\n", "i2->h2\n", "\n", "\n", "\n", "\n", "\n", "i2->h3\n", "\n", "\n", "\n", "\n", "\n", "i2->h4\n", "\n", "\n", "\n", "\n", "\n", "i3\n", "\n", "\n", "\n", "\n", "i3->h1\n", "\n", "\n", "\n", "\n", "\n", "i3->h2\n", "\n", "\n", "\n", "\n", "\n", "i3->h3\n", "\n", "\n", "\n", "\n", "\n", "i3->h4\n", "\n", "\n", "\n", "\n", "\n", "o1\n", "\n", "\n", "\n", "\n", "h1->o1\n", "\n", "\n", "\n", "\n", "\n", "h2->o1\n", "\n", "\n", "\n", "\n", "\n", "h3->o1\n", "\n", "\n", "\n", "\n", "\n", "h4->o1\n", "\n", "\n", "\n", "\n", "\n" ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#| label: fig-network\n", "#| fig-alt: \"Diagram of a small neural network: a column of input nodes connects to a hidden layer, which connects in turn to the output.\"\n", "import graphviz\n", "graphviz.Source(r\"\"\"digraph G {\n", " bgcolor=\"transparent\"; rankdir=LR; splines=line;\n", " node [shape=circle, style=filled, width=0.3, fixedsize=true, label=\"\", fillcolor=\"#dde8f0\"];\n", " i1 i2 i3;\n", " node [fillcolor=\"#f3e9d8\"]; h1 h2 h3 h4;\n", " node [fillcolor=\"#e3efe1\"]; o1;\n", " {i1 i2 i3} -> {h1 h2 h3 h4} [color=\"#b8c4d0\"];\n", " {h1 h2 h3 h4} -> o1 [color=\"#b8c4d0\"];\n", " labelloc=\"b\";\n", " label=\"inputs → hidden layer → output\";\n", "}\"\"\")" ] }, { "cell_type": "markdown", "id": "8108c813", "metadata": {}, "source": [ "**Reading it:** every neuron in one column connects to every neuron in the next. Why does stacking help? Because each layer learns patterns built from the layer before it. Shown millions of photos, the **early** layers learn to spot simple things — an edge, a patch of color. **Later** layers combine those into bigger things — a curve, then an eye, then a face. Simple parts, combined and recombined, become the ability to recognize almost anything.\n", "\n", "And here's the punchline: every one of those neurons is doing the exact guess-check-nudge you just watched. The giant models behind today's AI are this same tiny part — multiply, add, check the bar, nudge — repeated *billions* of times across many layers. The difference between your perceptron and a system that writes essays is **scale, not kind.**" ] }, { "cell_type": "markdown", "id": "8b611bdd", "metadata": {}, "source": [ "### ✏️ Your Turn — Retrain the Neuron\n", "\n", "The bank changes its policy: now it cares about **savings** instead of debt, and wants to approve people with high income *and* high savings. Change the training `data` below so the second number is savings (higher = better), retrain, and check whether the learned weight for the second input flips from negative to **positive**." ] }, { "cell_type": "code", "execution_count": 7, "id": "97091de0", "metadata": {}, "outputs": [], "source": [ "#| eval: false\n", "# CHANGE the data so the 2nd number is savings (high = approve), then re-run the training loop.\n", "data = [([6,1],1), ([7,2],1), ([8,1],1), ([5,0],1),\n", " ([2,5],0), ([1,4],0), ([3,6],0), ([2,3],0)]\n", "# TODO: edit the examples above, then copy the training loop from earlier and run it.\n", "# Did the 2nd weight become positive?" ] }, { "cell_type": "markdown", "id": "b6851720", "metadata": {}, "source": [ "## 3. What a Language Model Actually Does\n", "\n", "**Prometheus** runs the lab that built the city's chatbot — the same kind of system that's been your assistant all semester. People treat it as if it *understands* them. Athena's audit replaces that impression with something simpler, and stranger.\n", "\n", "A **large language model** (LLM) does exactly one thing: **it predicts the next word.** Give it some text, it guesses what comes next, adds that, and guesses again. Everything it seems to do — answer questions, translate, write code — is that single trick, run over and over at enormous scale. The rest of this section takes that claim apart until you believe it." ] }, { "cell_type": "markdown", "id": "c8c44ac9", "metadata": {}, "source": [ "### Step One: Turn Words Into Numbers\n", "\n", "A machine can only do math, so before anything else the text must become numbers. This step is **tokenization**: chop the text into pieces called **tokens**, and give each piece a number.\n", "\n", "Tokens are like the Lego bricks of language — a few thousand reusable pieces the model snaps together. Common words are their own brick; rarer words get built from smaller ones (\"unbelievable\" might be `un` + `believ` + `able`). The next cell tokenizes a sentence." ] }, { "cell_type": "code", "execution_count": 8, "id": "c3773760", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tokens: ['the', 'model', 'sees', 'numbers', 'not', 'words', '.']\n", "ids: [0, 1, 2, 3, 4, 5, 6]\n" ] } ], "source": [ "def tokenize(text):\n", " vocabulary = {}\n", " tokens = text.replace(\".\", \" .\").split()\n", " ids = [vocabulary.setdefault(tok, len(vocabulary)) for tok in tokens]\n", " return tokens, ids\n", "\n", "tokens, ids = tokenize(\"the model sees numbers not words .\")\n", "print(\"tokens:\", tokens)\n", "print(\"ids: \", ids)" ] }, { "cell_type": "markdown", "id": "2648c8bb", "metadata": {}, "source": [ "The model never sees \"words\" — only that list of numbers. (Because it works in bricks, not letters, it can be strangely bad at spelling: ask an LLM how many *r*'s are in \"strawberry\" and it may miss, because it never saw the letters, only the bricks.)\n", "\n", "### Step Two: Predict the Next Token\n", "\n", "Now the heart of it. How does the model know what word comes next? During training it read enormous amounts of text and kept track of **what tends to follow what**. Its \"knowledge\" is, in essence, a giant tally.\n", "\n", "We can build a tiny version and *look inside it*. The next cell reads a short passage and, for each word, records every word that followed it." ] }, { "cell_type": "code", "execution_count": 9, "id": "ff109997", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "after 'the', the model saw: {'hero': 4, 'sword': 1, 'dragon': 1, 'town': 2}\n", "after 'hero', the model saw: {'takes': 1, 'fights': 1, 'saves': 1}\n" ] } ], "source": [ "from collections import Counter\n", "\n", "passage = (\"the hero takes the sword the hero fights the dragon \"\n", " \"the hero saves the town the town cheers the hero\").split()\n", "\n", "next_words = {}\n", "for current, following in zip(passage, passage[1:]):\n", " next_words.setdefault(current, []).append(following)\n", "\n", "# Look inside: after the word \"the\", what did the model actually see?\n", "print(\"after 'the', the model saw:\", dict(Counter(next_words[\"the\"])))\n", "print(\"after 'hero', the model saw:\", dict(Counter(next_words[\"hero\"])))" ] }, { "cell_type": "markdown", "id": "d4d1e0ec", "metadata": {}, "source": [ "There is the whole \"mind\" of the model, in the open: after **\"the\"** it saw *hero* four times, *town* twice, *sword* and *dragon* once each. So to predict what follows \"the,\" it just picks from that tally — usually \"hero,\" because that's what it saw most. No meaning, no understanding. A frequency table.\n", "\n", "To **generate** text, it does this repeatedly: pick a likely next word, move to it, pick again. The next cell chains it into a sentence." ] }, { "cell_type": "code", "execution_count": 10, "id": "8a37fbcc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "the hero saves the hero takes the hero fights the\n" ] } ], "source": [ "import random\n", "\n", "word = \"the\"\n", "story = [word]\n", "random.seed(1)\n", "for _ in range(9):\n", " word = random.choice(next_words[word]) # pick a word that really followed this one\n", " story.append(word)\n", "\n", "print(\" \".join(story))" ] }, { "cell_type": "markdown", "id": "187d5282", "metadata": {}, "source": [ "A real LLM builds this same kind of \"what follows what\" knowledge — but incomparably richer, weighing thousands of previous words instead of one, across billions of examples. And it learns it the same way your perceptron did: **guess the next word, check against the real text, nudge the weights.** Guess-check-nudge, the whole way down — just predicting words instead of approving loans.\n", "\n", "### What It Is, and Isn't\n", "\n", "Scaled up massively, this next-word trick becomes fluent enough to feel like thought. But look hard at the mechanism and you can see what it is — and isn't:\n", "\n", "- It **is** an extraordinarily powerful *pattern-continuer*: it produces plausible next words.\n", "- It is **not** a database of facts. It stores patterns, not truths, so it can state a falsehood with total confidence.\n", "- It is **not** reasoning or understanding. It has no idea what the words *mean*. Our toy wrote \"the hero\" without knowing what a hero is — and the giant version, underneath, is doing the same thing.\n", "\n", "This is *why* the rule you've followed all course is true: **AI is a fast first draft — you verify.** A machine built to produce plausible words will produce plausible-*sounding* mistakes, delivered with perfect confidence. Now you know the reason in your bones: it was never checking whether it was right. It was only ever predicting the next word." ] }, { "cell_type": "markdown", "id": "7527eee9", "metadata": {}, "source": [ "### ✏️ Your Turn — Change Its Voice\n", "\n", "The generator's \"voice\" is nothing but its training text. Replace the `passage` with a few sentences in a very different style — song lyrics, a recipe, a sports recap — keep the seed, and generate again. The model has no style of its own; it only echoes what it was fed. What does that tell you about where an AI's \"personality\" really comes from — and who chose it?" ] }, { "cell_type": "code", "execution_count": 11, "id": "0bbcc2b6", "metadata": {}, "outputs": [], "source": [ "#| eval: false\n", "from collections import Counter\n", "import random\n", "# Replace with 3-4 sentences of your own, then re-run the tally + generate steps.\n", "passage = (\"the hero takes the sword the hero fights the dragon \"\n", " \"the hero saves the town the town cheers the hero\").split()\n", "# TODO: rebuild next_words from your passage, then generate from it." ] }, { "cell_type": "markdown", "id": "1a1a68f0", "metadata": {}, "source": [ "## 4. The Mirror: Where Bias Comes From\n", "\n", "Now the audit turns serious. **Cassandra** — cursed in the old story to see the truth and never be believed — runs the risk-scoring system the courts and banks want to use. Athena's hardest question: *is it fair?*\n", "\n", "Here is the uncomfortable heart of machine learning. A model learns from data about the past. **If the past was biased, the model learns the bias** — and then applies it to the future wearing a mask of mathematical objectivity. The model is a **mirror**: it reflects the data it was trained on, warts and all.\n", "\n", "Suppose a company's past hiring favored one group over another, regardless of skill. The next cell holds that history: equally skilled people, but Group 1 was rarely hired." ] }, { "cell_type": "code", "execution_count": 12, "id": "d0d9d7dc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model's decision for a Group 0 applicant: 1\n", "Model's decision for a Group 1 applicant: 0\n" ] } ], "source": [ "# Historical hiring. skill is high for everyone here, but group 1 was denied.\n", "history = [\n", " {\"skill\": 8, \"group\": 1, \"hired\": 0},\n", " {\"skill\": 9, \"group\": 1, \"hired\": 0},\n", " {\"skill\": 7, \"group\": 1, \"hired\": 0},\n", " {\"skill\": 6, \"group\": 0, \"hired\": 1},\n", " {\"skill\": 7, \"group\": 0, \"hired\": 1},\n", " {\"skill\": 5, \"group\": 0, \"hired\": 1},\n", "]\n", "\n", "# A simple learner: predict \"hire\" based on what happened to this group before.\n", "def learned_rule(group):\n", " outcomes = [r[\"hired\"] for r in history if r[\"group\"] == group]\n", " return round(sum(outcomes) / len(outcomes))\n", "\n", "print(\"Model's decision for a Group 0 applicant:\", learned_rule(0))\n", "print(\"Model's decision for a Group 1 applicant:\", learned_rule(1))" ] }, { "cell_type": "markdown", "id": "6bfcecbe", "metadata": {}, "source": [ "The model denies every Group 1 applicant and approves every Group 0 applicant — even though Group 1 here is *more* skilled. It didn't invent this; it faithfully learned the past. That's the mirror.\n", "\n", "\"Easy fix,\" says the company. \"Delete the group column so the model can't see it.\" The next cell does exactly that — and shows why it fails." ] }, { "cell_type": "code", "execution_count": 13, "id": "36b06b19", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Applicant from 'east': 0\n", "Applicant from 'west': 1\n" ] } ], "source": [ "# Remove 'group'. But 'neighborhood' quietly tracks group membership.\n", "history2 = [\n", " {\"skill\": 8, \"neighborhood\": \"east\", \"hired\": 0}, # was group 1\n", " {\"skill\": 9, \"neighborhood\": \"east\", \"hired\": 0},\n", " {\"skill\": 7, \"neighborhood\": \"east\", \"hired\": 0},\n", " {\"skill\": 6, \"neighborhood\": \"west\", \"hired\": 1}, # was group 0\n", " {\"skill\": 7, \"neighborhood\": \"west\", \"hired\": 1},\n", " {\"skill\": 5, \"neighborhood\": \"west\", \"hired\": 1},\n", "]\n", "\n", "def rule_by_neighborhood(neighborhood):\n", " outcomes = [r[\"hired\"] for r in history2 if r[\"neighborhood\"] == neighborhood]\n", " return round(sum(outcomes) / len(outcomes))\n", "\n", "print(\"Applicant from 'east':\", rule_by_neighborhood(\"east\"))\n", "print(\"Applicant from 'west':\", rule_by_neighborhood(\"west\"))" ] }, { "cell_type": "markdown", "id": "f420c52a", "metadata": {}, "source": [ "### Understanding the Failure\n", "\n", "The group column is gone — and the model discriminates *exactly as before*. Why? Because neighborhood is tangled up with group: it's a **proxy**, a stand-in variable that carries the same information through a side door. The model doesn't need the forbidden label; it reconstructs it from whatever correlates with it — a zip code, a name, a school.\n", "\n", "This is the lesson that makes AI fairness genuinely hard:\n", "\n", "- Bias lives in the **data**, not the code — the algorithm is \"just math,\" which is exactly why it launders history into a decision that looks neutral.\n", "- **Hiding the sensitive variable doesn't remove the bias.** Proxies smuggle it back in.\n", "- A model can be **accurate about the past and unjust about the future** at the same time — those aren't in conflict.\n", "\n", "Fairness, then, can't be an afterthought or a deleted column. It takes deliberately examining what the data encodes, and what the model does to real people — the work Athena's whole audit exists to do." ] }, { "cell_type": "markdown", "id": "2fdc3436", "metadata": {}, "source": [ "### 💭 Think About It — Two Kinds of Danger\n", "\n", "Cassandra's curse was to speak true predictions that no one believed. Modern risk scores are almost the opposite: predictions people believe *too much*, because a number on a screen feels objective.\n", "\n", "Which is more dangerous — a true warning ignored, or a biased guess trusted completely? Where have you seen a number treated as fact just because a computer produced it?" ] }, { "cell_type": "markdown", "id": "468b25cd", "metadata": {}, "source": [ "### ✏️ Your Turn — Predict the Bias\n", "\n", "Below is a small dataset of past loan decisions. Before running anything, **read it and predict**: if you train a simple rule on this history, who will it favor? Then explain in a sentence what real-world harm could follow if a bank deployed it." ] }, { "cell_type": "code", "execution_count": 14, "id": "5ba6c390", "metadata": {}, "outputs": [], "source": [ "#| eval: false\n", "# Past loans. Look at who got approved, and predict what a model would learn.\n", "loans = [\n", " {\"income\": 40, \"zip\": \"A\", \"approved\": 1},\n", " {\"income\": 42, \"zip\": \"A\", \"approved\": 1},\n", " {\"income\": 41, \"zip\": \"B\", \"approved\": 0},\n", " {\"income\": 43, \"zip\": \"B\", \"approved\": 0},\n", "]\n", "# TODO (in words): Whom does this history favor? What proxy is doing the work?\n", "# What harm follows if a bank ships a model trained on it?" ] }, { "cell_type": "markdown", "id": "12d82e3b", "metadata": {}, "source": [ "## 5. The Costs We Don't See\n", "\n", "The models work. But Athena's audit isn't only \"does it work?\" — it's \"what does it cost, and who pays?\" Three costs stay hidden behind the magic, kept by **Pandora**, whose data company gathered the training sets, and **Hephaestus**, whose servers run the forge that trains the models.\n", "\n", "**Privacy.** A model has to learn from *something*, and that something is data made by real people — their photos, their posts, their medical notes, their code — gathered at a scale no one meaningfully consented to. Pandora's old story is the warning: once the box is open, it can't be closed. Once a model has trained on your data, there's no clean way to reach in and take your part back out. It's baked in.\n", "\n", "**Labor.** AI changes whose work has value — and not only by replacing jobs. There's a hidden workforce behind the magic: thousands of low-paid people who label the training data and filter the worst content, so the system can seem effortless. The \"automatic\" system runs on human hands you never see." ] }, { "cell_type": "markdown", "id": "0394b2b7", "metadata": {}, "source": [ "**Environment.** Training a large model runs thousands of processors for weeks, and that electricity has a carbon cost. The exact numbers are debated, but the *scale* is not in doubt. The chart below compares the estimated carbon emissions of training one large model against everyday high-carbon activities." ] }, { "cell_type": "code", "execution_count": 15, "id": "1ef92a09", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "image/png": { "height": 335, "width": 660 } }, "output_type": "display_data" } ], "source": [ "#| label: fig-carbon\n", "#| fig-alt: \"Bar chart of approximate CO2 emissions in metric tonnes, showing the hidden cost of a single model training run.\"\n", "import matplotlib.pyplot as plt\n", "\n", "activities = [\"One transatlantic\\nflight (per seat)\", \"A gas car\\n(one year)\",\n", " \"One US person\\n(one year, all)\", \"Training one\\nlarge AI model\"]\n", "tonnes = [1, 4.6, 15, 500]\n", "colors = [\"#2a78d6\", \"#2a78d6\", \"#2a78d6\", \"#eb6834\"]\n", "\n", "fig, ax = plt.subplots(figsize=(7, 3.6))\n", "bars = ax.barh(activities, tonnes, color=colors)\n", "ax.set_xlabel(\"Approximate CO₂ emissions (metric tonnes)\")\n", "ax.set_title(\"The hidden cost of one training run\", fontsize=12, loc=\"left\")\n", "for bar, val in zip(bars, tonnes):\n", " ax.text(bar.get_width() + 6, bar.get_y() + bar.get_height()/2,\n", " f\"~{val}\", va=\"center\", fontsize=10)\n", "ax.set_xlim(0, 560)\n", "ax.invert_yaxis()\n", "for s in [\"top\", \"right\"]:\n", " ax.spines[s].set_visible(False)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "745da764", "metadata": {}, "source": [ "**Reading it:** each blue bar is an everyday high-carbon activity; the orange bar is *one* training run for a large model (estimates vary, and newer efficient methods lower it — but the gap is the point). And that's a single run: real systems are trained many times over. The forge is enormous, and it runs out of sight." ] }, { "cell_type": "markdown", "id": "ce09e111", "metadata": {}, "source": [ "### Accountability: Who Answers?\n", "\n", "Which brings the audit to its final question, the one under all the others. When an AI system denies the right loan, jails the wrong person, or crashes the wrong car — **who is responsible?**\n", "\n", "- The engineers who built it? They'll say they only wrote general code; the data decided.\n", "- The company that deployed it? They'll say they trusted the vendor's model.\n", "- The data? Data can't be sued.\n", "- The user who followed its recommendation? They'll say the machine told them to.\n", "\n", "Everyone can point somewhere else. This is the **accountability gap**: powerful automated decisions with no clear person who answers for them. In the old story, Prometheus was punished for handing dangerous power to mortals. The modern question is harder — when the fire burns someone, there's often *no one* standing where Prometheus stood. Closing that gap isn't a technical problem you can code away. It's a human decision about who we *require* to answer. And now that you can open these machines, you're equipped to be part of making it." ] }, { "cell_type": "markdown", "id": "3ed8a31f", "metadata": {}, "source": [ "## ✏️ Capstone — Build It, Then Audit It\n", "\n", "This is the final build of the course, and it's the one that matters most for your project. You'll build one small AI feature — then do what almost no one does: **audit your own creation** the way Athena would.\n", "\n", "### Step 0 — Design & Build (prompt #1)\n", "\n", "Pick one small AI feature for an app — your own, or whatever you are considering for the optional final project:\n", "\n", "- a **classifier** — flags a message as urgent / not urgent\n", "- an **LLM feature** — summarizes text, suggests a reply, or recommends something\n", "- an **extended perceptron** — trained on your own labeled examples\n", "\n", "Turn it into a prompt for your AI assistant. A skeleton:\n", "\n", "> Help me build a small **[classifier / summarizer / recommender]** in Python.\n", "> It should take **[input]** and return **[output]**.\n", "> Keep it under 30 lines and explain each part.\n", "\n", "Build it in the cell below. Get the simplest version working before adding anything." ] }, { "cell_type": "code", "execution_count": 16, "id": "1e513a46", "metadata": {}, "outputs": [], "source": [ "#| eval: false\n", "# ✏️ Build your small AI feature here (with your assistant's help)." ] }, { "cell_type": "markdown", "id": "3fc27c25", "metadata": {}, "source": [ "### Step 1 — Test It Honestly\n", "\n", "Before trusting it, try to break it — the habit this whole course has drilled:\n", "\n", "1. Give it a normal input. Does it work?\n", "2. Give it a weird or empty input. Does it fail gracefully, or crash?\n", "3. Give it an input from a *different* group or style than your examples. Does the quality drop?\n", "\n", "Note what you find in a comment. Surprises here are the whole point." ] }, { "cell_type": "code", "execution_count": 17, "id": "cd2a595d", "metadata": {}, "outputs": [], "source": [ "#| eval: false\n", "# ✏️ Test your feature on normal, weird, and out-of-group inputs. Note what breaks." ] }, { "cell_type": "markdown", "id": "ab96a969", "metadata": {}, "source": [ "### Step 2 — Audit It (the Athena review)\n", "\n", "Now write a short **impact audit** of your own feature — the documentation professionals increasingly call a *model card*. Answer honestly, in the cell below:\n", "\n", "1. **What could it get wrong?** Name a realistic mistake and who it would affect.\n", "2. **Whose data would train it** at real scale — and did they consent?\n", "3. **Who is harmed if it fails**, and who is **accountable** — you, the user, the AI vendor?\n", "4. **Should it be built at all?** If yes, what safeguard would you require first?\n", "\n", "*AI is a fast first draft — and now you know why. You verify what it makes, and you answer for what you ship.*" ] }, { "cell_type": "markdown", "id": "6a32a85c", "metadata": {}, "source": [ "*(Write your four-point audit here — double-click to edit.)*\n", "\n", "1. **What could it get wrong:**\n", "2. **Whose data / consent:**\n", "3. **Harm & accountability:**\n", "4. **Should it be built:**" ] }, { "cell_type": "markdown", "id": "e9c886a7", "metadata": {}, "source": [ "## Key Terms\n", "\n", "- **Accountability gap** — The absence of a clear responsible party when an automated system causes harm.\n", "- **Algorithmic bias** — Systematic unfairness in a model's outputs, usually learned from biased training data.\n", "- **Feature** — One input variable a model uses to make a prediction (like income or debt).\n", "- **Inference** — Using a trained model to make a prediction on new input (as opposed to training it).\n", "- **Label** — The correct answer attached to an example in supervised learning.\n", "- **Large language model (LLM)** — A model trained to predict the next token, producing fluent text.\n", "- **Machine learning** — Building programs that learn rules from examples instead of being given the rules.\n", "- **Model** — The learned set of weights and rules a machine-learning system produces from data.\n", "- **Neural network** — Many perceptrons wired in layers, able to learn complex patterns.\n", "- **Next-token prediction** — The core operation of an LLM: repeatedly guessing the next piece of text.\n", "- **Perceptron** — The simplest artificial neuron: a weighted sum passed through a threshold, able to learn its weights.\n", "- **Proxy variable** — A feature that stands in for a sensitive one (like a zip code for race), letting bias slip back in.\n", "- **Supervised learning** — Learning from labeled examples to predict labels for new cases.\n", "- **Token** — A piece of text (word or word-part) that a language model treats as one unit.\n", "- **Tokenization** — Splitting text into tokens and mapping them to numbers a model can process.\n", "- **Training data** — The examples a model learns from; its quality and bias shape everything the model does.\n", "- **Unsupervised learning** — Finding structure (like groups) in data that has no labels.\n", "- **Weight** — A number saying how much one input counts toward a model's decision; learning means adjusting weights." ] }, { "cell_type": "markdown", "id": "73b20872", "metadata": {}, "source": [ "## Summary\n", "\n", "Machine learning flips programming around: instead of writing the rule, you show the machine examples and it learns the rule — supervised (with labeled answers) or unsupervised (finding structure alone). Underneath the biggest systems is the humble perceptron: weighted sum, threshold, and a nudge toward the right answer, stacked billions of times into a neural network. A language model is that mechanism trained to do one thing — predict the next token — which makes it a brilliant pattern-continuer and a poor truth-teller, and explains why you always verify it. Bias is the shadow of this power: a model is a mirror of its data, and hiding a sensitive variable only lets proxies smuggle it back. Behind the results sit real costs — privacy given without consent, hidden human labor, real carbon — and a hard question no code can answer: when an AI harms someone, who is accountable? You can open these machines now. That is exactly what it takes to hold them, and their makers, to account." ] }, { "cell_type": "markdown", "id": "f227f901", "metadata": {}, "source": [ "## What's Next\n", "\n", "This is the last notebook — but not the end of the work. Ahead, if you want it, is the **optional final project**: a Python program of your own design — a Colab notebook, a standalone script, or a small Flask web app — that ties together what you've built, from control flow and data structures to databases, security, and now a touch of AI. The full specification is posted to D2L. And beyond this course, you leave with something rarer than any one skill: you can look at the systems deciding more and more of the world and, instead of seeing an oracle, see a machine you're equipped to question. Go build carefully. Verify what you ship. And keep asking who answers when it fails." ] }, { "cell_type": "markdown", "id": "d26be0a5", "metadata": {}, "source": [ "*COMP 1150 — Computer Science Concepts · Brendan Shea, PhD*\n", "*Content licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).*" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.9" } }, "nbformat": 4, "nbformat_minor": 5 }