Upload 4 files

app/main.py

@@ -0,0 +1,85 @@
+# /app/main.py
+import torch, os
+from importlib.metadata import version
+import streamlit as st
+import tiktoken
+from pathlib import Path
+from scripts import MultiHeadAttention, LayerNorm, GELU, FeedForward, TransformerBlock, GPTModel, build_old_policy
+
+# library = ["numpy", "torch", "tensorflow", "streamlit", "pandas", "tiktoken"]
+# for lib in library:
+#     st.write(f"{lib} version: {version(lib)}")
+
+# Set basic page configuration (optional, but good for wider layouts)
+st.set_page_config(
+    page_title="Spam or Ham",
+    page_icon="🤖",
+    layout="centered", # or "wide"
+    initial_sidebar_state="collapsed"
+)
+
+# BUILD THE CLASSIFIER POLICY MODEL
+@st.cache_resource
+def load_model_and_tokenizer():
+    # --- CONFIGURATION ---
+    BASE_CONFIG = {
+        "vocab_size": 50257,     # Vocabulary size
+        "context_length": 1024,  # Context length
+        "drop_rate": 0.1,        # Dropout rate
+        "qkv_bias": True         # Query-key-value bias
+    }
+    policy = build_old_policy(base_config=BASE_CONFIG, chosen_model="gpt2-small (124M)", num_classes=2)
+    
+    model_parameters_path= Path("./app/models/Spam-Classifier-GPT2-Model.pt")   # Factor in that the docker image will start in a different working directory (see Dockerfile)
+
+    if not model_parameters_path.exists():
+        st.error(f"Model Parameter file not found at: {model_parameters_path}. Please ensure it's in the correct location.")
+        st.stop() # Stop the script
+
+
+    policy.load_state_dict(torch.load(f=model_parameters_path, weights_only=True, map_location='cpu'))
+    policy.to('cpu')
+    tokenizer = tiktoken.get_encoding("gpt2")
+
+    return policy.eval(), tokenizer
+
+st.title("Spam Classifier Agent!")
+
+# https://docs.streamlit.io/develop/api-reference/widgets/st.text_area
+text_block = st.text_area(label="Enter your text to classify if it is SPAM or NOT SPAM", placeholder ="ConGratulations!!!1 You won $1.000. Click the link beelow to claime you're Prize.!")
+
+
+# --- Add a button to trigger analysis ---
+if st.button("Analyze Text"):
+    if text_block:  # Run if there is an input ; maybe introduce a 'submit' button
+
+        policy, tokenizer = load_model_and_tokenizer()
+
+        # Tokenize the input string and restrict it to the model's context length
+        tokenized_input = tokenizer.encode(text_block)[-policy.pos_emb.num_embeddings:]
+
+        batched_input = torch.tensor(data=tokenized_input).unsqueeze(0)  # turn the tokenized input into a tensor and add a batch dimension
+        with torch.no_grad():
+            logits = policy(batched_input)[:,-1,:]   # Run the logits through the model and extract the probabilities of the last timestep
+
+        prediction_index = torch.argmax(input=logits, dim=-1).item()  # Get the prediction of the model
+
+        prediction_label = "SPAM" if prediction_index == 1 else "NOT SPAM"  # Map the prediction index to a label
+        
+        # --- Streamlit Output ---
+        st.subheader("Classification Result:")
+        st.write("---") # Separator
+
+        st.markdown(f"**Classification:**")
+        if prediction_label == "SPAM":
+            st.error(f"Prediction: {prediction_label} 🚨") # Red box for spam
+        else:
+            st.success(f"Prediction: {prediction_label} ✅") # Green box for not spam
+
+        # Optional: Show probabilities
+        softmax_probs = torch.nn.functional.softmax(logits, dim=-1)
+        st.info(f"Probabilities: SPAM={softmax_probs[0, 1]:.4f}, NOT SPAM={softmax_probs[0, 0]:.4f}")
+
+        st.write("---") # Another separator
+    else:
+        st.warning("Please enter some text in the text area before clicking 'Analyze Text'.")

app/models/Spam-Classifier-GPT2-Model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5e86fedfc703659ea74a2d636d3c2a7b21d1c07b20cd0f6013cf87638625540
+size 548173616

app/scripts/__init__.py

@@ -0,0 +1,5 @@
+#/scripts/__init__.py
+
+from .modules import *
+
+__all__ = ["MultiHeadAttention", "LayerNorm", "GELU", "FeedForward", "TransformerBlock", "GPTModel", "build_old_policy"]

app/scripts/modules.py

@@ -0,0 +1,193 @@
+# /streamlit/app/scripts/modules.py
+# Copyright (c) Sebastian Raschka under Apache License 2.0 (see LICENSE.txt).
+# Source for "Build a Large Language Model From Scratch"
+#   - https://www.manning.com/books/build-a-large-language-model-from-scratch
+# Code: https://github.com/rasbt/LLMs-from-scratch
+
+# This file has been modified by [Brian Perez] for the [Spam_Classifier_Agent] project.
+# The modifications are licensed under the same Apache License, Version 2.0.
+import torch
+import torch.nn as nn
+
+#####################################
+# Chapter 3
+#####################################
+class MultiHeadAttention(nn.Module):
+    def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False):
+        super().__init__()
+        assert d_out % num_heads == 0, "d_out must be divisible by n_heads"
+
+        self.d_out = d_out
+        self.num_heads = num_heads
+        self.head_dim = d_out // num_heads  # Reduce the projection dim to match desired output dim
+
+        self.W_query = nn.Linear(d_in, d_out, bias=qkv_bias)
+        self.W_key = nn.Linear(d_in, d_out, bias=qkv_bias)
+        self.W_value = nn.Linear(d_in, d_out, bias=qkv_bias)
+        self.out_proj = nn.Linear(d_out, d_out)  # Linear layer to combine head outputs
+        self.dropout = nn.Dropout(dropout)
+        self.register_buffer('mask', torch.triu(torch.ones(context_length, context_length), diagonal=1))
+
+    def forward(self, x):
+        b, num_tokens, d_in = x.shape
+
+        keys = self.W_key(x)  # Shape: (b, num_tokens, d_out)
+        queries = self.W_query(x)
+        values = self.W_value(x)
+
+        # We implicitly split the matrix by adding a `num_heads` dimension
+        # Unroll last dim: (b, num_tokens, d_out) -> (b, num_tokens, num_heads, head_dim)
+        keys = keys.view(b, num_tokens, self.num_heads, self.head_dim)
+        values = values.view(b, num_tokens, self.num_heads, self.head_dim)
+        queries = queries.view(b, num_tokens, self.num_heads, self.head_dim)
+
+        # Transpose: (b, num_tokens, num_heads, head_dim) -> (b, num_heads, num_tokens, head_dim)
+        keys = keys.transpose(1, 2)
+        queries = queries.transpose(1, 2)
+        values = values.transpose(1, 2)
+
+        # Compute scaled dot-product attention (aka self-attention) with a causal mask
+        attn_scores = queries @ keys.transpose(2, 3)  # Dot product for each head
+
+        # Original mask truncated to the number of tokens and converted to boolean
+        mask_bool = self.mask.bool()[:num_tokens, :num_tokens]
+
+        # Use the mask to fill attention scores
+        attn_scores.masked_fill_(mask_bool, -torch.inf)
+
+        attn_weights = torch.softmax(attn_scores / keys.shape[-1]**0.5, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+
+        # Shape: (b, num_tokens, num_heads, head_dim)
+        context_vec = (attn_weights @ values).transpose(1, 2)
+
+        # Combine heads, where self.d_out = self.num_heads * self.head_dim
+        context_vec = context_vec.reshape(b, num_tokens, self.d_out)
+        context_vec = self.out_proj(context_vec)  # optional projection
+
+        return context_vec
+
+#####################################
+# Chapter 4
+#####################################
+class LayerNorm(nn.Module):
+    def __init__(self, emb_dim):
+        super().__init__()
+        self.eps = 1e-5
+        self.scale = nn.Parameter(torch.ones(emb_dim))
+        self.shift = nn.Parameter(torch.zeros(emb_dim))
+
+    def forward(self, x):
+        mean = x.mean(dim=-1, keepdim=True)
+        var = x.var(dim=-1, keepdim=True, unbiased=False)
+        norm_x = (x - mean) / torch.sqrt(var + self.eps)
+        return self.scale * norm_x + self.shift
+
+
+class GELU(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        return 0.5 * x * (1 + torch.tanh(
+            torch.sqrt(torch.tensor(2.0 / torch.pi)) *
+            (x + 0.044715 * torch.pow(x, 3))
+        ))
+
+
+class FeedForward(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.layers = nn.Sequential(
+            nn.Linear(cfg["emb_dim"], 4 * cfg["emb_dim"]),
+            GELU(),
+            nn.Linear(4 * cfg["emb_dim"], cfg["emb_dim"]),
+        )
+
+    def forward(self, x):
+        return self.layers(x)
+
+
+class TransformerBlock(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.att = MultiHeadAttention(
+            d_in=cfg["emb_dim"],
+            d_out=cfg["emb_dim"],
+            context_length=cfg["context_length"],
+            num_heads=cfg["n_heads"],
+            dropout=cfg["drop_rate"],
+            qkv_bias=cfg["qkv_bias"])
+        self.ff = FeedForward(cfg)
+        self.norm1 = LayerNorm(cfg["emb_dim"])
+        self.norm2 = LayerNorm(cfg["emb_dim"])
+        self.drop_resid = nn.Dropout(cfg["drop_rate"])
+
+    def forward(self, x):
+        # Shortcut connection for attention block
+        shortcut = x
+        x = self.norm1(x)
+        x = self.att(x)   # Shape [batch_size, num_tokens, emb_size]
+        x = self.drop_resid(x)
+        x = x + shortcut  # Add the original input back
+
+        # Shortcut connection for feed-forward block
+        shortcut = x
+        x = self.norm2(x)
+        x = self.ff(x)
+        x = self.drop_resid(x)
+        x = x + shortcut  # Add the original input back
+
+        return x
+
+
+class GPTModel(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.tok_emb = nn.Embedding(cfg["vocab_size"], cfg["emb_dim"])
+        self.pos_emb = nn.Embedding(cfg["context_length"], cfg["emb_dim"])
+        self.drop_emb = nn.Dropout(cfg["drop_rate"])
+
+        self.trf_blocks = nn.Sequential(
+            *[TransformerBlock(cfg) for _ in range(cfg["n_layers"])])
+
+        self.final_norm = LayerNorm(cfg["emb_dim"])
+        self.out_head = nn.Linear(cfg["emb_dim"], cfg["vocab_size"], bias=False)
+
+    def forward(self, in_idx):
+        batch_size, seq_len = in_idx.shape  # (Batch_size, max_num_tokens)
+        tok_embeds = self.tok_emb(in_idx)
+        pos_embeds = self.pos_emb(torch.arange(seq_len, device=in_idx.device))  # Shape: (max_seq_len, emb_dim)
+        x = tok_embeds + pos_embeds  # Broadcasting! Resulting Shape=[batch_size, num_tokens, emb_size]
+        x = self.drop_emb(x)
+        x = self.trf_blocks(x)
+        x = self.final_norm(x)
+        logits = self.out_head(x)
+        return logits
+
+def build_old_policy(base_config: dict, chosen_model: str="gpt2-small (124M)", num_classes: int = 2) -> GPTModel:
+    """Construct the GPT2 model architecture without loading the weights. Code inspired from: https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb
+    Args:
+        base_config (dict): The base configurations of the gpt2 model indicating vocab_size, context_length, drop_rate, and qkv_bias.
+        chosen_model (str): The specific gpt2 model to construct.
+        num_classes (int): The amount of classes in the classification task.
+    Returns:
+        model (GPTModel): The constructed Transformer model for classification."""
+    
+    model_configs = {
+        "gpt2-small (124M)": {"emb_dim": 768, "n_layers": 12, "n_heads": 12},
+        "gpt2-medium (355M)": {"emb_dim": 1024, "n_layers": 24, "n_heads": 16},
+        "gpt2-large (774M)": {"emb_dim": 1280, "n_layers": 36, "n_heads": 20},
+        "gpt2-xl (1558M)": {"emb_dim": 1600, "n_layers": 48, "n_heads": 25},
+    }
+
+    base_config.update(model_configs[chosen_model]) # Add the emb_dim, n_layers, and n_heads to the config
+
+    model_size = chosen_model.split(" ")[-1].lstrip("(").rstrip(")")
+    allowed_sizes = ("124M", "355M", "774M", "1558M")
+    if model_size not in allowed_sizes:
+        raise ValueError(f"Model size not in {allowed_sizes}")
+    model = GPTModel(base_config)
+
+    model.out_head = torch.nn.Linear(in_features=base_config["emb_dim"], out_features=num_classes) # Reconfigure the output layer
+    return model