{ "cells": [ { "cell_type": "markdown", "metadata": { "tags": [ "remove-cell" ] }, "source": [ "---\n", "license:\n", " code: MIT\n", " content: CC-BY-4.0\n", "github: https://github.com/ocademy-ai/machine-learning\n", "venue: By Ocademy\n", "open_access: true\n", "bibliography:\n", " - https://raw.githubusercontent.com/ocademy-ai/machine-learning/main/open-machine-learning-jupyter-book/references.bib\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "vePKj2Q6Huai" }, "source": [ "# Transformers for Language Modelling" ] }, { "cell_type": "markdown", "metadata": { "id": "Z5MqS6YYVoUr" }, "source": [ "As we have familiarized ourselves with the attention mechanism in Transformers, now let's see how these models can be trained as language models.\n", "\n", "* In the first part, I prepared a few pretrained language models for you to examine and play with.\n", "* In the second part, we will train a transformer language model from scratch.\n", " * We will handcraft a simple English language with [Probabilistic Context free Grammar](https://en.wikipedia.org/wiki/Probabilistic_context-free_grammar).\n", " * Then let the GPT learn this artificial language, and we will examine the emergent phenomena from training.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "uLMOx_hoJCJM" }, "source": [ "## Play with Pre-trained transformers language models" ] }, { "cell_type": "markdown", "metadata": { "id": "jQBE1UBKJNUK" }, "source": [ "`transformers` library from huggingface is the *de facto* standard library for loading and using transformer architectures." ] }, { "cell_type": "markdown", "metadata": { "id": "rOAOnHgbNgbQ" }, "source": [ "Let's load some common models and see their inner architecture. Specifically, we will look at two classic models, BERT and GPT2. (developped ~ 2018)\n", "\n", "They are both transformers but with some prominal differences\n", "\n", "* BERT: Bidirectional Encoder Representations from Transformers\n", " * **Architecture**: All-to-all attention. Transformer Encoder.\n", " * **Objective**: Masked language modelling\n", " * **Usage**:\n", " * Can fill in blanks and perform cloze task\n", " * Provide representation for many downstream language understanding tasks.\n", "* GPT2: Generative Pre-trained Transformer 2\n", " * **Architecture**: Causal attention. Transformer Decoder\n", " * **Objective**: autoregressive language modelling\n", " * **Usage**:\n", " * Can continue prompt and answer questions\n", " * Can be finetuned to follow task specific instructions.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "8O5wkUxciWes" }, "source": [ "Here are the conceptual picture of BERT and GPT2, let's keep it in mind and try to map them to the modules we see\n", "\n", "**BERT**\n", "\n", "![BERT (Transformer encoder)](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/llm/clipboard_20240409_034503.png)\n", "\n", "**GPT2**\n", "\n", "![](https://static-1300131294.cos.ap-shanghai.myqcloud.com/images/llm/clipboard_20240409_034531.png)" ] }, { "cell_type": "markdown", "metadata": { "id": "U9qWUlFcfhNq" }, "source": [ "### Loading" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "id": "s0SBgGkDf5Qa" }, "outputs": [], "source": [ "import transformers\n", "from transformers import GPT2Tokenizer, GPT2Model, GPT2Config, GPT2LMHeadModel, DataCollatorForLanguageModeling\n", "from transformers import pipeline, BertModel, BertConfig, BertTokenizer, BertLMHeadModel" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "id": "lbBL4AOEOCxg" }, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "def recursive_print(module, prefix=\"\", depth=0, deepest=3):\n", " \"\"\"Simulating print(module) for torch.nn.Modules\n", " but with depth control. Print to the `deepest` level. `deepest=0` means no print\n", " \"\"\"\n", " if depth == 0:\n", " print(f\"[{type(module).__name__}]\")\n", " if depth >= deepest:\n", " return\n", " for name, child in module.named_children():\n", " if len([*child.named_children()]) == 0:\n", " print(f\"{prefix}({name}): {child}\")\n", " else:\n", " if isinstance(child, nn.ModuleList):\n", " print(f\"{prefix}({name}): {type(child).__name__} len={len(child)}\")\n", " else:\n", " print(f\"{prefix}({name}): {type(child).__name__}\")\n", " recursive_print(child, prefix + \" \", depth + 1, deepest)" ] }, { "cell_type": "markdown", "metadata": { "id": "vu-Oe_jUNp5A" }, "source": [ "### BERT" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ktwsjxaYjoSh", "outputId": "cf594f06-fb52-4616-bff3-145540d48bc9" }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3da08a0571344893b36c4b7938aa98fa", "version_major": 2, "version_minor": 0 }, "text/plain": [ "model.safetensors: 0%| | 0.00/440M [00:00 a small big cow smelled the thin fat zebra\n", "\n", "But let's ignore it for a moment and let a transformer learn to \"speak\" this simply English." ] }, { "cell_type": "markdown", "metadata": { "id": "Zb_liucABJnA" }, "source": [ "### Tokenization: map words to numbers" ] }, { "cell_type": "markdown", "metadata": { "id": "rMyAT6ekBN8Y" }, "source": [ "For a computational system to understand language, first, we need to break the sentence into words and turn the words into something they know , indices. This is known as tokenization and encoding." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "id": "zdEB1j1MBe9a" }, "outputs": [], "source": [ "full_word_set = set(sum([words for words in word_map.values()], []))\n", "dictionary = {word: i for i, word in enumerate(full_word_set)} # Mapping words to indices\n", "dictionary[\"[End]\"] = len(dictionary)\n", "EOS_ID = dictionary[\"[End]\"] # end of sentence token\n", "PAD_ID = len(dictionary) # padding token\n", "dictionary[\"\"] = PAD_ID\n", "\n", "inverse_dictionary = {i: word for word, i in dictionary.items()} # Mapping indices to words" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "id": "NLawdrkoBnpo" }, "outputs": [], "source": [ "def tokenize_sentence(sentence):\n", " \"\"\" Tokenize a sentence into a list of words. \"\"\"\n", " word_seq = sentence.split(\" \")\n", " return word_seq\n", "\n", "\n", "def encode_sentence(sentence):\n", " \"\"\" Encode a sentence into a list of indices. \"\"\"\n", " word_seq = tokenize_sentence(sentence)\n", " inds = encode2indices(word_seq)\n", " return inds\n", "\n", "\n", "def encode2indices(word_seq):\n", " \"\"\" Encode a list of words into a list of indices. \"\"\"\n", " inds = [dictionary[word] for word in word_seq]\n", " return inds\n", "\n", "\n", "def decode2words(indices):\n", " \"\"\" Decode a list of indices into a list of words. \"\"\"\n", " words = [inverse_dictionary[ind] for ind in indices]\n", " return words\n", "\n", "\n", "def decode2sentence(indices):\n", " \"\"\" Decode a list of indices into a sentence. \"\"\"\n", " words = decode2words(indices)\n", " sentence = \" \".join(words)\n", " return sentence" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "OOONetGNBsUg", "outputId": "9fd25b6c-3350-4137-9846-98db06741c05" }, "outputs": [ { "data": { "text/plain": [ "[2, 3, 1, 26, 2, 10, 30, 19]" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "encode_sentence(\"a smart fox saw a cat that ran\")" ] }, { "cell_type": "markdown", "metadata": { "id": "xv1r6svjCNbw" }, "source": [ "### Build Sequence Dataset: `pad_seq` etc." ] }, { "cell_type": "markdown", "metadata": { "id": "wCEr77XUCXPA" }, "source": [ "Since we don't have a fixed dataset, but a generative model of language, we can simply generate new sentences on the fly and fed it to our transformer. (this is usually not the case)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "id": "QjreQ9A1CWuQ" }, "outputs": [], "source": [ "import torch\n", "from torch.nn.utils.rnn import pad_sequence\n", "\n", "def batch_sampler(batch_size=32, max_len=128):\n", " batch = []\n", " for i in range(batch_size):\n", " word_seq, _ = generate_sentences(rules, word_map)\n", " word_seq.append(\"[End]\") # add this marker to say, the sentence has ended.\n", " inds = encode2indices(word_seq)\n", " batch.append(torch.tensor(inds, dtype=torch.long))\n", " # pad the batch to be equal length, same len as the longest senetence.\n", " padded_batch = pad_sequence(batch, batch_first=True, padding_value=PAD_ID)\n", " # chuck to the max_len\n", " padded_batch = padded_batch[:, :max_len]\n", " return padded_batch" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "id": "UdutjfrLC6YZ" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([32, 20])\n", "the cat that sat heard that the cat that sat smelled that the bird saw a sheep [End] \n", "a dog swam [End] \n", "a bird that swam heard that a giraffe smelled a fat horse [End] \n", "a short smart dog saw that the sheep that stood saw that a bear sat [End] \n", "the round cat swam [End] \n", "the thin cow smelled a zebra that slept [End] \n", "a bird heard that a cow saw a smart thin zebra [End] \n", "a dog jumped [End] \n", "a horse smelled that a cat danced [End] \n", "the small dog saw that a wide bear smelled that the long sheep slept [End] \n", "a thin thin cat slept [End] \n", "a thin zebra saw the wide zebra [End] \n", "the dog saw a big pretty cat [End] \n", "the dog sat [End] \n", "the small smart bear danced [End] \n", "the horse that flew sat [End] \n", "the sheep that stood smelled the sheep that jumped [End] \n", "a long wide bird saw a zebra [End] \n", "a zebra smelled that a big sheep walked [End] \n", "a tall round fox saw the zebra [End] \n", "a thin long bear walked [End] \n", "the fox slept [End] \n", "the fat short cat sat [End] \n", "the big wide cat stood [End] \n", "a long cow smelled that the horse that slept smelled the tall fat cat [End] \n", "the long smart sheep smelled that a small cow heard the fat pretty bear [End] \n", "the cat jumped [End] \n", "a bird saw the zebra [End] \n", "the wide small zebra jumped [End] \n", "a fox smelled that the fat sheep smelled that the square fat fox walked [End] \n", "the giraffe that walked saw that a dog that sat smelled that the wide tall giraffe smelled a cow [End]\n", "the horse smelled that a bear saw a square smart horse [End] \n" ] } ], "source": [ "batch = batch_sampler()\n", "print(batch.shape)\n", "for j in range(batch.shape[0]):\n", " print(decode2sentence(batch[j].tolist()))" ] }, { "cell_type": "markdown", "metadata": { "id": "1mY8pNhGAEa4" }, "source": [ "### Train a transformer on this language" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "id": "0ErkXcuHAHQp" }, "outputs": [], "source": [ "import torch\n", "from torch.optim import AdamW\n", "from transformers import GPT2Model, GPT2Tokenizer, GPT2LMHeadModel, GPT2Config" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "id": "EtgQC-vgAYcw" }, "outputs": [], "source": [ "miniGPTconfig = GPT2Config(vocab_size=len(dictionary), n_positions=128, n_ctx=128,\n", " n_embd=64, n_layer=3, n_head=8,\n", " eos_token_id=EOS_ID, pad_token_id=PAD_ID)\n", "miniGPT = GPT2LMHeadModel(miniGPTconfig, )" ] }, { "cell_type": "markdown", "metadata": { "id": "Libcy4nWCChr" }, "source": [ "Finally, let's run our training loops!" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "WtyKfvjzB9IQ", "outputId": "b5d0eab5-09ad-4d6a-8f93-66c6fca2bd5a" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "We strongly recommend passing in an `attention_mask` since your input_ids may be padded. See https://huggingface.co/docs/transformers/troubleshooting#incorrect-output-when-padding-tokens-arent-masked.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "epoch 0, batch 0, loss 3.2727038860321045\n", "epoch 0, batch 1, loss 3.013523817062378\n", "epoch 0, batch 2, loss 2.9508156776428223\n", "epoch 0, batch 3, loss 2.864698648452759\n", "epoch 0, batch 4, loss 2.8440003395080566\n", "epoch 0, batch 5, loss 2.792489528656006\n", "epoch 0, batch 6, loss 2.7530574798583984\n", "epoch 0, batch 7, loss 2.712508201599121\n", "epoch 0, batch 8, loss 2.7014684677124023\n", "epoch 0, batch 9, loss 2.6464850902557373\n", "epoch 0, batch 10, loss 2.6130788326263428\n", "epoch 0, batch 11, loss 2.6004862785339355\n", "epoch 0, batch 12, loss 2.5547451972961426\n", "epoch 0, batch 13, loss 2.492750883102417\n", "epoch 0, batch 14, loss 2.4694128036499023\n", "epoch 0, batch 15, loss 2.4235713481903076\n", "epoch 0, batch 16, loss 2.3857686519622803\n", "epoch 0, batch 17, loss 2.4006121158599854\n", "epoch 0, batch 18, loss 2.3581535816192627\n", "epoch 0, batch 19, loss 2.2853527069091797\n", "epoch 0, batch 20, loss 2.2719969749450684\n", "epoch 0, batch 21, loss 2.2839810848236084\n", "epoch 0, batch 22, loss 2.259561061859131\n", "epoch 0, batch 23, loss 2.1954007148742676\n", "epoch 0, batch 24, loss 2.1371004581451416\n", "epoch 0, batch 25, loss 2.0955264568328857\n", "epoch 0, batch 26, loss 2.1326050758361816\n", "epoch 0, batch 27, loss 2.0571255683898926\n", "epoch 0, batch 28, loss 2.0366766452789307\n", "epoch 0, batch 29, loss 2.017181396484375\n", "epoch 0, batch 30, loss 1.9762787818908691\n", "epoch 0, batch 31, loss 1.9193634986877441\n", "epoch 0, batch 32, loss 1.9848976135253906\n", "epoch 0, batch 33, loss 1.9038301706314087\n", "epoch 0, batch 34, loss 1.872957468032837\n", "epoch 0, batch 35, loss 1.8023127317428589\n", "epoch 0, batch 36, loss 1.8214008808135986\n", "epoch 0, batch 37, loss 1.7515637874603271\n", "epoch 0, batch 38, loss 1.7599962949752808\n", "epoch 0, batch 39, loss 1.7228972911834717\n", "epoch 0, batch 40, loss 1.7311118841171265\n", "epoch 0, batch 41, loss 1.6666715145111084\n", "epoch 0, batch 42, loss 1.6528854370117188\n", "epoch 0, batch 43, loss 1.6836789846420288\n", "epoch 0, batch 44, loss 1.6230767965316772\n", "epoch 0, batch 45, loss 1.6041755676269531\n", "epoch 0, batch 46, loss 1.55047607421875\n", "epoch 0, batch 47, loss 1.5431965589523315\n", "epoch 0, batch 48, loss 1.512395977973938\n", "epoch 0, batch 49, loss 1.4878454208374023\n", "epoch 1, batch 0, loss 1.484283685684204\n", "epoch 1, batch 1, loss 1.5147674083709717\n", "epoch 1, batch 2, loss 1.4420981407165527\n", "epoch 1, batch 3, loss 1.4802629947662354\n", "epoch 1, batch 4, loss 1.4735491275787354\n", "epoch 1, batch 5, loss 1.3835302591323853\n", "epoch 1, batch 6, loss 1.4120527505874634\n", "epoch 1, batch 7, loss 1.3814001083374023\n", "epoch 1, batch 8, loss 1.420322299003601\n", "epoch 1, batch 9, loss 1.3910599946975708\n", "epoch 1, batch 10, loss 1.3818882703781128\n", "epoch 1, batch 11, loss 1.2963616847991943\n", "epoch 1, batch 12, loss 1.2820688486099243\n", "epoch 1, batch 13, loss 1.3216276168823242\n", "epoch 1, batch 14, loss 1.3533740043640137\n", "epoch 1, batch 15, loss 1.3162024021148682\n", "epoch 1, batch 16, loss 1.334485650062561\n", "epoch 1, batch 17, loss 1.2350927591323853\n", "epoch 1, batch 18, loss 1.2650562524795532\n", "epoch 1, batch 19, loss 1.1813908815383911\n", "epoch 1, batch 20, loss 1.2223633527755737\n", "epoch 1, batch 21, loss 1.2036733627319336\n", "epoch 1, batch 22, loss 1.2159011363983154\n", "epoch 1, batch 23, loss 1.1888813972473145\n", "epoch 1, batch 24, loss 1.1954584121704102\n", "epoch 1, batch 25, loss 1.202561616897583\n", "epoch 1, batch 26, loss 1.1740601062774658\n", "epoch 1, batch 27, loss 1.1533219814300537\n", "epoch 1, batch 28, loss 1.1416406631469727\n", "epoch 1, batch 29, loss 1.1652735471725464\n", "epoch 1, batch 30, loss 1.1516095399856567\n", "epoch 1, batch 31, loss 1.1084500551223755\n", "epoch 1, batch 32, loss 1.1114088296890259\n", "epoch 1, batch 33, loss 1.2187308073043823\n", "epoch 1, batch 34, loss 1.1055666208267212\n", "epoch 1, batch 35, loss 1.131159782409668\n", "epoch 1, batch 36, loss 1.1152591705322266\n", "epoch 1, batch 37, loss 1.1260128021240234\n", "epoch 1, batch 38, loss 1.0647740364074707\n", "epoch 1, batch 39, loss 1.110844373703003\n", "epoch 1, batch 40, loss 1.0777372121810913\n", "epoch 1, batch 41, loss 1.116552710533142\n", "epoch 1, batch 42, loss 1.081486701965332\n", "epoch 1, batch 43, loss 1.0923397541046143\n", "epoch 1, batch 44, loss 1.1311514377593994\n", "epoch 1, batch 45, loss 1.0535675287246704\n", "epoch 1, batch 46, loss 1.033979892730713\n", "epoch 1, batch 47, loss 1.0270079374313354\n", "epoch 1, batch 48, loss 1.0034534931182861\n", "epoch 1, batch 49, loss 1.1141964197158813\n", "epoch 2, batch 0, loss 1.0811495780944824\n", "epoch 2, batch 1, loss 1.0718233585357666\n", "epoch 2, batch 2, loss 1.0568015575408936\n", "epoch 2, batch 3, loss 1.054729700088501\n", "epoch 2, batch 4, loss 1.0524795055389404\n", "epoch 2, batch 5, loss 1.028294563293457\n", "epoch 2, batch 6, loss 1.0320098400115967\n", "epoch 2, batch 7, loss 1.0048317909240723\n", "epoch 2, batch 8, loss 0.9804179072380066\n", "epoch 2, batch 9, loss 0.9944889545440674\n", "epoch 2, batch 10, loss 0.9846476316452026\n", "epoch 2, batch 11, loss 1.0662739276885986\n", "epoch 2, batch 12, loss 0.9852057695388794\n", "epoch 2, batch 13, loss 0.9804151654243469\n", "epoch 2, batch 14, loss 0.9822817444801331\n", "epoch 2, batch 15, loss 0.9655719995498657\n", "epoch 2, batch 16, loss 0.9616129994392395\n", "epoch 2, batch 17, loss 0.9799185395240784\n", "epoch 2, batch 18, loss 0.9711923003196716\n", "epoch 2, batch 19, loss 0.9525609016418457\n", "epoch 2, batch 20, loss 0.9145498871803284\n", "epoch 2, batch 21, loss 0.9677637219429016\n", "epoch 2, batch 22, loss 0.9333570599555969\n", "epoch 2, batch 23, loss 0.9609147310256958\n", "epoch 2, batch 24, loss 0.9711549878120422\n", "epoch 2, batch 25, loss 0.949081301689148\n", "epoch 2, batch 26, loss 0.9375740885734558\n", "epoch 2, batch 27, loss 0.9734074473381042\n", "epoch 2, batch 28, loss 0.9486612677574158\n", "epoch 2, batch 29, loss 0.9926449060440063\n", "epoch 2, batch 30, loss 0.9132639765739441\n", "epoch 2, batch 31, loss 0.9556533098220825\n", "epoch 2, batch 32, loss 0.9298215508460999\n", "epoch 2, batch 33, loss 0.9498323202133179\n", "epoch 2, batch 34, loss 0.950808048248291\n", "epoch 2, batch 35, loss 0.922825038433075\n", "epoch 2, batch 36, loss 0.893294632434845\n", "epoch 2, batch 37, loss 0.948309600353241\n", "epoch 2, batch 38, loss 0.8933826684951782\n", "epoch 2, batch 39, loss 0.914124608039856\n", "epoch 2, batch 40, loss 0.8858266472816467\n", "epoch 2, batch 41, loss 0.9069903492927551\n", "epoch 2, batch 42, loss 0.8635560274124146\n", "epoch 2, batch 43, loss 0.9506620168685913\n", "epoch 2, batch 44, loss 0.9094947576522827\n", "epoch 2, batch 45, loss 0.9231759309768677\n", "epoch 2, batch 46, loss 0.9350917935371399\n", "epoch 2, batch 47, loss 0.9076787233352661\n", "epoch 2, batch 48, loss 0.869784951210022\n", "epoch 2, batch 49, loss 0.8812459111213684\n" ] }, { "data": { "text/plain": [ "GPT2LMHeadModel(\n", " (transformer): GPT2Model(\n", " (wte): Embedding(39, 64)\n", " (wpe): Embedding(128, 64)\n", " (drop): Dropout(p=0.1, inplace=False)\n", " (h): ModuleList(\n", " (0-2): 3 x GPT2Block(\n", " (ln_1): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", " (attn): GPT2Attention(\n", " (c_attn): Conv1D()\n", " (c_proj): Conv1D()\n", " (attn_dropout): Dropout(p=0.1, inplace=False)\n", " (resid_dropout): Dropout(p=0.1, inplace=False)\n", " )\n", " (ln_2): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", " (mlp): GPT2MLP(\n", " (c_fc): Conv1D()\n", " (c_proj): Conv1D()\n", " (act): NewGELUActivation()\n", " (dropout): Dropout(p=0.1, inplace=False)\n", " )\n", " )\n", " )\n", " (ln_f): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n", " )\n", " (lm_head): Linear(in_features=64, out_features=39, bias=False)\n", ")" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "loss_curve = []\n", "optimizer = AdamW(miniGPT.parameters(), lr=5e-4)\n", "miniGPT.train()\n", "miniGPT.to(device)\n", "batch_size = 512\n", "for epoch in range(3):\n", " for i in range(50):\n", " batch = batch_sampler(batch_size=batch_size)\n", " output = miniGPT(batch.to(device), labels=batch.to(device), )\n", " loss = output.loss\n", " loss.backward()\n", " optimizer.step()\n", " optimizer.zero_grad()\n", " print(f\"epoch {epoch}, batch {i}, loss {loss.item()}\")\n", " loss_curve.append(loss.item())\n", "\n", "\n", "miniGPT.eval().to(\"cpu\")" ] }, { "cell_type": "markdown", "metadata": { "id": "6LK6lE5bDZSD" }, "source": [ "### Say Something? (or I'm Giving Up On You)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "iAXCBRvMDn0w", "outputId": "0ca3cb3b-1be6-4a0c-ec10-bacc4a2b3a4d" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "the dog that heard that a bird that the square fox flew [End] \n", "the dog saw a zebra [End] \n", "the dog that slept flew [End] \n", "the dog that walked saw that the sheep that danced saw that the smart smart giraffe swam [End]\n", "the dog that sat saw that a fat fat sheep smelled that the thin square cow swam [End]\n" ] } ], "source": [ "prompt = \"the dog\"\n", "prompt_inds = encode_sentence(prompt)\n", "ind_tsr = miniGPT.generate(torch.tensor(prompt_inds).long()[None, :],\n", " max_length=32, do_sample=True, top_k=0, top_p=0.9, temperature=0.7,\n", " num_return_sequences=5, pad_token_id=PAD_ID)\n", "for ind_seq in ind_tsr:\n", " print(decode2sentence(ind_seq.tolist()))" ] }, { "cell_type": "markdown", "metadata": { "id": "kTtBiBFYAHtA" }, "source": [ "### Does our transformer \"understand\" part-of-speech?" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "id": "-8ZJ0DkCAMQ4" }, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.cluster import KMeans\n", "from sklearn.manifold import TSNE" ] }, { "cell_type": "markdown", "metadata": { "id": "o3lbxJdOGHo5" }, "source": [ "First, let's extract the embeddings of the words and the positions" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "XOTdV7NWE7ow", "outputId": "a2f8a7b4-01ca-4ae5-db7b-9a65cece1f26" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([39, 64])\n", "torch.Size([128, 64])\n" ] } ], "source": [ "token_embedding = miniGPT.transformer.wte.weight.detach()\n", "position_embedding = miniGPT.transformer.wpe.weight.detach()\n", "print(token_embedding.shape)\n", "print(position_embedding.shape)" ] }, { "cell_type": "markdown", "metadata": { "id": "tW9e6bUjGNJp" }, "source": [ "We'd want to see how these learned embeddings cluster." ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "s89TVRDxE34H", "outputId": "6f26c247-6282-43bb-fcbc-8aac372c9728" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "d:\\app\\anaconda3\\envs\\open-machine-learning-jupyter-book\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n", " warnings.warn(\n" ] } ], "source": [ "tsne = TSNE(n_components=2, random_state=0, perplexity=15.0)\n", "token_embedding_2d = tsne.fit_transform(token_embedding.numpy())\n", "kmeans = KMeans(n_clusters=6, random_state=0).fit(token_embedding_2d)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "id": "XOSlmKNvFwSB" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10, 10])\n", "plt.scatter(token_embedding_2d[:, 0], token_embedding_2d[:, 1], c=kmeans.labels_)\n", "# annotate each word on the plot\n", "for i, word in enumerate(inverse_dictionary.values()):\n", " plt.annotate(word, (token_embedding_2d[i, 0], token_embedding_2d[i, 1]), fontsize=12)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "id": "14KJx0sUHkg4" }, "source": [ "Let's print out which words are in each cluster." ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "id": "s2pOMTtGFByp" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cluster 0: ['smelled', 'saw', 'heard']\n", "cluster 1: ['wide', 'fox', 'smart', 'small', 'tall', 'bird', 'short', 'cat', 'sheep', 'bear', 'cow', 'horse', 'giraffe', 'round', 'dog', 'big', 'zebra', 'square', 'thin', 'fat', 'pretty', 'long']\n", "cluster 2: ['jumped', 'danced', 'walked', 'ran', 'stood', 'sat', 'swam', 'flew', 'slept']\n", "cluster 3: ['[End]']\n", "cluster 4: ['a', 'the']\n", "cluster 5: ['']\n", "cluster 6: ['that']\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "d:\\app\\anaconda3\\envs\\open-machine-learning-jupyter-book\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n", " warnings.warn(\n" ] } ], "source": [ "nCluster = 7\n", "kmeans2 = KMeans(n_clusters=nCluster, random_state=42).fit(token_embedding.numpy())\n", "# print the list of words in each cluster\n", "for icluster in range(nCluster):\n", " cluster_words = [word for word, ind in dictionary.items() if kmeans2.labels_[ind] == icluster]\n", " print(f\"cluster {icluster}: {cluster_words}\")\n" ] }, { "cell_type": "markdown", "metadata": { "id": "j4X0n5YjHcQ4" }, "source": [ "Overall birds eye view of the word representations (embeddings)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "id": "GIeE198aGxVv" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[10,5])\n", "plt.imshow(token_embedding)\n", "plt.ylabel(\"words\")\n", "plt.xlabel(\"embedding dim\")\n", "plt.colorbar()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "id": "3YxZahn9Gfc4" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=[5,10])\n", "plt.imshow(position_embedding)\n", "plt.ylabel(\"positions\")\n", "plt.xlabel(\"embedding dim\")\n", "plt.colorbar()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Your turn! 🚀\n", "tbd." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Acknowledgments\n", "\n", "Thanks to [Binxu Wang](https://github.com/Animadversio) for creating the open-source course [From Transformer to LLM: Architecture, Training and Usage](https://github.com/Animadversio/TransformerFromScratch). It inspires the majority of the content in this chapter." ] } ], "metadata": { "colab": { "provenance": [] }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.18" } }, "nbformat": 4, "nbformat_minor": 0 }