Upload 2 files

app.py

@@ -0,0 +1,143 @@
+import gradio as gr
+import torch
+import json
+from transformers import GPT2Tokenizer
+from safetensors.torch import load_file
+import torch.nn as nn
+from torch.nn import functional as F
+from dataclasses import dataclass
+
+# [Keep all your model code (CausalSelfAttention, MLP, Block, GPTConfig, GPT classes) as is]
+
+# Define the GPTConfig and GPT classes (same as your original code)
+# ...
+
+# Initialize global variables
+model = None
+tokenizer = None
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+def load_model():
+    """Load the Leap0 model and tokenizer."""
+    global model, tokenizer
+    
+    try:
+        # Paths to config and model files
+        config_path = "config.json"
+        model_path = "model.safetensors"
+        
+        print(f"Loading configuration from {config_path}...")
+        # Load the configuration
+        with open(config_path, "r") as f:
+            config_dict = json.load(f)
+            
+        print("Configuration loaded. Creating model config...")
+        config = GPTConfig.from_dict(config_dict)
+        print(f"Model config created: {config}")
+        
+        print(f"Loading model weights from {model_path}...")
+        # Load the model weights
+        tensors = load_file(model_path)
+        
+        print("Instantiating model...")
+        # Instantiate the model with the loaded config
+        model = GPT(config)
+        
+        print("Loading weights into model...")
+        model.load_state_dict(tensors, strict=False)
+        model.to(device)
+        model.eval()
+        
+        print("Loading tokenizer...")
+        # Load the tokenizer
+        tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+        
+        print("Model and tokenizer loaded successfully")
+    except Exception as e:
+        print(f"Error loading model: {str(e)}")
+        raise
+
+def generate_text(prompt, max_length=50, temperature=0.7, top_k=40):
+    """Generate text based on the provided prompt."""
+    if model is None or tokenizer is None:
+        load_model()
+    
+    # Tokenize the input text
+    input_ids = tokenizer.encode(prompt, return_tensors="pt").to(device)
+    
+    # Generate text
+    with torch.no_grad():
+        output_ids = model.generate(
+            input_ids, 
+            max_new_tokens=max_length,
+            temperature=temperature,
+            top_k=top_k
+        )
+    
+    # Decode the output
+    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+    
+    return output_text
+
+# Create the Gradio interface
+def create_interface():
+    with gr.Blocks(css="footer {visibility: hidden}") as demo:
+        gr.Markdown("# Leap0 Language Model")
+        gr.Markdown("A GPT-2 based model trained on the Tiny Stories dataset")
+        
+        with gr.Row():
+            with gr.Column():
+                prompt = gr.Textbox(
+                    label="Enter your prompt",
+                    placeholder="once upon a time in the village of",
+                    lines=3
+                )
+                
+                with gr.Row():
+                    max_length = gr.Slider(
+                        minimum=1, 
+                        maximum=200, 
+                        value=50, 
+                        step=1, 
+                        label="Max Length"
+                    )
+                    temperature = gr.Slider(
+                        minimum=0.1, 
+                        maximum=2.0, 
+                        value=0.7, 
+                        step=0.1, 
+                        label="Temperature"
+                    )
+                    top_k = gr.Slider(
+                        minimum=1, 
+                        maximum=100, 
+                        value=40, 
+                        step=1, 
+                        label="Top K"
+                    )
+                
+                generate_btn = gr.Button("Generate Text")
+                
+            with gr.Column():
+                output = gr.Textbox(
+                    label="Generated Output",
+                    lines=10,
+                    placeholder="Your generated text will appear here..."
+                )
+        
+        generate_btn.click(
+            fn=generate_text,
+            inputs=[prompt, max_length, temperature, top_k],
+            outputs=output
+        )
+    
+    return demo
+
+# Load the model when the script is run
+load_model()
+
+# Create and launch the interface
+demo = create_interface()
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+torch
+transformers
+safetensors