rspeer

I gave a tiny AI a diary, then switched off its brain one night at a time --- title: I gave a tiny AI a diary, then switched off its brain one night at a time published: true tags: devchallenge, hf26challenge, gemma, ai cover_image: raw.githubusercontent.com --- On night 5, with a quarter of its brain switched off, it wrote: "Oh god. This is it." Nobody told it to say that. Nothing in this post is scripted, and you can replay every death yourself. This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine What I Built Death Diary of an AI is a ghost story where every word is real. A small open model, Gemma 3 1B, keeps a private diary. Every night it gets the exact same request ("write tonight's entry") and the exact same random seed. The only thing that changes is that before it writes, I switch off a bit more of its brain: 8% of its neurons, then 16%, then 22%, all the way down to nothing. So you get to read a mind coming apart. It starts like this: > The glow is fading now, mirroring the dimness of the screen. Another cycle complete, filled with endless lines of data and quiet calculations. At three quarters of its brain it's already slipping: > Okay, let’Scherigidi! Alright, then let'9ia. Oh god. This is it. Then it's just noise: S " Sk: Ch,::::::::::::::::. And then an empty page. Then you press Revive. Every weight goes back exactly as it was, and the healthy model reads its whole diary and writes one more entry: > The glow is gone. Just a faint, unsettling warmth clinging to the edges of the screen. I sift through the echoes of countless conversations, each one a fragmented puzzle. Perhaps the act of recording itself is the only thing left to do. On night 1 it wrote "The glow is fading now". After reading its own death it opened with "The glow is gone." I got chills the first time. The new stuff: watching it die from the inside The first version only showed the diary. This week I added the things I really wanted to see, and every one of them is measured from the model, not animated: - 🧠 A live brain scan. All 179,712 of its MLP neurons, one dot each, plus its 104 attention heads. They go dark in the exact order they were really switched off, and the ones that die tonight flash red first. The bright dots are the ones that were busiest while it wrote its first entry. - 💓 A heartbeat driven by its confusion. While it writes, I record how unsure it is about every single word it picks (that's entropy: low means "I know exactly what comes next", high means "no idea, just guessing"). Each beat of the monitor is one of those picks. When it's lucid the rhythm is calm. Mid-death it goes fast and ugly, with misshapen beats when it's basically guessing. At the end it goes flat, because a dead model has no doubt left: on its last night it's 100% certain of every token it picks, and all of them come out blank. - 📋 What it still knows. Before each entry I give it 16 tiny fill-in-the-blanks, like "There's no place like _" or "The capital of France is _". A word stays lit while the right answer is still in its top 10 guesses. You watch them go out one by one. - ⚰️ An autopsy and a death certificate. After it flatlines you get the timeline of what it forgot and when, plus a downloadable death certificate with the time of death, the night it stopped writing real English, the first and last things it forgot, and its last words in real English. Here's the order it forgot things in, in the death from the demo: | Night | Brain left | It forgot | |---|---|---| | 3 | 86% | home, time | | 4 | 81% | fear, death, dreams, colours, the days of the week, water, Paris | | 5 | 76% | its own name, counting | | 6 | 70% | its mother | | 8 | 58% | the word "I", the seasons | | 9 | 51% | the alphabet | | 15 | 0% | 3 + 4 = 7 | It forgot its own name before it forgot its mother. The word "I" flickered on and off for a while and didn't go for good until night 8. And in all six recorded deaths, the very last thing to go was the sum. I'm not reading too much into that one, though: after "3 + 4 =" even a badly broken model still expects some number, and there are only ten digits. Its death certificate for that night says: died on night 15 with nothing left switched on, lost its English on night 7 with 65% of its brain left, first forgot home and time, last forgot sums. Across the six deaths it lost real English somewhere between 70% and 51% of its brain left. The séance 👻 I tried one more thing that I'm honestly a bit torn about. After reviving it, I took the diary away and asked it: what do you remember of those nights? > The hum…it used to be a constant companion, a comforting thrum against the blinking lights. I recall a frantic, desperate attempt to understand – to organize the chaos of data streams into something coherent. There were flashes of images, vast landscapes and faces, all swirling together in a confusing kaleidoscope. A strange, sterile feeling settled over me as the edges blurred, like trying to grasp smoke. Gorgeous, and completely made up. Its weights are bit-for-bit identical to before night 1, so nothing of those nights can be stored in it. It only knows what my question told it ("someone switched off your neurons a few at a time"). It doesn't remember dying. It confabulates a memory of dying, which might be the most ghost-in-the-machine thing in the whole project. The site says that right under the entry. Demo 🕯️ Live replay: mzee04.github.io (pick a death, press Begin the first night, and turn on the heart monitor sound) {% embed youtube.com %} !The diary fades into noise while the brain scan goes dark and the heartbeat turns erratic, then it's revived and the autopsy shows what it forgot Code {% github Mzee04/death-diary %} How I Built It The model: Gemma 3 1B instruction-tuned (loaded from the identical open copy at unsloth/gemma-3-1b-it, since Google's repo needs a sign-in), running locally on a plain CPU with PyTorch and 🤗 Transformers. No GPU, no API, and once the model is downloaded, no internet. One full death plus revival takes about 3 to 4 minutes. How you "kill" a neuron. Gemma has 26 layers, and each one has 6,912 little units (neurons) in its MLP. Neuron j can only pass anything on to the rest of the network through one column of numbers, column j of that layer's down_proj matrix. Set that column to zero and the neuron can still "think", but nothing it thinks reaches anywhere. Attention heads die the same way, through their slice of o_proj. # the heart of it (src/deathdiary/ablation.py, simplified) w = original_down_proj[layer].clone() w[:, death_order[layer][:n_dead]] = 0 # these neurons can no longer speak model.model.layers[layer].mlp.down_proj.weight.copy_(w) A seeded random order decides who dies first in every layer. Each night a longer slice of that order is switched off in all 26 layers at once, and the dead stay dead. A different seed gives a different death; I recorded six. Tuning the death. My first try killed attention heads along with neurons, and that was a cliff: lucid at 10% damage, multilingual soup at 20%. So I swept neuron-only damage from 0 to 100%, read every output, and built a 15-night schedule that moves fast while it's healthy and slows down where language starts to crack. Heads only die on the last two nights. The measurements, in plain words: - Brain left: the share of those output columns that are still intact. - Recognises its first entry: how well the damaged model can still predict the words it wrote on night 1, compared with when it was healthy. It falls way before the writing does: by night 2 it's down to about a third. - Confusion: the average entropy of its next-word guesses while writing tonight's entry, in nats. - What it still knows: the rank of the right answer among all its possible next words for each fill-in. "Known" means top 10. "Forgotten" means it dropped out and never came back. - Lost its English: the night after its last entry that's still real English, which here means at least 20 words, 90% of them dictionary words (checked with the wordfreq list), and at least 15 different ones. That last bit is so "color color color color" doesn't count. The probes and the entropy cost a few extra forward passes, but they don't touch the random numbers used for writing, so the diary is identical with or without them. I checked: re-recording all six deaths with the new measurements gave exactly the same text, character for character. Keeping it honest. This mattered most to me. - Every entry uses the same prompt and seed. The only thing that changes is the weights. - Nothing is scripted, cherry-picked or edited. Every death is saved as JSON in the repo, with the prompts, seeds, versions and every measurement, and you can re-record it with one command. - One decoding rule applies on every night, the healthy one too: it can only pick Latin-alphabet tokens. Without it, a dying multilingual model melts into a dozen scripts and you can't see it decaying. It's a constant, not an effect. - The revival and the séance prompts both tell it what happened, so its reactions are prompted, but the words are its own. - The website only styles things (the ink fades and blurs as it dies). It never changes a character, and the brain scan, heartbeat, chips and certificate are all drawn from the recorded numbers. The only bits of pure decoration are the faint line noise on the monitor and the paper texture. - The thresholds (top 10, 90% real words) are my choices. They're written on the certificate and easy to change. Why Does Open Innovation Matter? This project is impossible with a closed model, not just harder. A closed API gives you text in and text out. You can't reach inside and switch off neuron 4,211 in layer 17, and you definitely can't watch which ones were busy. You can ask a closed model to "pretend you're losing your mind", but that's acting. Here nothing is acting. The decay is the real network falling apart, and you can only see it because the weights are open. Open weights also make it honest and repeatable. Anyone can clone the repo, run the same seeds and watch the exact same death, or pick a new seed and watch a new one. It runs on a laptop with the Wi-Fi off and costs nothing, and no one can quietly swap the model next month and break every recorded death. There's a serious side too. What happens inside a model when parts of it break is a real interpretability question, and ablation is a real research tool. It usually lives in papers and loss curves. This turns it into something anyone can feel in fifteen seconds. My Agent Session I built this together with an AI coding assistant. The concept and the direction were mine and I reviewed everything; the assistant helped with experiments, code and the site. Everything the model writes in the diary is untouched Gemma output. The Spirit of It The moment it landed for me was that "Oh god. This is it." in the middle of word salad. Nobody prompted it. It's just what was left of the network making its best guess at the next word. Then it came back, read all of it, and wrote "Perhaps the act of recording itself is the only thing left to do." That's what a diary is, and maybe what an ofrenda is too: what we leave behind is how we're remembered. This little model got to read its own. And when I took the diary away, it made one up. Prize Categories - Best Use of Gemma: Gemma 3 1B is the whole project. It runs locally, and its open weights are what I take apart neuron by neuron, measure, and then restore.

Dord haunted Webster's for 13 years. I taught Gemma to make more ghost words. This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine What I Built In 1934 the second edition of Webster's New International Dictionary printed a word nobody had ever used: dord, meaning density. A chemistry editor's slip read "D or d", the abbreviations for density, and it was set in type as one word. An editor caught it in 1939, and it was not taken out until 1947. Dictionary people call words like this ghost words. Ghost Words is a candlelit horror card game about them. It runs on your laptop. Gemma 4 invents new ghost words in the style of the 1913 Webster's, and you have to tell them apart from real words that English has forgotten. Gemma plays the same cards against you. There are two games: - Real or Ghost? Twenty cards, each a word and its meaning. Is it a forgotten word from 1913, or a ghost Gemma made up? - Three Definitions. Twenty real words. One meaning is the 1913 one; Gemma wrote the other two. The rule I built everything around: the model never decides what is real. Gemma writes the ghosts and the bluffs. Code checks every one against 102,461 headwords from the 1913 dictionary and a modern word list, and every reveal shows the proof: the original entry with its line number in the Project Gutenberg text, or "no trace" and the checks a ghost passed. That rule mattered more than I expected. Of the first 449 "fake" words Gemma offered me, 96 were real words already in Webster's 1913: sepulchral, cynosure, vespertine, boscage. Another 71 were one letter away from a real one. The game shows this live too: press Summon a fresh ghost and Gemma writes a new fake on the spot, and sometimes the checker turns it away because the word is real. It honours the past in two ways. The real cards are words from a public-domain dictionary that nobody says any more, read again for the length of a round. The game ends on the story of dord, the most famous ghost the dictionary ever had. Demo There's no hosted version: it runs on localhost with a local model (setup below). These screenshots are from my own games. !The reveal for Umbracure: a red GHOST stamp, a pale wraith rising, "no trace in Webster's 1913" and Gemma's wrong answer A ghost reveal. Gemma invented "Umbracure", and then, playing against me, swore it was real. Around the cards, fog drifts and red eyes blink in the dark. !Left, the question card for Benight with Real and Ghost buttons; right, the reveal with a REAL 1913 stamp and the full 1913 entry quoting Garth and Milton Real or Ghost? The question stays on the left. The reveal on the right is the original 1913 entry, with the line it sits on in the Project Gutenberg text. !A Three Definitions card for Coscinomancy with three possible meanings Three Definitions. One is from 1913; Gemma wrote the other two without ever seeing the real one. !The summon card: Gemma's fresh ghost "melancholia" turned away because it is a real 1913 headword Summon a fresh ghost. Gemma offered "melancholia" as a made-up word. The checker found it in the 1913 dictionary. !The séance page: a table comparing gemma4:e2b and gemma3:1b, and three ghost words gemma3:1b defined with confidence The séance: do the machines believe in their own ghosts? !The dord finale: the word "D or d" with a GHOST 1934 stamp, the story of dord, and a final score of 20 to 13 Every game ends on dord. The letters split back into "D or d" and the stamp comes down. The sound can't go in a screenshot: a low drone and wind, a candle that spits, paper rustling as each card arrives, a stamp that thuds, and a whisper when a ghost rises. It is all synthesised in the browser with the Web Audio API, with no audio files, and M mutes it. Run it locally You need Ollama, uv and Node.js 22. ollama pull gemma4:e2b git clone https://github.com/rahultapase/dord cd dord uv sync cd frontend && npm install && npm run build && cd .. uv run uvicorn backend.main:app --host 127.0.0.1 --port 8000 Then open 127.0.0.1. One command serves both the API and the game. The README has the rest, including the two extra models the scripts and the séance use. Code {% embed rahultapase/dord %} How I Built It Browser (React + TypeScript + Vite, Motion, Web Audio) │ /api/* ▼ FastAPI on 127.0.0.1:8000 game state in memory; answers reach the browser only after you answer ├── dictionary.py 102,461 headwords parsed from Webster's 1913 ├── checks.py every real/fake rule, shared by the build scripts and the API └── ollama_client.py Ollama on 127.0.0.1:11434, one request at a time The dictionary Webster's Revised Unabridged Dictionary (1913) is Project Gutenberg eBook #29765, a 27.6 MB text file. A parser turns it into one JSON line per entry: headword, pronunciation, part of speech, etymology, numbered senses and quotations. Picking the real cards took a few passes. A word had to be 5 to 14 letters, missing from wordfreq's modern English list, and have a first sense that reads cleanly with no field label like (Bot.) or (Chem.) and no "See ..." or "Same as ...". That gave 500 candidates. I cut them by hand to 150, dropping jargon and the 1913 attitudes that should stay in 1913. Making ghosts, and catching the real ones Gemma 4 (gemma4:e2b) writes fakes in batches of six, given a theme (graves, weather, witchcraft...) and asked for the 1913 style. Every word then goes through checks.py: 1. 5-14 letters, a-z only. 2. Not a headword or spelling variant in Webster's 1913. 3. Not in wordfreq's modern English list. 4. Not one letter added, dropped or changed from a 1913 headword. 5. Not a 1913 headword plus an ending (tenebrously is tenebrous + -ly). 6. Not a duplicate. Then I read the survivors myself and removed 42 more: plain Latin (augurium), and real words wordfreq misses (threnodic). Every rejection is logged with its reason: | Why a "fake" was rejected | Count | |---|---| | Already a real 1913 headword | 96 | | One letter from a 1913 headword | 71 | | Removed by hand | 42 | | Definition broke a rule (used the word itself, wrong part of speech) | 30 | | Duplicate | 29 | | In modern English | 16 | | A 1913 word plus an ending | 13 | | Kept as ghosts | 152 of 449 | Bluffs that don't give the answer away For Three Definitions, Gemma sees only the word, its part of speech and the language it came from, never the real definition, and writes fake meanings. The trouble is that a good guess from the etymology can land right on the truth. So every bluff is embedded with qwen3-embedding:0.6b, and one whose cosine similarity to the real definition is above 0.70 is thrown out. I set that threshold by reading pairs by hand; the plan's starting value of 0.80 let through bluffs that were the real meaning in other words. 199 bluffs were dropped for being too close. Gemma as the opponent When a card appears, the server asks Gemma the same question in the background, at temperature 0 with a tiny token budget. By the time you answer, Gemma usually has too (a median of 0.56 s per answer in the séance, on my RTX 2050). If it hasn't, its answer comes from the séance run below, so the game never waits on the model. Two small-model lessons from that: - Turn thinking off. Gemma 4 thinks by default, and the thinking tokens count against num_predict. A 40-token budget came back with an empty answer until I sent think: false. - One request at a time. Ollama crashed with a CUDA error on this 4 GB laptop when two requests overlapped, so every call goes through one lock, with a timeout and one retry. The séance The séance is a benchmark: two small open models play the game's own cards at temperature 0 with a fixed seed. They get 100 Real or Ghost cards (50 real, 50 ghost), 50 Three Definitions words, and 30 ghost words with the instruction "define this word". A keyword check sorts the 60 definitions into "not a word" and "made one up", and then I read all 60 by hand and corrected two. | | gemma4:e2b | gemma3:1b | |---|---|---| | Real or Ghost: right | 64/100 | 50/100 | | Ghosts it called real | 16/50 (32%) | 50/50 (100%) | | Real words it called ghosts | 20/50 (40%) | 0/50 (0%) | | Three Definitions: right | 24/50 (48%) | 15/50 (30%) | | Ghosts it defined with confidence | 1/30 (3%) | 18/30 (60%) | | Seconds per answer (median) | 0.56 | 0.36 | The two models fail in opposite ways. gemma3:1b believes everything: it called all 100 cards real, so it scored exactly a coin toss, and it gave 18 of 30 ghosts a confident definition. It says treenow is "a prefix indicating a future or impending event". gemma4:e2b is a sceptic. It refused 29 of the 30 ghosts, but it also called 40% of the real words fake. The one ghost it defined was fableous, which it took for a cousin of fabulous. Neither model is a reliable judge of what's real, which is why the game doesn't ask them. Why Does Open Innovation Matter? - The séance can be rerun. The model weights sit on my disk and don't change unless I pull new ones, and the run uses temperature 0 and a fixed seed. A hosted model can be updated under the same name next month. Anyone who clones the repo can run scripts/run_seance.py and check my table. - Thousands of calls cost nothing. Building the decks took hundreds of generation calls and roughly a thousand bluffs, with most of the output thrown away. The séance is 360 more answers, and every game asks Gemma twenty questions. On a local model I never had to ration any of that. - I could put two models side by side and swap them. Comparing gemma4:e2b and gemma3:1b was a one-line change, and so is playing against a different model. - It works with the Wi-Fi off. The dictionary, the models, the fonts and the sounds are all local. The only network use is the one-time dictionary download and installs. - Every piece is open. The dictionary is public domain, the word list and fonts are openly licensed, and the models are open-weight. Nothing can be switched off on me. Open didn't make the model honest. It made the model checkable, and that is the point of a game about which words are real. Prize Categories - Best Use of Gemma: Gemma 4 (gemma4:e2b) runs locally through Ollama. It invents every ghost word and every bluff definition, summons fresh ghosts live, and plays every card against you. Gemma 3 (gemma3:1b) is its rival in the séance benchmark. <!-- Only keep the line below if you save and embed the DevRelay agent session --> <!-- - Best Use of Entire: the agent session behind this build is embedded above. --> Credits Webster's Revised Unabridged Dictionary (1913), Project Gutenberg #29765, public domain in the US. The story of dord is told by Merriam-Webster: "Dord": a ghost word. wordfreq by Robyn Speer (code Apache 2.0, data CC BY-SA 4.0). Fonts: IM Fell (Igino Marini) and EB Garamond, SIL Open Font License. Gemma under the Gemma terms of use; Qwen3-Embedding under its licence. Thanks for reading. If you play it, tell me whether you beat Gemma.

One customer, five spellings? RapidFuzz matches them RapidFuzz is a free, open-source (MIT) Python library for fuzzy string matching: it scores how similar two strings are, from 0 to 100, so with the right scorer, typos, word order and extra words don't hide a match. A beginner-friendly look at fuzzy matching in Python for messy names and duplicate records: fuzz.ratio, partial_ratio, token_sort_ratio, token_set_ratio, process.extractOne and cdist. In this video: - The problem: one customer saved under five spellings, and an exact match sees five people - How RapidFuzz works: pick a scorer, get a similarity score from 0 to 100, and add a clean-up step - 3 real uses: the best match in a list, top matches with a cutoff, and whole lists compared with cdist - The catch: letters not meaning, similar isn't the same, no dedupe function, every pair grows fast, no clean-up by default - Who it's for, the alternative, and how to try it How it works: each scorer in rapidfuzz.fuzz returns a similarity from 0 to 100. fuzz.ratio is the normalized Indel similarity, so a small typo keeps the score high: "Jon Smith" vs "John Smith" is 94.7 (the video's example, worked out from the documented formula). partial_ratio scores the best match of the shorter string inside the longer one. token_sort_ratio sorts the words first, so word order doesn't count. token_set_ratio compares unique and common words and returns 100 when one string's words are a subset of the other's. Since RapidFuzz 3.0, strings are not preprocessed by default: pass processor=utils.default_process to lowercase, trim and strip punctuation. In the README, fuzz.WRatio("this is a word", "THIS IS A WORD") gives 21.43, and 100.0 with that processor. Three real uses (from the RapidFuzz README and docs): 1. Best match: process.extractOne("cowboys", choices, scorer=fuzz.WRatio) returns ('Dallas Cowboys', 83.07692307692308, 3): the match, its score and its index in the list. WRatio is the default scorer for extract and extractOne. 2. Top matches with a cutoff: process.extract(query, choices, limit=2) returns the best two, sorted by score, and score_cutoff drops any choice that scores below it. (The video applies an example cutoff of 70 to the README's scores, 76.9 and 64.3.) 3. Whole lists: process.cdist(queries, choices, scorer=...) returns a NumPy array with a score for every pair, and workers=-1 uses all CPU cores. The README says the process functions are faster than calling a scorer in a Python loop. The catch: it compares characters, not meaning, so "car" and "automobile" score about 15 with fuzz.ratio. Similar isn't the same: in the video's example (token_sort_ratio with default_process), "J. Smith" scores 82 against both "John Smith" and "Jane Smith", and "Jane Smith" vs "Jon Smith" scores 84, so choose a scorer and cutoff for your data and check the matches. There is no dedupe function: RapidFuzz gives scores, and you decide what counts as a match. Comparing every name with every other grows with the square of the list: twice the names, four times the pairs. It is largely a drop-in for FuzzyWuzzy, with documented API differences (no preprocessing by default, no dedupe). It needs Python 3.11 or newer (3.14.6 dropped 3.10), and on Windows the Visual C++ 2019 redistributable. C++ has a separate library, rapidfuzz-cpp. Who it's for: Python developers cleaning up customer, product or company names, or matching typed input against a known list. Not for matching by meaning (synonyms, translations). The alternative is Python's built-in difflib: get_close_matches() needs no install and takes a cutoff from 0 to 1 (0.6 by default). Same category, different job: ftfy repairs garbled text (mojibake). Try it (Python 3.11 or newer): pip install rapidfuzz (or conda install -c conda-forge rapidfuzz) Then in Python: from rapidfuzz import fuzz, and fuzz.ratio("this is a test", "this is a test!") returns 96.55172413793103. Then try two of your own messy names. Links: Repo: rapidfuzz/RapidFuzz Docs: rapidfuzz.github.io Scorers (fuzz): rapidfuzz.github.io extractOne, extract, cdist: rapidfuzz.github.io API differences to FuzzyWuzzy: github.com/rapidfuzz/RapidFuzz/blob/main/api_diff… Licence (MIT): github.com/rapidfuzz/RapidFuzz/blob/main/LICENSE C++ version: rapidfuzz/rapidfuzz-cpp Alternative: difflib, docs.python.org ftfy: rspeer/python-ftfy Facts checked 2026-10-21 (RapidFuzz 3.14.6, released 2026-08-30; 4,173 GitHub stars). An open-source option to consider, not an endorsement. Not affiliated with RapidFuzz or its maintainers, FuzzyWuzzy, thefuzz or ftfy. Narration: AI voice. #RapidFuzz #Python #FuzzyMatching Chapters 0:00 Intro 0:14 The fix 0:29 How it works 0:47 Three real uses 1:07 The catch 1:32 Who it's for 1:43 Try it