{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Created by [Fareed Khan](https://www.linkedin.com/in/fareed-khan-dev/)\n", "\n", "If you find this notebook helpful, there's no \"like\" option, but you can connect with me on [LinkedIn](https://www.linkedin.com/in/fareed-khan-dev/) or follow me on [Medium](https://medium.com/@fareedkhandev)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 2.3M Params LLM From Scratch Python\n", "\n", "\n", "\"Cropped\n", "\n", "Making your own Large Language Model (LLM) is a cool thing that many big companies like Google, Twitter, and Facebook are doing. They release different versions of these models, like 7 billion, 13 billion, or 70 billion. Even smaller communities are doing it too. You might have read blogs or watched videos on creating your own LLM, but they usually talk a lot about theory and not so much about the actual steps and code." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Table of Contents\n", "\n", "- Prerequisites\n", "- Understanding the Transformer Architecture of LLaMA\n", " - Pre-normalization Using RMSNorm\n", " - SwiGLU Activation Function\n", " - Rotary Embeddings (RoPE)\n", "- Setting the Stage\n", "- Data Preprocessing\n", "- Evaluation Strategy\n", "- Setting Up a Base Neural Network Model\n", "- Replicating LLaMA Architecture\n", " - RMSNorm for pre-normalization\n", " - Rotary Embeddings\n", " - SwiGLU activation function\n", "- Experimenting with hyperparameters\n", "- Conclusion\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Prerequisites\n", "\n", "Make sure you have a basic understanding of object-oriented programming (**OOP**) and neural networks (**NN**). Familiarity with **PyTorch** will also be helpful in coding.\n", "\n", "| Topic | Video Link |\n", "|---------------------|-----------------------------------------------------------|\n", "| OOP | [OOP Video](https://www.youtube.com/watch?v=Ej_02ICOIgs&pp=ygUKb29wIHB5dGhvbg%3D%3D) |\n", "| Neural Network | [Neural Network Video](https://www.youtube.com/watch?v=Jy4wM2X21u0&pp=ygUbbmV1cmFsIG5ldHdvcmsgcHl0aG9uIHRvcmNo) |\n", "| Pytorch | [Pytorch Video](https://www.youtube.com/watch?v=V_xro1bcAuA&pp=ygUbbmV1cmFsIG5ldHdvcmsgcHl0aG9uIHRvcmNo) |" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Understanding the Transformer Architecture of LLaMA\n", "\n", "Before diving into creating our own LLM using the LLaMA approach, it’s essential to understand the architecture of LLaMA. Below is a comparison diagram between the vanilla transformer and LLaMA.\n", "\n", "\"Difference\n", "(Llama architecture by Umar Jamil)\n", "\n", "In case you’re not familiar with the vanilla transformer architecture, you can read [this blog](https://medium.com/@fareedkhandev/understanding-transformers-a-step-by-step-math-example-part-1-a7809015150a) for a basic guide.\n", "\n", "Let’s look into the essential concepts of LLaMA with a bit more detail:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Pre-normalization Using RMSNorm:\n", "\n", "In the LLaMA approach, a technique called RMSNorm is employed for normalizing the input of each transformer sub-layer. This method is inspired by GPT-3 and is designed to optimize the computational cost associated with Layer Normalization. RMSNorm provides similar performance to LayerNorm but reduces the running time significantly (by 7%∼64%).\n", "\n", "\"Root\n", "\n", "\n", "It achieves this by emphasizing re-scaling invariance and regulating the summed inputs based on the root mean square (RMS) statistic. The primary motivation is to simplify LayerNorm by removing the mean statistic. Interested readers can explore the detailed implementation of RMSNorm [here](https://github.com/bzhangGo/rmsnorm/blob/master/rmsnorm_torch.py)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### SwiGLU Activation Function:\n", "\n", "LLaMA introduces the SwiGLU activation function, drawing inspiration from PaLM. To understand SwiGLU, it’s essential to first grasp the Swish activation function. SwiGLU extends Swish and involves a custom layer with a dense network to split and multiply input activations.\n", "\n", "\"SwiGLU:\n", "\n", "The aim is to enhance the expressive power of the model by introducing a more sophisticated activation function. Further details on SwiGLU can be found in the associated [paper](https://arxiv.org/pdf/2002.05202v1.pdf)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Rotary Embeddings (RoPE):\n", "\n", "Rotary Embeddings, or RoPE, is a type of position embedding used in LLaMA. It encodes absolute positional information using a rotation matrix and naturally includes explicit relative position dependency in self-attention formulations. RoPE offers advantages such as scalability to various sequence lengths and decaying inter-token dependency with increasing relative distances.\n", "\n", "This is achieved by encoding relative positions through multiplication with a rotation matrix, resulting in decayed relative distances — a desirable feature for natural language encoding. Those interested in the mathematical details can refer to the [RoPE paper](https://arxiv.org/pdf/2104.09864v4.pdf).\n", "\n", "In addition to these concepts, the LLaMA paper introduces other significant approaches, including the use of the **AdamW optimizer** with specific parameters, efficient implementations such as the causal [multi-head attention operator](https://facebookresearch.github.io/xformers/components/mha.html) available in the xformers library, and manually implemented backward functions for transformer layers to optimize computation during backward passes.\n", "\n", "A special acknowledgment and thanks to [Anush Kumar](https://akgeni.medium.com/) for providing an in-depth explanation of each crucial aspect of LLaMA." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setting the Stage\n", "\n", "We’ll be working with a range of Python libraries throughout this project, so let’s import them:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:45:22.346574Z", "start_time": "2025-06-29T17:45:17.082393Z" } }, "outputs": [], "source": [ "# PyTorch for implementing LLM (No GPU)\n", "import torch\n", "\n", "# Neural network modules and functions from PyTorch\n", "from torch import nn\n", "from torch.nn import functional as F\n", "\n", "# NumPy for numerical operations\n", "import numpy as np\n", "\n", "# Matplotlib for plotting Loss etc.\n", "from matplotlib import pyplot as plt\n", "\n", "# Time module for tracking execution time\n", "import time\n", "\n", "# Pandas for data manipulation and analysis\n", "import pandas as pd\n", "\n", "# urllib for handling URL requests (Downloading Dataset)\n", "import urllib.request" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:45:48.422752Z", "start_time": "2025-06-29T17:45:48.418958Z" } }, "outputs": [], "source": [ "torch.set_default_device('cuda')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Furthermore, I’m creating a configuration object that stores model parameters." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:45:50.709047Z", "start_time": "2025-06-29T17:45:50.704610Z" } }, "outputs": [], "source": [ "# Configuration object for model parameters\n", "MASTER_CONFIG = {\n", " # Adding parameters later\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This approach maintains flexibility, allowing for the addition of more parameters as needed in the future." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data Preprocessing\n", "\n", "In the original LLaMA paper, diverse open-source datasets were employed to train and evaluate the model.\n", "\n", "\"LLaMA\n", "\n", "\n", "Unfortunately, utilizing extensive datasets may be impractical for smaller projects. Therefore, for our implementation, we’ll take a more modest approach by creating a dramatically scaled-down version of LLaMA.\n", "\n", "Given the constraints of not having access to vast amounts of data, we will focus on training a simplified version of LLaMA using the TinyShakespeare dataset. This open source dataset, available [here](https://github.com/karpathy/char-rnn/blob/master/data/tinyshakespeare/input.txt), contains approximately 40,000 lines of text from various Shakespearean works. This choice is influenced by the [Makemore series by Karpathy](https://www.youtube.com/playlist?list=PLAqhIrjkxbuWI23v9cThsA9GvCAUhRvKZ), which provides valuable insights into training language models.\n", "\n", "While LLaMA was trained on an extensive dataset comprising **1.4 trillion** tokens, our dataset, TinyShakespeare, containing around **1 million characters**.\n", "\n", "First, let’s obtain our dataset by downloading it:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:08.626597Z", "start_time": "2025-06-29T17:45:54.597835Z" } }, "outputs": [ { "data": { "text/plain": [ "('tinyshakespeare.txt', )" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# The URL of the raw text file on GitHub\n", "url = \"https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt\"\n", "\n", "# The file name for local storage\n", "file_name = \"tinyshakespeare.txt\"\n", "\n", "# Execute the download\n", "urllib.request.urlretrieve(url, file_name)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This Python script fetches the tinyshakespeare dataset from the specified URL and saves it locally with the filename **“tinyshakespeare.txt.”**\n", "\n", "Next, let’s determine the vocabulary size, which represents the unique number of characters in our dataset. Here’s the code snippet:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:13.105120Z", "start_time": "2025-06-29T17:46:13.088623Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Printing the first 10 characters of the vocab list: ['\\n', ' ', '!', '$', '&', \"'\", ',', '-', '.', '3']\n", "Total number of characters in our dataset (Vocabulary Size): 65\n" ] } ], "source": [ "# Read the content of the dataset\n", "lines = open(\"tinyshakespeare.txt\", 'r').read()\n", "\n", "# Create a sorted list of unique characters in the dataset\n", "vocab = sorted(list(set(lines)))\n", "\n", "# Display the first 10 characters in the vocabulary list\n", "print('Printing the first 10 characters of the vocab list:', vocab[:10])\n", "\n", "# Output the total number of characters in our dataset (Vocabulary Size)\n", "print('Total number of characters in our dataset (Vocabulary Size):', len(vocab))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "Now, we’re creating mappings between integers to characters (**itos**) and characters to integers (**stoi**). Here’s the code:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:15.647028Z", "start_time": "2025-06-29T17:46:15.642304Z" } }, "outputs": [], "source": [ "# Mapping integers to characters (itos)\n", "itos = {i: ch for i, ch in enumerate(vocab)}\n", "\n", "# Mapping characters to integers (stoi)\n", "stoi = {ch: i for i, ch in enumerate(vocab)}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "In the original LLaMA paper, the [SentencePiece byte-pair encoding tokenizer](https://github.com/google/sentencepiece) from Google was used. However, for simplicity, we’ll opt for a basic character-level tokenizer. Let’s create encode and decode functions that we’ll later apply to our dataset:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:18.350543Z", "start_time": "2025-06-29T17:46:18.341380Z" } }, "outputs": [ { "data": { "text/plain": [ "'morning'" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Encode function: Converts a string to a list of integers using the mapping stoi\n", "def encode(s):\n", " return [stoi[ch] for ch in s]\n", "\n", "# Decode function: Converts a list of integers back to a string using the mapping itos\n", "def decode(l):\n", " return ''.join([itos[i] for i in l])\n", "\n", "# Example: Encode the string \"hello\" and then decode the result\n", "decode(encode(\"morning\"))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The final line will output `morning` confirms the proper functionality of the encode and decode functions.\n", "\n", "We are now converting our dataset into a torch tensor, specifying its data type for further operations using **PyTorch**:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:24.538264Z", "start_time": "2025-06-29T17:46:24.252668Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([1115394])\n" ] } ], "source": [ "# Convert the dataset into a torch tensor with specified data type (dtype)\n", "dataset = torch.tensor(encode(lines), dtype=torch.int8)\n", "\n", "# adding the vocab size\n", "MASTER_CONFIG = {\n", " \"vocab_size\": len(vocab),\n", "}\n", "\n", "# Display the shape of the resulting tensor\n", "print(dataset.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The output is `torch.Size([1115394])` indicates that our dataset contains approximately **one million tokens**. It's worth noting that this is significantly smaller than the LLaMA dataset, which consists of **1.4 trillion tokens**.\n", "\n", "We’ll create a function responsible for splitting our dataset into training, validation, or test sets. In machine learning or deep learning projects, such splits are crucial for developing and evaluating models, and the same principle applies here in replicating a Large Language Model (LLM) approach:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:27.750121Z", "start_time": "2025-06-29T17:46:27.741323Z" } }, "outputs": [], "source": [ "# Function to get batches for training, validation, or testing\n", "def get_batches(data, split, batch_size, context_window, config=MASTER_CONFIG):\n", " # Split the dataset into training, validation, and test sets\n", " train = data[:int(.8 * len(data))]\n", " val = data[int(.8 * len(data)): int(.9 * len(data))]\n", " test = data[int(.9 * len(data)):]\n", "\n", " # Determine which split to use\n", " batch_data = train\n", " if split == 'val':\n", " batch_data = val\n", " if split == 'test':\n", " batch_data = test\n", "\n", " # Pick random starting points within the data\n", " ix = torch.randint(0, batch_data.size(0) - context_window - 1, (batch_size,))\n", "\n", " # Create input sequences (x) and corresponding target sequences (y)\n", " x = torch.stack([batch_data[i:i+context_window] for i in ix]).long()\n", " y = torch.stack([batch_data[i+1:i+context_window+1] for i in ix]).long()\n", "\n", " return x, y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that our splitting function is defined, let’s establish two parameters crucial for this process:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:30.461100Z", "start_time": "2025-06-29T17:46:30.455375Z" } }, "outputs": [], "source": [ "# Update the MASTER_CONFIG with batch_size and context_window parameters\n", "MASTER_CONFIG.update({\n", " 'batch_size': 8, # Number of batches to be processed at each random split\n", " 'context_window': 16 # Number of characters in each input (x) and target (y) sequence of each batch\n", "})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "batch_size determines how many batches are processed at each random split, while context_window specifies the number of characters in each input (x) and target (y) sequence of each batch.\n", "\n", "Let’s print a random sample from the train split of batch 8 and context window 16 from our dataset:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:32.910031Z", "start_time": "2025-06-29T17:46:32.877084Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[(' theirs and in t', 'theirs and in th'), ('e you well serve', ' you well served'), (' of Derby?\\n\\nDERB', 'of Derby?\\n\\nDERBY'), (' my womb, when\\ny', 'my womb, when\\nyo'), ('mit to my tongue', 'it to my tongue.'), ('d seconds.\\n\\nCOMI', ' seconds.\\n\\nCOMIN'), ('nted\\nTo those wh', 'ted\\nTo those who'), (', if love be bli', ' if love be blin')]\n" ] } ], "source": [ "# Obtain batches for training using the specified batch size and context window\n", "xs, ys = get_batches(dataset, 'train', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Decode the sequences to obtain the corresponding text representations\n", "decoded_samples = [(decode(xs[i].tolist()), decode(ys[i].tolist())) for i in range(len(xs))]\n", "\n", "# Print the random sample\n", "print(decoded_samples)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Evaluation Strategy\n", "\n", "Now, we are set to create a function dedicated to evaluating our self-created LLaMA architecture. The reason for doing this before defining the actual model approach is to enable continuous evaluation during the training process." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:38.391372Z", "start_time": "2025-06-29T17:46:38.386337Z" } }, "outputs": [], "source": [ "@torch.no_grad() # Don't compute gradients for this function\n", "def evaluate_loss(model, config=MASTER_CONFIG):\n", " # Placeholder for the evaluation results\n", " out = {}\n", " \n", " # Set the model to evaluation mode\n", " model.eval()\n", "\n", " # Iterate through training and validation splits\n", " for split in [\"train\", \"val\"]:\n", " # Placeholder for individual losses\n", " losses = []\n", "\n", " # Generate 10 batches for evaluation\n", " for _ in range(10):\n", " # Get input sequences (xb) and target sequences (yb)\n", " xb, yb = get_batches(dataset, split, config['batch_size'], config['context_window'])\n", " \n", " # Perform model inference and calculate the loss\n", " _, loss = model(xb, yb)\n", " \n", " # Append the loss to the list\n", " losses.append(loss.item())\n", "\n", " # Calculate the mean loss for the split and store it in the output dictionary\n", " out[split] = np.mean(losses)\n", " \n", " # Set the model back to training mode\n", " model.train()\n", " \n", " return out" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We have used the **loss** as a metric to assess the performance of the model during training iterations. Our function iterates through the training and validation splits, computes the mean loss over 10 batches for each split, and finally returns the results. The model is then set back to training mode with model.train().\n", "\n", "## Setting Up a Base Neural Network Model\n", "\n", "We’re building a basic neural network that we’ll improve later using LLaMA techniques." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:41.667467Z", "start_time": "2025-06-29T17:46:41.663163Z" } }, "outputs": [], "source": [ "# Definition of a basic neural network class\n", "class SimpleBrokenModel(nn.Module):\n", " def __init__(self, config=MASTER_CONFIG):\n", " super().__init__()\n", " self.config = config\n", "\n", " # Embedding layer to convert character indices to vectors (vocab size: 65)\n", " self.embedding = nn.Embedding(config['vocab_size'], config['d_model'])\n", "\n", " # Linear layers for modeling relationships between features\n", " # (to be updated with SwiGLU activation function as in LLaMA)\n", " self.linear = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " nn.ReLU(), # Currently using ReLU, will be replaced with SwiGLU as in LLaMA\n", " nn.Linear(config['d_model'], config['vocab_size']),\n", " )\n", "\n", " # Print the total number of model parameters\n", " print(\"Model parameters:\", sum([m.numel() for m in self.parameters()]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the current architecture, the embedding layer has a vocabulary size of 65, representing the characters in our dataset. As this serves as our base model, we are using **ReLU **as the activation function in the linear layers; however, this will later be replaced with SwiGLU, as used in LLaMA.\n", "\n", "To create a forward pass for our base model, we must define a forward function within our NN model." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:45.178887Z", "start_time": "2025-06-29T17:46:45.170403Z" } }, "outputs": [], "source": [ "# Definition of a basic neural network class\n", "class SimpleBrokenModel(nn.Module):\n", " def __init__(self, config=MASTER_CONFIG):\n", " super().__init__()\n", " self.config = config\n", "\n", " # Embedding layer to convert character indices to vectors (vocab size: 65)\n", " self.embedding = nn.Embedding(config['vocab_size'], config['d_model'])\n", "\n", " # Linear layers for modeling relationships between features\n", " # (to be updated with SwiGLU activation function as in LLaMA)\n", " self.linear = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " nn.ReLU(), # Currently using ReLU, will be replaced with SwiGLU as in LLaMA\n", " nn.Linear(config['d_model'], config['vocab_size']),\n", " )\n", "\n", " # Print the total number of model parameters\n", " print(\"Model parameters:\", sum([m.numel() for m in self.parameters()]))\n", "\n", " # Forward pass function for the base model\n", " def forward(self, idx, targets=None):\n", " # Embedding layer converts character indices to vectors\n", " x = self.embedding(idx)\n", " \n", " # Linear layers for modeling relationships between features\n", " a = self.linear(x)\n", " \n", " # Apply softmax activation to obtain probability distribution\n", " logits = F.softmax(a, dim=-1)\n", "\n", " # If targets are provided, calculate and return the cross-entropy loss\n", " if targets is not None:\n", " # Reshape logits and targets for cross-entropy calculation\n", " loss = F.cross_entropy(logits.view(-1, self.config['vocab_size']), targets.view(-1))\n", " return logits, loss\n", "\n", " # If targets are not provided, return the logits\n", " else:\n", " return logits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This forward pass function takes character indices (idx) as input, applies the embedding layer, passes the result through linear layers, applies a softmax activation to obtain a probability distribution (logits). If targets are provided, it calculates the cross-entropy loss and returns both logits and loss. If targets are not provided, it returns only the logits.\n", "\n", "To instantiate this model, we can directly invoke the class and print the total number of parameters in our Simple Neural Network Model. We’ve set the dimension of our linear layers to 128, specifying this value in our config object:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:46:48.087303Z", "start_time": "2025-06-29T17:46:48.079910Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model parameters: 33217\n", "Total number of parameters in the Simple Neural Network Model: 33217\n" ] } ], "source": [ "# Update MASTER_CONFIG with the dimension of linear layers (128)\n", "MASTER_CONFIG.update({\n", " 'd_model': 128,\n", "})\n", "\n", "# Instantiate the SimpleBrokenModel using the updated MASTER_CONFIG\n", "model = SimpleBrokenModel(MASTER_CONFIG)\n", "\n", "# Print the total number of parameters in the model\n", "print(\"Total number of parameters in the Simple Neural Network Model:\", sum([m.numel() for m in model.parameters()]))" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:47:04.655738Z", "start_time": "2025-06-29T17:47:04.651622Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cuda:0\n" ] } ], "source": [ "print(next(model.parameters()).device)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "Our Simple Neural Network Model comprises approximately 33,000 parameters.\n", "\n", "Similarly, to compute logits and loss, we only need to feed our split dataset into our model:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:47:08.479293Z", "start_time": "2025-06-29T17:47:08.336811Z" } }, "outputs": [], "source": [ "# Obtain batches for training using the specified batch size and context window\n", "xs, ys = get_batches(dataset, 'train', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Calculate logits and loss using the model\n", "logits, loss = model(xs, ys)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To train our base model and note its performance, we need to specify some parameters. We are training for a total of 1000 epochs. Increasing the batch size to 32 from 8, and set the log_interval to 10, indicating that the code will print or log information about the training progress every 10 batches. For optimization, we’ll use the Adam optimizer." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:47:11.526363Z", "start_time": "2025-06-29T17:47:10.492498Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model parameters: 33217\n" ] } ], "source": [ "# Update MASTER_CONFIG with training parameters\n", "MASTER_CONFIG.update({\n", " 'epochs': 1000, # Number of training epochs\n", " 'log_interval': 10, # Log information every 10 batches during training\n", " 'batch_size': 32, # Increase batch size to 32\n", "})\n", "\n", "# Instantiate the SimpleBrokenModel with updated configuration\n", "model = SimpleBrokenModel(MASTER_CONFIG)\n", "\n", "# Define the Adam optimizer for model parameters\n", "optimizer = torch.optim.Adam(\n", " model.parameters(), # Pass the model parameters to the optimizer\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s execute the training process and capture the loss from our base model, including the total number of parameters. **Additionally, each line is commented for clarity**:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:47:30.541652Z", "start_time": "2025-06-29T17:47:15.640349Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Validation loss: 3.9338863849639893\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Function to perform training\n", "def train(model, optimizer, scheduler=None, config=MASTER_CONFIG, print_logs=False):\n", " # Placeholder for storing losses\n", " losses = []\n", " \n", " # Start tracking time\n", " start_time = time.time()\n", "\n", " # Iterate through epochs\n", " for epoch in range(config['epochs']):\n", " # Zero out gradients\n", " optimizer.zero_grad()\n", "\n", " # Obtain batches for training\n", " xs, ys = get_batches(dataset, 'train', config['batch_size'], config['context_window'])\n", "\n", " # Forward pass through the model to calculate logits and loss\n", " logits, loss = model(xs, targets=ys)\n", "\n", " # Backward pass and optimization step\n", " loss.backward()\n", " optimizer.step()\n", "\n", " # If a learning rate scheduler is provided, adjust the learning rate\n", " if scheduler:\n", " scheduler.step()\n", "\n", " # Log progress every specified interval\n", " if epoch % config['log_interval'] == 0:\n", " # Calculate batch time\n", " batch_time = time.time() - start_time\n", " \n", " # Evaluate loss on validation set\n", " x = evaluate_loss(model)\n", " \n", " # Store the validation loss\n", " losses += [x]\n", " \n", " # Print progress logs if specified\n", " if print_logs:\n", " print(f\"Epoch {epoch} | val loss {x['val']:.3f} | Time {batch_time:.3f} | ETA in seconds {batch_time * (config['epochs'] - epoch)/config['log_interval'] :.3f}\")\n", " \n", " # Reset the timer\n", " start_time = time.time()\n", "\n", " # Print learning rate if a scheduler is provided\n", " if scheduler:\n", " print(\"lr: \", scheduler.get_lr())\n", "\n", " # Print the final validation loss\n", " print(\"Validation loss: \", losses[-1]['val'])\n", " \n", " # Plot the training and validation loss curves\n", " return pd.DataFrame(losses).plot()\n", "\n", "# Execute the training process\n", "train(model, optimizer)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "The initial cross-entropy loss before training stands at 4.17, and after 1000 epochs, it reduces to 3.93. In this context, cross-entropy reflects the likelihood of selecting the incorrect word.\n", "\n", "Our model incorporates a softmax layer on the logits, which transforms a vector of numbers into a probability distribution. Let’s use the built-in F.cross_entropy function, we need to directly pass in the [unnormalized logits](https://pytorch.org/docs/stable/generated/torch.nn.functional.cross_entropy.html). Consequently, we will modify our model accordingly." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:47:48.532386Z", "start_time": "2025-06-29T17:47:48.525357Z" } }, "outputs": [], "source": [ "# Definition of a basic neural network class\n", "class SimpleBrokenModel(nn.Module):\n", " def __init__(self, config=MASTER_CONFIG):\n", " super().__init__()\n", " self.config = config\n", "\n", " # Embedding layer to convert character indices to vectors (vocab size: 65)\n", " self.embedding = nn.Embedding(config['vocab_size'], config['d_model'])\n", "\n", " # Linear layers for modeling relationships between features\n", " # (to be updated with SwiGLU activation function as in LLaMA)\n", " self.linear = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " nn.ReLU(), # Currently using ReLU, will be replaced with SwiGLU as in LLaMA\n", " nn.Linear(config['d_model'], config['vocab_size']),\n", " )\n", "\n", " # Print the total number of model parameters\n", " print(\"Model parameters:\", sum([m.numel() for m in self.parameters()]))\n", "\n", " # Forward pass function for the base model\n", " def forward(self, idx, targets=None):\n", " \n", " # Embedding layer converts character indices to vectors\n", " x = self.embedding(idx)\n", " \n", " # Linear layers for modeling relationships between features\n", " logits = self.linear(x)\n", "\n", " # If targets are provided, calculate and return the cross-entropy loss\n", " if targets is not None:\n", " # Reshape logits and targets for cross-entropy calculation\n", " loss = F.cross_entropy(logits.view(-1, self.config['vocab_size']), targets.view(-1))\n", " return logits, loss\n", "\n", " # If targets are not provided, return the logits\n", " else:\n", " return logits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s recreate the updated SimpleModel and train it for 1000 epochs to observe any changes:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:48:07.389485Z", "start_time": "2025-06-29T17:47:52.364540Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model parameters: 33217\n", "Validation loss: 2.5096785545349123\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAafpJREFUeJzt3Xd4U2X/x/F3krbpLrMtZS9BliCgFBAQUEBFcIso4hbRR9wP/tzjAfcWt7gQF+BERJYgZcpG2RtKodDdpm1yfn/cbaC2he4U+LyuKxfNycnJndPSfPq9x7FZlmUhIiIiUo3Zfd0AERERkeNRYBEREZFqT4FFREREqj0FFhEREan2FFhERESk2lNgERERkWpPgUVERESqPQUWERERqfb8fN2AiuDxeNi7dy9hYWHYbDZfN0dERERKwLIsUlNTiYmJwW4/dg3lpAgse/fupWHDhr5uhoiIiJTBrl27aNCgwTH3OSkCS1hYGGDecHh4uI9bIyIiIiWRkpJCw4YNvZ/jx3JSBJb8bqDw8HAFFhERkRNMSYZzaNCtiIiIVHsKLCIiIlLtKbCIiIhItXdSjGERERGpLJZlkZubi9vt9nVTTkj+/v44HI5yH0eBRUREpBjZ2dns27ePjIwMXzflhGWz2WjQoAGhoaHlOo4Ci4iISBE8Hg/btm3D4XAQExNDQECAFictJcuyOHDgALt376Zly5blqrQosIiIiBQhOzsbj8dDw4YNCQ4O9nVzTlh169Zl+/bt5OTklCuwaNCtiIjIMRxvyXg5toqqSum7ICIiItWeAouIiIhUewosIiIiUqwmTZrw6quv+roZGnQrIiJysunTpw8dO3askKCxdOlSQkJCyt+oclJgOYak/TvZO/0FLJuDtte/6uvmiIiIVAjLsnC73fj5HT8G1K1btwpadHzqEjqG5KRDtNn+KQ23feXrpoiIiI9ZlkVGdq5PbpZllbidI0eOZN68ebz22mvYbDZsNhsTJ07EZrMxffp0OnfujNPpZMGCBWzZsoUhQ4YQFRVFaGgoXbt25ffffy9wvH93CdlsNj744AMuueQSgoODadmyJT/88ENFneZiqcJyDAEh4QAEWS6wLNCCQSIip6zMHDdtHpvhk9de/9QAggNK9pH92muvsXHjRtq1a8dTTz0FwLp16wD473//y4svvkizZs2oWbMmu3bt4oILLuDZZ5/F6XTy6aefMnjwYDZs2ECjRo2KfY0nn3yS559/nhdeeIE33niD4cOHs2PHDmrVqlX+N1sMVViOISgvsPjb3ORkZ/m4NSIiIscXERFBQEAAwcHBREdHEx0d7V2w7amnnuK8886jefPm1KpVizPOOIPbbruNdu3a0bJlS55++mmaN29+3IrJyJEjGTZsGC1atOB///sfaWlpLFmypFLflyosxxAUEub9OjM9BX9nkA9bIyIivhTk72D9UwN89toVoUuXLgXup6Wl8cQTT/Dzzz+zb98+cnNzyczMZOfOncc8TocOHbxfh4SEEB4eTkJCQoW0sTgKLMcQ4B+Ay/LHacshKz2V8FpRvm6SiIj4iM1mK3G3THX179k+999/PzNnzuTFF1+kRYsWBAUFcfnll5OdnX3M4/j7+xe4b7PZ8Hg8Fd7eo53YZ76S2Ww2MmyBOMkhKyPF180REREpkYCAANxu93H3+/PPPxk5ciSXXHIJYCou27dvr+TWlY3GsBxHJoEA5GSk+rglIiIiJdOkSRMWL17M9u3bOXjwYLHVj5YtWzJlyhRWrlzJqlWruOaaayq9UlJWCizHkW03gSU7U4FFRERODPfffz8Oh4M2bdpQt27dYsekvPzyy9SsWZPu3bszePBgBgwYwJlnnlnFrS0ZdQkdh8tmBtrmZCmwiIjIieG0004jLi6uwLaRI0cW2q9JkybMnj27wLbRo0cXuP/vLqKi1oRJSkoqUztLQxWW48h2mMDizkrzcUtEREROXQosx5GbF1g8CiwiIiI+o8ByHLmOYAA8rnQft0REROTUpcByHLl+JrBY2QosIiIivqLAchyWvwksZKtLSERExFcUWI7D8jerAtpUYREREfEZBZbjsAJMYLHnZvq4JSIiIqcuBZbjsAWEAuDIVYVFRETEVxRYjsOWV2Hxy83wcUtERESqRpMmTXj11Vd93YwCFFiOwxGUF1g86hISERHxFQWW43A4wwAIcCuwiIiI+IoCy3H4BZoxLAGqsIiIyAngvffeIyYmptBVl4cMGcKNN97Ili1bGDJkCFFRUYSGhtK1a1d+//13H7W25BRYjiMg2FRYAi0FFhGRU5plQXa6b25FXHCwOFdccQWJiYnMmTPHu+3QoUP8+uuvDB8+nLS0NC644AJmzZrFihUrGDhwIIMHDy72is7VRbmu1jx+/HjGjh3L3XfffczBOd988w2PPvoo27dvp2XLljz33HNccMEF3scty+Lxxx/n/fffJykpiR49ejBhwgRatmxZnuZViICgcAACLZePWyIiIj6VkwH/i/HNaz+8F/ImgRxPzZo1GTRoEJMmTaJfv34AfPvtt9SpU4dzzz0Xu93OGWec4d3/6aefZurUqfzwww/ceeedldL8ilDmCsvSpUt599136dChwzH3W7hwIcOGDeOmm25ixYoVDB06lKFDh7J27VrvPs8//zyvv/4677zzDosXLyYkJIQBAwaQlZVV1uZVGGdehSXIyixVwhUREfGV4cOH89133+FymT+2v/jiC66++mrsdjtpaWncf//9nH766dSoUYPQ0FD+/vvvk7PCkpaWxvDhw3n//fd55plnjrnva6+9xsCBA3nggQcAk+RmzpzJm2++yTvvvINlWbz66qs88sgjDBkyBIBPP/2UqKgopk2bxtVXX12WJlaYwBATWBw2CysnE1tAsE/bIyIiPuIfbCodvnrtUhg8eDCWZfHzzz/TtWtX5s+fzyuvvALA/fffz8yZM3nxxRdp0aIFQUFBXH755WRnZ1dGyytMmQLL6NGjufDCC+nfv/9xA0tcXBz33ntvgW0DBgxg2rRpAGzbto34+Hj69+/vfTwiIoKzzz6buLi4IgOLy+XypkaAlJSUsryNEgkKCfd+nZWRRpACi4jIqclmK3G3jK8FBgZy6aWX8sUXX7B582ZatWrFmWeeCcCff/7JyJEjueSSSwBThNi+fbsPW1sypQ4skydP5q+//mLp0qUl2j8+Pp6oqKgC26KiooiPj/c+nr+tuH3+bdy4cTz55JOlbXqZBDkDyLQCCLJlk5WeTFCNyCp5XRERkfIYPnw4F110EevWrePaa6/1bm/ZsiVTpkxh8ODB2Gw2Hn300UIziqqjUo1h2bVrF3fffTdffPEFgYGBldWm4xo7dizJycne265duyrttRx2G5k4AXBlpFba64iIiFSkvn37UqtWLTZs2MA111zj3f7yyy9Ts2ZNunfvzuDBgxkwYIC3+lKdlarCsnz5chISEgq8MbfbzR9//MGbb76Jy+XC4XAUeE50dDT79+8vsG3//v1ER0d7H8/fVq9evQL7dOzYsch2OJ1OnE5naZpeLpm2ICAVV0bldT2JiIhUJLvdzt69hcfcNGnShNmzZxfYNnr06AL3q2MXUakqLP369WPNmjWsXLnSe+vSpQvDhw9n5cqVhcIKQGxsLLNmzSqwbebMmcTGxgLQtGlToqOjC+yTkpLC4sWLvfv4WpbNVJOyM9N83BIREZFTU6kqLGFhYbRr167AtpCQEGrXru3dPmLECOrXr8+4ceMAuPvuu+nduzcvvfQSF154IZMnT2bZsmW89957ANhsNsaMGcMzzzxDy5Ytadq0KY8++igxMTEMHTq0At5i+bnsQeCG3Ex1CYmIiPhCuRaOK8rOnTux248Ubrp3786kSZN45JFHePjhh2nZsiXTpk0rEHwefPBB0tPTufXWW0lKSqJnz578+uuvPh0nc7Sc/MCSpQqLiIiIL9gs68RfDS0lJYWIiAiSk5MJDw8//hNKaen4gXTNimNlxyfoOPSeCj++iIhUP1lZWWzbto2mTZtWmz+gT0THOo+l+fzWtYRKwO0wa694VGERERHxCQWWEsj1M4HFyk73cUtERKSqnQQdET5VUedPgaUErLwlkW3ZqrCIiJwq/P39AcjIyPBxS05s+Uv+FzWTuDQqfNDtycjjn7cUc45+aEVEThUOh4MaNWqQkJAAQHBwMDabzcetOrF4PB4OHDhAcHAwfn7lixwKLCWQX2GxK7CIiJxS8hc3zQ8tUnp2u51GjRqVO+wpsJSALe9iV45cjWERETmV2Gw26tWrR2RkJDk5Ob5uzgkpICCgwHInZaXAUgI2ZygAjtxMH7dERER8weFwlHsMhpSPBt2WgD0vsPi71SUkIiLiCwosJeAXmB9YVGERERHxBQWWEsgPLE6PAouIiIgvKLCUgF9QGAABVpaPWyIiInJqUmApAWewub5BkKUKi4iIiC8osJSAM9h0CQXiAi3RLCIiUuUUWEogv8Jix4IcVVlERESqmgJLCQSHhHm/zs1K9WFLRERETk0KLCUQ5PQnw3ICkJmR4uPWiIiInHoUWErA6WcnAxNYstMVWERERKqaAksJ2Gw2MgkCICtDXUIiIiJVTYGlhLJsgQBkK7CIiIhUOQWWEnLZTWDJzUrzcUtEREROPQosJZRtDwYgN1OBRUREpKopsJRQjsOMYXG7FFhERESqmgJLCeXmBRaPAouIiEiVU2ApoVw/0yVkKbCIiIhUOQWWEvL4hZgvstN92xAREZFTkAJLCVn+pkuInAzfNkREROQUpMBSQlaAuWKzPUcVFhERkaqmwFJS/qZLyJ6rCouIiEhVU2ApIVugCSx+CiwiIiJVToGlhOxO0yWkwCIiIlL1FFhKyJEXWPw9mT5uiYiIyKlHgaWE/INMYAlQYBEREalyCiwl5BcYBoDTk+XjloiIiJx6FFhKKCDYBJZASxUWERGRqqbAUkL5gSUIF3g8Pm6NiIjIqUWBpYQCg8OP3NFqtyIiIlVKgaWEgoND8Vg2AKxsXQBRRESkKimwlFCQ048MnABkZyqwiIiIVCUFlhIKDvAjg0AAstJTfNwaERGRU0upAsuECRPo0KED4eHhhIeHExsby/Tp04vdv0+fPthstkK3Cy+80LvPyJEjCz0+cODAsr+jSuKw28jMq7C4MhRYREREqpJfaXZu0KAB48ePp2XLlliWxSeffMKQIUNYsWIFbdu2LbT/lClTyM7O9t5PTEzkjDPO4Iorriiw38CBA/n444+9951OZ2nfR5XIspkKS3ZGqo9bIiIicmopVWAZPHhwgfvPPvssEyZMYNGiRUUGllq1ahW4P3nyZIKDgwsFFqfTSXR0dGma4hNZtiCwICdLY1hERESqUpnHsLjdbiZPnkx6ejqxsbEles6HH37I1VdfTUhISIHtc+fOJTIyklatWjFq1CgSExOPeRyXy0VKSkqBW1XItgcBkJupCouIiEhVKlWFBWDNmjXExsaSlZVFaGgoU6dOpU2bNsd93pIlS1i7di0ffvhhge0DBw7k0ksvpWnTpmzZsoWHH36YQYMGERcXh8PhKPJY48aN48knnyxt08stxxEEbnCrwiIiIlKlbJZlWaV5QnZ2Njt37iQ5OZlvv/2WDz74gHnz5h03tNx2223ExcWxevXqY+63detWmjdvzu+//06/fv2K3MflcuFyubz3U1JSaNiwIcnJyYSHhxf5nIow77nL6J35O+va3k/bKx6ttNcRERE5FaSkpBAREVGiz+9SdwkFBATQokULOnfuzLhx4zjjjDN47bXXjvmc9PR0Jk+ezE033XTc4zdr1ow6deqwefPmYvdxOp3emUr5t6rg9gsGwHKpwiIiIlKVyr0Oi8fjKVDtKMo333yDy+Xi2muvPe7xdu/eTWJiIvXq1Stv0yqc28+MYSE73bcNEREROcWUagzL2LFjGTRoEI0aNSI1NZVJkyYxd+5cZsyYAcCIESOoX78+48aNK/C8Dz/8kKFDh1K7du0C29PS0njyySe57LLLiI6OZsuWLTz44IO0aNGCAQMGlPOtVTzL3wwWtuUosIiIiFSlUgWWhIQERowYwb59+4iIiKBDhw7MmDGD8847D4CdO3ditxcs2mzYsIEFCxbw22+/FTqew+Fg9erVfPLJJyQlJRETE8P555/P008/XS3XYskPLLr4oYiISNUqVWD59wyff5s7d26hba1ataK4cb1BQUHe6swJIcAEFocqLCIiIlVK1xIqBbszL7DkqsIiIiJSlRRYSsEWEAqAnzvTxy0RERE5tSiwlIIj0AQWf7cqLCIiIlVJgaUU/IJMYAnwqMIiIiJSlRRYSsEvMAwApwKLiIhIlVJgKYWAoLzAYmX5uCUiIiKnFgWWUggIMZcACCQbPG4ft0ZEROTUocBSCoHBoUfuaHl+ERGRKqPAUgqBgSG4LZu5o9VuRUREqowCSymEBPqTTiAA7ixdsVlERKSqKLCUQnCAg0zMNY6y0pN93BoREZFThwJLKTj97GRYpsKSnZHq49aIiIicOhRYSsFms5FpCwLAlakuIRERkaqiwFJKLrupsORkpvi4JSIiIqcOBZZSyrabCkuuKiwiIiJVRoGllLyBxaXAIiIiUlUUWEopxxEMgCdLg25FRESqigJLKeX6mcBiqcIiIiJSZRRYSinXL295fpcqLCIiIlVFgaWU3AEmsNizFVhERESqigJLKXn8wwCwZ6tLSEREpKoosJRWYDgAfjmqsIiIiFQVBZZSsucHllxVWERERKqKAksp5QeWgNx0H7dERETk1KHAUkp+wREAON2qsIiIiFQVBZZSCggxgSXIk+HjloiIiJw6FFhKKSCkhvmXbMjN9m1jREREThEKLKUUGFrjyB0tHiciIlIlFFhKKTQokAzLae64UnzbGBERkVOEAksphTgdpGGu2KwKi4iISNVQYCmlMKc/qZYJLDkZyT5ujYiIyKlBgaWUQpwOUvMqLK60JN82RkRE5BShwFJKfg47GQQD4EpP8m1jREREThEKLGWQ5QgBIFtdQiIiIlVCgaUMXHmBxa3AIiIiUiUUWMogOz+wZGlas4iISFVQYCmDXP9QACwFFhERkSqhwFIGuf5h5gstHCciIlIlShVYJkyYQIcOHQgPDyc8PJzY2FimT59e7P4TJ07EZrMVuAUGBhbYx7IsHnvsMerVq0dQUBD9+/dn06ZNZXs3VcQKMIHF5tIVm0VERKpCqQJLgwYNGD9+PMuXL2fZsmX07duXIUOGsG7dumKfEx4ezr59+7y3HTt2FHj8+eef5/XXX+edd95h8eLFhISEMGDAALKyssr2jqqA5TSBxZ6jlW5FRESqgl9pdh48eHCB+88++ywTJkxg0aJFtG3btsjn2Gw2oqOji3zMsixeffVVHnnkEYYMGQLAp59+SlRUFNOmTePqq68uTfOqjM0ZDoC/AouIiEiVKPMYFrfbzeTJk0lPTyc2NrbY/dLS0mjcuDENGzYsVI3Ztm0b8fHx9O/f37stIiKCs88+m7i4uGKP6XK5SElJKXCrSvagvMCSm16lrysiInKqKnVgWbNmDaGhoTidTm6//XamTp1KmzZtity3VatWfPTRR3z//fd8/vnneDweunfvzu7duwGIj48HICoqqsDzoqKivI8VZdy4cURERHhvDRs2LO3bKBdHXmAJcCuwiIiIVIVSB5ZWrVqxcuVKFi9ezKhRo7j++utZv359kfvGxsYyYsQIOnbsSO/evZkyZQp169bl3XffLVejx44dS3Jysve2a9euch2vtAJCagAQqMAiIiJSJUo1hgUgICCAFi1aANC5c2eWLl3Ka6+9VqIQ4u/vT6dOndi8eTOAd2zL/v37qVevnne//fv307Fjx2KP43Q6cTqdpW16hfEPjjD/kgO5LvDzXVtEREROBeVeh8Xj8eByuUq0r9vtZs2aNd5w0rRpU6Kjo5k1a5Z3n5SUFBYvXnzMcTG+5gyJOHLHpYG3IiIila1UFZaxY8cyaNAgGjVqRGpqKpMmTWLu3LnMmDEDgBEjRlC/fn3GjRsHwFNPPUW3bt1o0aIFSUlJvPDCC+zYsYObb74ZMDOIxowZwzPPPEPLli1p2rQpjz76KDExMQwdOrRi32kFCgtykmYFEmrLgqxkCKnj6yaJiIic1EoVWBISEhgxYgT79u0jIiKCDh06MGPGDM477zwAdu7cid1+pGhz+PBhbrnlFuLj46lZsyadO3dm4cKFBQbpPvjgg6Snp3PrrbeSlJREz549+fXXXwstMFedhDj9SCOIULJUYREREakCNsuyLF83orxSUlKIiIggOTmZ8PDwSn+9XYcycL3amRb2vXD9T9D0nEp/TRERkZNNaT6/dS2hMgh1+pFKMADuzGQft0ZEROTkp8BSBiFOP1KtIABc6QosIiIilU2BpQwC/Oxk2Exgyc5I8m1jRERETgEKLGWU5QgFIEcVFhERkUqnwFJG2Y4QQGNYREREqoICSxnl+JkKiyerai+8KCIicipSYCmjXH8TWCwFFhERkUqnwFJGnrzAYtPCcSIiIpVOgaWMPM4wAOzZaT5uiYiIyMlPgaWMbE6zIp8jRxUWERGRyqbAUka2QBNY/HJVYREREalsCixl5AgygSUgN93HLRERETn5KbCUkV9QBACB7jQ48a8fKSIiUq0psJSRf0gNABy4ITfLt40RERE5ySmwlJEz5KjLYGtqs4iISKVSYCmjsMAA7xWb0eJxIiIilUqBpYxCnH6kkhdYXAosIiIilUmBpYxCnA7S8iss6hISERGpVAosZRTm9CdNFRYREZEqocBSRiFOB6lWMKArNouIiFQ2BZYyOnoMiys92cetERERObkpsJSR089Ohs1UWHIzknzbGBERkZOcAksZ2Ww2suwhAORmqMIiIiJSmRRYyiHHLxQAd6bGsIiIiFQmBZZyyPUzFRZPlqY1i4iIVCYFlnLIDQgzX2has4iISKVSYCkHT15gsWerwiIiIlKZFFjKwxtY0nzcEBERkZObAkt5BJorNvvlqMIiIiJSmRRYysERGAGAf266j1siIiJyclNgKQe/INMlFOBOB8vycWtEREROXgos5eAfYiosDtyQk+Hj1oiIiJy8FFjKISA4HI9lM3dcGsciIiJSWRRYyiE00J+0vAsgKrCIiIhUHgWWcgg96orNZGnxOBERkcqiwFIOIU4/Ui1zxWatdisiIlJ5FFjKIdTppy4hERGRKqDAUg6hTj/SrPzAogqLiIhIZVFgKYeQo8aweDSGRUREpNKUKrBMmDCBDh06EB4eTnh4OLGxsUyfPr3Y/d9//33OOeccatasSc2aNenfvz9LliwpsM/IkSOx2WwFbgMHDizbu6liYYF+pOZVWHIyFFhEREQqS6kCS4MGDRg/fjzLly9n2bJl9O3blyFDhrBu3boi9587dy7Dhg1jzpw5xMXF0bBhQ84//3z27NlTYL+BAweyb98+7+3LL78s+zuqQk4/Oxk2M+g2NyPJt40RERE5ifmVZufBgwcXuP/ss88yYcIEFi1aRNu2bQvt/8UXXxS4/8EHH/Ddd98xa9YsRowY4d3udDqJjo4uTVOqBZvNRpYjBAB3piosIiIilaXMY1jcbjeTJ08mPT2d2NjYEj0nIyODnJwcatWqVWD73LlziYyMpFWrVowaNYrExMRjHsflcpGSklLg5iu5fqGAAouIiEhlKlWFBWDNmjXExsaSlZVFaGgoU6dOpU2bNiV67kMPPURMTAz9+/f3bhs4cCCXXnopTZs2ZcuWLTz88MMMGjSIuLg4HA5HkccZN24cTz75ZGmbXily/UMhF3Al+7opIiIiJ61SB5ZWrVqxcuVKkpOT+fbbb7n++uuZN2/ecUPL+PHjmTx5MnPnziUwMNC7/eqrr/Z+3b59ezp06EDz5s2ZO3cu/fr1K/JYY8eO5d577/XeT0lJoWHDhqV9KxXC7R8GmWgdFhERkUpU6i6hgIAAWrRoQefOnRk3bhxnnHEGr7322jGf8+KLLzJ+/Hh+++03OnTocMx9mzVrRp06ddi8eXOx+zidTu9Mpfybr1jOMADs2Wk+a4OIiMjJrtQVln/zeDy4XK5iH3/++ed59tlnmTFjBl26dDnu8Xbv3k1iYiL16tUrb9OqRl5g8ctRhUVERKSylCqwjB07lkGDBtGoUSNSU1OZNGkSc+fOZcaMGQCMGDGC+vXrM27cOACee+45HnvsMSZNmkSTJk2Ij48HIDQ0lNDQUNLS0njyySe57LLLiI6OZsuWLTz44IO0aNGCAQMGVPBbrRz2wAgA/HJUYREREakspQosCQkJjBgxgn379hEREUGHDh2YMWMG5513HgA7d+7Ebj/SyzRhwgSys7O5/PLLCxzn8ccf54knnsDhcLB69Wo++eQTkpKSiImJ4fzzz+fpp5/G6XRWwNurfPYg0x0V4E4HywKbzcctEhEROfmUKrB8+OGHx3x87ty5Be5v3779mPsHBQV5qzMnKr+gGgDYsMz1hPIqLiIiIlJxdC2hcgoMCSXDyqsGpR/0bWNEREROUgos5RTi9CPRypulpMAiIiJSKRRYyinU6eAged1A6Qd82xgREZGTlAJLOYU6/TnorbAosIiIiFQGBZZyCnE61CUkIiJSyRRYyinM6U8iqrCIiIhUJgWWcjIVlvwxLAm+bYyIiMhJSoGlnEKdft4xLJYqLCIiIpVCgaWcwgL9vbOErDQFFhERkcqgwFJOQQEOMvxqAgosIiIilUWBpQI4QiMBsGcdBneuj1sjIiJy8lFgqQAB4XXwWDZzPaHMQ75ujoiIyElHgaUC1I0I4TCh5o4G3oqIiFQ4BZYKEBnm5GD+1OY0TW0WERGpaAosFSAqPFCr3YqIiFQiBZYKEBnu1Gq3IiIilUiBpQJEhgUe6RJSYBEREalwCiwVICrceVSXkAKLiIhIRVNgqQCR4YHeLqFcLR4nIiJS4RRYKkCo049Uh1nt1p2y38etEREROfkosFQQK6Su+VddQiIiIhVOgaWCOEJNYPHLTPRxS0RERE4+CiwVJKBGNAB+7kzITvdxa0RERE4uCiwVpEZ4DbIsf3NH3UIiIiIVSoGlgkRGBHKQ/LVYtNqtiIhIRVJgqSBR4YEc1FosIiIilUKBpYJEhgWSqAsgioiIVAoFlgoSqdVuRUREKo0CSwWJOmq125xUVVhEREQqkgJLBQl1+pFirwGAK0mr3YqIiFQkBZYKlBtUBwC3KiwiIiIVSoGlAnnylue3ZWhas4iISEVSYKlA/mGRAPhlaXl+ERGRiqTAUoECI6LMv9mHweP2cWtEREROHgosFSiklqmw2PFA5mEft0ZEROTkocBSgSJrhHHYCjV3tBaLiIhIhVFgqUB1w7R4nIiISGVQYKlAUeFHXwBRgUVERKSiKLBUoMgwp/cCiNnJWjxORESkopQqsEyYMIEOHToQHh5OeHg4sbGxTJ8+/ZjP+eabb2jdujWBgYG0b9+eX375pcDjlmXx2GOPUa9ePYKCgujfvz+bNm0q/TupBkKdfiTnrXabcViBRUREpKKUKrA0aNCA8ePHs3z5cpYtW0bfvn0ZMmQI69atK3L/hQsXMmzYMG666SZWrFjB0KFDGTp0KGvXrvXu8/zzz/P666/zzjvvsHjxYkJCQhgwYABZWVnle2c+YLPZcAXUAiA7Od7HrRERETl52CzLsspzgFq1avHCCy9w0003FXrsqquuIj09nZ9++sm7rVu3bnTs2JF33nkHy7KIiYnhvvvu4/777wcgOTmZqKgoJk6cyNVXX12iNqSkpBAREUFycjLh4eHleTvl9v7Lj3BLyhvE1+tH9G1TfNoWERGR6qw0n99lHsPidruZPHky6enpxMbGFrlPXFwc/fv3L7BtwIABxMXFAbBt2zbi4+ML7BMREcHZZ5/t3acoLpeLlJSUArfqwhaavzy/Bt2KiIhUlFIHljVr1hAaGorT6eT2229n6tSptGnTpsh94+PjiYqKKrAtKiqK+Ph47+P524rbpyjjxo0jIiLCe2vYsGFp30alceQtz++fdcjHLRERETl5lDqwtGrVipUrV7J48WJGjRrF9ddfz/r16yujbcUaO3YsycnJ3tuuXbuq9PWPJahmNADBOQosIiIiFcWvtE8ICAigRYsWAHTu3JmlS5fy2muv8e677xbaNzo6mv37C86W2b9/P9HR0d7H87fVq1evwD4dO3Ystg1OpxOn01napleJ0FrmfQR6MiAnE/yDfNwiERGRE1+512HxeDy4XK4iH4uNjWXWrFkFts2cOdM75qVp06ZER0cX2CclJYXFixcXOy6muqtVqzYuKy8Hph/0bWNEREROEqWqsIwdO5ZBgwbRqFEjUlNTmTRpEnPnzmXGjBkAjBgxgvr16zNu3DgA7r77bnr37s1LL73EhRdeyOTJk1m2bBnvvfceYKYBjxkzhmeeeYaWLVvStGlTHn30UWJiYhg6dGjFvtMqEhkeRCLhxHAI0hOgRvUZXyMiInKiKlVgSUhIYMSIEezbt4+IiAg6dOjAjBkzOO+88wDYuXMndvuRok337t2ZNGkSjzzyCA8//DAtW7Zk2rRptGvXzrvPgw8+SHp6OrfeeitJSUn07NmTX3/9lcDAwAp6i1UrKtzJdiucGNshspL3E1jf1y0SERE58ZV7HZbqoDqtw2JZFvOf6EMv20oO9n2ZOr0Kr08jIiIiVbQOixTNZrOR4V8TgIwkrXYrIiJSERRYKoHLWRuAHF0AUUREpEIosFQCV3AMAH7J23zcEhERkZODAkslyKzVGoAaKRt93BIREZGTgwJLJXBEm1lQEdnxkHnYx60RERE58SmwVIKmDeuz26pj7uxf59vGiIiInAQUWCrBaVFh/O1pDED2nlU+bo2IiMiJT4GlEtQNc7LdrykAqTtW+rYxIiIiJwEFlkqSVtMMvLXFr/VxS0RERE58CiyVxFGvAwDhqZvBnevj1oiIiJzYFFgqSVTjVqRZgfhZ2ZC4ydfNEREROaEpsFSS06Ij+MdqZO6oW0hERKRcFFgqiZkpZAJL5q6Vvm2MiIjICU6BpZKEOP3YH9QSgKzdmtosIiJSHgoslSinbhsAnIl/+7glIiIiJzYFlkoU3LADHstGcPZBSDvg6+aIiIicsBRYKlGzmEi2W1Hmzv41vm2MiIjICUyBpRK1jg7j77yZQp59mikkIiJSVgoslahJnRA20gTQTCEREZHyUGCpRP4OO8nhrQDwaC0WERGRMlNgqWS2eu0BCE7ZDLkuH7dGRETkxKTAUsmiGjQn2QrGYbnhwD++bo6IiMgJSYGlkrWKDme9p4m5o24hERGRMlFgqWStjpoplLtvtY9bIyIicmJSYKlk9SIC2ebXFADXbgUWERGRslBgqWQ2mw1XbbNEv/+BdWBZPm6RiIjIiUeBpQoE129DrmUnICcZDm/3dXNEREROOAosVaB5vTos8bQ2d9Z849vGiIiInIAUWKpAq+hwvnb3MXdWfAYej0/bIyIicqJRYKkCraLCmO45ixQrGJJ2wrZ5vm6SiIjICUWBpQpEBPvTumEk09w9ANjx+7tYGnwrIiJSYgosVeSDEV3Y1OASAKL3zuShz+eSkpXj41aJiIicGBRYqkjdMCdP3noNB0Jb47TlEvzPFC54bT7r96b4umkiIiLVngJLFbLbbdTtdTMA1wbMY/fhDO75aiUej7qHREREjkWBpaq1vxwcTlpYO+jm3MGG/anM/Hu/r1slIiJSrSmwVLWgmtBmCAD/jV4KwJuzN2sQroiIyDEosPjCmdcB0OHw79Tyz2HNnmTmbjzg40aJiIhUXwosvtC4J9Rsgj07lSdbbALgjVmbVGUREREpRqkCy7hx4+jatSthYWFERkYydOhQNmzYcMzn9OnTB5vNVuh24YUXevcZOXJkoccHDhxYtnd0IrDboZOpsly4+2WG+i/ir51JxG1N9HHDREREqqdSBZZ58+YxevRoFi1axMyZM8nJyeH8888nPT292OdMmTKFffv2eW9r167F4XBwxRVXFNhv4MCBBfb78ssvy/aOThRn3w5NzsGek8Grjtd5zO9T3v79b1+3SkREpFryK83Ov/76a4H7EydOJDIykuXLl9OrV68in1OrVq0C9ydPnkxwcHChwOJ0OomOji5Nc05szlC4bhrMeQYWvMKNfr/SYc9WVq37hDPatvF160RERKqVco1hSU5OBgqHkmP58MMPufrqqwkJCSmwfe7cuURGRtKqVStGjRpFYmLx3SMul4uUlJQCtxOSww/6PwFXTyLLHkIX+0aafHcBpCX4umUiIiLVSpkDi8fjYcyYMfTo0YN27dqV6DlLlixh7dq13HzzzQW2Dxw4kE8//ZRZs2bx3HPPMW/ePAYNGoTb7S7yOOPGjSMiIsJ7a9iwYVnfRvXQ+kISh//GdiuaCM9h9s7/zNctEhERqVZsVhmnpowaNYrp06ezYMECGjRoUKLn3HbbbcTFxbF69epj7rd161aaN2/O77//Tr9+/Qo97nK5cLlc3vspKSk0bNiQ5ORkwsPDS/dGqpEpEx7h0v1vsDmwAy3+O9/XzREREalUKSkpRERElOjzu0wVljvvvJOffvqJOXPmlDispKenM3nyZG666abj7tusWTPq1KnD5s2bi3zc6XQSHh5e4HYy6ND/GgCaZa5h+47tvm2MiIhINVKqwGJZFnfeeSdTp05l9uzZNG3atMTP/eabb3C5XFx77bXH3Xf37t0kJiZSr1690jTvhNeiZRu2B7TEbrNY/tsXvm6OiIhItVGqwDJ69Gg+//xzJk2aRFhYGPHx8cTHx5OZmendZ8SIEYwdO7bQcz/88EOGDh1K7dq1C2xPS0vjgQceYNGiRWzfvp1Zs2YxZMgQWrRowYABA8r4tk5c/m0HA1B712/EJ2f5uDUiIiLVQ6kCy4QJE0hOTqZPnz7Uq1fPe/vqq6+8++zcuZN9+/YVeN6GDRtYsGBBkd1BDoeD1atXc/HFF3Paaadx00030blzZ+bPn4/T6Szj2zpx1Y+9EoBY21o+/2Otj1sjIiJSPZRqHZaSjM+dO3duoW2tWrUq9rlBQUHMmDGjNM04udVtTUZYE4JTt7N36Y8k9zuDiGB/X7dKRETEp3QtoerGZiOovbmacx9rMZ/Gbfdte0RERKoBBZZqyHa6Gcdyrn0ln/+5iczsotejEREROVUosFRH9TtjhUYTZsvk9KwVfL1sl69bJCIi4lMKLNWR3Y6t9QUAnG9fykd/bivR+CEREZGTlQJLddX6IgDOd/zFrsQ0lu847OMGiYiI+I4CS3XV5BxwRlDHlkwn2ya++2u3r1skIiLiMwos1ZVfAJxmFs4b4TeTxavXkZWjwbciInJqUmCpzvJmCw1xLGQ2t5P9xtkw4/9g61zQmBYRETmFKLBUZ60vhL6PsC+kDR7LRnjKJoh7Ez4dAt/eCK5UX7dQRESkSiiwVGd2B/R6gIyRMznT9Q535vyHzLZXg90P1k2B986FhL993UoREZFKp8ByAmheN5SmjRryk7sbn0c9BCN/gbAYSNwE7/eFVV8d/yAiIiInMAWWE8SlZzYAMLOFGp0Nt8+HZudCTgZMvRV+e6T8L3JoK+z5q/zHERERqWAKLCeIwR3qEeCw8098Kuv2JkNIHbj2O+j9X8AGC9+A7QvK/gLJu+HdPvDheXB4ewW1WkREpGIosJwgagQH0L9NJADfLd9jNtodcO5Y6HKDuf/Lg+DOLf3BLQt+uAtcyeDJhQ2/VlCrRUREKoYCywnk0k6mW+iHVXvIcXuOPND3UQiqCQnrYNlHpT/w8o9hy+wj9zf9Vs6WioiIVCwFlhNI71Z1qR0SwMG0bN77Y+uRB4JrQd+8MSxznoH0gyU/6KFtMCPvuZ3zKjXbF0B2esU0WkREpAIosJxA/B12buvdDIAXZmzgpd82HLkoYucbILo9ZCXDrKdKdkCPB6bdATnp0LgnXPgy1GgEbhdsm19J70JERKT0FFhOMLec04wHBrQC4I3Zm3nih3V4PJYZzzLoBbPTX5+WbLbP4gmwcyH4h8DQt8Buh5bnm8c2zaikdyAiIlJ6CiwnGJvNxuhzW/D0kLbYbPBJ3A7u+2YVyRk5LLVasSX6AsBiyyej+GPD/uIPtHPRkUrMgGehZhPztTewzNTy/yIiUm3YLOvE/1RKSUkhIiKC5ORkwsPDfd2cKvP9yj3c+/Uq3J4j38JIDjPbeR+htixmus9kR7u7uO6yITj9HGaHzMPw+5OwfCJgQfN+Znq0zWYez86A55tCbhbcsQgiT6/y9yUiIqeG0nx+q8JyAhvSsT7vXdcZp5/5NtaLCKTD6a1Y1OIePNg4z/EXN/99A6vHn8fuVbNh5ZfwRhczKwgLzhgGl394JKwABARDk3PM1xvVLSQiItWDKiwngcQ0FxZQJ9R5ZGPCP+z9+VmidvyEA0/BJ9RpBRe9DE16Fn3Axe/B9AfMQNwbfj7u6y/ZdogmtYOJDA8s+5sQEZFTjiosp5jaoc6CYQUgsjUxN3xG0o1xzAkZRLblINMKYFrtW0geOaf4sALQ8jzz7844M+voGH5fv58r343jls+Wl/NdiIiIFE+B5SRXu1Fret/3JV+d8xt9ct9gzJ5zufCtxazYebj4J9VqCnVOA8sNW+YUu5tlWbw962/OtG2E3cvYsWunBuqKiEilUJfQKWTVriTu/PIvdh3KxM9u44EBrbjlnGbY7bbCO8/4P4h7EzoOh6FvF3wsOwO2zCJhybcEbJ1JDdtRi8z5h0DNxmaw7rn/B7WbV+6bEhGRE1ZpPr8VWE4xKVk5jJ2yhp9X7wPgP31bcO/5rQrvuHUufDoEQiLhvg1mjZYDG2DBq7BuKuRmenc9TDhZlh9RtsPYOerHKSAMLn4N2l1WuW9KREROSBrDIsUKD/TnzWGdeOyiNgC8+8dW9iVnFt6xUXcICIX0BFj5OXx1Hbx1NqyaBLmZuEIb8EHuIK7OeZw9N62iZ85btM6ayK7h82H4d9C4B2Snwrc3wk/3Qk5WFb9TERE5mSiwnIJsNhs39GjCWU1q4cr18MrMjYV38guAZn3M1z/cBX//AFjQ+iK46XfuqjuRZ3Kvo/4Z/WjXsBbdm9cmG39+2B0MLfvDiB/gnPvN85d9CB/2h4ObquotyvFkpUB6oq9bISJSYgospyibzcZDg1oD8O3y3Wzcn1pon011+gLgxkFOuyvNQnJXf8GmgNb89ncCNhuM6mOubXRh+3oA3q4mHH7Q71GzKF1wbYhfA293g5/ugeQ9hRvk8cC+1ZC0sxLerRSQuh8mdIc3OkFqvK9bIyJSIgosp7DOjWsysG00Hgue//WfAo9t3J/KpQvqc332Q/R2vUT/bdfwV1Y0ABPmbQHg/DZRtIgMM1+3jcZht7F+XwrbDh41CLdFf7h9AbQ4Dzy5sOwjeL0TTP8vHNoKf/8I34+Gl1rBu+fAhB6QtKvy37xlmYpP8h7IKaJL7GTlzoFvb4DkXWbK+uJ3fN0iEZESUWA5xT0wsBUOu43f/05gybZDACSkZHHDx0tJzXJzOKYXnvBG7EjM4Ip34nj6p/X8sHIvAHf0aeE9Tq2QALo3rw3AL2v2FXyR8Bi49lsY+YsZG+N2mQsvvt4JvroWVnxuxsoAuFLg5/uKnx6d8A/siCvfm3alwsQL4c0u8EobeDYanomGl9vC3PHlO3ZFinsL3uoG+9dX3DF/fwJ2/Am2vEs1LP3InA9f2/y7Of///OLrlhgeD/z5Oiz/xNctEZE8CiynuOZ1Q7mqa0MAxk3/mzRXLjdMXMqepEya1QnhkxvOYvqYXgzpGIPbY/Hhgm3keix6tqjDGQ1rFDhWoW6hf2vSA274Ba6bCvW7mG01m8DZo+C6aaYS4wgwV4peN6Xw83fEmSrMxwNhy+yyvWFXKnx+ufnQtvuZG5hZTym7Ye44WPtd0c/NOGQqQB+ebyoVpeVxw64l5qKTE3qaMJKyt+h90xJg1tNw4G/47mbIdRW934ENMPNx2Lfq+K+/bqqZqg5w+UdmrR1Xsu8/lD0eM40+ZTdMfwhys8t+rJR9JvBu/r18bZr9NMx8FH78j7mkhYj4nKY1CwkpWfR+YS6ZOW6a1Qlh68F0aocEMPWOHjSqHezd7/uVe3hk2lrSXblMuqUb3ZrVLnCcQ+nZdH32d9wei7n396FJnZDiX9SyTHhwhhW8ltHc8SY0hNSF0UsguJbZnrgFPugPmaYKRM0mMCrOXPuopPLDyq5FEBhhQlJMJ7M9I9EMDl74BgTVhDsWQ1jUked6PDDpiiMfhBe/AWeOKNnrxq811ZJNM8zrHK3TtTDkrcLPmfk4/Pnqkfvd/wPnP11wn6Sd8H6/I9Wp1hdBn7EQ3a7w8Q5sgPfOhZx06HE3nPcU/PUZ/HAnhNeH/6w0A6194Z9fYPKwI/cvehW63FD64xzYAJ9fZrq7AsLgruUFv4cltXISTBt15L5fENwyC6Lalv5YInJMmtYspRIZHsgt5zQFYOvBdAL97Xw4smuBsALmYovzHjiXGWN6FQorULBb6Od/dwv9m80GgeEFwwpAz3vMtY7SD7Ds/dH0GD+b6UvWwRdXmLAS08l8wB7eDn88X+L3mHDwIJ7PLisYVuqfeaQdtZpC38cgur25ovVPYwp2S/3xQsG/2v944fiVgMQtpjryTk8zHTwj0bx220uh32Nmn5WTIOHvgs/LOARLPzBfd7nR/LvwDdj+55F9MpPMOUlPMOEOG/zzE7zTw0xBXzfNVFTWfAurJpuut5x0c2HLvnmv3eFKCI2GlD3FV5WO58AG07YdC8tWGbEsWPCy+bqm+Rlk/kulP9bORabylZw3/ik7FWY/Vfr27IiDH/5jvu55DzTva6pvX19fPbrORE5hCiwCwK29m1M3zIndBm8MO5OO/+ruyVcrJICWUWHFHueC43ULHcWV6yY710N+kc+yLOZtTeEpxyg8lo0uh3+hZUocdX++EQ5tgYhGMOwruOBFc4A/XzfVi+NYuWoFu14fhH334oJh5d/8AuCSd8HuDxt+gVV5XQGbfzdVH4ALXzKL6SXtNCGkKKnx8OMYeOssWPMNYEGboTDyZ3hgC1zxMZxzn6mIWB74/cmCz1/8DmSnQVR7uPBlU4XBgmm3m+nIudkmgBz4B8Ji4NZ5ZgZX20sBm5mC/s318M1I+O4mmHobHNxo9r38YzODC8DPCd1uN18vfL30l1XIOGQWF/ztEfh4EDzXxFSwFr5hAmVJ7FgIu5eCwwkjppkAlbwLVnxW8nb8/aNpR1YSNOgKwyab7Su+gL0rSn6cQ9vgq+HgyYHTLzbB7tL3TUBO3GSm95/4BemiZRwyAftUtXu5GR8n1Zq6hMRrX3ImqVm5nHaMQHI8R3cLPTWkLQPbRRMZduQqzmmuXH5ZvY9vlu9i6fYj1zNy2G04bDay3ebK0k/7f8x1jpm4sePAQ4YtmKDbZ2GLMgve8dV15oO5fme4aSbYHYUbk5aANe953Es/wg83yVYwuy6cRLuzzj32m5j/Msx6EpwRMPxr+PJqU3XpPJJtsf+jxqr3qTn/cYhoCHf9VbAr5fAO03WV303Toj/0fRRiOhZ+nYObzGJ8lhtumA6Nu5uZO6+0N2NLrvgE2g41IeWdHiYkdRxuQs6qL83Cfjf+aqpC+favhz9fM4HB7si7+UFgDej1AOSfv3yZSfBKO1ORGP7tkQtfHo9lmUUB100xAc7yQMbBI4/b/UyXWa8HIbxe8cf54grY9Bt0vgEGvwqL34XpD+Z1U60woepYlk804RALWl0Al31ougm/u9mExYbdzDn6dyXv37KS4YPz4OAGqNfRfD/yuxt3LTGBzJMLg16As2897unxmV1LYN5zpoJX74ySPcey4J1zYP9aM7ap3aWV28bqJnGL+ePC4YQ74sylRUrC44a9K815zv8joCw8HvP/z1lExfkUoKX5xadGfryEuRsOAOb/X8eGNejXOpLtiRn8smYfGdnuYp8b6vTjqq4NGdm5Ng0n9YHUveRYDkbmPMjgoddw9VmNzI4p+8wvGVdK4Q+RtAOw5D0zbiTHTLGe5+7A07nXUq9FRz676exjvwF3Lnw0APYsA5vdfBjX68jM2E+546t11PR3syj0Puxp+wuOt8g8DB8OMB96dVrBRa+YgcbH8uMYWP6xqQzcNNN0h8x+2jz/jkXmkghgKhEfXwD5lz6wOeCar80ifcex/WA6b8zezKg+zbzT0AvIv25Uk3Ng5E/HPR4Aq7+BKTebdtw8E+p1goR1sHUebPwVts83+/kFme9NjzFHxiPli19rgpjNDncuM9edyskys8dS95pK2lm3FN+G+LXwXm8TJLrcaH4O8j84kveYWWA5GXkfwse4PETaAfjyKtiz3FShbpldOGTFvQ0zxprqW99HoM3FUKtZyc5VWWUeBv/g44e2fCn7zKD09APQvB9cV8TA9aLsXGR+3sG8v2u/PbJo5Klg1lPm/x2YLsBrpxw/OOS6TGD/5ydodzlc/mHJXsuy4K9PYe23kH7Q3DISzR8t0e3h4jeL/uOmpBL+NrfMQ5Bx2PybkwEtB0CrQdUyECmwiE8dTHMxeclOZq7fz6rdyYUeb1YnhMu7NODiM2IIC/Qn1+0h12OR4/ZQJ9RJoH9etWTbfPjt/5hd6ypuXN6EUKcfM+7pRf0aQebxpR+YGSEBodDrfrPw3J5lBRafW29rwdOuq2jWdRBfLd1Frsdi6h3d6dSo5nHexCYz9iQ3CwJrMKfPt9zywwFyPea/y6T2K+i+6YUjVRaAzy81H9RhMXDz7xBR//gnKzXefEDnZMAl78Gv/zW/ZC5934wxOdrMx0z1BGDwa9B55HEPb1kWl78Tx/Idh+nRojZf3Nyt8E7Je+C1DuaD/+bZ0KDzsQ+atMvMlnIlQ5+Hoc9DhffZ/qepUu1abO47I6D3g3D2beDwN9vyqyBtLzXdZPmWvA+/3G/O439WgH9g4eO7c+CDfmZ2VOuL4KrPC/8ynvsczP0fhDeAO5cWPUD74Gb44jJTkQqqCSO+L7oyYVnw9Yi8FZ/zRLaF0y8yH3K1mpmxRCX5QEj4x1TIGneH0wYU/VrLPjI/C85wiL0Dut5ixloVx50LnwyGnQvzNtjg7pVmcPrx/HCX+RD1DzY/hwFhJriW5YPTsky1KjCidB+Ou5dD0g5oFFs4LGanmxC8bqoJtINfhYgGRR8nZZ+ZWdfs3JK9vsdtKoypR83WGzoBOl5T/HOyM0zX4dEzFfMrpMeScQi+vxM2/Fz8PjYH9BwDvR8qeVA9tM0EoDXfmfdenKh2cM69pnu6qIq0jyiwSLWxPyWL3//ezx8bD1ArJIDLzmxA58Y1sZXil5nbY3HFOwv5a2cSvU6ryyc3dDXP93jMFOf8D8WjRbfn11rXcvtfDYiJCGL2/X14dNpavlm+m36tI/lwZNfjv/CKL2Dec8S1fZRr54Tg9lg0rxvClgPpNI1wMNv/bmxp8WZcy+5lxXfTHEfuzKfw+/MlcnHgh9sMPr1zWeEyc64L5jwLtVvCmdeV6Ni/rNnHHV/85b0//e5zOL1eEf9Hpo4yY3JqNoUrPym+O8HjgU8vNsGsfhe4cUbx5XDLgo0zzF+wCevMtjqtYNB48zpvnGmqV7f9UfD1cl0mxKXsKb4L5o8XTSUqsIaZTZY3G2jT/lQum7CQS89swBMDm5oqXPKuooPVzkVHuvtqNDarMtdpWcyZzGvXis9g/Q+wfYH5q/hoAaEmINRsYgaHN+4OMWeawGVZ5oKicW8WHLzd9lIY9DyE1jX3s9PNatCrvyp47MAIOOs26DaqcKUKjoTZgDCo3cwEuXPuOzK4uzjZGfDiaaZL4topsOAV870NqQs3/Vb6KtLvT5hjOMOhbiuo29pcub3JOVCvQ+H9XWnw2/+Zrr18tVtAk57mZ2L7Atgw3QSpfKHRpqv23z+j//wCU283QbrjcBj8+vG7ajb/bmaWBdWEbneY/1//+pkqICsZJl0FO+NMwGvQBbbl/fzeMvdIRfTfti+AKbean2lHgAnv9TtDcB0IqWN+Pn77PxPKwJy3IW+Z4xdn70rzB9ueZUe2OQLyjlvbvKfgWibkrfzCjIvLP7/n3G/+IKoGwaXSAsu4ceOYMmUK//zzD0FBQXTv3p3nnnuOVq2KuNpvnokTJ3LDDQWnKDqdTrKyjlwMz7IsHn/8cd5//32SkpLo0aMHEyZMoGXLY/zyOIoCy8lvy4E0Br02n+xcD89d1p6ruuZ1DR3cbKbmBtc2A2nrd4aYTiTmBtL7hbmkuXJ55aozuKRTA7YdTKffS3PxWPDTXT1pVz/iuK87dcVu7vt6FR4LLjuzAU8PbUvP5+ZwKD2bX85eR5tVz5pfEu7sUnXTAOxMzOCLxTv4eekGvvfcSW2bmYXyz1n/o/UFo8t8rvK5ct2c9/If7DyUQajTjzRXLld0bsALVxQOI3+tWkX0lEuJsR00ffmDxptxJf8OlnFvwYyHzS/r2xeYbpzj8XjMBTR/f/LIOJewGPNXbXFdF/nVs5BIEySO/rBL+Bve7WXO+SXvwhlXex968NtVfL1sNw67jT8ePJf6u38xpXu/QDM+J6KhuWGZ9rhdJlRc8xWERnqPY1kWz8/YQEiAgzv7FvF7KOOQ+av/n5/NB0fKHqCIX6UOp/m5dKWaMSIA2MzFQXfGmdATVBMGPmf2+3oEJKw3P0v9HzcfzvNfNIOmAfxDTBdktzsgoj4pWTkEbP6VwG+vNY9f8Yn5nn09AkKj4J51RypaRVn1FUy91YSsu1aY4DLxQnMpjZpN4IK8rhJPjqlqBdcyYaIoh7bCm11Npa4ojXtC97ug5fnmg31HnBlInj9AO7KNGUhueQo/t2YTaHuJCcAJ6815uGIinHa+qS7NfupI9THfaQPNIPNjLX3wzUgTEs66FQaMgw/6mrB3+sVw1b8GfqcnmirqvpV549u+MT//r3cyXdND3oZOwws+x+M2Y4r+eMG8r9otTBdlcX8QrP/e/NynHzBdpUPeKrrak7QT3u97ZL+mvaH95abaGFSj8P4Zh0w3+aIJZnA6QHQHGDiu6O+nZZnw7BdYvvE5JVBpgWXgwIFcffXVdO3aldzcXB5++GHWrl3L+vXrCQkpes2NiRMncvfdd7Nhw4YjL2qzERV1JL0+99xzjBs3jk8++YSmTZvy6KOPsmbNGtavX09gYBHl4H9RYDk1vPfHFv73yz847DbOaBBB9+Z16N68Nmc2rnmkGynPY9+v5dO4HbSvH8H3o3tgt5sP3rsnr+D7lXsZ2Daad6470vVhWRbzNx3kn/gU9qe42J+Sxf6ULJbtOIxlwVVdGjLu0vbY7TZe/m0Dr8/eTGyjEL7MHHWknJw3nmVnYgY7D2XQNiacmiEF1zY5mObi17Xx/LJmH3FbE72TTv4TOot7cz9kt1WHIbbXmXrXuYWmlZfWB/O38szPf1M3zMkrV3bk2g8XE+Cw8+d/+1I37Ei52ZXrZuCr8zl0cD8v+U+gvyNvZk27y+GCFyBxs/kLccdCUyXw5JjxOflTrksqM8mss7PkvSPViet/gqbnFN4312Wud5S42YyrOHcs9BiDx+PB/vEAM96k5QATNPJCVXJGDmeP+52sHPOBd1uvZowd1Bo+G2raXZTTBpnxBwEFf38t2HSQaz80lbu3h5/pnf1WrJwsU8k5tM3MKNq5yASS9ANH9vEPMTO+ut1uKhd7V8D3d8H+NeZxm8Ocl9Ao80GbP/7J4zFdUfNfNEECwO6Pq+0V3LOuGeM9rxBOulmAcdB4EyxebmMGfl/5mRlvU5xPLoZt8wpWoFL3w4fnmS6aogx+HTpfX3j7tzea6fHN+8L5z5ruiYR/TJs3zzwSZGq3hIZnm7/6sUyAHDrB/BxkJsHOOJbO/YGc3SvZ5GhOh4E30Onsvub7nJVswtjWueaDuv8TJsTsyJvy3+0OaNTNVDNys8yg62FfFl2VyjhkLgnizjYz7WI6mra+18e09cpPoc0QM5B99VdmeYC0ePPH0XVTj4SOP183iwyGRpnuYWdo3s9Epun2/CdvXFina00wzX+8OBmHTGhZN8W8x8s/NoPv87lSzRT+hPWmkjv8WwiLPvYxj37u0g9g/iumEgUmnJ33FPgHmfOaf0vNm+lp9zeP+QeZ790Nx+jSKoMq6xI6cOAAkZGRzJs3j169ehW5z8SJExkzZgxJSUlFPm5ZFjExMdx3333cf7+5um9ycjJRUVFMnDiRq6++usjnHU2B5dTg9ljc/vlyZq7fX2B7gJ+dtjHhdKgfQfsGNagTGsBNnyzD7bH48pZuxDY/smbMxv2pnP/KHwD8dk8vTosK46+dh3n2579ZvuMwRRl+diOeHtLOG3oSUrLo8dxsctwWf5y/n0Z/3GNmw/T9PzbuT+WytxeS6jK/nBvVCqZ9gwha1A1lybZDLN6WiOeo/3G9TqvLdd0a0/e02nj++pT74wL4fl9N2tQL57tR3QkKKFvJ9nB6Nr1fmENKVq63IjX0rT9ZuSuJu/u15J7zTvPu+/bczTz/q/mDwoaH/wT9yhi+xPbvLo98bS8xv0TLOoAv4W8TXMLrw4Bniz9O+kH48W7vL/ztwe2YldqImxy/mL9wRy8yl33I8+GCbTz903pvNSks0I9FY/sR4meZ0n/SLhMqkneZsUNNe5mxAkWUxW/9dBm/5f2c1QkN4Ld7elPrX+HzuCzLzEDZudCEiHaXmmrK0dw5pjIw7znzwdm4h/kLvKgPICvvfSx4FXYsKPDQP36taXL/XAID88Z3/f6kWd+meV/z4VqUpJ3wagfAgjFroEYj70OpezdwYPJdRNkOExIUaKo0udkmXAWEwqg/C46P2bvCfNBjg9vnF+4STd5jpusvn2iqEfk6DoeB4wuMz0nKyKbH+Nmk5w3Ot9vgwYGtua1XM9MVnJtt1kla+cWR4wSEwpA3zc8mmOrNl1eZgFP3dFOl+/eYsvyxUlHtTZvzfw5nPW3CYXAdCKt3JFCCCVfXToG6R/7/kOsys/0ObzNdLf0eNaHjy2Fm3SdHgKmU/HtM2rFYlhlbtOIzExiunmSqSR63Oe6mGSYg3TK7+PE8x5J+EOb8zwz4tzxHwvLx1G0No4vogi+HKgssmzdvpmXLlqxZs4Z27YpYXRMTWG6++Wbq16+Px+PhzDPP5H//+x9t25pVI7du3Urz5s1ZsWIFHTt29D6vd+/edOzYkddee63QMV0uFy7XkaXKU1JSaNiwoQLLKWL34QwWbkkkbksif24+SEJq0cvW9z89ig+uL9wHfPtny/l1XTzntqpLsNPPu2ZMkL+D/m2iiIkIJDI8kKhwJ01qh9A2JrzQmJt7v1rJlBV7GNoxhlcvaw3+QSSmuRj69p/sOpRJmNPPG1r+rUODCC5oX48L29ejYa2CVZR9yZlc9PoCEtOzufTM+rx0xRmlGu+T78kf1/Hxn9tpHR3Gz/85B4fdxo+r9nLXlyuoExrAgof6EujvYF9yJn1fnEdmjpvxl7bns0U7WLc3hRH19/Fk9kvYUvdCUC0zHqNJT/NvdIdjhpWl2w/hZ7fRoUENHPbyzUrIdOWy4LvXid3wPKG2IxepTOj7MpG9bvLetyyLfi/NY+vBdJ4e0paP/tzOtoPpPDWkLSNimxQ45s7EDIa9v4gzGkbw1jVnFjq/e5IyOee52XgsqF8jiD1Jmeb7fHWncr2XY0rccqQrogQleNe2OOI+eZQ+LCXRCuci17PEntnhyM/LoW3wekez892rih58O+95M2ajaS+4/kfvZsuyuO2z5fy2fj9+dhsfjuxK79Pqmg/LiReZANa4p3lO/piNT4eYv8o7XAWXvneMhqeaFZY3/24qdKdfVGiXV2Zu5LVZm2gdHUaHBhF8vWw3YC798fzlHQhx+pkP9D9ehDnPmK6kKz8tPP5o/3rThZO6z7z/G34tOKD33d6me2fgeDM2KF9Olpltld8NZ/c3g6M7XGmqekUNAv/7JzMQN389oR/HmNmCzggYNqn4bjQgK8fN2Clr2J6YTq7bTD7IdnsI9YfPa31E+ObvTdfM8G9NN2Tcm+b+yF+OP0D+ePavN7Pfts4FbKZq1KwPND/XjMPyuE2lKCfTLKCIreiVtMuhSgKLx+Ph4osvJikpiQULFhS7X1xcHJs2baJDhw4kJyfz4osv8scff7Bu3ToaNGjAwoUL6dGjB3v37qVevSM/TFdeeSU2m42vvvqq0DGfeOIJnnzyyULbFVhOPZZlsT0xg9W7k1i9O5k1e5JZtycZh93G1NE9aF63cPl17Z5kLnrjyM+szQZXdG7Afee3Iir8+F2QAGt2JzP4zQX42W38+d++1Aj2Z/j7i1m24zCNagUzbXQPHDYba/Yks2p3EpsT0mgdHcYFRYSUf1u45SDXfrAYjwWPD25D/9OjiE/JYl9yFgkpWbSMCqNXyzrFBpltB9M57+V55HosPrvpLM5paQZ05ro99Hp+DnuTs3j+8g5c2aUhoyf9xc+r99GlcU2+uT2W7YkZXPT6fNKz3dzbtwn/6RpiFuwrbjDhUTweixd+28CEuWYBslohAfQ5rS7nto6k12l1iQg6xliKf8l1e5jy1x5enrmR+JQsGtgO8E7o+7TLWctsd0e+bPEi719/ZOD0n5sPMvyDxYQ6/Vj0cD+m/LWbx75fR9M6Icy6t7e3Opbj9nDFO3Gs3JUEwPsjunBem4KDK1+Y8Q9vzdlCbLPaPDSoNZe+/SceCz68vgv9Ti/DUv+VYNLinTw8dQ1nRqRx3wUdGPHVNtwei0cuPJ2bz8kbKPvZJWYmS897zXiYo3jcHuxvdjLjR/41Dmjin9t44scjF9wMDnAw6ZZuZjHJQ9vMDLGcdBjwP4gdbV7js0tMJeHOZSVfx6QIqVk59Bg/m5SsXN4efiaD2kXzxeKdPPnjOnLcFo1rBzPkjBjObR3JGQ1qYE+LNwOEiwt5STtNt9fhbaY6MPIXCKl9ZEq93R/u22C2HS3hb1PJanS2mVVTVJfS0SzLzNLKn84PZpzWtd8VXvvoX75euosHv1td5GPto4P5vu472Df9asKQO++Ps+NN1S+N/EpgUM3C56EKVElgGTVqFNOnT2fBggU0aFDyklROTg6nn346w4YN4+mnny5TYFGFRY7F7bGwLAs/R/Efsvkf1Oe0rMPDF5xe9MyZ47jynTiWbD/E6HObsy85iyl/7SEs0I+pd3Qver2TUsgfr1Oc06JCubVXcy4+I4YAP/M+c90eVu9J5sUZG1i4JZE+reoy8YazCjzv3XlbGDf9H1pHh/HYRW245oPF2G3w4109aRtjBiFPXbGbe75ahd1GgWtGeTwW2W4PTj97obDkynXzwDer+WGVGc+T3y2Tz99h48ouDbmrb0uiI4oPhbluD1NX7OHNOZvZkWhmhtSvEcRDg1ozuH0Uu9f9yXlfJpHlcTDplrPp3rwOcKRqdl23xjw9tB3prlxix80iJSu3QNB4ccYG3pyz2ft6zeqEMOOeXvjn/ay4ct10HzebxPRsJgw/k0Ht6/G/X/7mvT+2Eh0eyG/39iI88NjBy7KsMlXFSsrjsej/sqkmPXpRG27q2ZSPFmzjqZ/WY7fBxzecZSoi67834z1CIuHe9d7BtzPWxfPlN18ykSewAkKx3b/RO4Zn7Z5kLn17IdluDw9f0Jr5mw4yf9NBagb78+2o7uYPgGUfmZlMDifcNs+MF4lfbcaPDBxXrvf21pzNvDBjAy0iQ/ltTC9v0Fy2/RCjvviLA0dVU2uHBNC7VV2uj21S6EKsBRzeAR8NNGPN6nWE638wXZKL3obTB5sp8RUhfo1ZgA8rrxvq2xJ11+T/Hhl+diP6t4nC327HY1n8Z/IKkjJyuL9vY+7c97AZawTmemF9/lvksbJzPeS4PaYKdYKo9MBy55138v333/PHH3/QtGnTUjfwiiuuwM/Pjy+//LJMXUL/pjEsUlrZuR7ik7NoWCuozB8uv67dx+2f/4XDbsPtsXDYbXw8siu9Tqtb7vZZlsU9X61k2sq9OP3sREcEEhUeSM1gf/7cnOgNA9HhgQzpGMOmhDSWbDvk3W63wa9jehVatTg5I4du42aRmeOmZrA/hzNyGBHbmKeGFCzz3v/NKr5dvpsgfwchTgfpLjeZOaaPu1ndEC47swGXdKpPTI0gkjNyuPWzZSzeZrqCxl/WgSEdY1i2/TBzNiQw+58ENieYKZVOPzvXd2/C7b2be8eE5Lo97E3KYtHWRN6aeySo1A4J4PbezbkutnGBQdX5A6pPrxfOT3f15ECqix7PzcbtsZgxphetos17HvfL37z7x1a6N6/NpFu6sWhrIsPeX4RlwfhL2/PCjA0kpmcX6DaatmIPY75aSXR4IAseOhc/h53MbDeDXvuD7YkZDDurIeMuLWJ6bt737L0/tvLG7M0MaBvNk0PaElrEB0dmtpufVu/Fz2GjZWQYzeuGlmqs0sz1+7nl02WEBfoRN7YfoU4/LMviwW9X883y3YQH+pnqYi1nocG32w6mM/iNBTzmfosr/ebxa8B5tLr1E5rWCSHNlctFr89ne2IG57WJ4r3rOpOR7eaa9xexancy9WsE8d2o7kSHO+GLy023TnBts/CZM9xcQLMcf6FnZOd6Z+C9elVHhnYqOOYkOSOH39bHM2dDAvM3HvR2udptMPrcFvynX0tv8CzkwEazWnHGQbPWy8GNpt3XfF30Wjhl9denZj2ovv9XeLxSEXYkptP7hbnYbbDwv/0KhPnvV+7h7skr8bPb+PG2Mzl91f/M2KY+Ywt1ycYnZ/Hxwm1MWryTNFcuraLC6NKkJl0a16JDgwgyst3sTcpkb1Im+5KzSHXlEuCwE+BnJ8BhJyjAwYC2UeX+Q6ssKi2wWJbFXXfdxdSpU5k7d26Jpx0fze1207ZtWy644AJefvll76Db+++/n/vuu8/7BiIjIzXoVqo1t8ei9wtz2H3YjK0oarxEeViWRXq2m5AAR4FQlZyZw6TFO/n4z22Fxu9EBPkT26w2w85uZP7KLkL+Bz6Ybps59/UhIrhg1SDdlcvQt/5kU17QKIrNBrHNarM/JYstB9IJdfrxzrWd6dmyTqF9F21N5MUZG1iWN7A51OlHhwYR7D6cyZ6kTNxHjUSuHRLAbb2bcW23xgQHFP7AP5Q3oDg1b0Dx3qQsXpu1ibOa1uLr22K9++1JyqTX83O8g6/v/Xol+5KzvFO7P1u0g0enraVWSABzH+hDeKA/l779J3/tTOLe807jP/2O/H5bvDWRq95bBMAjF57Otd0KhqjkjBzu+2YVv/99ZEB4k9rBvDHsTNo3ODJ9/vf1+3nix3Xen5n889ioVjBt6oUzqH09zjs96pgBJv8v8tt7N+e/g1p7t7ty3Qx7bxF/7UwiOjyQL2/tRtOVL5rBt/W7kH3W7TwzcxcbD7n5KOAlgsnkctdjbAhox0tXnsEva/YxbeVeYiIC+eXuc6gRbAJlYpqLy9+JY9vBdFpFhfHFLWdTx5MIb3czg1rBXH6i1/2F2urxWHy+eAc2m41LOtUvMsDly5/V1rh2MLPu7X3MCmmO28PS7YeYtHgnP+WNQWtXP5xXr+pY/IfuvtVmDE7+7JjQ6Lxp376rRrw8cyOvz9pEr9Pq8umNBauhlmUmGcxYt5+2MeFMG92jUCD7e18K78/fyg8r93oXtSyrAIedBwa04qaeTb2VraPbMn/TQTyWRZ9WkcUcoWwqLbDccccdTJo0ie+//77A2isREREEBZnR6SNGjKB+/fqMG2dKg0899RTdunWjRYsWJCUl8cILLzBt2jSWL19Omzamb++5555j/PjxBaY1r169WtOapdr7cslOxk5Zww09mvD44LZV+tquXDfTVuxh8dZDnF4vnNjmtWlTL7zQL5t/23Ywnb4vzcWyKLimzb+kZuWwKSGN4AAHwf5+BDsd2G02fv97P1P+2s2irYe8+0aHB/LxDV2P2bVmWRZzNx7gxRkbWLc3pcBjAX52mtQO5vLODYoNKkfL/3CrE2ou2JmQ6uL1YZ24+IyYAvvld/05/ey4cj00rRPCT3f1JMTpR67bw4BX/2DLgXRu692MwR1iuOiNBfg7zLiko6+BBfD492v5JC/o1Q1zcluvZlxzdiO2JKRzx6Tl7DqUSYDDzm29m/Hd8t3sTc7C32HjoYGtTcXlx/XeQFMvIpCGtYLZtD+Vwxk5BV4n1OnHwHbRXNKpPt2a1S4wcHnFzsNc8vZC/B025j/Yt1D32sE0F8PeW8SmhDSiwwP59qp6NPgslqLk1mjKMOdbLN2R5N3msNv46tZudGlScMzGrkMZXDZhIQmpLurXCOLDkV1onTDDXJ4hrB7ctbzQ1HBXrpt7v17lHdQeFujHNWc14vruTYjJX606T1aOm3Oen8OBVBfPX9aBK7s2LLLNRflp9V7+b+pakjNzcPrZeXBga0bENi6y2rJ7zVzqTLmKQCuLZfVH0Pnm1yus+y4pI5vPF+1gf4qLge2iiW1W+5j/Fz0ei3Oen8OepExeu7ojQzoWXhk7ITWL81/5g6SMHG+ItiyLPzYd5IP5W5m/6cj1u85uWotbezWjXf0I/tpxmGV5t7/3phAe5E/9GoHUiwgipkYQEUH+5Lg93gvQbtyfRtzWRAC6NavFS1d2pH6NILJy3ExdsYePFmxjU0IaLSND+e2eXhXa5VlpgaW4Rn788ceMHDkSgD59+tCkSRMmTpwIwD333MOUKVOIj4+nZs2adO7cmWeeeYZOnY6MuM9fOO69994jKSmJnj178vbbb3PaaacV8WqFKbCILx1IdRVY1+RE8PmiHSSkZDGm/2nHDTjF2XUog2kr9rDzUAb3nn8a9SKCjv8kzC/qeZsOcDDVRePaITSqFUxkmLNU7cjO9XD+K/PYntd9VCc0gIX/7ecdz5Pvr52HufRts1y9v8PGlFE9ClQ8Zv29n5s+WUaAn53YZrWZt/EAg8+I4Y1hhWcE5bo9fLl0F+/M3cKeJFMhqRUSQFpWLtluDw1rBfH2NZ1p3yCCpIxsHvpuNTPWmYBit4HHAj+7jZvPacZ/+rUgOMB05SSmZ7NxfyoLNycybeWeAtWXBjWDuK5bY67q2pAawQGM/uIvfl6zj8vObMBLVxa9+NiBVBfXvH8ktPwcu4Hsf35lx74EQsikRQQEOTzQ73Fy2lzK+On/8OGCbQA8MKAVo89tUeRxtxxI48aJS9mRmEFIgIPXh3WiX8B6Mx36XwsIJmfmcOunppvQ32Gjfo0g7/fKYbcxsF007etHUDfUSWS4k+U7DvPq75uoXyOIOff3KfR9PJ79KVk88O1q/tho1r2pXyOI23s344ouDQn0d5Dj9vDeH1t5bdYm2rn/4WLHQl7JvZxeZ5zGC5d3KLSOU2kcTHPxwfxtfBa33TsVO78Nl3VuwBWdGxQ50H7hloNc8/5iwpx+LH2kf7FtyO8a8nfYuOe805i2Yg8b95vKp90Gg9rX49Zzmh17HM9xWJbFl0t28fRP68nMcRPm9OPijjH8smafN1CHBDi4oktDHhrYuszLLRRFS/OLyElvxrp4bvtsOQB3ntuC+wcUveL25RMWsmzHYcYOas1tvQt+sFqWxfAPFrNwS6J32ze3x9K1SfGzQrJzPUz5azdvz93CzkPmQ/i8NlG8ePkZBbrWLMvi88U7efqn9WTneujWrBZPD2lHy2NcDd3jsVi+8zBTV+zhp1V7Scky4zQC/e1c0L4e01bswWPBr2POoXV08b/rjg4tUeFOUjJzycxxM6Z/S8b0L/yH4LyNB9h9OINhXRsdMzgeTs9m1BfLWbT1EDYb/N8Fp3NTz6YF/pjdm5TJyI+XsHF/GqFOP969rjOxzWozZ0MCH8zf5v1LvihPD23Hdd3KNsvIsiwmLdnJKzM3cTDNdJXWCXVybbdGzFi3n7/3mareOS3r0KtlXZ779R9yPRYdG9bgvRGdvRW1fcmZzP4ngU370xjQNrrAOk5H25ecyXt/bOXLJTu9ixXmT8Wevia+wLIGt/VqxtgLTi/w/Pu+XsV3f+1m2FmNGHdp8ZfyOHqaeb6QAAdXdW3EDT2aHHfWYWlsP5jOmK9WemfRgQleN/RowpVdGx53wHlZKLCIyEnPsizu+OIvlu84zA939ix29tHBNBcb4lPp3rx2kVXitXvMFHXLMh840+8+p0Ql71y3h1/WxpPr9nBJp/rFPmf7wXR2H86kR4uiX784WTluvl+5h4kLd3g/bIEixzsU5ejQAtCzRR0+ufGscq+Nk53r4bHv1zJ56S4AWkaGUifUSY1gf2oE+zN3wwH2JWcRGebk4xu6emef5Vu7J5mf1+xjf3IWCakuElLNv83rhvLFzWeXq9oB5rx9vWwX787b6q2EAdQI9uexi9p4v1dxWxIZ9cVykjJyiIkI5OKO9Zm38UCBcw3Qo0Vt7j2vFZ0bm0G0OxMzmDBvC98u30WO23x8ntEggrv6tqTf6ZHYbDayctzMWBfPN8t2s2Cz6bZ58uK2XN+9CWDGiHV99ncyst18NyqWzo2PPW06ITWLS99eiMdjMbJHE67q2qhUywSURq7bw3vzt7J8+2Eu79yA89pEHXM8UXkpsIjIKaGiphA/PHUNkxbvLHJ2iq9ZlsXS7YeZuHAb6/emFBrIeywHUl3c9tkyMrLdfH7z2dQJrZiuS8uy+OjP7Tz783qKGuvZvG4In9x4Fg1qVtxf/6WV4/YwbcUePlu0gxaRoTx8wemF3v/2g+nc+MlSth5I926z2aBTwxo0rh3CT6v3ekPJua3qUiM4gB9W7fUOEj+rSS3u7NuCc46xLtI787Ywfvo/2G3w0ciu9GkVyTfLdvHAt6tpWieE2ff1LtHPsMdjlbn7tjpTYBERKQW3x2LnoQya1in6mmgnuspaG2bXoQy2HkwnKSOb5MwckjJy8HfYGXZWQ+8so+ouOTOHp35cjyvXTd/WkfQ+rS6184LN7sMZvDFrM9/+tbvATLbep9Vl9LktOKvpcRaUgwJTzkOdfky5ozuPTlvL4m2Hjjlm6FShwCIiIlJBth1M5/35W8nO9XB9bJMSV7jyZed6uPbDxSzZdojo8EDiU7Kw2eDPh/oWmjF1qinN5/eJsxyeiIiIDzStE8L/Lil+YOzxBPjZeefazlzy9p/ehRF7NK9zyoeV0qq8kTQiIiICmCnwH17flbBAUye4vHMZrrJ8ilOFRUREpAq0iAzlm9tjWb7jcKFFDuX4FFhERESqSOvo8GOuoSPFU5eQiIiIVHsKLCIiIlLtKbCIiIhItafAIiIiItWeAouIiIhUewosIiIiUu0psIiIiEi1p8AiIiIi1Z4Ci4iIiFR7CiwiIiJS7SmwiIiISLWnwCIiIiLVngKLiIiIVHsnxdWaLcsCICUlxcctERERkZLK/9zO/xw/lpMisKSmpgLQsGFDH7dERERESis1NZWIiIhj7mOzShJrqjmPx8PevXsJCwvDZrNV6LFTUlJo2LAhu3btIjw8vEKPLQXpXFcdneuqo3NddXSuq05FnWvLskhNTSUmJga7/dijVE6KCovdbqdBgwaV+hrh4eH6D1BFdK6rjs511dG5rjo611WnIs718Sor+TToVkRERKo9BRYRERGp9hRYjsPpdPL444/jdDp93ZSTns511dG5rjo611VH57rq+OJcnxSDbkVEROTkpgqLiIiIVHsKLCIiIlLtKbCIiIhItafAIiIiItWeAssxvPXWWzRp0oTAwEDOPvtslixZ4usmnfDGjRtH165dCQsLIzIykqFDh7Jhw4YC+2RlZTF69Ghq165NaGgol112Gfv37/dRi08e48ePx2azMWbMGO82neuKs2fPHq699lpq165NUFAQ7du3Z9myZd7HLcviscceo169egQFBdG/f382bdrkwxafmNxuN48++ihNmzYlKCiI5s2b8/TTTxe4Fo3Oddn98ccfDB48mJiYGGw2G9OmTSvweEnO7aFDhxg+fDjh4eHUqFGDm266ibS0tPI3zpIiTZ482QoICLA++ugja926ddYtt9xi1ahRw9q/f7+vm3ZCGzBggPXxxx9ba9eutVauXGldcMEFVqNGjay0tDTvPrfffrvVsGFDa9asWdayZcusbt26Wd27d/dhq098S5YssZo0aWJ16NDBuvvuu73bda4rxqFDh6zGjRtbI0eOtBYvXmxt3brVmjFjhrV582bvPuPHj7ciIiKsadOmWatWrbIuvvhiq2nTplZmZqYPW37iefbZZ63atWtbP/30k7Vt2zbrm2++sUJDQ63XXnvNu4/Oddn98ssv1v/93/9ZU6ZMsQBr6tSpBR4vybkdOHCgdcYZZ1iLFi2y5s+fb7Vo0cIaNmxYudumwFKMs846yxo9erT3vtvttmJiYqxx48b5sFUnn4SEBAuw5s2bZ1mWZSUlJVn+/v7WN998493n77//tgArLi7OV808oaWmplotW7a0Zs6cafXu3dsbWHSuK85DDz1k9ezZs9jHPR6PFR0dbb3wwgvebUlJSZbT6bS+/PLLqmjiSePCCy+0brzxxgLbLr30Umv48OGWZelcV6R/B5aSnNv169dbgLV06VLvPtOnT7dsNpu1Z8+ecrVHXUJFyM7OZvny5fTv39+7zW63079/f+Li4nzYspNPcnIyALVq1QJg+fLl5OTkFDj3rVu3plGjRjr3ZTR69GguvPDCAucUdK4r0g8//ECXLl244ooriIyMpFOnTrz//vvex7dt20Z8fHyBcx0REcHZZ5+tc11K3bt3Z9asWWzcuBGAVatWsWDBAgYNGgToXFemkpzbuLg4atSoQZcuXbz79O/fH7vdzuLFi8v1+ifFxQ8r2sGDB3G73URFRRXYHhUVxT///OOjVp18PB4PY8aMoUePHrRr1w6A+Ph4AgICqFGjRoF9o6KiiI+P90ErT2yTJ0/mr7/+YunSpYUe07muOFu3bmXChAnce++9PPzwwyxdupT//Oc/BAQEcP3113vPZ1G/U3SuS+e///0vKSkptG7dGofDgdvt5tlnn2X48OEAOteVqCTnNj4+nsjIyAKP+/n5UatWrXKffwUW8ZnRo0ezdu1aFixY4OumnJR27drF3XffzcyZMwkMDPR1c05qHo+HLl268L///Q+ATp06sXbtWt555x2uv/56H7fu5PL111/zxRdfMGnSJNq2bcvKlSsZM2YMMTExOtcnOXUJFaFOnTo4HI5CsyX2799PdHS0j1p1crnzzjv56aefmDNnDg0aNPBuj46OJjs7m6SkpAL769yX3vLly0lISODMM8/Ez88PPz8/5s2bx+uvv46fnx9RUVE61xWkXr16tGnTpsC2008/nZ07dwJ4z6d+p5TfAw88wH//+1+uvvpq2rdvz3XXXcc999zDuHHjAJ3rylSScxsdHU1CQkKBx3Nzczl06FC5z78CSxECAgLo3Lkzs2bN8m7zeDzMmjWL2NhYH7bsxGdZFnfeeSdTp05l9uzZNG3atMDjnTt3xt/fv8C537BhAzt37tS5L6V+/fqxZs0aVq5c6b116dKF4cOHe7/Wua4YPXr0KDQ9f+PGjTRu3BiApk2bEh0dXeBcp6SksHjxYp3rUsrIyMBuL/jR5XA48Hg8gM51ZSrJuY2NjSUpKYnly5d795k9ezYej4ezzz67fA0o15Ddk9jkyZMtp9NpTZw40Vq/fr116623WjVq1LDi4+N93bQT2qhRo6yIiAhr7ty51r59+7y3jIwM7z6333671ahRI2v27NnWsmXLrNjYWCs2NtaHrT55HD1LyLJ0rivKkiVLLD8/P+vZZ5+1Nm3aZH3xxRdWcHCw9fnnn3v3GT9+vFWjRg3r+++/t1avXm0NGTJEU23L4Prrr7fq16/vndY8ZcoUq06dOtaDDz7o3UfnuuxSU1OtFStWWCtWrLAA6+WXX7ZWrFhh7dixw7Kskp3bgQMHWp06dbIWL15sLViwwGrZsqWmNVe2N954w2rUqJEVEBBgnXXWWdaiRYt83aQTHlDk7eOPP/buk5mZad1xxx1WzZo1reDgYOuSSy6x9u3b57tGn0T+HVh0rivOjz/+aLVr185yOp1W69atrffee6/A4x6Px3r00UetqKgoy+l0Wv369bM2bNjgo9aeuFJSUqy7777batSokRUYGGg1a9bM+r//+z/L5XJ599G5Lrs5c+YU+Tv6+uuvtyyrZOc2MTHRGjZsmBUaGmqFh4dbN9xwg5Wamlruttks66jlAUVERESqIY1hERERkWpPgUVERESqPQUWERERqfYUWERERKTaU2ARERGRak+BRURERKo9BRYRERGp9hRYREREpNpTYBEREZFqT4FFREREqj0FFhEREan2FFhERESk2vt/xi4p/eur8zQAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create the updated SimpleModel\n", "model = SimpleBrokenModel(MASTER_CONFIG)\n", "\n", "# Obtain batches for training\n", "xs, ys = get_batches(dataset, 'train', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Calculate logits and loss using the model\n", "logits, loss = model(xs, ys)\n", "\n", "# Define the Adam optimizer for model parameters\n", "optimizer = torch.optim.Adam(model.parameters())\n", "\n", "# Train the model for 100 epochs\n", "train(model, optimizer)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "After reducing the loss to 2.51, let’s explore how our language model with approximately **33,000 parameters** generates text during inferencing. We’ll create a ‘generate’ function, which we’ll later use when replicating LLaMA:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:48:19.384110Z", "start_time": "2025-06-29T17:48:19.334455Z" } }, "outputs": [ { "data": { "text/plain": [ "['\\nCHe? opis ld!\\nE mamp itare I k',\n", " '\\nKE mefusthe w, s nuscelan bar ',\n", " '\\nWhathat owndicckthe we d o cow',\n", " '\\nRY er! ye bengr at po:\\nSent Th',\n", " '\\n\\nK:\\nS:\\nHESinds Makenk, mathyou']" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Generate function for text generation using the trained model\n", "def generate(model, config=MASTER_CONFIG, max_new_tokens=30):\n", " idx = torch.zeros(5, 1).long()\n", " for _ in range(max_new_tokens):\n", " # Call the model\n", " logits = model(idx[:, -config['context_window']:])\n", " last_time_step_logits = logits[\n", " :, -1, :\n", " ] # all the batches (1), last time step, all the logits\n", " p = F.softmax(last_time_step_logits, dim=-1) # softmax to get probabilities\n", " idx_next = torch.multinomial(\n", " p, num_samples=1\n", " ) # sample from the distribution to get the next token\n", " idx = torch.cat([idx, idx_next], dim=-1) # append to the sequence\n", " return [decode(x) for x in idx.tolist()]\n", "\n", "# Generate text using the trained model\n", "generate(model)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "The generated text doesn’t look great with our basic model of around 33K parameters. However, now that we’ve laid the groundwork with this simple model, we’ll move on to constructing the LLaMA architecture in the next section." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Replicating LLaMA Architecture\n", "\n", "In the earlier part of the blog, we covered essential concepts, and now, we’ll integrate these concepts into our base model. LLaMA introduces three architectural modifications to the original Transformer:\n", "\n", " 1. RMSNorm for pre-normalization\n", "\n", " 2. Rotary embeddings\n", "\n", " 3. SwiGLU activation function\n", "\n", "We’ll incorporate each of these modifications one by one into our base model, iterating and building upon them." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### RMSNorm for pre-normalization:\n", "\n", "We are defining an RMSNorm function with the following functionalities:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:48:27.049403Z", "start_time": "2025-06-29T17:48:27.042316Z" } }, "outputs": [], "source": [ "class RMSNorm(nn.Module):\n", " def __init__(self, layer_shape, eps=1e-8, bias=False):\n", " super(RMSNorm, self).__init__()\n", "\n", " # Registering a learnable parameter 'scale' as a parameter of the module\n", " self.register_parameter(\"scale\", nn.Parameter(torch.ones(layer_shape)))\n", "\n", " def forward(self, x):\n", " \"\"\"\n", " Assumes shape is (batch, seq_len, d_model)\n", " \"\"\"\n", " # Calculating the Frobenius norm, RMS = 1/sqrt(N) * Frobenius norm\n", " ff_rms = torch.linalg.norm(x, dim=(1,2)) * x[0].numel() ** -.5\n", "\n", " # Normalizing the input tensor 'x' with respect to RMS\n", " raw = x / ff_rms.unsqueeze(-1).unsqueeze(-1)\n", "\n", " # Scaling the normalized tensor using the learnable parameter 'scale'\n", " return self.scale[:x.shape[1], :].unsqueeze(0) * raw" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "we define the RMSNorm class. During initialization, it registers a scale parameter. In the forward pass, it calculates the **Frobenius norm** of the input tensor and then normalizes the tensor. Finally, the tensor is scaled by the registered scale parameter. This function is designed for use in LLaMA to replace the LayerNorm operation.\n", "\n", "Now it’s time to incorporate the first implementation concept of LLaMA, which is RMSNorm, into our simple NN model. Here’s the updated code:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:48:30.267802Z", "start_time": "2025-06-29T17:48:30.256755Z" } }, "outputs": [], "source": [ "# Define the SimpleModel_RMS with RMSNorm\n", "class SimpleModel_RMS(nn.Module):\n", " def __init__(self, config):\n", " super().__init__()\n", " self.config = config\n", "\n", " # Embedding layer to convert character indices to vectors\n", " self.embedding = nn.Embedding(config['vocab_size'], config['d_model'])\n", "\n", " # RMSNorm layer for pre-normalization\n", " self.rms = RMSNorm((config['context_window'], config['d_model']))\n", "\n", " # Linear layers for modeling relationships between features\n", " self.linear = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " nn.ReLU(), # Currently using ReLU, will be replaced with SwiGLU as in LLaMA\n", " nn.Linear(config['d_model'], config['vocab_size']),\n", " )\n", "\n", " # Print the total number of model parameters\n", " print(\"Model parameters:\", sum([m.numel() for m in self.parameters()]))\n", "\n", " def forward(self, idx, targets=None):\n", " # Embedding layer converts character indices to vectors\n", " x = self.embedding(idx)\n", "\n", " # RMSNorm pre-normalization\n", " x = self.rms(x)\n", "\n", " # Linear layers for modeling relationships between features\n", " logits = self.linear(x)\n", "\n", " # If targets are provided, calculate and return the cross-entropy loss\n", " if targets is not None:\n", " # Reshape logits and targets for cross-entropy calculation\n", " loss = F.cross_entropy(logits.view(-1, self.config['vocab_size']), targets.view(-1))\n", " return logits, loss\n", "\n", " # If targets are not provided, return the logits\n", " else:\n", " return logits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s execute the modified NN model with RMSNorm and observe the updated number of parameters in the model, along with the loss:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:48:49.314433Z", "start_time": "2025-06-29T17:48:33.345452Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model parameters: 35265\n", "Validation loss: 2.4966535329818726\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create an instance of SimpleModel_RMS\n", "model = SimpleModel_RMS(MASTER_CONFIG)\n", "\n", "# Obtain batches for training\n", "xs, ys = get_batches(dataset, 'train', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Calculate logits and loss using the model\n", "logits, loss = model(xs, ys)\n", "\n", "# Define the Adam optimizer for model parameters\n", "optimizer = torch.optim.Adam(model.parameters())\n", "\n", "# Train the model\n", "train(model, optimizer)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The validation loss experiences a small decrease, and the parameters of our updated LLM now total approximately 35,000." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Rotary Embeddings:\n", "\n", "Next, we will implement rotary positional embeddings. In RoPE, the authors suggest embedding the position of a token in a sequence by rotating the embedding, applying a different rotation at each position. Let’s create a function that mimics the actual paper implementation of RoPE:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:48:56.537567Z", "start_time": "2025-06-29T17:48:56.531037Z" } }, "outputs": [], "source": [ "def get_rotary_matrix(context_window, embedding_dim):\n", " # Initialize a tensor for the rotary matrix with zeros\n", " R = torch.zeros((context_window, embedding_dim, embedding_dim), requires_grad=False)\n", " \n", " # Loop through each position in the context window\n", " for position in range(context_window):\n", " # Loop through each dimension in the embedding\n", " for i in range(embedding_dim // 2):\n", " # Calculate the rotation angle (theta) based on the position and embedding dimension\n", " theta = 10000. ** (-2. * (i - 1) / embedding_dim)\n", " # Calculate the rotated matrix elements using sine and cosine functions\n", " m_theta = position * theta\n", " R[position, 2 * i, 2 * i] = np.cos(m_theta)\n", " R[position, 2 * i, 2 * i + 1] = -np.sin(m_theta)\n", " R[position, 2 * i + 1, 2 * i] = np.sin(m_theta)\n", " R[position, 2 * i + 1, 2 * i + 1] = np.cos(m_theta)\n", " return R" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "we generate a rotary matrix based on the specified context window and embedding dimension, following the proposed RoPE implementation.\n", "\n", "As you may be familiar with the architecture of transformers, which involves attention heads, we similarly need to create attention heads when replicating LLaMA. To start, let’s first create a single **masked attention head** using the get_rotary_matrix function we previously developed for rotary embeddings. **Additionally, each line is commented for clarity**:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:48:58.885876Z", "start_time": "2025-06-29T17:48:58.877461Z" } }, "outputs": [], "source": [ "class RoPEMaskedAttentionHead(nn.Module):\n", " def __init__(self, config):\n", " super().__init__()\n", " self.config = config\n", " # Linear transformation for query\n", " self.w_q = nn.Linear(config['d_model'], config['d_model'], bias=False)\n", " # Linear transformation for key\n", " self.w_k = nn.Linear(config['d_model'], config['d_model'], bias=False)\n", " # Linear transformation for value\n", " self.w_v = nn.Linear(config['d_model'], config['d_model'], bias=False)\n", " # Obtain rotary matrix for positional embeddings\n", " self.R = get_rotary_matrix(config['context_window'], config['d_model'])\n", "\n", " def get_rotary_matrix(context_window, embedding_dim):\n", " # Initialize a tensor for the rotary matrix with zeros\n", " R = torch.zeros((context_window, embedding_dim, embedding_dim), requires_grad=False)\n", " \n", " # Loop through each position in the context window\n", " for position in range(context_window):\n", " # Loop through each dimension in the embedding\n", " for i in range(embedding_dim // 2):\n", " # Calculate the rotation angle (theta) based on the position and embedding dimension\n", " theta = 10000. ** (-2. * (i - 1) / embedding_dim)\n", " # Calculate the rotated matrix elements using sine and cosine functions\n", " m_theta = position * theta\n", " R[position, 2 * i, 2 * i] = np.cos(m_theta)\n", " R[position, 2 * i, 2 * i + 1] = -np.sin(m_theta)\n", " R[position, 2 * i + 1, 2 * i] = np.sin(m_theta)\n", " R[position, 2 * i + 1, 2 * i + 1] = np.cos(m_theta)\n", " return R\n", "\n", " def forward(self, x, return_attn_weights=False):\n", " # x: input tensor of shape (batch, sequence length, dimension)\n", "\n", " b, m, d = x.shape # batch size, sequence length, dimension\n", "\n", " # Linear transformations for Q, K, and V\n", " q = self.w_q(x)\n", " k = self.w_k(x)\n", " v = self.w_v(x)\n", "\n", " # Rotate Q and K using the RoPE matrix\n", " q_rotated = (torch.bmm(q.transpose(0, 1), self.R[:m])).transpose(0, 1)\n", " k_rotated = (torch.bmm(k.transpose(0, 1), self.R[:m])).transpose(0, 1)\n", "\n", " # Perform scaled dot-product attention\n", " activations = F.scaled_dot_product_attention(\n", " q_rotated, k_rotated, v, dropout_p=0.1, is_causal=True\n", " )\n", "\n", " if return_attn_weights:\n", " # Create a causal attention mask\n", " attn_mask = torch.tril(torch.ones((m, m)), diagonal=0)\n", " # Calculate attention weights and add causal mask\n", " attn_weights = torch.bmm(q_rotated, k_rotated.transpose(1, 2)) / np.sqrt(d) + attn_mask\n", " attn_weights = F.softmax(attn_weights, dim=-1)\n", " return activations, attn_weights\n", "\n", " return activations" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have a single masked attention head that returns attention weights, the next step is to create a multi-Head attention mechanism." ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:49:01.672881Z", "start_time": "2025-06-29T17:49:01.665375Z" } }, "outputs": [], "source": [ "class RoPEMaskedMultiheadAttention(nn.Module):\n", " def __init__(self, config):\n", " super().__init__()\n", " self.config = config\n", " # Create a list of RoPEMaskedAttentionHead instances as attention heads\n", " self.heads = nn.ModuleList([\n", " RoPEMaskedAttentionHead(config) for _ in range(config['n_heads'])\n", " ])\n", " self.linear = nn.Linear(config['n_heads'] * config['d_model'], config['d_model']) # Linear layer after concatenating heads\n", " self.dropout = nn.Dropout(.1) # Dropout layer\n", "\n", " def forward(self, x):\n", " # x: input tensor of shape (batch, sequence length, dimension)\n", "\n", " # Process each attention head and concatenate the results\n", " heads = [h(x) for h in self.heads]\n", " x = torch.cat(heads, dim=-1)\n", " \n", " # Apply linear transformation to the concatenated output\n", " x = self.linear(x)\n", " \n", " # Apply dropout\n", " x = self.dropout(x)\n", " return x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The original paper used 32 heads for their smaller 7b LLM variation, but due to constraints, we’ll use 8 heads for our approach." ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:49:03.989516Z", "start_time": "2025-06-29T17:49:03.984816Z" } }, "outputs": [], "source": [ "# Update the master configuration with the number of attention heads\n", "MASTER_CONFIG.update({\n", " 'n_heads': 8,\n", "})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we’ve implemented Rotational Embedding and Multi-head Attention, let’s re-write our RMSNorm neural network model with the updated code. We’ll test its performance, compute the loss, and check the number of parameters. We’ll refer to this updated model as **“RopeModel”**" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:49:06.646682Z", "start_time": "2025-06-29T17:49:06.636292Z" } }, "outputs": [], "source": [ "class RopeModel(nn.Module):\n", " def __init__(self, config):\n", " super().__init__()\n", " self.config = config\n", "\n", " # Embedding layer for input tokens\n", " self.embedding = nn.Embedding(config['vocab_size'], config['d_model'])\n", " \n", " # RMSNorm layer for pre-normalization\n", " self.rms = RMSNorm((config['context_window'], config['d_model']))\n", " \n", " # RoPEMaskedMultiheadAttention layer\n", " self.rope_attention = RoPEMaskedMultiheadAttention(config)\n", "\n", " # Linear layer followed by ReLU activation\n", " self.linear = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " nn.ReLU(),\n", " )\n", "\n", " # Final linear layer for prediction\n", " self.last_linear = nn.Linear(config['d_model'], config['vocab_size'])\n", "\n", " print(\"model params:\", sum([m.numel() for m in self.parameters()]))\n", "\n", " def forward(self, idx, targets=None):\n", " # idx: input indices\n", " x = self.embedding(idx)\n", "\n", " # One block of attention\n", " x = self.rms(x) # RMS pre-normalization\n", " x = x + self.rope_attention(x)\n", "\n", " x = self.rms(x) # RMS pre-normalization\n", " x = x + self.linear(x)\n", "\n", " logits = self.last_linear(x)\n", "\n", " if targets is not None:\n", " loss = F.cross_entropy(logits.view(-1, self.config['vocab_size']), targets.view(-1))\n", " return logits, loss\n", "\n", " else:\n", " return logits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s execute the modified NN model with RMSNorm, Rotational Embeddings and Masked Multi Head Attentions to observe the updated number of parameters in the model, along with the loss:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:49:46.171094Z", "start_time": "2025-06-29T17:49:08.914246Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "model params: 559681\n", "Validation loss: 2.0745564699172974\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create an instance of RopeModel (RMSNorm, RoPE, Multi-Head)\n", "model = RopeModel(MASTER_CONFIG)\n", "\n", "# Obtain batches for training\n", "xs, ys = get_batches(dataset, 'train', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Calculate logits and loss using the model\n", "logits, loss = model(xs, ys)\n", "\n", "# Define the Adam optimizer for model parameters\n", "optimizer = torch.optim.Adam(model.parameters())\n", "\n", "# Train the model\n", "train(model, optimizer)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "The validation loss experiences a small decrease again, and the parameters of our updated LLM now total approximately 55,000.\n", "\n", "Let’s train the model for more epochs to see if the loss of our recreated LLaMA LLM continues to decrease or not." ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:53:24.651718Z", "start_time": "2025-06-29T17:50:10.814301Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Validation loss: 1.9139058709144592\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Updating training configuration with more epochs and a logging interval\n", "MASTER_CONFIG.update({\n", " \"epochs\": 5000,\n", " \"log_interval\": 10,\n", "})\n", "\n", "# Training the model with the updated configuration\n", "train(model, optimizer)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "The validation loss continues to decrease, suggesting that training for more epochs could lead to further loss reduction, though not significantly." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### SwiGLU activation function:\n", "\n", "As mentioned before, the creators of LLaMA use SwiGLU instead of ReLU, so we’ll be implementing SwiGLU equation in our code.\n", "\n", "![[https://arxiv.org/pdf/2002.05202v1.pdf](https://arxiv.org/pdf/2002.05202v1.pdf)](https://cdn-images-1.medium.com/max/27072/1*db6BeMw78FH_ZkVEGIyVPA.png)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:53:39.878681Z", "start_time": "2025-06-29T17:53:39.873905Z" } }, "outputs": [], "source": [ "class SwiGLU(nn.Module):\n", " \"\"\"\n", " Swish-Gated Linear Unit\n", " https://arxiv.org/pdf/2002.05202v1.pdf\n", " \"\"\"\n", " def __init__(self, size):\n", " super().__init__()\n", " self.linear_gate = nn.Linear(size, size)\n", " self.linear = nn.Linear(size, size)\n", " self.beta = torch.randn(1, requires_grad=True)\n", "\n", " self.beta = nn.Parameter(torch.ones(1))\n", " self.register_parameter(\"beta\", self.beta)\n", "\n", " def forward(self, x): \n", " swish_gate = self.linear_gate(x) * torch.sigmoid(self.beta * self.linear_gate(x))\n", " out = swish_gate * self.linear(x)\n", " return out" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After implementing the SwiGLU equation in python, we need to integrate it into our modified LLaMA language model (**RopeModel**)." ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:53:43.236799Z", "start_time": "2025-06-29T17:53:43.229975Z" } }, "outputs": [], "source": [ "class RopeModel(nn.Module):\n", " def __init__(self, config):\n", " super().__init__()\n", " self.config = config\n", "\n", " # Embedding layer for input tokens\n", " self.embedding = nn.Embedding(config['vocab_size'], config['d_model'])\n", " \n", " # RMSNorm layer for pre-normalization\n", " self.rms = RMSNorm((config['context_window'], config['d_model']))\n", " \n", " # Multi-head attention layer with RoPE (Rotary Positional Embeddings)\n", " self.rope_attention = RoPEMaskedMultiheadAttention(config)\n", "\n", " # Linear layer followed by SwiGLU activation\n", " self.linear = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " SwiGLU(config['d_model']), # Adding SwiGLU activation\n", " )\n", "\n", " # Output linear layer\n", " self.last_linear = nn.Linear(config['d_model'], config['vocab_size'])\n", "\n", " # Printing total model parameters\n", " print(\"model params:\", sum([m.numel() for m in self.parameters()]))\n", "\n", " def forward(self, idx, targets=None):\n", " x = self.embedding(idx)\n", "\n", " # One block of attention\n", " x = self.rms(x) # RMS pre-normalization\n", " x = x + self.rope_attention(x)\n", "\n", " x = self.rms(x) # RMS pre-normalization\n", " x = x + self.linear(x) # Applying SwiGLU activation\n", "\n", " logits = self.last_linear(x)\n", "\n", " if targets is not None:\n", " # Calculate cross-entropy loss if targets are provided\n", " loss = F.cross_entropy(logits.view(-1, self.config['vocab_size']), targets.view(-1))\n", " return logits, loss\n", "\n", " else:\n", " return logits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s execute the modified NN model with RMSNorm, Rotational Embeddings, Masked Multi Head Attentions and SwiGLU to observe the updated number of parameters in the model, along with the loss:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T17:56:57.292748Z", "start_time": "2025-06-29T17:53:47.201344Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "model params: 592706\n", "Validation loss: 1.9461039900779724\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create an instance of RopeModel (RMSNorm, RoPE, Multi-Head, SwiGLU)\n", "model = RopeModel(MASTER_CONFIG)\n", "\n", "# Obtain batches for training\n", "xs, ys = get_batches(dataset, 'train', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Calculate logits and loss using the model\n", "logits, loss = model(xs, ys)\n", "\n", "# Define the Adam optimizer for model parameters\n", "optimizer = torch.optim.Adam(model.parameters())\n", "\n", "# Train the model\n", "train(model, optimizer)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "Once again the validation loss experiences a small decrease, and the parameters of our updated LLM now total approximately 60,000.\n", "\n", "So far, we have successfully implemented the key components of the paper, namely RMSNorm, RoPE, and SwiGLU. We observed that these implementations led to a minimal decrease in the loss.\n", "\n", "Now we will add layers to our LLaMA to examine its impact on the loss. The original paper used 32 layers for the 7b version, but we will use only 4 layers. Let’s adjust our model settings accordingly." ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T18:00:26.764314Z", "start_time": "2025-06-29T18:00:26.761261Z" } }, "outputs": [], "source": [ "# Update model configurations for the number of layers\n", "MASTER_CONFIG.update({\n", " 'n_layers': 4, # Set the number of layers to 4\n", "})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s start by creating a single layer to understand its impact." ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T18:00:30.436636Z", "start_time": "2025-06-29T18:00:30.431504Z" } }, "outputs": [], "source": [ "# add RMSNorm and residual conncection\n", "class LlamaBlock(nn.Module):\n", " def __init__(self, config):\n", " super().__init__()\n", " self.config = config\n", "\n", " self.rms = RMSNorm((config['context_window'], config['d_model']))\n", " \n", " self.attention = RoPEMaskedMultiheadAttention(config)\n", " self.feedforward = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " SwiGLU(config['d_model']),\n", " )\n", "\n", " def forward(self, x):\n", " x = self.rms(x) # rms pre-normalization\n", " x = x + self.attention(x)\n", "\n", " x = self.rms(x) # rms pre-normalization\n", " x = x + self.feedforward(x)\n", " return x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Create an instance of the LlamaBlock class and applies it to a random tensor." ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T18:00:33.519770Z", "start_time": "2025-06-29T18:00:33.511634Z" } }, "outputs": [ { "data": { "text/plain": [ "{'vocab_size': 65,\n", " 'batch_size': 32,\n", " 'context_window': 16,\n", " 'd_model': 128,\n", " 'epochs': 5000,\n", " 'log_interval': 10,\n", " 'n_heads': 8,\n", " 'n_layers': 4}" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "MASTER_CONFIG" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T18:00:36.707880Z", "start_time": "2025-06-29T18:00:35.604848Z" } }, "outputs": [], "source": [ "block = LlamaBlock(MASTER_CONFIG)\n", "block(torch.randn(MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'], MASTER_CONFIG['d_model']));" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T18:00:38.619455Z", "start_time": "2025-06-29T18:00:37.684349Z" } }, "outputs": [], "source": [ "# Create an instance of the LlamaBlock class with the provided configuration\n", "block = LlamaBlock(MASTER_CONFIG)\n", "\n", "# Generate a random tensor with the specified batch size, context window, and model dimension\n", "random_input = torch.randn(MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'], MASTER_CONFIG['d_model'])\n", "\n", "# Apply the LlamaBlock to the random input tensor\n", "output = block(random_input)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Having successfully created a single layer, we can now use it to construct multiple layers. Additionally, we will rename our model class from **“ropemodel”** to **“Llama”** as we have replicated every component of the LLaMA language model." ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T18:00:40.815121Z", "start_time": "2025-06-29T18:00:40.808892Z" } }, "outputs": [], "source": [ "from collections import OrderedDict\n", "\n", "MASTER_CONFIG.update({\n", " 'n_layers': 4,\n", "})\n", "\n", "class Llama(nn.Module):\n", " def __init__(self, config):\n", " super().__init__()\n", " self.config = config\n", " # Embedding layer for token representations\n", " self.embeddings = nn.Embedding(config['vocab_size'], config['d_model'])\n", " # Sequential block of LlamaBlocks based on the specified number of layers\n", " self.llama_blocks = nn.Sequential(\n", " OrderedDict([(f\"llama_{i}\", LlamaBlock(config)) for i in range(config['n_layers'])])\n", " )\n", " # Feedforward network (FFN) for final output\n", " self.ffn = nn.Sequential(\n", " nn.Linear(config['d_model'], config['d_model']),\n", " SwiGLU(config['d_model']),\n", " nn.Linear(config['d_model'], config['vocab_size']),\n", " )\n", "\n", " # Print total number of parameters in the model\n", " print(\"model params:\", sum([m.numel() for m in self.parameters()]))\n", "\n", " def forward(self, idx, targets=None):\n", " # Input token indices are passed through the embedding layer\n", " x = self.embeddings(idx)\n", " # Process the input through the LlamaBlocks\n", " x = self.llama_blocks(x)\n", " # Pass the processed input through the final FFN for output logits\n", " logits = self.ffn(x)\n", "\n", " # If targets are not provided, return only the logits\n", " if targets is None:\n", " return logits\n", " # If targets are provided, compute and return the cross-entropy loss\n", " else:\n", " loss = F.cross_entropy(logits.view(-1, self.config['vocab_size']), targets.view(-1))\n", " return logits, loss" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s execute the modified LLaMA model with RMSNorm, Rotational Embeddings, Masked Multi Head Attentions, SwiGLU and N_layers to observe the updated number of parameters in the model, along with the loss:" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "ExecuteTime": { "end_time": "2025-06-29T18:09:09.096584Z", "start_time": "2025-06-29T18:00:44.234776Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "model params: 2370246\n", "Validation loss: 1.6072396039962769\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Create an instance of RopeModel (RMSNorm, RoPE, Multi-Head, SwiGLU, N_layers)\n", "llama = Llama(MASTER_CONFIG)\n", "\n", "# Obtain batches for training\n", "xs, ys = get_batches(dataset, 'train', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Calculate logits and loss using the model\n", "logits, loss = llama(xs, ys)\n", "\n", "# Define the Adam optimizer for model parameters\n", "optimizer = torch.optim.Adam(llama.parameters())\n", "\n", "# Train the model\n", "train(llama, optimizer)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "While there’s a possibility of overfitting, it’s crucial to explore whether extending the number of epochs leads to a further reduction in loss. Additionally, note that our current LLM has over 2 million parameters.\n", "\n", "Let’s train it for higher number of epochs." ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "ExecuteTime": { "end_time": "2025-06-30T03:24:54.590115Z", "start_time": "2025-06-30T03:04:39.904413Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Validation loss: 1.1109724998474122\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Update the number of epochs in the configuration\n", "MASTER_CONFIG.update({\n", " 'epochs': 10000,\n", "})\n", "# Train the LLaMA model for the specified number of epochs\n", "train(llama, optimizer, scheduler=None, config=MASTER_CONFIG)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "The loss here is 1.08, we can achieve even more lower loss without encountering significant overfitting. This suggests the model is performing well.\n", "\n", "Let’s train the model once more, this time incorporating a scheduler" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "ExecuteTime": { "end_time": "2025-06-30T03:43:43.056714Z", "start_time": "2025-06-30T03:25:51.708795Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Validation loss: 1.071915054321289\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Training the model again, scheduler for better optimization.\n", "train(llama, optimizer, config=MASTER_CONFIG)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "Up until now, we’ve successfully implemented a scaled-down version of the LLaMA architecture on our custom dataset. Now, let’s examine the generated output from our 2 million-parameter Language Model." ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "ExecuteTime": { "end_time": "2025-06-30T08:28:59.672993Z", "start_time": "2025-06-30T08:28:48.659849Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "k God Ro pay sand\n", "Well, are'sh me necomest and our pools stain.\n", "\n", "AUT:\n", "Laddownmy them,\n", "Whank well; that one myother\n", " hilled:\n", "That thine. rayoor for elboods,\n", "\n", "Hures alumpon,\n", "Them the trearh letts.\n", "\n", "BUCKINGBY:\n", "Say mern tid in Irans heaven:\n", "To ungeren tand\n", "Hus theeds, onesfever,\n", "And rist dy's hat lodd, fame,\n", "I condem have hour; 'o hout gured than like lift shall their.\n", "\n", "KING MARCIYK:\n", "Nort, an, ik prole men and no\n", "withone and Jea:\n", "And Wifioning a chones;\n", "Told stater, that it man\n", "What, Edra\n", "Them tis m\n" ] } ], "source": [ "# Generate text using the trained LLM (llama) with a maximum of 500 tokens\n", "generated_text = generate(llama, MASTER_CONFIG, 500)[0]\n", "print(generated_text)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\"\"\n", "\n", "\n", "Even though some generated words may not be perfect English, our LLM with just 2 million parameters has shown a basic understanding of the English language.\n", "\n", "Now, let’s see how well our model performs on the test set." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Get batches from the test set\n", "xs, ys = get_batches(dataset, 'test', MASTER_CONFIG['batch_size'], MASTER_CONFIG['context_window'])\n", "\n", "# Pass the test data through the LLaMA model\n", "logits, loss = llama(xs, ys)\n", "\n", "# Print the loss on the test set\n", "print(loss)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The computed loss on the test set is approximately 1.236.\n", "\n", "A simple way to check for changes in the generated output is to run training for a large number of epochs and observe the results." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Experimenting with hyperparameters\n", "\n", "Hyperparameter tuning is a crucial step in training neural networks. In the original Llama paper, the authors utilized the Cosine Annealing learning schedule. However, in our experimentation, it didn’t perform well. Here’s an example of experimenting with hyperparameters using a different learning schedule:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Update configuration\n", "MASTER_CONFIG.update({\n", " \"epochs\": 1000\n", "})\n", "\n", "# Create Llama model with Cosine Annealing learning schedule\n", "llama_with_cosine = Llama(MASTER_CONFIG)\n", "\n", "# Define Adam optimizer with specific hyperparameters\n", "llama_optimizer = torch.optim.Adam(\n", " llama.parameters(),\n", " betas=(9, .95),\n", " weight_decay=.1,\n", " eps=1e-9,\n", " lr=1e-3\n", ")\n", "\n", "# Define Cosine Annealing learning rate scheduler\n", "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(llama_optimizer, 300, eta_min=1e-5)\n", "\n", "# Train the Llama model with the specified optimizer and scheduler\n", "train(llama_with_cosine, llama_optimizer, scheduler=scheduler)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion\n", "\n", "In this notebook, we’ve walked through a step-by-step process on how to implement the LLaMA approach to build your own small Language Model (LLM). As a suggestion, consider expanding your model to around 15 million parameters, as smaller models in the range of 10M to 20M tend to comprehend English better. Once your LLM becomes proficient in language, you can fine-tune it for specific use cases.\n", "\n", "If you find this notebook helpful, there's no \"like\" option, but you can connect with me on [LinkedIn](https://www.linkedin.com/in/fareed-khan-dev/) or follow me on [Medium](https://medium.com/@fareedkhandev)." ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "ExecuteTime": { "end_time": "2025-06-30T08:31:54.454345Z", "start_time": "2025-06-30T08:31:54.191437Z" } }, "outputs": [], "source": [ "# Save the entire model\n", "torch.save(llama, 'llama_model.pth')\n", "\n", "# If you want to save only the model parameters\n", "torch.save(llama.state_dict(), 'llama_model_params.pth')" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 4 }