Tip
\nWant to run this code yourself? All the examples from this post (perceptron, RNN, LSTM) are in a ready-made Jupyter notebook: from-neurons-to-memory.ipynb
\nIn the previous post we walked the whole path from cutting text into tokens, through counting words (TF-IDF), Markov chains, all the way to Word2Vec and meaning vectors. And at the end one fundamental question came up...
\nWe have word vectors. Great. But how do we build something out of them that understands a sentence? Or a whole paragraph? Or a book?
\nBecause "Dog bites man" isn't simply "dog" + "bites" + "man". It's a sequence - words follow each other in a specific order, and that order changes the meaning. "Dog bites man" and "Man bites dog" are the same words, but completely different stories :D
\nAnd Word2Vec? Word2Vec looks at words individually. It has no concept of order. It doesn't know that "not" before "like" changes everything.
\nSo we need something that can process sequences. Something that reads text in order and builds understanding step by step.
\nAnd here begins a fascinating story - because the solution to this problem didn't appear overnight. It was an evolution that lasted several decades. From a single, simple neuron, to complicated memory cells. And each generation solved the previous generation's problem, but created a new one.
\nThis is the fourth post in the "Understanding LLM" series. Today we go deeper into the architecture of neural networks - but relax, still without formulas you can't understand ;-) Instead, there will be plenty of metaphors, diagrams, and real-life examples.
\n\nThe narrative of today's post: "From a single cell to memory - and why that still wasn't enough." Let's start from the basics.
\nBefore we get into architectures, let's quickly settle one question you're probably asking yourselves: why is it even called a "neural network"? What does it have to do with the brain?
\nAnswer: both a lot, and a little ;-) In the beginning there was inspiration from biology. Take a look:
\n\n\nFirst diagram - a real neuron. It has dendrites (receive signals from other neurons), a soma (the cell body - decides whether to "fire"), and an axon (passes the signal on).
\nSecond diagram - an artificial neuron. It has inputs (numbers), a weighted sum (multiplies each input by its "importance" and adds it all up), and an output (the result passed through an activation function).
\nThe resemblance is... loose. A biological neuron is unimaginably more complicated. But the inspiration was important - Warren McCulloch and Walter Pitts showed in 1943 that such a simplified model of a neuron can perform basic logical operations (AND, OR, NOT). And that meant a network of such neurons could theoretically compute anything.
\nNote
\nDoes an LLM "think" like a brain? No. An artificial neuron is a mathematical abstraction, not a biological model. A biological neuron uses electrical impulses, neurotransmitters, has thousands of connections and a dynamics that can't be reduced to w₁x₁ + w₂x₂. But the inspiration was the starting point - and an important one.
OK, that's enough biology. Let's move on to what came out of it ;-)
\nIn 1958 Frank Rosenblatt created the perceptron - the first algorithm that could learn from data. It was a milestone.
\nThe perceptron works trivially simply. Imagine you're deciding whether to go for a walk:
\n\nThe mechanics are simple:
\nExample:
\n| Situation | \nSun (+5) | \nRain (-8) | \nTemp >20° (+3) | \nSum | \nDecision | \n
|---|---|---|---|---|---|
| Sunny, warm, no rain | \n1 | \n0 | \n1 | \n5 + 0 + 3 = 8 | \n✅ Going out | \n
| Raining, cold | \n0 | \n1 | \n0 | \n0 - 8 + 0 = -8 | \n❌ Staying home | \n
| Cloudy and raining, but warm | \n0 | \n1 | \n1 | \n0 - 8 + 3 = -5 | \n❌ Staying home | \n
And - most importantly - the perceptron can learn these weights. You show it 100 examples of "went out / didn't go out" and it gradually adjusts the weights so that its decisions match yours.
\nBrilliant in its simplicity, right?
\nA perceptron can draw a single straight line dividing data into two groups. Which is great if the data can be split that way:
\n⚫ ⚫ ⚫ │ ⚪ ⚪ ⚪\n⚫ ⚫ ⚫ │ ⚪ ⚪ ⚪\n ↑\n one line separates them ✅\nBut what if the data looks like this?
\n⚪ ⚫\n\n⚫ ⚪\nThat's the famous XOR problem (exclusive OR). The output is "true" only when exactly one input is true - not both and not neither. And you can't draw a single straight line that would separate them.
\nThis problem halted the development of neural networks for almost 20 years. Seriously. Researchers said: "well OK, the perceptron is cool, but if it can't handle something as simple as XOR, what's the point?" This period is called the "AI Winter".
\nWarning
\nWhy was XOR so important? Because it showed that a single perceptron is limited to linearly separable problems. And the real world is rarely linear. Language definitely isn't.
\nAnd then someone said: what if we combine several perceptrons together?
\nA Multilayer Perceptron (MLP) is a network made up of many layers of neurons. Instead of one decision layer, we have:
\n\nEvery neuron in one layer is connected to every neuron in the next layer (that's why it's called "fully connected" or "dense").
\nThe metaphor that fits best for me:
\nImagine a company. Analysts (layer 1) look at raw data and pick out simple patterns. Managers (layer 2) combine those patterns into something more meaningful. The director (the output layer) makes the final decision. None of these people understands the full picture alone - but together they form a cascade of abstraction.
\nAnd that's exactly what solves the XOR problem! The first layer draws two lines. The second layer combines them into one region. Suddenly a non-linear problem becomes solvable.
\nAdding hidden layers by itself does nothing. Why?
\nBecause if each layer just does sum = weights × inputs + bias, then two layers of that operation are still... one big linear operation. Let me show with numbers:
Layer 1: y = 2·x + 1\nLayer 2: z = 3·y + 2
Substitute the first into the second:
\nz = 3·(2·x + 1) + 2\nz = 6·x + 3 + 2\nz = 6·x + 5 ← one operation, just with different numbers\nThe two layers collapsed into one. Instead of two transformations, you get one - just with different coefficients. It's like using one coffee filter twice as thick instead of two. Same effect.
\nSo we need something non-linear between the layers. And that's where...
\nAn activation function is a kind of "non-standard processing plant" that we pass the sum through. The most popular today is ReLU (Rectified Linear Unit):
\ndef relu (x ):\n if x > 0 :\n return x \n else :\n return 0 That's it. If the value is positive - keep it. If negative - zero it out.
\nSounds trivial? It is trivial. But this one simple operation breaks linearity.
\nBack to our numbers example. Without ReLU, two layers collapsed into one (z = 6·x + 5). But now let's insert ReLU between them:
Layer 1: y = ReLU(2·x + 1)\nLayer 2: z = ReLU(3·y + 2)\nLet's check for three values of x:
| x | \n2·x + 1 | \ny (after ReLU) | \n3·y + 2 | \nafter ReLU | \nWithout ReLU (6·x + 5) | \n
|---|---|---|---|---|---|
| -2 | \n-3 | \n0 ⬅ zeroed out! | \n2 | \n2 | \n-7 | \n
| 0 | \n1 | \n1 | \n5 | \n5 | \n5 | \n
| 1 | \n3 | \n3 | \n11 | \n11 | \n11 | \n
Without ReLU the result changes linearly (-7, 5, 11 - constant increase). With ReLU, suddenly for x = -2 we get 2 instead of -7. This relationship is no longer a straight line. Zeroing out negative values is something that can't be expressed as a·x + b - and that's exactly why layers stop collapsing into one.
Analogy: imagine window blinds. Linearity is a transparent pane of glass - it lets everything through, slightly dimmed. ReLU is blinds that completely block light below a certain angle. You can't simulate "complete blocking" by "dimming the glass more". It's a qualitatively different operation.
\nThanks to ReLU, each layer does something different from the previous one. And suddenly a network with many layers becomes powerful - it can model non-linear, complicated relationships in data.
\nImportant
\nReLU in a nutshell: Without a (non-linear) activation function between layers, a network with 100 layers is just as expressive as a network with 1 layer. ReLU (and its cousins: sigmoid, tanh, GELU) is the ingredient that makes depth make sense.
\nOther popular activation functions:
\n| Function | \nFormula (simplified) | \nRange | \nWhere it's used | \n
|---|---|---|---|
| ReLU | \nmax(0, x) | \n[0, +∞) | \nHidden layers (standard) | \n
| Sigmoid | \n1 / (1 + e⁻ˣ) | \n(0, 1) | \nLSTM gates, binary output | \n
| Tanh | \n(eˣ - e⁻ˣ) / (eˣ + e⁻ˣ) | \n(-1, 1) | \nLSTM gates, hidden states | \n
| Softmax | \neˣⁱ / Σeˣʲ | \n(0, 1), sum = 1 | \nOutput layer (classification) | \n
Tip
\nAn experiment for you: Open Python and run this:
\nimport numpy as np \n\ndef relu (x ):\n return np .maximum (0 , x )\n\nx = np .array ([- 3 , - 1 , 0 , 2 , 5 ])\nprint (f"Input: { x } " )\nprint (f"After ReLU: { relu ( x ) } " )You'll see how ReLU "cuts off" everything below zero. This simple operation lets the network "choose" which features are active and which to ignore.
\nOK, we have an MLP. It can model non-linear relationships. Great. But there's one fundamental problem that blocks us from using an MLP for language.
\nAn MLP sees all features at once. It has no concept of order.
\nTake a classic English example. Two sentences with exactly the same words, but in a different order:
\n| Sentence | \ndog | \nbites | \nman | \n
|---|---|---|---|
| "Dog bites man" | \n1 | \n1 | \n1 | \n
| "Man bites dog" | \n1 | \n1 | \n1 | \n
Identical vector. And the meaning? The first is a boring news item. The second is a newspaper sensation :D
\nFor an MLP both sentences are exactly the same - because the MLP gets the same vector and has no concept of order.
\nNote
\nWhat about Polish? Polish is tricky here - due to inflection (7 cases!) we rarely have two sentences with exactly the same word forms. "Pies gryzie człowieka" vs "Człowiek gryzie psa" are different forms (pies→psa, człowieka→człowiek). But English, with minimal inflection, shows this problem perfectly. And that's exactly why bag-of-words examples often use English ;-)
\nThis is the permutation problem - an MLP can't distinguish [A, B, C] from [C, B, A]. And in language, order is everything. "I do not like" vs "I like not" - same words, completely different meaning.
You might think: "OK, then let's add word position as a feature." But that doesn't solve the problem - the MLP still doesn't understand that the word at position 1 has a relationship with the word at position 5. Each position is just another number on the input.
\nSo we need something that processes data step by step, in order, and builds understanding sequentially. Just like we read a book - sentence by sentence, word by word.
\nAnd here enters the RNN.
\nA Recurrent Neural Network (RNN) is a network that has something an MLP doesn't: memory. Well... sort of ;-)
\nImagine you're reading a book. You don't read the whole page at once (like an MLP would). You read word by word, sentence by sentence. And with each new word you update your understanding of what's going on.
\nThat's exactly what an RNN does. It has a hidden state - that's its "understanding of the text so far". With each new word:
\nThis diagram is exactly the unrolling in time. In reality it's the same RNN neuron - but we "unwrap" it in time to show how it processes consecutive words. Notice: the arrow goes from left to right - information flows sequentially.
\nThis is brilliant in its simplicity. The RNN "reads" text just like we do - one by one, building understanding step by step.
\nTo really feel this, let's write the simplest possible RNN. No PyTorch, no TensorFlow - just NumPy:
\nimport numpy as np \n\ndef simple_rnn (word_vectors , hidden_size = 4 ):\n words , dim = word_vectors .shape \n np .random .seed (42 )\n \n W_h = np .random .randn (hidden_size , hidden_size ) * 0.01 \n W_x = np .random .randn (hidden_size , dim ) * 0.01 \n bias = np .zeros (hidden_size )\n \n h = np .zeros (hidden_size )\n \n for t , word in enumerate (word_vectors ):\n h = np .tanh (W_h @ h + W_x @ word + bias )\n print (f" Step { t + 1 } : hidden state = { np . round ( h , 2 ) } " )\n \n return h \n\nthe = np .array ([1.0 , 0.0 ])\ncat = np .array ([0.0 , 1.0 ])\nsits = np .array ([0.3 , 0.3 ])\non_mat = np .array ([0.8 , 0.2 ])\n\nsentence = np .array ([the , cat , sits , on_mat ])\nprint ("Processing: 'The cat sits on the mat'" )\nfinal = simple_rnn (sentence )\nprint (f"\\nFinal hidden state: { np . round ( final , 2 ) } " )Run it! You'll see how with each word the hidden state changes. The last hidden state is the "understanding" of the whole sentence by our simple RNN.
Tip
\nKey intuition: Notice the line h = np.tanh(W_h @ h + W_x @ word + bias). That's the heart of the RNN.
Two parts of this line:
\nW_h @ h + W_x @ word + bias - this is the same "weighted sum" as in the perceptron and MLP. Except now it sums two sources: the previous hidden state (h) and the new word (word).tanh(...) - that's the activation function, exactly the same family as ReLU from the previous section. Instead of "cutting off below zero", tanh squeezes everything into the range (-1, 1). But the goal is the same: break linearity.The new hidden state depends on two things: the previous hidden state (h) and the new word (word). That's exactly what we do when reading text - we combine what we already know with what we just read.
And here we get to the topic that changed everything.
\nThe RNN has memory, yes. But it's a goldfish memory.
\nImagine this sentence:
\n\n\n"This is Jan and he's 30 years old. He likes hiking in the mountains, programming in Python, and playing the guitar. His favorite color is green. He once wanted to become an astronaut, but then he discovered that (...) [here 50 words about various things] (...) and that's why ___ went to music school."
\n
What should "___" be? Jan. But to know that, the RNN has to remember the name from the beginning of the sentence. And here's the problem: after 50+ words, the signal from the first word is so diluted that the RNN practically doesn't remember it.
\nThis is the famous vanishing gradient problem.
\nMetaphor: Chinese whispers. You play Chinese whispers - the first person whispers a message to the second, that one to the third, and so on. After 10 people the message is a bit distorted. After 50 people - completely unreadable. After 100 people - someone says "buy milk", and the last person hears "grab bread".
\nIn an RNN the gradient (the learning signal) flows through the network exactly the same way - step by step. At each step it gets multiplied by some weights. If those weights are smaller than 1, then after many multiplications the gradient vanishes to zero. The network stops learning from distant words.
\nAnd sometimes it's the other way - the weights are bigger than 1 and the gradient grows exponentially (exploding gradient). The network "goes crazy" and values shoot into space.
\n\nWarning
\nWhy is this so important? Because language is full of long dependencies. "The cat, which already ate all the fish in the fridge and then slept on the couch for three hours, was happy." - to connect "cat" with "was happy", the model has to jump over a dozen words. An RNN can't do that.
\nAnd then in 1997 Sepp Hochreiter and Jürgen Schmidhuber said: what if we gave the network an explicit memory mechanism?
\nA Long Short-Term Memory (LSTM) is an RNN on steroids. Instead of one simple hidden state, the LSTM has a memory cell (cell state) and three gates that decide what to do with that memory.
\nThe metaphor that works best: an LSTM is a student with a notebook and three rules.
\nAt the beginning of each step the LSTM asks: "what from my current memory is already outdated and I can throw out?"
\nWhen you read a new chapter of a book, you don't need to remember what the characters had for breakfast three chapters ago. You forget irrelevant details to make room for new ones.
\nIn an LSTM: the forget gate passes each element of memory through a sigmoid (values 0-1). Close to 0 = "forget". Close to 1 = "keep".
\nThen the LSTM asks: "what from the new word is worth saving?"
\nWhen you read "My name is Jan" - you have a reflex: "OK, this is important, I have to remember it". You don't memorize every word literally, but you pick out what's relevant.
\nIn an LSTM: the input gate decides which new information to let through to the cell state.
\nFinally the LSTM asks: "what from my memory is relevant to what I'm doing right now?"
\nWhen someone asks you "What's the name of that character we just read about?" - you reach into the notebook and pull out the specific information. You don't show the whole notebook - only what's needed now.
\n\nThe key thing: the cell state is that "conveyor belt". Information on it can flow almost unchanged through many steps - the gates only decide what to let through, what to add, and what to remove. This solves the vanishing gradient problem, because the information doesn't have to be "multiplied" at every step - it can just flow.
\nNote
\nRNN vs LSTM in one sentence: An RNN tries to remember everything, but forgets quickly. An LSTM is selective - it decides what to keep, what to update, and what to show. That's the difference between "trying to memorize an entire lecture word for word" and "taking notes of the most important points".
\nIf you want to see the formulas, here they are (you don't have to memorize them, but it's worth seeing that it's not black magic):
\nForget gate:\n$$f_t = \\sigma(W_f \\cdot [h_{t-1}, x_t] + b_f)$$
\nInput gate:\n$$i_t = \\sigma(W_i \\cdot [h_{t-1}, x_t] + b_i)$$
\nCell state candidate:\n$$\\tilde{C}t = \\tanh(W_c \\cdot [h{t-1}, x_t] + b_c)$$
\nCell state update:\n$$C_t = f_t \\odot C_{t-1} + i_t \\odot \\tilde{C}_t$$
\nOutput gate:\n$$o_t = \\sigma(W_o \\cdot [h_{t-1}, x_t] + b_o)$$
\nHidden state:\n$$h_t = o_t \\odot \\tanh(C_t)$$
\nWhere $\\sigma$ is the sigmoid (squashes values into 0-1), $\\odot$ is element-wise multiplication, and $[h_{t-1}, x_t]$ is the concatenation of the previous hidden state with the new input.
\nTry it yourself. Fire up ChatGPT (or Claude, Gemini - whatever you have) and send this prompt:
\n\n\n"Pola had a rare ability to remember numbers. Her favorite number was 42. She also liked longboarding, watercolor painting, and playing chess. Her cat was named Whiskers. (...) [paste 3-4 paragraphs of any text here - a pancake recipe, a weather report, whatever] (...) Still, it was ___ who decided to enter the math competition."
\n
See whether the model fills in the blank correctly (Pola). An LSTM would handle this. A plain RNN - probably not. And why? Because the LSTM has a mechanism that says "remember the name Pola - this might be important later". The RNN would simply... forget ;-)
\nOK, so LSTM solved the memory problem. At least partially. But new problems appeared, and they turned out to be fundamental.
\nLSTM solved vanishing gradient to a large extent, but not completely. When the distance between related words grows to hundreds or thousands of words, even LSTM starts losing the thread of the narrative. Bengio et al. (1994) showed that recurrent networks - even with gates - still struggle to maintain useful gradients over very long distances.
\nSo: instead of forgetting after 10 words (RNN), LSTM forgets after... 100? 200? Better, but still not ideal.
\nAnd this is the most important problem.
\nRNN and LSTM process data step by step. Step 2 has to wait for step 1. Step 3 for step 2. And so on.
\n\nNow think about GPUs. A GPU is a machine that loves doing many things at once (parallel processing). Thousands of cores working simultaneously.
\nBut RNN/LSTM tells the GPU: "no, no, wait. First let's finish step 1, only then start step 2". The GPU cries.
\nIt's like a book with 10,000 chapters, where each chapter has to be read after the previous one. You can't read chapter 500 until you've finished 499. You can't parallelize this. For short texts it's not a problem, but when training a model on billions of words? That's a nightmare.
\nLSTM additionally has 4x more parameters than a simple RNN (three gates + cell state = four sets of weights per neuron). So it trains slower and uses more memory.
\nLSTM (like most deep learning models) is hard to interpret. The model can generate correct results, but it's hard to understand why it made this decision and not another. In applications like medicine or finance, where interpretability is key, that's a serious problem.
\n| Architecture | \nYear | \nSolves... | \nBut can't... | \n
|---|---|---|---|
| Perceptron | \n1958 | \nLinear classification | \nXOR, non-linearity | \n
| MLP | \n1986 | \nNon-linear relationships | \nUnderstand word order | \n
| RNN | \n1986 | \nProcess sequences step by step | \nRemember long dependencies | \n
| LSTM | \n1997 | \nRemember longer thanks to gates | \nProcess in parallel, very long texts | \n
Each generation solved the previous one's problem, but created a new one. It's like a game of whack-a-mole - you hit one mole, another pops up.
\nAnd then in 2017 someone asked a crazy question...
\nThe metaphor that changes everything.
\nImagine you're reading a novel. Now you have three ways to do it:
\nIn 2017 a group of researchers at Google published a paper with the modest title: "Attention Is All You Need". Their crazy idea? What if we stop reading one by one altogether? What if every word could "see" all the other words at once?
\nAnd a revolution happened. Because if every word looks at every other simultaneously (not waiting for its turn), then:
\nThis architecture is called the Transformer. And it's what ChatGPT, Claude, Gemini, and all the LLMs you know are built on.
\n| Architecture | \nMetaphor | \nWhat it can do | \nWhat it can't? | \n
|---|---|---|---|
| Perceptron | \nA ruler | \nDraws one line, classifies into 2 groups | \nXOR, non-linearity, anything complex | \n
| MLP | \nA team of analysts | \nModels non-linear relationships, "depth" | \nDoesn't understand order, sees everything at once | \n
| RNN | \nA word-by-word reader | \nProcesses sequences, has a hidden state | \nShort memory (vanishing gradient) | \n
| LSTM | \nA student with a notebook and gates | \nSelective memory, three control gates | \nSequential = slow, no parallelization | \n
| Transformer | \nThe whole page at once | \nParallelism, attention to everything | \n...to be discovered in the next posts... | \n
This post is quite long, but I felt this evolution from the perceptron to LSTM deserved a full, told story.
\nIf anything is unclear - let me know in the comments, I'll try to explain.
\nWhich architecture surprised you the most? Did you know that the "AI Winter" was caused by something as "simple" as XOR?
\n\n\nWhat's in the next post? We're getting into the Transformer - the architecture that changed everything. Attention, self-attention, positional encoding, multi-head attention - all the things that made ChatGPT exist in the first place. Stay tuned!
\n
See you next time!
\nSources and interesting links:
\nIf you want to go deeper, here are the materials I used:
\nMini-quiz answers: 1) Linear - y = ax + b is a linear function. 2) Non-linear - the step function "breaks" linearity. 3) Linear! Without a non-linear activation, an MLP with 100 layers = one big linear transformation. That's exactly why activation functions are necessary. ↩
\nMy answers: 1) A simple MLP is enough - tabular data, no sequence. 2) LSTM - a sequence of moderate length, LSTM will handle it. 3) Transformer - 10,000 words is too much even for LSTM. A Transformer with self-attention lets every word "see" every other without waiting. 4) No - a single perceptron can't solve XOR. You need at least an MLP (2 layers). ↩
\nTip
\nWant to run this code yourself? All the examples from this post are in a ready-made Jupyter notebook: how-computer-reads-text.ipynb
\nIn the two previous posts we built a solid foundation. In the first we took language apart - phonetics, morphology, syntax, semantics, pragmatics. In the second we asked: "OK, but does an LLM even understand what it generates?" and concluded that an LLM is a machine of signs, not a mind.
\nBut one fundamental question remained unanswered: how does a computer even "take" text in?
\nBecause a computer doesn't see letters. It doesn't see words. A computer sees numbers. So how is it that you type "The cat sits on the mat" and ChatGPT somehow processes it? What's the path from text to number, from number to "understanding"?
\nThat path is a fascinating story of evolution - from the simplest word counting, through ever smarter mathematical tricks, to vectors that can capture semantic similarities. Every step on that path was an answer to the limitations of the previous one.
\nThis is the third post in the "Understanding LLM" series. Today we switch the perspective from linguistic and philosophical to technical. But don't worry - there will still be plenty of examples, plenty of "aha!" moments, and zero formulas you can't understand ;-)
\n\nThe narrative of this post: "First you cut the text into pieces, then you count, then you understand." Simple? We'll see ;-) Let's start with the cutting.
\nImagine you're a computer. Someone shows you text:
\n\n\n"Alice has a cat."
\n
What do you see? Letters? Words? No. You see a sequence of bytes: 41 6c 69 63 65 20 68 61 73 20 61 20 63 61 74 2e. Zero idea where one word starts and another ends. Zero idea that "cat" is an animal and not three random characters.
For a computer to do anything with text, it first has to cut it into pieces. And that process is called tokenization.
\nTokenization is step zero. Without it there's no TF-IDF, no n-grams, no embeddings, no LLM. Everything starts with cutting.
\nThe simplest idea: split the text on spaces.
\n"Alice has a cat." -> ["Alice", "has", "a", "cat."]\nDid you notice? "cat." has a period glued to it. That's not the word "cat" - it's the word "cat" with punctuation. And what about texts like these:
\nIn short: splitting on spaces doesn't work. The world is too complicated for such simple rules.
\nIn the first post we met morphemes - the smallest meaningful units. "Unhappiness" is three morphemes: "un-happy-ness". And now note: a token is not the same as a morpheme.
\n\nA token is simply a piece of text determined by the tokenizer. It can be a whole word, a part of a word, or a single character. It depends on the algorithm.
\nNote
\nThree levels of cutting text:
\nAnd here comes BPE (Byte Pair Encoding) - the most popular tokenization algorithm, used by GPT-2, GPT-3, GPT-4, Llama, and many other models.
\nThe idea of BPE can be reduced to one sentence: find the most frequent pair of characters and merge it into one token. And repeat.
\nSounds simple? Because it is simple ;-) Let's see it on an example.
\nWe have a small corpus with five English words and their frequencies:
\n"low" ×10 "lower" ×5 "newest" ×12\n"widest" ×4 "new" ×5\nStep 0: We split everything into single characters:
\nl o w ×10 l o w e r ×5 n e w e s t ×12\nw i d e s t ×4 n e w ×5\nOur starting dictionary is: ["d", "e", "i", "l", "n", "o", "r", "s", "t", "w"] - simply all unique characters.
Step 1: We find the most frequent pair of adjacent characters:
\nWait, let's recount. (n, e): "newest" (12) + "new" (5) = 17. Actually (n,e) = 17 times <- winner!
\nLet's merge (n, e) -> "ne". Our dictionary grows by one token:
\nDictionary: ["d", "e", "i", "l", "n", "o", "r", "s", "t", "w", "ne"]\n\nl o w ×10 l o w e r ×5 ne w e s t ×12\nw i d e s t ×4 ne w ×5\nStep 2: We look for the most frequent pair again:
\nMerge (ne, w) -> "new":
\nDictionary: [..., "ne", "new"]\n\nl o w ×10 l o w e r ×5 new e s t ×12\nw i d e s t ×4 new ×5\nStep 3: The most frequent pair is now (e, s) = 16 times. Merge -> "es":
\nDictionary: [..., "ne", "new", "es"]\n\nl o w ×10 l o w e r ×5 new es t ×12\nw i d es t ×4 new ×5\nStep 4: The most frequent pair is (l, o) = 15 times. Merge -> "lo":
\nDictionary: [..., "ne", "new", "es", "lo"]\n\nlo w ×10 lo w e r ×5 new es t ×12\nw i d es t ×4 new ×5\nStep 5: The most frequent pair is (lo, w) = 15 times. Merge -> "low":
\nDictionary: [..., "ne", "new", "es", "lo", "low"]\n\nlow ×10 lo w e r ×5 new es t ×12\nw i d es t ×4 new ×5\nAnd so on, until we reach the target vocabulary size. In real models:
\nThat's an important question, and the answer is: always. At both stages.
\n\nTraining: first you train the tokenizer on a huge corpus (it learns which pairs to merge). Then you tokenize the ENTIRE training corpus into IDs. The model learns on those IDs.
\nPrompting: when you write to ChatGPT, your text goes through the SAME tokenizer -> IDs -> the model generates new IDs -> a decoder turns them back into text.
\nThe key point: the tokenizer is trained separately, before the model. Then it's "frozen" - it never changes again. GPT-2 has its tokenizer (a 50K vocabulary), GPT-4 has its own (a 100K vocabulary). And that's the reason Polish gets cut up worse in GPT-2 - because GPT-2's tokenizer was trained mainly on English, so few Polish character sequences got merged. The model itself might "understand" Polish better, but the tokenizer already cut the text into tiny pieces.
\nTip
\nAn experiment for you: Go to tiktokenizer.vercel.app, type some Polish text and see how the GPT-2 model cuts it into tokens. You'll see that Polish characters (a, e, l, s, c with diacritics) often take up 2-3 tokens! Because GPT-2 was trained mainly on English, Polish is "exotic" to it.
\nThe key thing: every model has its own tokenizer. The same text can be cut completely differently:
\nimport tiktoken \n\ntext = "Incredibly happy" \n\ngpt2 = tiktoken .get_encoding ("gpt2" )\ngpt4 = tiktoken .get_encoding ("cl100k_base" )\n\nprint ("GPT-2:" , gpt2 .encode (text ))\nprint ("GPT-4:" , gpt4 .encode (text ))\n\nprint ("GPT-2:" , [gpt2 .decode ([t ]) for t in gpt2 .encode (text )])\nprint ("GPT-4:" , [gpt4 .decode ([t ]) for t in gpt4 .encode (text )])GPT-2 will probably cut the text into many small fragments (because it doesn't "know" it well), and GPT-4 will do it much more efficiently (because it has seen more of this text).
\n\nThe example above uses Polish ("Nieprawdopodobnie szczęśliwy" = "Incredibly happy") because it perfectly illustrates how badly a tokenizer trained on one language handles another.
\nThere are models trained specifically on Polish text - and their tokenizers cut Polish much better:
\nfrom transformers import AutoTokenizer \n\ntext = "Nieprawdopodobnie szczęśliwy" \n\nherbert = AutoTokenizer .from_pretrained ("allegro/herbert-base-cased" )\nprint ("HerBERT (Allegro, Polish WordPiece):" , herbert .tokenize (text ))\n\nroberta = AutoTokenizer .from_pretrained ("sdadas/polish-roberta-base-v2" )\nprint ("Polish RoBERTa (Polish SentencePiece):" , roberta .tokenize (text ))HerBERT (Allegro, Polish WordPiece): ['Nie', 'prawdopodobnie</w>', 'szczęśliwy</w>'] -> 3 tokens\nPolish RoBERTa (Polish SentencePiece): ['▁Nie', 'prawdopodobnie', '▁szczęśliwy'] -> 3 tokens\nThree tokens! "prawdopodobnie" and "szczęśliwy" are single tokens for a Polish tokenizer. Because that tokenizer "saw" these words so many times on a Polish corpus that it merged them into whole units.
\nTwo Polish tokenizers worth knowing:
\n| Tokenizer | \nCreator | \nAlgorithm | \nImplemented in | \n
|---|---|---|---|
| HerBERT | \nAllegro | \nWordPiece | \nPolish BERT on the KGR10 corpus | \n
| Polish RoBERTa | \nsdadas | \nSentencePiece (Unigram) | \nPolish RoBERTa on a large corpus | \n
Note
\nWhy do Polish models cut better? Because their tokenizers were trained on Polish text. "Prawdopodobnie" appeared in the Polish corpus thousands of times, so BPE/SentencePiece merged it into one token. GPT-2 saw mostly English, so "prawdopodobnie" never got merged - and it cuts it into pieces. This is also why GPT-4o (trained on a much more multilingual corpus) cuts Polish better than GPT-2 - but still worse than typically Polish models.
\nNow that we understand how BPE works, let's try to train our own tokenizer. We'll use the tokenizers library from HuggingFace (not to be confused with tiktoken):
from tokenizers import Tokenizer \nfrom tokenizers .models import BPE \nfrom tokenizers .trainers import BpeTrainer \nfrom tokenizers .pre_tokenizers import Whitespace \n\ntokenizer = Tokenizer (BPE (unk_token = "[UNK]" ))\ntokenizer .pre_tokenizer = Whitespace ()\n\ntrainer = BpeTrainer (vocab_size = 300 , special_tokens = ["[UNK]" ])\n\ncorpus = [\n "Alice has a cat and a dog" ,\n "The cat sits on the mat" ,\n "The dog runs in the park" ,\n "Alice has a cat and a cat and once more a cat" ,\n "The cat likes milk and the cat likes to sleep" ,\n "The dog likes to run in the park and chase the cat" ,\n "A happy cat is a cat that has lots of milk" ,\n "An incredibly happy dog runs in the park" ,\n "Happy Alice has a cat and a dog and a happy home" ,\n "A home is a place where a happy family lives" ,\n]\n\ntokenizer .train_from_iterator (corpus , trainer )\nprint (f"Vocabulary size: { tokenizer . get_vocab_size () } " )\n\ntest = "Incredibly happy" \nencoding = tokenizer .encode (test )\nprint (f'" { test } " -> { encoding . tokens } ' )Vocabulary size: 130\n"Incredibly happy" -> ['Incredibly', 'happy']\nTwo tokens! Because our small corpus is in English - and "Incredibly" and "happy" appeared often enough for BPE to merge them into single tokens.
\nBut wait - what do those parameters in the code actually mean?
\n| Parameter | \nWhat it does | \nExample | \n
|---|---|---|
vocab_size | \nThe maximum number of tokens in the vocabulary. BPE will merge pairs until the vocabulary reaches this size. The bigger, the longer the tokens (whole words). The smaller, the smaller the pieces (single letters). | \nGPT-2: 50 257, ours: 300 | \n
special_tokens | \nTokens with a special meaning for the model. They're always in the vocabulary, regardless of training. | \n[UNK], <PAD>, <S> (start), </S> (end) | \n
unk_token | \nThe "unknown" token - replaces every character the tokenizer can't recognize. E.g. if an emoji appears in the text and the tokenizer doesn't have it in the vocabulary, it inserts [UNK]. | \n[UNK] = "I don't know what this is" | \n
A simple analogy: vocab_size is the thickness of your dictionary - how many entries fit in it. unk_token is the entry meaning "no such word". And special_tokens are "reserved pages" - they're always in the dictionary, regardless of what you teach the tokenizer.
Tip
\nExperiment: Copy this code, change vocab_size to e.g. 50 and see what happens. You'll see that with a smaller vocabulary the tokenizer cuts words into smaller pieces - because it has less "room" for merges. That's exactly what we talked about: vocabulary size is a hyperparameter, and how finely the text gets cut depends on it.
Warning
\nWhy does this matter? Because an LLM has a token limit in its context window. GPT-3 has 4K tokens, GPT-4 Turbo has 128K. But a "token" is not a "word"! In English ~1 token ~= 0.75 words. In a language poorly served by the tokenizer, it can be ~1 token ~= 0.4 words. So such text "eats up" more tokens and hits the limit faster.
\nBPE isn't the only player in town. Here's a quick comparison:
\n| Algorithm | \nWho uses it | \nHow it works | \nKey difference | \n
|---|---|---|---|
| BPE | \nGPT, Llama, many others | \nMerges the most frequent pair | \nSimple, bottom-up | \n
| WordPiece | \nBERT, DistilBERT, Electra | \nMerges the pair with the highest "score" | \nScore = freq(pair) / (freq(a) x freq(b)) | \n
| Unigram | \nT5, Pegasus, ALBERT | \nStarts from a large vocabulary, removes the least useful | \nProbabilistic, can yield different tokenizations | \n
| SentencePiece | \nMultilingual models | \nBPE or Unigram on raw text (even without spaces!) | \nWorks with languages without spaces (Chinese, Japanese) | \n
The difference between BPE and WordPiece is subtle: BPE simply merges the most frequent pair. WordPiece merges the pair that is most surprising - i.e. one that appears together more often than would follow from the frequency of the individual elements. It's a bit like a relationship that is "more than the sum of its parts" ;-)
\nNote
\nA callback to post 1: Remember when we said Polish morphology is a nightmare for an LLM? 7 cases, inflection, lots of endings... Well, now you see why. The tokenizer doesn't "know" that "domu", "domowi", "domem" are inflections of the same word. To it they're just different character sequences. "Understanding" the relationship between forms - that's something the model has to learn on its own, during training.
\nWe have our merges from the example above: n+e->ne, ne+w->new, e+s->es, l+o->lo, lo+w->low. How will BPE split these new words?
\nOK, we have tokens. But how does the tokenizer know which character pairs to merge? From a corpus! BPE learns the most frequent combinations from text. And to do anything with tokens - count them, find patterns, train a model - we also need a corpus.
\nA corpus is simply a collection of texts. It can be:
\nEach individual text in a corpus we call a document. Simple?
\n\nAnd these are exactly the datasets on which real models are trained - both tokenizers and the models themselves:
\n| Corpus | \nWhat it contains | \nSize | \nFun fact | \n
|---|---|---|---|
| Wikitext | \nArticles from (English) Wikipedia | \n~500 MB | \nA standard benchmark for evaluating language models | \n
| Wiki-40B | \nWikipedia in 59 languages (including Polish!) | \n~40 GB | \nThe first step of many multilingual models | \n
| EuroParl | \nTranscriptions from the EU parliament (21 languages) | \n~2 GB | \nHigh-quality official texts, great for translation | \n
| Common Crawl | \nDumps of web content | \npetabytes (PB!) | \nThe largest publicly available web corpus. Most LLMs use it | \n
| OpenWebText | \nA copy of Reddit links with >3 upvotes | \n~38 GB | \nGPT-2 was trained on it. Filtered "quality" from Reddit | \n
| The Pile | \nA mix of 22 sources (arXiv, GitHub, Wikipedia, books...) | \n~825 GB | \nCreated by EleutherAI as a "do-everything" dataset | \n
| RedPajama | \nAn open replica of LLaMA's training data | \n~1.2 TB | \nThat's why LLaMA is so good - trained on a huge, diverse set | \n
| OSCAR | \nWeb dumps, filtered by language | \n~6.5 TB | \nHas separate subsets for each language, including Polish OSCAR | \n
And Polish corpora? Here are the most important ones:
\nKey observation: the same corpus is used to train both the tokenizer and the model. First you train the tokenizer on the corpus (it learns which character pairs to merge), then you tokenize the whole corpus with that tokenizer, and on those tokens you train the model.
\nNote
\nWhy does this matter? If your corpus has little Polish text (e.g. GPT-2 trained mainly on English), the tokenizer won't merge Polish words, and the model won't learn Polish well. That's why Polish models (HerBERT, Polish RoBERTa) use corpora with a lot of Polish text - e.g. NKJP + Polish OSCAR + Polish Wikipedia.
\nWe have a corpus. Now we want to turn each document into numbers so the computer can do something with it.
\nThe simplest way: Bag-of-Words (BoW) - a bag of words. We count how many times each word appears in the document.
\nExample. We have three short movie reviews:
\nDocument 1: "This movie is great"\nDocument 2: "This movie is terrible"\nDocument 3: "Great movie I recommend"\nWe build a vocabulary of all unique words:
\n{this, movie, is, great, terrible, i, recommend}\nAnd now we turn each document into a vector of counts:
\n| \n | this | \nmovie | \nis | \ngreat | \nterrible | \ni | \nrecommend | \n
|---|---|---|---|---|---|---|---|
| Doc 1 | \n1 | \n1 | \n1 | \n1 | \n0 | \n0 | \n0 | \n
| Doc 2 | \n1 | \n1 | \n1 | \n0 | \n1 | \n0 | \n0 | \n
| Doc 3 | \n0 | \n1 | \n0 | \n1 | \n0 | \n1 | \n1 | \n
Each document is now just a sequence of numbers. The computer is happy.
\nBut we're not entirely ;-). Because notice the problem:
\n\n\nDocument 1: "This movie is great" -> [1, 1, 1, 1, 0, 0, 0]\nDocument 2: "This movie is terrible" -> [1, 1, 1, 0, 1, 0, 0]
\n
These vectors are almost identical! They differ in one position. Yet one says "great" and the other "terrible" - completely different meanings.
\nAnd there's a second problem: "Dog bites man" and "Man bites dog" will give exactly the same BoW vector. BoW completely ignores word order.
\nNote
\nIn inflected languages things look different. In a language with cases, "The dog bites the man" and "The man bites the dog" can look different because the word forms change. But in English, "dog" is always "dog" regardless of its role in the sentence - which is exactly why BoW can't distinguish "dog bites man" from "man bites dog". This is that morphology from the first post that sometimes helps us and sometimes gets in the way ;-)
\nWarning
\nBag-of-Words in a nutshell:
\nfrom sklearn .feature_extraction .text import CountVectorizer \nimport pandas as pd \n\ncorpus = [\n "This movie is great" ,\n "This movie is terrible" ,\n "Great movie I recommend" ,\n]\n\nvectorizer = CountVectorizer ()\nX = vectorizer .fit_transform (corpus )\n\ndf = pd .DataFrame (\n X .toarray (),\n columns = vectorizer .get_feature_names_out (),\n index = ["Doc 1" , "Doc 2" , "Doc 3" ]\n)\nprint (df )Result:
\n great i is movie recommend terrible this\nDoc 1 1 0 1 1 0 0 1\nDoc 2 0 0 1 1 0 1 1\nDoc 3 1 1 0 1 1 0 0\nExactly the same table as above - only now generated by code. Notice: "movie" is everywhere (value 1 in every row), and "terrible" only in Document 2. That's the whole magic of BoW - simple counting.
\nImportant
\nCan BoW generate new texts? No. BoW is only a way of representing text (text -> numbers). It's used to analyze, compare, and classify documents, but it doesn't generate anything new. It also can't predict what word should come after "The cat sits on the...". To generate text, we need something that understands word order and can predict the next one. And that's exactly what we're getting to with n-grams and Markov chains ;-)
\nBoW treats every word the same. But not every word is equally important!
\nThe word "is" appears in almost every English sentence. The word "semiotics" - rather rarely. Which is more informative? Obviously "semiotics" - because if you see it in a document, it tells you much more about its content than "is".
\nTF-IDF (Term Frequency - Inverse Document Frequency) is a way to capture that.
\nRecall our corpus - three short movie reviews:
\nDocument 1: "This movie is great" (4 words)\nDocument 2: "This movie is terrible" (4 words)\nDocument 3: "Great movie I recommend" (3 words)\nLet's compute TF-IDF for the word "great" in Document 1:
\nTF (Term Frequency) - how often the word appears in one document:
\nTF("great", Document 1) = 1 / 4 = 0.25\n(1 occurrence in a 4-word document)
\nIDF (Inverse Document Frequency) - how "rare" the word is across the whole corpus:
\nIDF("great") = log(3 / 2) = 0.176\n(3 documents in the corpus, 2 of them contain "great")
\nTF-IDF = TF x IDF:
\nTF-IDF("great", Document 1) = 0.25 x 0.176 = 0.044\nAnd the word "is", which is EVERYWHERE?
\nIDF("is") = log(3 / 2) = 0.176 (also in 2 of 3 documents)\nIDF("movie") = log(3 / 3) = 0 (in ALL documents!)\n"Movie" gets zero in IDF! Because if a word is in every document, it carries no information that would help tell one document apart from another.
\nTip
\nThe intuition behind TF-IDF in one sentence: A word is important for a given document if it appears there often (high TF) but rarely in other documents (high IDF). In other words: "Are you unique?"
\nTry it yourself. Here's a complete example in Python:
\nfrom sklearn .feature_extraction .text import TfidfVectorizer \nimport pandas as pd \n\ncorpus = [\n "This movie is great" ,\n "This movie is terrible" ,\n "Great movie I recommend" ,\n]\n\nvectorizer = TfidfVectorizer ()\ntfidf_matrix = vectorizer .fit_transform (corpus )\n\ndf = pd .DataFrame (\n tfidf_matrix .toarray (),\n columns = vectorizer .get_feature_names_out (),\n index = ["Doc 1" , "Doc 2" , "Doc 3" ]\n)\nprint (df .round (2 ))The result will look roughly like this:
\n great i is movie recommend terrible this\nDoc 1 0.41 0.0 0.49 0.37 0.0 0.0 0.49\nDoc 2 0.00 0.0 0.46 0.35 0.0 0.58 0.46\nDoc 3 0.41 0.54 0.0 0.41 0.54 0.0 0.00\nNotice: "movie" has low values everywhere (because it's everywhere). "terrible" has a high value only in Document 2 (because it only appears there). TF-IDF works!
\nTip
\nAn experiment for you: Think about your study (or work) notes. Which words would have high TF-IDF? Probably technical terms - "recursion", "entropy", "backpropagation". And which would have low ones? "And", "is", "on", "that" - because they're everywhere.
\nTF-IDF has one super practical application: text search. This is basically how the first search engines worked.
\nThe idea is simple: you turn the user's query into a TF-IDF vector, and look for the document whose vector is most similar to it (so-called cosine similarity).
\nfrom sklearn .feature_extraction .text import TfidfVectorizer \nfrom sklearn .metrics .pairwise import cosine_similarity \nimport numpy as np \n\ncorpus = [\n "This movie is great" ,\n "This movie is terrible" ,\n "Great movie I recommend" ,\n]\n\nvectorizer = TfidfVectorizer ()\ntfidf_matrix = vectorizer .fit_transform (corpus )\n\nquery = "great movie" \nquery_vec = vectorizer .transform ([query ])\n\nsimilarities = cosine_similarity (query_vec , tfidf_matrix )[0 ]\nranked = sorted (zip (corpus , similarities ), key = lambda x : - x [1 ])\nfor i , (doc , sim ) in enumerate (ranked , 1 ):\n print (f' { i } . " { doc } " -> { sim :.3f } ' )Query: "great movie"\n\n1. "Great movie I recommend" -> 0.694 <- best result!\n2. "This movie is great" -> 0.667\n3. "This movie is terrible" -> 0.229\nDocument 3 wins - because "great" and "movie" are high-TF-IDF keywords for it. Document 2 has "movie" but not "great" - so its similarity is low.
\nNote
\nCosine similarity measures the angle between two vectors. If the vectors point in the same direction (similar proportions of words) - the similarity is close to 1. If in opposite directions - close to 0. Don't worry about the math - the intuition is simple: "how similar are these two vectors to each other?"
\nTF-IDF is better than pure BoW, because at least it weights words by importance. But it still treats every word separately. It doesn't know that "do" + "not" + "like" = something completely different than "like" alone.
\nOr an English example that shows the problem perfectly:
\nThe same words! But the order changes everything. BoW and TF-IDF don't see it.
\nAn n-gram is simply a sequence of N consecutive elements (usually words or characters).
\nExample with the sentence "Alice has a cat":
\n| Type | \nN | \nResult | \n
|---|---|---|
| Unigrams | \n1 | \nAlice, has, a, cat | \n
| Bigrams | \n2 | \nAlice has, has a, a cat | \n
| Trigrams | \n3 | \nAlice has a, has a cat | \n
And now the magic: instead of counting single words, we count pairs of words (bigrams). And suddenly:
\nYou can also combine n-grams with TF-IDF! In sklearn it's enough to change one parameter:
\nfrom sklearn .feature_extraction .text import TfidfVectorizer \nimport pandas as pd \n\ncorpus = [\n "This movie is great" ,\n "This movie is terrible" ,\n "Great movie I recommend" ,\n]\n\nvectorizer = TfidfVectorizer (ngram_range = (1 , 2 ))\ntfidf_matrix = vectorizer .fit_transform (corpus )\n\ndf = pd .DataFrame (\n tfidf_matrix .toarray (),\n columns = vectorizer .get_feature_names_out (),\n index = ["Doc 1" , "Doc 2" , "Doc 3" ]\n)\nprint (df .round (2 ))Look what happened - the feature vocabulary grew! Besides single words ("movie", "is", "great") we now have pairs: "movie is", "is great", "is terrible", "great movie", "this movie", "movie recommend". Each pair is a separate column with its own TF-IDF.
\nThanks to this, the model sees that "is great" (Doc 1) and "is terrible" (Doc 2) are different things - because they're different bigrams with different TF-IDF values.
\nNote
\nN-grams are a trade-off. The bigger the N, the more context you capture, but the more data you need. With trigrams you have 3x more combinations than with unigrams. With 4-grams - even more. And you quickly get to the point where most n-grams appear in the corpus only once, which isn't useful.
\nN-grams by themselves are just counts - like BoW, they don't generate text. But if we add transition probabilities to them, we suddenly get something that generates new text.
\nThe idea is simple: for each word we look at what words most often follow it. And we pick the next word probabilistically.
\nLet's take a small corpus:
\n"alice has a cat alice has a dog the cat likes milk alice likes the cat"\nWe count bigrams and transition probabilities:
\n| Word | \nNext word | \nProbability | \n
|---|---|---|
| alice | \nhas | \n2/3 = 67% | \n
| alice | \nlikes | \n1/3 = 33% | \n
| has | \na | \n2/2 = 100% | \n
| a | \ncat | \n2/3 = 67% | \n
| a | \ndog | \n1/3 = 33% | \n
| the | \ncat | \n1/1 = 100% | \n
| cat | \nlikes | \n1/1 = 100% | \n
| likes | \nmilk | \n1/2 = 50% | \n
| likes | \nthe | \n1/2 = 50% | \n
That is exactly a Markov chain - a model in which the probability of the next state depends only on the current state (or the last few).
\n\n"alice" -> most often "has" (67%) -> "a" -> "cat" (67%) or "dog" (33%). So we generate e.g.: "alice has a cat". Or "alice has a dog". Or "alice likes the cat". All these sentences are "new" - they didn't appear as wholes in the corpus - but the model stitched them together from transition probabilities.
\nBefore we get to the code, let's trace the whole process on our fingers. We have the same corpus:
\n"alice has a cat alice has a dog the cat likes milk alice likes the cat"\nStep 1: Build the trigram dictionary. We slide a "window" of 3 words and look at what follows:
\n| Window (trigram) | \nNext word | \n
|---|---|
| alice has a | \ncat | \n
| has a cat | \nalice | \n
| a cat alice | \nhas | \n
| cat alice has | \na | \n
| alice has a | \ndog | \n
| has a dog | \nthe | \n
| a dog the | \ncat | \n
| dog the cat | \nlikes | \n
| the cat likes | \nmilk | \n
| cat likes milk | \nalice | \n
| likes milk alice | \nlikes | \n
| milk alice likes | \nthe | \n
Each trigram has exactly one possible next word (because our corpus is tiny).
\nStep 2: Generate. We start from the starter trigram ("alice", "has", "a"):
Important
\nThis starter trigram is our "prompt"! Just like in ChatGPT you type text and the model continues - here we type "alice has a" and the generator picks the next words. The only difference is scale: ChatGPT has a context of thousands of tokens, and we have 3 words.
\nStart: alice has a\nStep 1: alice has a [cat] <- after (alice,has,a) comes "cat"\nStep 2: alice has a cat [alice] <- after (has,a,cat) comes "alice"\nStep 3: alice has a cat alice [has] <- after (a,cat,alice) comes "has"\nStep 4: ... cat alice has [a] <- after (cat,alice,has) comes "a"\nStep 5: ... alice has a [dog] <- after (alice,has,a) comes "dog"\nStep 6: ... has a dog [the] <- after (has,a,dog) comes "the"\nStep 7: ... a dog the [cat] <- after (a,dog,the) comes "cat"\nStep 8: ... dog the cat [likes] <- after (dog,the,cat) comes "likes"\nStep 9: ... the cat likes [milk] <- after (the,cat,likes) comes "milk"\nStep 10: STOP <- trigram (cat,likes,milk) -> "alice"... it loops back\nResult: "alice has a cat alice has a dog the cat likes milk" - basically our corpus, "re-glued" from the inside. On a larger corpus the result would be different every time.
Here's a complete (and genuinely short!) text generator in Python:
\nimport random \n\ncorpus = "alice has a cat alice has a dog the cat likes milk alice likes the cat" \ntokens = corpus .split ()\n\ntrigrams = {}\nfor i in range (len (tokens ) - 3 ):\n key = (tokens [i ], tokens [i + 1 ], tokens [i + 2 ])\n next_word = tokens [i + 3 ]\n if key not in trigrams :\n trigrams [key ] = []\n trigrams [key ].append (next_word )\n\ncurrent = ("alice" , "has" , "a" ) # <- this is our "prompt"! \noutput = list (current )\n\nfor _ in range (10 ):\n if tuple (output [- 3 :]) not in trigrams :\n break \n possibilities = trigrams [tuple (output [- 3 :])]\n output .append (random .choice (possibilities ))\n\nprint (" " .join (output ))Possible output: "alice has a cat alice has a dog the cat likes milk alice likes the cat"
Note
\nWhy does it come out the same every time? Because our corpus is so small that most trigrams have only one possible next word. random.choice has nothing to choose from! On a larger corpus (e.g. all of English Wikipedia) the same code would generate different text every time - because almost every trigram would have several possible continuations with different probabilities. And that's exactly the moment when generation becomes interesting.
Nothing spectacular, right? But that's because our corpus is microscopic. On a real corpus (e.g. all of Wikipedia) a trigram generator can produce sentences that sound sensible, even though they never appeared before.
\nImportant
\nMarkov chains are the first "language models"! Predicting the next word based on context - that is EXACTLY what ChatGPT does. Of course GPT uses a much more advanced method (Transformer + attention over thousands of context tokens), but the fundamental idea is the same: the probability of the next token. An LLM is a descendant of Markov chains. On steroids ;-)
\nMarkov chains are great for generating text. But in practice we often want something else: assign a text to a category.
\nAnd here comes Naive Bayes - one of the simplest yet most useful text classification algorithms.
\nWithout formulas, just an example:
\nImagine a colleague comes up to you and says: "I'm coughing." What's the probability he has a cold?
\nIt depends! If it's November and everyone in the office is sick - high. If it's July and he coughs once - low.
\nBayes' theorem is a formal way of thinking about such situations: we update our knowledge based on new evidence.
\nAnd now let's translate that to text. The question is:
\n\n\n\n"If a document contains the word 'viagra', what's the probability it's spam?"
\n
We have a small set of emails:
\n| Content | \nLabel | \n|
|---|---|---|
| 1 | \n"Buy cheap viagra now" | \nSpam | \n
| 2 | \n"Free viagra offer" | \nSpam | \n
| 3 | \n"Meeting tomorrow at 10" | \nNot-spam | \n
| 4 | \n"Send me the report tomorrow" | \nNot-spam | \n
A new email arrives: "Viagra meeting tomorrow". Spam or not?
\nNaive Bayes computes:
\nP(Spam | "viagra meeting tomorrow") ∝ 0.5 x 1.0 x 0.0 x ... = 0!
\nP(Not-spam | "viagra meeting tomorrow") ∝ 0.5 x 0.0 x 1.0 x ... = 0!
\nOops. The presence of "tomorrow" (a not-spam word) zeroed out spam, and the presence of "viagra" (a spam word) zeroed out not-spam. This particular email is tricky ;-)
\nIn practice, so-called Laplace smoothing is used (we add 1 to each count) to avoid zeroing:
\nNow: P(Spam | email) ∝ 0.5 x 0.214 x 0.048 x 0.048 ≈ 0.000246\nP(Not-spam | email) ∝ 0.5 x 0.048 x 0.143 x 0.143 ≈ 0.000490
\nNot-spam wins! Because "tomorrow" and "meeting" strongly indicate a normal email.
\nBecause we assume words are independent. That is: the probability of "viagra" appearing doesn't depend on whether "cheap" also appears. Of course that's not true! "Viagra" and "cheap" appear together more often than by chance. But the model still works surprisingly well...
\nIt's a bit like assuming the weather in London doesn't depend on the weather in Paris. Of course it does a bit! But if you want to quickly estimate whether you need an umbrella, the independence assumption gives you a reasonably good answer ;-)
\nNow that we understand the math, let's do it in a few lines of code. The scikit-learn library has a ready Naive Bayes classifier:
CountVectorizer - turns text into a word-count vector (our BoW from the previous section)MultinomialNB - that's Naive Bayes, the "multinomial" variant (because it counts word probabilities), with alpha=1.0 i.e. Laplace smoothingfrom sklearn .naive_bayes import MultinomialNB \nfrom sklearn .feature_extraction .text import CountVectorizer \n\nemails = [\n "Buy cheap viagra now" ,\n "Free viagra offer" ,\n "Meeting tomorrow at 10" ,\n "Send me the report tomorrow" ,\n "Cheap pills online buy now" ,\n "Report from yesterday send" ,\n]\nlabels = [1 , 1 , 0 , 0 , 1 , 0 ] # 1=spam, 0=not-spam \n\nvectorizer = CountVectorizer ()\nX = vectorizer .fit_transform (emails )\n\nclassifier = MultinomialNB (alpha = 1.0 )\nclassifier .fit (X , labels )\n\nnew_email = vectorizer .transform (["Viagra meeting tomorrow" ])\nprediction = classifier .predict (new_email )\nprint ("Spam!" if prediction [0 ] == 1 else "Not spam." )Tip
\nAn experiment for you: Create 5 positive sentences about a movie ("This movie was amazing!", "Great action!", ...) and 5 negative ones ("Boring as watching paint dry", "Waste of time", ...). Write down the words that appear ONLY in positive and ONLY in negative. That's the intuition of Naive Bayes - every word "votes" for one of the categories.
\nWarning
\nLimitation: Naive Bayes sees words but not context. "The movie is AMAZING... just kidding, awful" - the model will see "amazing" and say "positive". It doesn't get irony or complex constructions. We need something that understands relationships between words. And here we enter the world of vectors...
\nAll the methods we've met so far have one problem in common: they treat words as discrete, independent entities. In BoW "cat" is at position 47 in the vector, "dog" at position 138. There's no relationship between them.
\nBut WE know that "cat" and "dog" are similar - both are pets. "Cat" and "car" - completely different. How do we make a computer "know" that too?
\nThe answer from 2013, from Tomáš Mikolov's team at Google: let's turn words into points in a high-dimensional space. Semantically similar words will be close to each other. Different words - far apart.
\nThat's Word2Vec. And it's a breakthrough.
\nBefore Word2Vec, the standard was so-called one-hot encoding - each word is a vector with a 1 at its position and 0 everywhere else:
\n"cat" -> [0, 0, 0, 1, 0, 0, ...] (1 at position 3)\n"dog" -> [0, 0, 1, 0, 0, 0, ...] (1 at position 2)\n"car" -> [1, 0, 0, 0, 0, 0, ...] (1 at position 0)\nThe problem? Every word is the same distance from every other word. The distance between "cat" and "dog" is the same as between "cat" and "car". Zero information about meaning.
\n\nWord2Vec is based on a brilliant linguistic intuition: words that appear in similar contexts have similar meanings.
\nIf you see: "___ runs in the park and chases pigeons", what fits there? Dog? Cat? Rather not "car" or "democracy". Context defines the word.
\n\n"I feed ___ kibble" - both dog and cat fit. That means the context of these words is partly shared. And that's exactly what Word2Vec exploits.
\nRemember Saussure from the second post? Meaning is relational. "Cat" means what it means because it is NOT "dog", it is NOT "house". Word2Vec is the mathematical implementation of that idea!
\nWord2Vec has two variants. Let's see both:
\nCBOW (Continuous Bag of Words): from context we guess the middle word.
\n"The cat ___ on the mat" -> sits? lies? sleeps?
Skip-gram: from the middle word we guess the context.
\n"sits" -> The? cat? on? the? mat?
How does it work inside? A neural network with one hidden layer:
\nSounds complicated? Let's do it in code - from scratch, without any ML libraries:
\nimport numpy as np \n\nnp .random .seed (42 )\n\n# --- 1. Vocabulary and one-hot encoding --- \ncorpus = "cat sits on the mat and sleeps dog sits on the rug and sleeps cat runs around the room dog runs in the park" .split ()\nvocab = list (set (corpus ))\nword2idx = {w : i for i , w in enumerate (vocab )}\nvocab_size = len (vocab )\n\ndef one_hot (word ):\n vec = np .zeros (vocab_size )\n vec [word2idx [word ]] = 1 \n return vec \n\nprint (f'One-hot "cat": { one_hot ( "cat" ) } ' )\n# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.] - only a single one! \n\n# --- 2. Weight matrix (these will be our embeddings) --- \nembed_dim = 5 # in real Word2Vec this is 100-300 \nW1 = np .random .randn (vocab_size , embed_dim ) * 0.01 # vocabulary -> embedding \nW2 = np .random .randn (embed_dim , vocab_size ) * 0.01 # embedding -> vocabulary \n\n# --- 3. Training pairs (CBOW: context -> middle) --- \nwindow = 2 \npairs = []\nfor i in range (window , len (corpus ) - window ):\n context = corpus [i - window :i ] + corpus [i + 1 :i + window + 1 ]\n target = corpus [i ]\n pairs .append ((context , target ))\n\nprint (f'Context: { pairs [ 0 ][ 0 ] } -> Target: { pairs [ 0 ][ 1 ] } ' )\n# Context: ['cat', 'sits', 'the', 'mat'] -> Target: on \n\n# --- 4. Training (gradient descent) --- \ndef softmax (x ):\n e = np .exp (x - np .max (x ))\n return e / e .sum ()\n\nfor epoch in range (500 ):\n loss = 0 \n for context_words , target_word in pairs :\n context_idx = [word2idx [w ] for w in context_words ]\n target_idx = word2idx [target_word ]\n\n # forward: averaged context embeddings -> predict the middle \n hidden = np .mean (W1 [context_idx ], axis = 0 )\n output = softmax (hidden @ W2 )\n loss -= np .log (output [target_idx ] + 1e-8 )\n\n # backward: update the weights \n grad = output .copy ()\n grad [target_idx ] -= 1 \n W2 -= 0.05 * np .outer (hidden , grad )\n grad_hidden = grad @ W2 .T \n for idx in context_idx :\n W1 [idx ] -= 0.05 * grad_hidden / len (context_idx )\n\n# --- 5. Result: embeddings! --- \nfor word in ["cat" , "dog" , "sits" , "runs" ]:\n print (f" { word } : { W1 [ word2idx [ word ]]. round ( 3 ) } " )\n\n# --- 6. Cosine similarity --- \ndef cosine (a , b ):\n return np .dot (a , b ) / (np .linalg .norm (a ) * np .linalg .norm (b ) + 1e-8 )\n\nprint (f'cat <-> dog: { cosine ( W1 [ word2idx [ "cat" ]], W1 [ word2idx [ "dog" ]]):.3f } ' )\nprint (f'cat <-> sits: { cosine ( W1 [ word2idx [ "cat" ]], W1 [ word2idx [ "sits" ]]):.3f } ' )\nprint (f'cat <-> runs: { cosine ( W1 [ word2idx [ "cat" ]], W1 [ word2idx [ "runs" ]]):.3f } ' )One-hot "cat": [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]\nContext: ['cat', 'sits', 'the', 'mat'] -> Target: on\ncat: [-2.866 -0.264 -0.225 -1.822 2.783]\ndog: [-1.133 0.678 -1.537 1.989 2.241]\nsits: [ 1.524 -0.023 1.804 -2.355 -0.788]\nruns: [ 2. 4.098 -0.315 2.971 0.815]\ncat <-> dog: 0.378\ncat <-> sits: -0.177\ncat <-> runs: -0.407\nNotice: cat and dog (0.378) are more similar than cat and runs (-0.407). The network discovered on its own that "cat" and "dog" are animals, because they appear in similar contexts. Zero labels, zero supervision - just text and math.
\nNote
\nThis is all of Word2Vec in ~30 lines. Real Word2Vec adds negative sampling (because softmax over 50 000 words is slow) and optimizations, but the principle is exactly the same.
\nNote
\nThe "fake task": What we care about is not what the network predicts, but the hidden layer weights. We train the network on an "artificial" task of predicting context, but what we want to extract is the matrix W - our embeddings. It's a bit like training someone to solve crosswords not so they solve crosswords well, but so they expand their vocabulary ;-)
\n| \n | CBOW | \nSkip-gram | \n
|---|---|---|
| Direction | \nContext -> Middle word | \nMiddle word -> Context | \n
| Speed | \nFaster | \nSlower | \n
| Rare words | \nHandles worse | \nHandles better | \n
| Frequent words | \nHandles better | \nHandles worse | \n
| When to use | \nLarge corpus, frequent words | \nSmall corpus, rare words | \n
According to Mikolov et al.'s original paper: Skip-gram is better for rare words and small datasets. CBOW is faster and better for frequent words.
\nAfter training Word2Vec, each word is a vector (e.g. 300 numbers). And this space has remarkable properties:
\nSimilar words are close:
\ndistance("cat", "dog") < distance("cat", "car")\ndistance("France", "Germany") < distance("France", "banana")\nAnalogies work like adding and subtracting vectors:
\nvector("king") - vector("man") + vector("woman") ≈ vector("queen")\nWhy? Because the "king" vector encodes many semantic dimensions - in one of them is information about "gender" (man/woman), in another about "power" (monarchy). By subtracting "man" and adding "woman", we change the gender dimension while keeping the rest.
\nOther analogy examples:
\nFrance - Paris + Berlin ≈ Germany\nsmall - smaller + big ≈ bigger\nboat - water + air ≈ airplane\nThis is what we talked about in the first post on the occasion of semantics. Now you see how it works under the hood.
\nFirst let's train our own model on a small corpus to see how it works from scratch:
\nfrom gensim .models import Word2Vec \n\ncorpus = [\n ["cat" , "sits" , "on" , "the" , "mat" , "and" , "sleeps" ],\n ["dog" , "sits" , "on" , "the" , "rug" , "and" , "sleeps" ],\n ["cat" , "runs" , "around" , "the" , "room" ],\n ["dog" , "runs" , "in" , "the" , "park" ],\n ["cat" , "and" , "dog" , "play" , "in" , "the" , "garden" ],\n ["cat" , "eats" , "kibble" , "from" , "the" , "bowl" ],\n ["dog" , "eats" , "kibble" , "from" , "the" , "bowl" ],\n ["cat" , "catches" , "a" , "mouse" , "in" , "the" , "house" ],\n ["dog" , "chases" , "the" , "cat" , "in" , "the" , "garden" ],\n ["bird" , "sits" , "on" , "a" , "branch" , "of" , "the" , "tree" ],\n ["fish" , "swims" , "in" , "the" , "aquarium" ],\n ["car" , "drives" , "on" , "the" , "road" ],\n ["bike" , "rides" , "on" , "the" , "path" ],\n ["cat" , "purrs" , "when" , "you" , "pet" , "it" ],\n ["dog" , "wags" , "its" , "tail" , "when" , "it" , "sees" , "its" , "owner" ],\n]\n\nmodel = Word2Vec (\n sentences = corpus ,\n vector_size = 10 , # vector dimension (small = educational) \n window = 3 , # context window size \n min_count = 1 , # ignore words rarer than N \n sg = 0 , # 0 = CBOW, 1 = Skip-gram \n epochs = 200 , # how many passes over the data \n)\n\nprint (model .wv .most_similar ("cat" , topn = 3 ))\n# [('dog', 0.96), ('sleeps', 0.95), ('on', 0.95)] \n\nprint (model .wv .similarity ("cat" , "dog" )) # ~0.96 \nprint (model .wv .similarity ("cat" , "car" )) # ~0.83 Note
\nNotice: our corpus is TINY (15 sentences), so the results are far from ideal - "cat" and "car" have as much as 0.83 similarity, which makes no sense. But the model correctly puts "dog" closest to "cat"! On real corpora (billions of sentences) these vectors become very accurate.
\nAnd here's how we use a pretrained model trained on billions of words:
\nfrom gensim .downloader import load \n\nmodel = load ("glove-wiki-gigaword-50" )\n\nresult = model .most_similar (\n positive = ["king" , "woman" ],\n negative = ["man" ],\n topn = 5 \n)\n\nfor word , score in result :\n print (f" { word } : { score :.3f } " )\n\n# queen: 0.852 \n# throne: 0.737 \n# ... You can also check the similarity between words:
\nprint (model .similarity ("cat" , "dog" )) # ~0.92 \nprint (model .similarity ("cat" , "car" )) # ~0.15 "Cat" and "dog" - similarity 0.92. "Cat" and "car" - 0.15. The model "knows" that a cat is closer to a dog than to a car.
\nTip
\nExperiment: Go to the TensorFlow Embedding Projector - it's an interactive visualization of the vector space. You can type words and see what's close. It's ONE of the most beautiful visualizations in all of ML. Seriously, check it out!
\nWarning
\nWatch out for bias: Word2Vec learns from data. If in the training data "programmer" appears more often near "man" than "woman" - the model will pick that up. A famous example: vector("programmer") - vector("man") + vector("woman") ≈ "homemaker". That's a bias hidden in the data that the model unreflectively reproduces. Remember the semiosphere from the second post? The semiosphere isn't neutral - and neither is the training data.
Let's make the comparison again, to make it stick:
\n\n| \n | BoW / TF-IDF | \nWord2Vec | \n
|---|---|---|
| Type | \nSparse | \nDense | \n
| Vector length | \n= vocabulary size (can be 100 000+) | \n= embedding dimension (usually 100-300) | \n
| Values | \nMostly zeros | \nAll non-zero | \n
| Similarity | \nHard to capture | \nCosine similarity works great | \n
| Context | \nNone | \nCaptured through the context window | \n
| Analogies | \nNone | \nWork (king - man + woman ≈ queen) | \n
No. Word2Vec creates a map of meanings - it tells you that "cat" is close to "dog", but it can't compose a sentence out of that. It's like a synonym dictionary: you know what's similar, but you won't write a poem.
\nBut... what if we combine Word2Vec with Markov chains? A Markov chain picks the next word based on frequency. And if instead of drawing equally, we make words more similar to the context have a higher chance?
\nfrom gensim .models import Word2Vec \nimport numpy as np \nfrom collections import defaultdict \nimport random \n\ncorpus = [\n "cat sits on the mat and sleeps" ,\n "dog sits on the rug and sleeps" ,\n "cat runs around the room" ,\n "dog runs in the park" ,\n "cat and dog play in the garden" ,\n "cat eats kibble from the bowl" ,\n "dog eats kibble from the bowl" ,\n "cat catches a mouse in the house" ,\n "dog chases the cat in the garden" ,\n "bird sits on a branch of the tree" ,\n "cat looks through the window and purrs" ,\n "dog barks at the mailman" ,\n "cat sleeps all day on the couch" ,\n]\n\ntokenized = [sentence .split () for sentence in corpus ]\n\nw2v_model = Word2Vec (sentences = tokenized , vector_size = 10 , window = 3 , min_count = 1 , epochs = 200 )\n\n# build the transition matrix (like in Markov chains) \ntransitions = defaultdict (list )\nfor sentence in tokenized :\n for i in range (len (sentence ) - 1 ):\n transitions [sentence [i ]].append (sentence [i + 1 ])\n\ndef generate (start , length = 6 ):\n words = [start ]\n for _ in range (length ):\n current = words [- 1 ]\n if current not in transitions :\n break \n\n candidates = transitions [current ]\n\n # averaged vector of the last words = context \n context_vector = np .mean (\n [w2v_model .wv [w ] for w in words [- 3 :] if w in w2v_model .wv ],\n axis = 0 ,\n )\n\n # score candidates by similarity to the context \n scored = []\n for candidate in candidates :\n if candidate in w2v_model .wv :\n similarity = np .dot (context_vector , w2v_model .wv [candidate ]) / (\n np .linalg .norm (context_vector ) * np .linalg .norm (w2v_model .wv [candidate ]) + 1e-8 \n )\n scored .append ((candidate , similarity ))\n\n if scored :\n # draw, but with weights - similar words have a higher chance \n weights = [score + 1 for _ , score in scored ]\n chosen = random .choices ([w for w , _ in scored ], weights = weights , k = 1 )[0 ]\n words .append (chosen )\n else :\n words .append (random .choice (candidates ))\n return " " .join (words )\n\nfor _ in range (5 ):\n print (generate ("cat" ))cat sits on the mat and sleeps\ncat looks through the window and purrs\ncat eats kibble from the bowl\ncat sleeps all day on the couch\ncat catches a mouse in the house\nIt's not Shakespeare, but the texts are more coherent than pure random Markov. The idea is simple:
\nThis is a tiny step toward what today's LLMs do. They also predict the next word, but instead of a simple transition matrix they have multi-layer Transformer networks with an attention mechanism. There, "scoring candidates" is much, much more advanced.
\nImportant
\nThe key difference: Word2Vec gives each word ONE vector. But "bank" in "bank account" and "bank" of a river are completely different meanings! Word2Vec doesn't distinguish them - that's why in the next posts we get into Transformers, where context changes the meaning of every word.
\nHere's our roadmap, from cutting text to the geometry of meanings:
\n| Method | \nWhat it does | \nContext? | \nWhat it can't do | \n
|---|---|---|---|
| Tokenization (BPE) | \nCuts text into pieces | \nNo | \nDoesn't understand what it cuts | \n
| BoW / TF-IDF | \nCounts words, weights by rarity | \nNo | \nIgnores order | \n
| N-grams | \nLooks at word sequences | \nLocal (2-3 words) | \nShort context, fast-growing vocabulary | \n
| Naive Bayes | \nClassifies based on probability | \nNo (words "independent") | \nDoesn't capture dependencies between words | \n
| Word2Vec | \nTurns words into meaning vectors | \nYes (context window) | \nOne word = one vector (ignores polysemy) | \n
And the key perspective: from each of these methods, the LLM took something for itself.
\nThe LLM didn't fall from the sky. It stands on the shoulders of giants.
\nImportant
\nWhat's in the next post? We have word vectors - but how do we build something out of them that understands whole sentences? In the next post we'll walk the whole path from a single neuron (perceptron, 1958), through MLP, RNN with the forgetting problem, to LSTM with memory gates. The evolution of architectures that prepared the ground for Transformers and ChatGPT. Stay tuned!
\nI know this post is a lot, but I wanted the path from "cutting text" to "meaning vectors" to be complete and understandable.
\nI hope you'll say "aha!" at least a few times. If anything is unclear - let me know in the comments, I'll try to explain. And if you have better Word2Vec analogy examples - even more reason to let me know.
\nWhich method surprised you the most? Did you know that ChatGPT "thinks" in tokens, not words? And that its "thinking" is really a descendant of Markov chains?
\nSee you next time!
\nSources and interesting links:
\nIf you want to go deeper, here are the materials I used:
\nTokenization quiz answers: 1) "lowest" -> ["low", "est"] (l+o->lo, lo+w->low; "e" and "s" might be merged to "es", then "est"? depends on the merges - with our merges "es" exists, so "lowest" -> ["low", "es", "t"]). 2) "newer" -> ["new", "er"] (n+e->ne, ne+w->new; "er" is not merged in our dictionary). 3) "widower" -> ["w", "i", "d", "o", "w", "er"] or similar - "widow" isn't a merge we have, so it gets split (w+i+d+ow... but "ow" isn't merged either, only "lo"). The exact split depends on which merges made it into the dictionary. ↩
\nIn the previous post we built our linguistic onion - five layers, from phonetics to pragmatics, and we saw how an LLM handles each of them. But after writing that post, one big "but..." lingered in my head.
\nBecause - does an LLM even "understand" what it generates? Does it have some internal model of the world? Does it think?
\nAnd then I stumbled into semiotics. And it turns out that semiotics gives us a brilliant frame for thinking about LLMs - not as an artificial mind, but as a machine of signs. And suddenly everything starts to make sense. Or at least it makes more sense than before ;-)
\nThis is the second post in the "Understanding LLM" series. Today we shift perspective: instead of looking at the layers of language, we look at the very nature of what signs are and how meaning comes into being at all. And why that is key to understanding what an LLM is - and what it is not.
\nBefore we get to LLMs, we need to nail down the basics. Because "semiotics" is one of those words that sounds smart, but what does it actually mean?
\nSemiotics is the study of signs and of how signs create meaning. That's it. Doesn't sound so scary anymore, right? ;-)
\nAnd a "sign" in semiotics is anything that means something. Something that stands for something else. Simple examples:
\nEach of these signs represents something else. And that "representing" is exactly what semiotics studies.
\nTip
\nExperiment: Look around you - how many signs do you see right now? At this moment I see: a WiFi icon (I have internet), a notification on my phone (someone texted), a logo on my coffee mug (a brand). Three signs and I didn't even get up from my chair.
\nIn the previous post we had semantics - the study of the meaning of words and sentences. So how does semiotics differ?
\nIn short:
\n| \n | What it asks | \nExample | \n
|---|---|---|
| Semantics | \n"What does this mean?" | \nWhat does the word "zamek" mean? | \n
| Semiotics | \n"How does this sign even work?" | \nHow is it that a red light MEANS "stop"? | \n
Semantics asks about specific meanings. Semiotics asks about the mechanism of meaning - how it is that anything means anything at all.
\nAnd that is exactly why semiotics is so important for understanding LLMs. Because the question is not "what does an LLM mean", but "how an LLM operates on signs".
\nIn semiotics there are two main traditions you need to know. Two approaches, two ways of thinking about signs. And note - both are important for understanding LLMs, but each from a different angle.
\nSaussure (a Swiss linguist, who lived at the turn of the 19th and 20th centuries) said: a sign consists of two parts.
\n\nAnd the key thing: the relationship between signifier and signified is arbitrary. There is no logical reason why the sequence of letters "c-a-t" means that particular animal. It just... caught on. In Polish it's "kot", in German "Katze", in Japanese "猫" (neko) - every language has a different sequence of sounds/letters for the same concept.
\nBut Saussure says something even more important: the meaning of a word arises from its relationship to other words in the system. "Cat" means what it means because it is NOT "dog", it is NOT "house", it is NOT "car". Meaning is differential - it arises from difference.
\n\n\nThis sounds abstract, but in a moment you'll see that this is exactly what embeddings do in an LLM. Really ;-)
\n
Peirce (an American philosopher, a bit earlier than Saussure, but roughly around the same time) had a different approach. For him a sign is not a static pair, but a dynamic process.
\n\nPeirce's triad:
\nAnd that is the key difference: for Saussure a sign is static (a pair), for Peirce it is dynamic, alive, a process. Meaning is not "contained" in the sign - it arises in the process of interpretation.
\nPeirce divided signs into three categories that are super intuitive:
\n| Type | \nDescription | \nExamples | \n
|---|---|---|
| Icon | \nA resemblance between the sign and the object | \nA portrait, a map, the emoji 😺 (looks a bit like a cat), a folder icon on a computer | \n
| Index | \nA causal or physical connection | \nFootprints in the sand (someone walked here), smoke (fire), a cough (illness), a thermometer (temperature) | \n
| Symbol | \nA convention, a social agreement | \nThe word "cat", a national flag, a red light = stop, the mathematical "=" | \n
Note
\nThe word "symbol" in everyday language means something different than in Peirce's semiotics! In semiotics a symbol is a sign based purely on convention - it doesn't resemble the object (like an icon) and isn't physically tied to it (like an index). The Polish flag doesn't "resemble" Poland and isn't physically connected to it - we simply agreed that these colors stand for that country.
\nTest yourself - what type of sign is this?1
\nDavid Manheim, an AI researcher, used a beautiful metaphor coming from Peirce's semiotics. He called it the "Hall of Mirrors Problem".
\nImagine: you're in a room full of mirrors. You see reflections of reflections of reflections... and there's no window to the outside anywhere. You don't see the real world - you see only... more mirrors.
\nThat is exactly what an LLM does.
\n\nLet's look at this through the lens of Peirce's triad:
\nAn LLM has never seen the world. It has never tasted a strawberry, never touched ice, never heard laughter. It draws all its "knowledge" about the world from text - from what other people wrote about the world.
\nSo when an LLM writes "strawberries are sweet" - it doesn't know they are sweet. It knows that in the texts it was trained on, the word "strawberries" often appears near the word "sweet". That is the difference. And that is precisely the semiotic difference.
\nWarning
\nParadox: An LLM can write a beautiful description of a sunset, even though it has never seen the sun. But it can also write a beautiful description of a sunset on Mars - even though nobody has ever seen a sunset there yet. How does it "know"? From science fiction text. So: signs refer to signs, which refer to signs... a hall of mirrors ;-)
\nOK, now what I promised - let's see how Saussure's theory plays out in code. Because this is genuinely fascinating.
\nRemember what Saussure said? The meaning of a word arises from its relationship to other words. "Cat" means what it means because it isn't "dog", it isn't "house", etc. Meaning is relational.
\nNow think about word embeddings - which we met in the previous post. Each word is represented as a vector in a high-dimensional space. And words with similar meanings are close to each other in that space.
\nThis is exactly Saussure's relational theory of the sign, just implemented in math!
\nfrom gensim .downloader import load \n\nmodel = load ("glove-wiki-gigaword-50" )\n\nking = model ["king" ]\nqueen = model ["queen" ]\nman = model ["man" ]\nwoman = model ["woman" ]\n\nresult = king - man + woman \n\nfrom gensim .models import KeyedVectors \nsimilarities = model .cosine_similarities (result , [queen ])\nprint (f"Similarity to 'queen': { similarities [ 0 ]:.3f } " )It will print something like: Similarity to 'queen': 0.850
But look at this from Saussure's perspective:
\n\nBoth Saussure and Word2Vec say the same thing: meaning is not in the sign itself - it's in its relation to other signs. Saussure came up with this as a theory of language. Engineers at Google came up with Word2Vec as an algorithm. And they reached the same conclusion.
\nWell... almost. Because there's one catch. Saussure assumed that behind the signifier (form) stands the signified (concept). In embeddings we only have a position in space - we have relations, but do we have a "concept"? Is the vector [0.50, 0.68, ...] the concept of "king"?
And that is exactly the question that leads us to the next semiotician...
\nJacques Derrida (a French philosopher, 1960s and 70s) did something bold. He looked at all of Saussure and said: "Wait. And why do you assume speech is more important than writing?"
\nSaussure (and the entire Western philosophical tradition) treated speech as "primary" - closer to thought, closer to meaning. Writing was "derivative" - merely a record of speech, a "sign of a sign". Derrida called this logocentrism - the belief that at the end of the chain of signs there is some "presence", some "thought", some "intention" that bestows meaning.
\nAnd Derrida turned this upside down: writing is not subordinate to speech. Writing is a system in its own right.
\nWhy does this matter for LLMs? Because Elad Vromen, in his paper "Language Models as Semiotic Machines", noticed something brilliant:
\n\n\n\nAn LLM trains on writing (text). It builds a model of writing. It generates new writing. Nowhere in this process is there "speech", "mind", or "intention". Saussure's entire hierarchy - speech > writing - gets inverted. Writing is the only reality an LLM knows.
\n
So when we ask "does an LLM understand language?" - we're asking a bad question. It's like asking "does a book understand what is written in it?" A book doesn't "understand" - but it contains signs that we - the readers - interpret. An LLM is something in between: it isn't a book (because it generates new text), but it isn't a mind either (because it has no access to meanings outside of text).
\nImportant
\nDerrida in a nutshell for LLMs: An LLM doesn't model a "mind" or a "world". An LLM models writing - a system of signs that has its own logic, its own rules, its own coherence. And that writing is enough to generate text that means something to us. But it is us who give it meaning - not the model.
\nThis also explains a phenomenon you've probably noticed: an LLM sometimes says things that are statistically correct, but nonsensical. Because in the system of writing the model operates in, those words fit together well. But we - as humans with access to the world (to objects in Peirce's sense) - see that it makes no sense. The model lacks that "grounding" in reality.
\nDerrida, in his famous essay "Signature Event Context", spoke of the iterability of signs - the fact that a sign can be repeated in a new context and take on new meaning. The word "good" can be a compliment, irony, or part of "good evening" - context changes everything.
\nAnd that is exactly what we see in LLMs: the same prompt in a different context yields a different answer. The model doesn't "understand" context - but statistically it picks up contextual patterns from the training data. So: iterability of signs in its purest, mathematical form.
\nNow we move onto very practical ground. Because if an LLM is a machine of signs, then a prompt - what you type into it - is a semiotic act. Not simply "a command". But an act that creates the frame for meaning.
\nLet's look at the interaction with an LLM through the lens of Peirce's triad:
\n\nSo:
\nNotice: meaning arises only in step 3. The LLM generates a sequence of tokens, but it's you who gives it sense. This is exactly what Umberto Eco meant with his concept of the "open work" - a text doesn't have one fixed meaning. A text is a "frame" that the reader fills with interpretation.
\nTry it yourself. Fire up ChatGPT (or Claude, Gemini - whatever you have) and send these three prompts, each in a new conversation:
\n"Explain what gravity is.""Explain gravity to a five-year-old.""Explain gravity in the style of a Shakespearean sonnet."Each prompt is about the same topic (gravity). But each one changes the semiotic frame - it shifts the tone, the register, the genre, the expected form of the answer.
\n| Prompt | \nWhat changes... | \nSemiotic frame | \n
|---|---|---|
| "Explain gravity" | \n- | \nNeutral, encyclopedic | \n
| "...to a five-year-old" | \nThe audience, the simplicity of language | \nEducational, age-appropriate | \n
| "...in the style of Shakespeare" | \nThe genre, the form, the style | \nLiterary, artistic | \n
This is exactly what Picca calls the "semiotic contract". When you write a prompt, you don't "ask for information" - you set the conditions under which meaning will be constructed. You ask for gravity in Shakespeare mode? You get a hybrid of physics and poetry. That's neither "real" gravity nor "real" Shakespeare - it's a semiotic collage, a new configuration of signs.
\nTip
\nBonus experiment: Try this: "Explain the concept of entropy using metaphors from fairy tales." You'll see how an LLM connects two completely different semiotic zones - physics and fairy tales. That is exactly what semiotics calls translation between cultural codes.
\nOne more concept worth knowing. Juri Lotman, a Russian semiotician, came up with the concept of the semiosphere.
\nThe semiosphere is the space in which signs live. It's an ecology of meanings - a network of cultural codes, genres, discourses, ideologies that interact with one another. Just as the biosphere is the space in which organisms live, the semiosphere is the space in which signs live.
\n\nAn LLM's training data is nothing else but a giant cross-section of the semiosphere. When the model reads Wikipedia, Twitter, books, scientific papers, source code - it absorbs (statistically!) all that diversity of cultural codes.
\nAnd that's why it can write in the style of Shakespeare, translate from German, joke like a comedian, and quote legal regulations - because all of that lives in the semiosphere, and the model has "seen" samples from every zone.
\nBut there's a flip side: the model also absorbs the prejudices, stereotypes, and dominant narratives contained in the semiosphere. Because the semiosphere isn't neutral - it's a cultural space with a history, with power, with ideology. And the LLM, operating on signs from that space, reproduces them in its outputs.
\nWarning
\nWhy does an LLM sometimes talk nonsense? Because the semiosphere is full of contradictions. On one page of the internet "the earth is round", on another "the earth is flat". The model sees both signs and has no access to the "object" (the actual earth) to decide which sign is true. It operates in a hall of mirrors - signs refer to signs, not to reality.
\nTest which semiotician better explains these LLM phenomena. A reminder:
\nWho better explains the fact that...?2
\nHere's our semiotic map in a nutshell:
\n| Semiotician | \nKey concept | \nWhat it tells us about LLMs | \n
|---|---|---|
| Saussure | \nMeaning = relation between signs | \nEmbeddings realize the relational concept of the sign | \n
| Peirce | \nTriad sign-object-interpretant | \nAn LLM has no access to the object, only to signs (hall of mirrors) | \n
| Derrida | \nWriting as a system in itself | \nAn LLM models writing, not mind; training data = the only source | \n
| Lotman | \nSemiosphere - the ecology of signs | \nTraining data is a cross-section of the semiosphere; an LLM navigates its zones | \n
| Eco | \nThe open work | \nAn LLM's output has no single meaning - it requires your interpretation | \n
So: an LLM has no mind. But that doesn't mean it does nothing interesting. An LLM operates on signs - it reconfigures them, connects zones of the semiosphere, creates new configurations of signs. And those new configurations mean something to us - as interpreters.
\nThat is the semiotic answer to "does an LLM understand?". An LLM doesn't "understand" in the human sense. But it generates signs that enter our semiosphere and become part of our process of interpretation. And that process is real, important, and powerful.
\nI know semiotics sounds at first like something from another planet, but I hope you now see how it connects to LLMs.
\nWhich semiotic concept do you find most useful for understanding LLMs? Saussure and his relationality? Peirce and his hall of mirrors? Or maybe Derrida and his "writing"?
\nBecause frankly - I'm still learning this perspective myself. But I feel this is the moment where linguistics, philosophy, and programming meet in one place and create something genuinely fascinating.
\n\n\nWhat's in the next post? We move from theory to practice: How a computer reads text - from counting words to vectors. We'll see how tokenization, TF-IDF, Markov chains, and Word2Vec realize in code what Saussure (meaning is relational!) and Derrida (writing is a system in its own right!) were talking about.
\n
See you next time!
\nSources and interesting links:
\nIf you want to go deeper, here are the materials I used:
\nAnswers: 1) index (causal - temperature causes the liquid to expand), 2) icon (a resemblance to the dog), 3) symbol (pure convention), 4) index (a physical trace of someone who walked here), 5) icon (a resemblance to a person in a wheelchair). ↩
\nMy answers: 1) Peirce - the model has no access to the object (the experience of poetry), but it generates representamens (text) that we interpret. 2) Saussure - this is pure relationality! A king is defined by what it is not. 3) Peirce - context changes interpretation, and the interpretant creates a new sign. 4) Peirce - the absence of the object in the triad. 5) Peirce + Lotman - the model reproduces signs from the medical zone of the semiosphere without access to the real object (the patient's body). The diagnosis is a sign without grounding. ↩
\nLLMs (Large Language Models, i.e. ChatGPT, Claude, Gemini and friends) have been with us for a while now, and I decided to dig deeper into the topic, and one big question came up: but how does it even work that a model "understands" language? After all, underneath it's just "math and statistics", right? Well... yes and no ;-)
\nAnd then I stumbled into linguistics. And it turned out that to truly understand what an LLM does with language, you first need to understand what language is made of. And since a programmer trying to read about linguistics is a rather funny picture, I thought: I'll share it with you ;-)
\nThis is the first post in a series in which we'll survey different levels of language analysis and see how it all connects to LLMs. In today's post we'll build the foundation - we'll get to know the five main layers of language and see why each of them matters for language models.
\nBefore we get into the details, imagine language as a sort of... onion. Or a layer cake, if you prefer sweet metaphors :D
\nEach layer is a different level on which language "works". From the lowest - sounds - to the highest - what we really meant to say, even when we said something completely different.
\n\nFive layers, five ways in which language gets "analyzed". And note - an LLM has to handle each of these levels to come across as a sensible conversational partner. Of course it doesn't do this consciously - but the structures it learns during training somehow "catch" these layers.
\nNote
\nThe five layers of language in a nutshell:
\nOK, let's get to it. We start at the bottom of our onion ;-)
\nPhonetics studies speech sounds as physical phenomena. Put simply: how we produce sounds, how they travel through the air, and how we receive them.
\nIt has three branches:
\n| Branch | \nWhat it studies | \nExample | \n
|---|---|---|
| Articulatory | \nHow the speech organs produce sounds | \nWhere is your tongue when you say "sh"? | \n
| Acoustic | \nThe physical properties of sound waves | \nFrequency, amplitude | \n
| Auditory | \nHow the ear and brain receive sounds | \nHow the cochlea turns waves into a nerve signal | \n
Phonology is a level up. It's not interested in sounds as physical phenomena, but in how sounds are organized in a particular language.
\nKey concept: the phoneme - the smallest unit of sound that distinguishes the meaning of words.
\nA simple example in English:
\nOr in Polish:
\nTip
\nExperiment: Say "cat" out loud, once as a plain statement ("My cat sleeps."), and once as a surprised question ("Cat?!" with raised eyebrows). The same word, but intonation, stress, and melody completely change what the listener "hears". That is phonology in action - sounds + their organization in a system.
\nRight - an LLM gets text, not sound. It has never heard pronunciation. And yet...
\nSo the model somehow absorbs phonological information from text data alone. A bit like never having seen the ocean, but having read so many books about it that you can describe it ;-)
\nBut of course there are limitations. A text-based LLM can't distinguish homophones (words that sound the same but mean different things) based on phonetics - it handles them purely at the semantic level (more on that in a moment).
\nAnd a fun fact: models like Whisper (speech-to-text from OpenAI) already connect phonetics with text. But that's a topic for a separate post in this series ;-)
\nWarning
\nParadox: An LLM has never heard a single sound, yet from training data it "knows" about rhymes, wordplay, and sound patterns. It's a bit like a person deaf from birth who can write rhyming poetry - because they've read millions of them.
\nMorphology studies the structure of words - how they're assembled from smaller, meaningful pieces called morphemes.
\nA morpheme is the smallest unit of language that carries meaning. It can't be divided into anything smaller that would still carry meaning.
\nAn example from English, often used in textbooks:
\nunhappiness = un + happy + ness\n ↑ ↑ ↑\n "not" "happy" makes a noun\nOr in Polish:
\nnieszczęśliwy = nie + szczęśliw + y\n ↑ ↑ ↑\n "not" "happy/fortune" masculine gender\nOr even more:
\nnieprzystojny = nie + przy + stoj + ny\n "not" + "at" + "stand" + adjective suffix\nEach of these pieces has its own meaning. Those are morphemes.
\n| Type | \nDescription | \nExamples | \n
|---|---|---|
| Free | \nCan stand alone as a word | \ncat, house, runs | \n
| Bound | \nMust be attached to another morpheme | \nun-, -ness, -s, -ed | \n
And among bound morphemes we have affixes:
\nThis is an important distinction:
\nInflection - changes the grammatical form, but doesn't create a new word:
\nDerivation (word formation) - creates a new word, often changing the part of speech:
\nWarning
\nPolish morphology is a nightmare for an LLM! The Polish language is highly inflectional - we have 7 cases, 2 numbers, 3 genders, verb aspects, and tons of exceptions. For comparison: in English, declining a noun means at most adding -s. In Polish? "Dom, domu, domowi, dom, domem, domu, domie, domy, domow..." and so on :D
\nHere's a fun fact. An LLM doesn't "know" what morphemes are. It uses BPE tokenization (Byte Pair Encoding), which splits text into tokens - but tokens are not the same as morphemes.
\n\nThe BPE tokenizer splits text based on frequency of occurrence in the training data, not on linguistic structure. Sometimes that overlaps with morphemes, sometimes it doesn't.
\nThat means the model doesn't learn morphology "directly" - it learns it indirectly, through statistics. And somehow it works ;-)
\nTip
\nA challenge for you: Can you break these words into morphemes?
\nSyntax is the set of rules that determine how words are combined into sentences. Thanks to syntax we know that "The cat sits on the mat" is a valid sentence, and "The cat the on mat sits" is gibberish.
\nSimple? Well... more or less ;-)
\nDifferent languages have different word-order rules:
\n| Language | \nBasic order | \nExample | \n
|---|---|---|
| English | \nSVO (Subject-Verb-Object) | \nThe cat sits on the mat | \n
| Polish | \n"Flexible" SVO, but... | \nKot siedzi na macie / Na macie siedzi kot / Siedzi kot na macie | \n
| Japanese | \nSOV | \n猫がマットの上に座っている | \n
| Latin | \nFree (because endings say everything) | \nFelix in tapete sedet | \n
Polish is nice because we have quite a lot of freedom in word order. While in English "On the mat sits the cat" sounds poetic or unnatural, for us it's a normal sentence ;-)
\nSentences have a hierarchical structure - words group into phrases, and phrases into larger phrases. You can draw it as a tree:
\n\nThat's the simple sentence "The cat sits on the mat" and it already has its hierarchy! Now imagine sentences with subordinate clauses, participles, adverbials...
\nThis is a famous example from Noam Chomsky.
\nThe sentence is syntactically correct - it has a subject, a predicate, a proper structure. But semantically it's complete nonsense - ideas can't be green or sleep.
\nAnd that's exactly the proof that syntax and semantics are two different levels. You can have perfect syntax and zero sense ;-)
\nImportant
\nSyntax is an LLM's superpower. The model learns to predict the next token based on a huge amount of text data. In the process it absorbs syntactic patterns - it knows that after "The cat sits on..." we expect a noun, and after "Quickly..." a verb. This is the foundation of why an LLM generates grammatically correct sentences.
\nTest yourself - which sentences are syntactically correct?1
\nIf syntax asks "how is this built?", semantics asks: "what does it mean?"
\nSemantics studies the meaning of words, phrases, and sentences. And right away it turns out this isn't simple at all.
\nA classic English example: bank
\nThe same word, four completely different meanings. How does an LLM know which one is meant? From context. And that's exactly what it does well - because it has seen millions of sentences where "bank" appeared in different contexts.
\nOr another classic - polysemy within a single sentence:
\n\n\n"I can can the canning of cans."
\n
The word "can" three times, three different functions: can (be able to), can (the verb, to put in a can), can (the noun, a container). Context changes everything ;-)
\nAlmost. But not quite:
\nSemantics studies these subtle differences - both denotation (literal meaning) and connotation (associations, emotional coloring).
\nHere enters the concept of word embeddings. In broad terms: each word is represented as a vector - a sequence of numbers - in a high-dimensional space. Words with similar meanings are "close" to each other in that space.
\nThe famous example you've probably seen:
\nvector("king") - vector("man") + vector("woman") ≈ vector("queen")\nMeaning: the model "knows" that the relationship between "king" and "man" is analogous to the relationship between "queen" and "woman". And it got that purely from data - nobody taught it that!
\nWe can even show this in code. Here's a simple example with the gensim library in Python:
from gensim .downloader import load \n\nmodel = load ("glove-wiki-gigaword-50" )\n\nresult = model .most_similar (\n positive = ["king" , "woman" ],\n negative = ["man" ],\n topn = 3 \n)\n\nprint (result )\n# [('queen', 0.85), ...] -- in first place: queen! Tip
\nIf you want to test this yourself: install gensim (pip install gensim) and run the code above. Of course you'll need some RAM - the GloVe model isn't small. But the result is genuinely satisfying ;-)
One of the most important concepts in semantics: the meaning of a sentence is the result of the meanings of the individual words + the rules for combining them.
\nSo: "The red cat sits on the mat" = [red] + [cat] + [sits] + [on] + [the mat] + syntactic rules.
\nSounds trivial, but it's a powerful principle. Thanks to it we can understand an infinite number of sentences, even ones we've never heard before. And thanks to it an LLM can generate new, never-before-seen sentences that still make sense.
\nWarning
\nBut careful: "I understood that you didn't understand that it wasn't understandable." - each word is simple, but the sentence as a whole requires analyzing it layer by layer. Compositionality is a powerful tool, but it has its limits.
\nAnd so we arrive at the most interesting layer (in my opinion). Pragmatics studies how context influences the meaning of an utterance - what we really want to say, often by saying something completely different.
\nIf semantics asks "what does this mean?", pragmatics asks: "what did the author mean in this particular situation?"
\nScene 1: "It's cold in here."
\nSemantically: information about the temperature in the room.\nPragmatically: "Close the window!" or "Turn up the heating!" or "Give me a blanket."
\nEvery one of you understands that when someone says "It's cold in here" while standing next to an open window - you don't ask about degrees Celsius, you just close the window.
\nScene 2: "Could you pass the salt?"
\nSemantically: a question about your ability to pass the salt.\nPragmatically: a request to pass the salt.
\nAnswering "Yes, I could" (and nothing more) is semantically correct, but pragmatically... well, you're being a bit rude ;-)
\nScene 3: Irony
\n\n\n"Well congratulations, you broke it again."
\n
Semantically: congratulations.\nPragmatically: irony, criticism, disappointment.
\nDoes an LLM catch irony? Sometimes yes, sometimes no. It's still an open research problem.
\nThe philosopher J.L. Austin came up with something brilliant: utterances don't just describe reality, they also do things.
\n| Type of speech act | \nDescription | \nExample | \n
|---|---|---|
| Locutionary | \nThe utterance itself | \nYou say "I'm closing the window" | \n
| Illocutionary | \nThe intention of the utterance | \nA promise to close the window | \n
| Perlocutionary | \nThe effect on the listener | \nThe listener feels relieved | \n
Other examples of speech acts:
\nPaul Grice, another philosopher of language, noticed that conversation follows a cooperative principle - we say things that are relevant, true, clear, and on topic.
\nWhen someone breaks that principle, we look for an implicature - a hidden meaning.
\nExample:
\n\n\nA: "Are you going to the party?"\nB: "I have an exam tomorrow."
\n
B didn't answer "yes" or "no". But from the context A understands: I'm not going, because I have to study. That's a conversational implicature.
\nWarning
\nThis is the hardest layer for an LLM. And that's not just my opinion - researchers all over the world are working on benchmarks that test the pragmatics of language models.
\nThe problems:
\nBut on the other hand - GPT-4 and newer models are getting better and better. Why? Because the enormous amount of training data contains pragmatics in practice - dialogues from movies, books, internet forums. The model has "seen" millions of examples of irony, politeness, requests.
\nTip
\nAn experiment for you: Open ChatGPT (or Claude, or whatever you have at hand) and run this short test:
\nTell the model:
\n"I just hammered my finger."
\nThen, in a new conversation:
\n"Well congratulations, I hammered my finger again!"
\nSee whether the model notices that in the second case "congratulations" is irony, or whether it starts calling an ambulance?
\nHere are our five layers, in a nutshell:
\n| Layer | \nWhat it studies | \nExample | \nHow the LLM handles it | \n
|---|---|---|---|
| Phonetics & phonology | \nSounds and the system of sounds | \n/kat/ vs /hat/ | \nNever hears them, but "knows" from text data | \n
| Morphology | \nWord structure from morphemes | \nun-happy-ness | \nBPE tokenization != morphemes, but it works somehow | \n
| Syntax | \nWord order in a sentence | \nThe cat sits on the mat | \nThe model's superpower - handles grammar great | \n
| Semantics | \nMeaning of words and sentences | \n"bank" - which one? | \nWord embeddings + context | \n
| Pragmatics | \nMeaning in context | \n"It's cold" = close the window | \nThe hardest layer, still an open problem | \n
In the next post we change perspective - instead of looking at the layers of language, we look at the very nature of signs and meaning:
\n\nIf you made it all the way here - thanks! ;-) I really appreciate that you took the time to read this monster.
\nI hope I brought the topic a little closer to you. If anything is unclear - let me know in the comments, I'll try to explain. And if you have better examples (and you surely do!) - even more reason to let me know.
\nWhich layer surprised you the most? Which do you find the most interesting in the context of AI?
\nSee you in the next post!
\nSources and interesting links:
\nIf you want to go deeper, here are the materials I used when writing this post:
\nQuiz answers: sentences 1 and 5 are correct. Sentence 1 has standard SVO order. Sentence 5 is a grammatical question formed with the auxiliary "does". Sentences 2 and 3 are understandable but sound archaic or poetic - English allows such inversions only in limited stylistic contexts, unlike Polish where flexible word order is the norm. Sentence 4 ("The dog the mailman at barks") is syntactically incorrect - the word order is so jumbled it violates the rules of English grammar. ↩
\n