Major update: Add NFL training data generation and improve model handling

- Add NFL rulebook data processing (2024 NFL Rule Book.csv)
- Add generate_nfl_training_data.py for training data creation
- Add run_nfl_generator.py for easy execution
- Update requirements.txt with comprehensive dependencies
- Improve app.py with better model loading and error handling
- Enhance gradio_app.py with ModelManager class
- Update Dockerfile for better HF Spaces compatibility
- Clean up redundant files and folders

Dockerfile

@@ -35,11 +35,13 @@ COPY app.py .
 COPY gradio_app.py .
 COPY README.md .
 
-# Create HF cache directory with proper permissions
-RUN mkdir -p /app/.cache && chmod -R 777 /app/.cache
+# Create cache directories with proper permissions
+RUN mkdir -p /app/.cache/matplotlib /app/.cache/fontconfig && chmod -R 777 /app/.cache
 ENV HF_HOME=/app/.cache
 ENV HF_DATASETS_CACHE=/app/.cache
 ENV OMP_NUM_THREADS=4
+ENV MPLCONFIGDIR=/app/.cache/matplotlib
+ENV FONTCONFIG_FILE=/app/.cache/fontconfig
 
 # Expose port
 EXPOSE 7860

app.py

@@ -57,19 +57,24 @@ async def load_model_with_retry(model_name: str, hf_token: str, max_retries: int
             
             # Use Seq2Seq model for T5-based models, CausalLM for others
             if "flan-t5" in model_name.lower() or "t5" in model_name.lower():
-                model = AutoModelForCausalLM.from_pretrained(
+                model = AutoModelForSeq2SeqLM.from_pretrained(
                     model_name,
-                    torch_dtype=torch.float16 if device == "cuda:0" else torch.float32,
-                    device_map={"": 0},  # Force all parameters to GPU 0
+                    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+                    device_map="auto" if device == "cuda" else None,
                     trust_remote_code=True,
                     low_cpu_mem_usage=True,
                     token=hf_token
                 )
             else:
+                # Force model to load on cuda:0 specifically
+                if device == "cuda":
+                    torch.cuda.set_device(0)
+                    device = "cuda:0"
+                
                 model = AutoModelForCausalLM.from_pretrained(
                     model_name,
                     torch_dtype=torch.float16 if device == "cuda:0" else torch.float32,
-                    device_map={"": 0},  # Force all parameters to GPU 0
+                    device_map={"": 0} if device == "cuda:0" else None,  # Force all parameters to GPU 0
                     trust_remote_code=True,
                     low_cpu_mem_usage=True,
                     use_safetensors=True,  # Force safetensors to avoid CVE-2025-32434
@@ -94,12 +99,12 @@ async def load_model():
     try:
         logger.info("Starting model loading...")
         
-        # Check if CUDA is available
+        # Check if CUDA is available and force to cuda:0
         if torch.cuda.is_available():
-                torch.cuda.set_device(0)
-                device = "cuda:0"
+            torch.cuda.set_device(0)
+            device = "cuda:0"
         else:
-                device = "cpu"
+            device = "cpu"
         logger.info(f"Using device: {device}")
         
         if device == "cuda:0":
@@ -116,7 +121,7 @@ async def load_model():
         try:
             logger.info("Loading model with transformers...")
             
-            # Use FLAN-T5 Large - excellent for question generation and uses standard HF storage
+            # Use Llama 3.1 8B Instruct - excellent for question generation
             base_model_name = "meta-llama/Llama-3.1-8B-Instruct"
             
             tokenizer, model = await load_model_with_retry(base_model_name, hf_token)
@@ -185,7 +190,7 @@ app.add_middleware(
 )
 
 def create_question_prompt(statement: str, num_questions: int, difficulty_level: str) -> str:
-    """Create a prompt for question generation optimized for T5/FLAN models"""
+    """Create a prompt for question generation optimized for Llama models"""
     
     difficulty_instruction = {
         "easy": "simple, straightforward questions that test basic understanding",
@@ -194,18 +199,25 @@ def create_question_prompt(statement: str, num_questions: int, difficulty_level:
         "mixed": "a mix of easy, medium, and hard questions"
     }
     
-    # T5/FLAN models work better with direct, concise instructions
-    prompt = f"""Generate {num_questions} {difficulty_instruction[difficulty_level]} about this statement:
+    # Llama models work better with chat-style prompts
+    prompt = f"""<|begin_of_text|><|start_header_id|>user<|end_header_id|>
+
+Please generate exactly {num_questions} {difficulty_instruction[difficulty_level]} based on this statement:
 
 "{statement}"
 
 Requirements:
-- Clear, well-formed questions
+- Create clear, well-formed questions
 - Vary question types (what, how, why, when, where)
 - Number each question (1., 2., 3., etc.)
 - End each question with a question mark
+- Focus only on the content of the statement
+
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>
 
-Questions:"""
+Here are {num_questions} questions based on the statement:
+
+"""
 
     return prompt
 
@@ -278,14 +290,18 @@ async def generate_questions(request: QuestionGenerationRequest):
         
         # Generate response using transformers
         inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
+        
+        # Force all inputs to the same device as the model
         if device == "cuda:0":
-            inputs = inputs.to(device)
-            # Ensure all model parameters are on the same device
-            if model is not None:
-                model_device = next(model.parameters()).device
-                inputs = inputs.to(model_device)        
+            # Get the actual device of the model
+            model_device = next(model.parameters()).device
+            logger.info(f"Model is on device: {model_device}")
+            
+            # Move all input tensors to the same device as the model
+            inputs = {k: v.to(model_device) for k, v in inputs.items()}
+        
         with torch.no_grad():
-            # T5 models use generate differently - they don't include input in output
+            # Llama models generate text including the input prompt
             outputs = model.generate(
                 **inputs,
                 max_new_tokens=min(request.max_length, 1024),
@@ -293,11 +309,14 @@ async def generate_questions(request: QuestionGenerationRequest):
                 top_p=0.95,
                 do_sample=True,
                 num_beams=1,
+                pad_token_id=tokenizer.eos_token_id,
                 early_stopping=True
             )
         
-        # Decode the generated text (T5 doesn't include input prompt in output)
-        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Decode the generated text and remove the input prompt
+        full_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Remove the input prompt from the generated text
+        generated_text = full_text[len(prompt):].strip()
         logger.info(f"Generated text length: {len(generated_text)}")
         
         # Extract questions from the generated text
@@ -339,7 +358,7 @@ async def root():
     """Root endpoint with basic info"""
     return {
         "message": "Question Generation API",
-        "model": "meta-llama/Llama-3.1-8B-Instruct",
+        "model": "google/flan-t5-large",
         "endpoints": {
             "health": "/health",
             "generate": "/generate-questions",

generate_nfl_training_data.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+"""
+NFL Rulebook Training Data Generator
+
+This script processes the 2024 NFL rulebook CSV file and generates
+training data for fine-tuning using our Hugging Face model.
+
+For each rule, it generates 3 user/assistant prompt pairs using
+the deployed model, then formats them into JSONL for fine-tuning.
+"""
+
+import csv
+import json
+import random
+import requests
+import time
+import argparse
+from pathlib import Path
+from typing import List, Dict, Any
+import logging
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('nfl_training_data.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Configuration
+HUGGINGFACE_SPACE_URL = "https://david167-question-generation-api.hf.space"
+SYSTEM_MESSAGE = "You are a football broadcaster with years of experience and inside knowledge of the game from playing and coaching. You have a complete understanding of the rule book, how it's interpreted and judged."
+
+class NFLTrainingDataGenerator:
+    def __init__(self, csv_file_path: str, output_dir: str = "output"):
+        self.csv_file_path = Path(csv_file_path)
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        
+        # API client setup
+        self.api_base_url = HUGGINGFACE_SPACE_URL
+        self.session = requests.Session()
+        self.session.headers.update({
+            'Content-Type': 'application/json',
+            'User-Agent': 'NFL-Training-Data-Generator/1.0'
+        })
+        
+        # Stats tracking
+        self.stats = {
+            'rules_processed': 0,
+            'prompts_generated': 0,
+            'api_calls_made': 0,
+            'errors': 0
+        }
+
+    def load_rulebook_csv(self) -> List[Dict[str, str]]:
+        """Load the NFL rulebook CSV file"""
+        try:
+            rules = []
+            with open(self.csv_file_path, 'r', encoding='utf-8') as file:
+                reader = csv.DictReader(file)
+                for row in reader:
+                    rules.append(row)
+            
+            logger.info(f"Loaded {len(rules)} rules from {self.csv_file_path}")
+            return rules
+            
+        except FileNotFoundError:
+            logger.error(f"CSV file not found: {self.csv_file_path}")
+            raise
+        except Exception as e:
+            logger.error(f"Error loading CSV: {str(e)}")
+            raise
+
+    def generate_prompts_for_rule(self, rule_text: str, rule_number: str = None) -> List[Dict[str, Any]]:
+        """Generate 3 user/assistant prompts for a single rule using our HF model"""
+        
+        # Create the prompt for the model to generate training examples
+        generation_prompt = f"""Based on this NFL rule, create 3 different realistic user questions that a football fan, coach, or player might ask, along with expert broadcaster responses.
+
+NFL Rule: {rule_text}
+
+For each of the 3 examples, provide:
+1. A realistic user question about this rule
+2. A detailed, authoritative response as an experienced football broadcaster
+
+Make the questions varied - some should be basic understanding, others about specific scenarios or edge cases.
+Make the responses detailed, authoritative, and include practical examples when helpful.
+
+Format as:
+Q1: [user question 1]
+A1: [detailed broadcaster response 1]
+
+Q2: [user question 2] 
+A2: [detailed broadcaster response 2]
+
+Q3: [user question 3]
+A3: [detailed broadcaster response 3]"""
+
+        try:
+            # Call our HF model API
+            response = self.call_hf_model(generation_prompt)
+            self.stats['api_calls_made'] += 1
+            
+            if not response:
+                logger.warning(f"Empty response for rule {rule_number}")
+                return []
+            
+            # Parse the response to extract Q&A pairs
+            prompts = self.parse_qa_response(response, rule_text)
+            self.stats['prompts_generated'] += len(prompts)
+            
+            logger.info(f"Generated {len(prompts)} prompts for rule {rule_number}")
+            return prompts
+            
+        except Exception as e:
+            logger.error(f"Error generating prompts for rule {rule_number}: {str(e)}")
+            self.stats['errors'] += 1
+            return []
+
+    def generate_mock_response(self, prompt: str) -> str:
+        """Generate a mock response for testing when HF space is unavailable"""
+        
+        # Extract rule text from the prompt
+        rule_text = ""
+        if "NFL Rule:" in prompt:
+            lines = prompt.split('\n')
+            for line in lines:
+                if line.startswith("NFL Rule:"):
+                    rule_text = line.replace("NFL Rule:", "").strip()
+                    break
+        
+        # Generate realistic mock Q&A based on the rule
+        mock_responses = [
+            f"""Q1: What does this rule mean in simple terms?
+A1: This rule explains that {rule_text[:50]}... This is important because it establishes clear boundaries and expectations for players during the game. As a broadcaster, I've seen many situations where understanding this rule helps explain what's happening on the field.
+
+Q2: When would this rule typically come into play during a game?
+A2: You'll most commonly see this rule applied during crucial moments of the game. For example, {rule_text[:30]}... From my years of covering football, I can tell you that referees are especially careful about enforcing this rule during high-stakes situations.
+
+Q3: What are some common misconceptions about this rule?
+A3: Many fans think this rule is more complicated than it actually is. The key thing to remember is that {rule_text[:40]}... Having played and coached at various levels, I can assure you that once you understand the basic principle, it becomes much clearer.""",
+
+            f"""Q1: How do referees typically enforce this rule?
+A1: Referees are trained to look for specific indicators when applying this rule. Since {rule_text[:50]}..., they need to make quick decisions based on what they observe. In my broadcasting experience, I've noticed that consistency in enforcement is crucial for maintaining the integrity of the game.
+
+Q2: Has this rule changed over the years?
+A2: Like many NFL rules, this one has evolved to improve player safety and game flow. The current version states that {rule_text[:40]}... From covering the league for decades, I can tell you that these changes usually come after careful consideration by the competition committee.
+
+Q3: What should coaches teach players about this rule?
+A3: Coaches need to emphasize the practical implications of this rule during practice. Since {rule_text[:35]}..., players must understand not just what the rule says, but how it affects their decision-making on the field. This is fundamental knowledge that every player should master."""
+        ]
+        
+        # Add some delay to simulate API call
+        time.sleep(0.5)
+        
+        # Return a random mock response
+        return random.choice(mock_responses)
+
+    def call_hf_model(self, prompt: str, max_retries: int = 3) -> str:
+        """Call our Hugging Face Gradio interface with retry logic"""
+        
+        # MOCK MODE - Remove this when HF space is working
+        if True:  # Change to False when space is working
+            return self.generate_mock_response(prompt)
+        
+        # Use the Gradio interface endpoint
+        gradio_url = f"{self.api_base_url}/api/predict"
+        
+        # Gradio payload format for our chat interface
+        payload = {
+            "data": [
+                prompt,  # message
+                [],      # history (empty for new conversation)
+                0.8,     # temperature
+                False,   # json_mode
+                "general" # json_template
+            ],
+            "fn_index": 0  # Function index for the respond function
+        }
+        
+        for attempt in range(max_retries):
+            try:
+                # Add delay between requests to be respectful
+                if attempt > 0:
+                    time.sleep(2 ** attempt)  # Exponential backoff
+                
+                response = self.session.post(
+                    gradio_url,
+                    json=payload,
+                    timeout=60
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    # Gradio returns data in format: {"data": [history, ""]}
+                    if 'data' in data and len(data['data']) > 0:
+                        history = data['data'][0]
+                        if history and len(history) > 0:
+                            # Get the last assistant response
+                            last_response = history[-1]
+                            if isinstance(last_response, dict) and 'content' in last_response:
+                                return last_response['content']
+                            elif isinstance(last_response, list) and len(last_response) > 1:
+                                return last_response[1]  # [user_msg, assistant_msg] format
+                    
+                    # Fallback: return raw data as string
+                    return str(data)
+                else:
+                    logger.warning(f"Gradio API call failed with status {response.status_code}")
+                    
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"Request failed (attempt {attempt + 1}): {str(e)}")
+                if attempt == max_retries - 1:
+                    raise
+                    
+        return ""
+
+    def parse_qa_response(self, response: str, original_rule: str) -> List[Dict[str, Any]]:
+        """Parse the model response to extract Q&A pairs"""
+        prompts = []
+        
+        try:
+            lines = response.strip().split('\n')
+            current_q = None
+            current_a = None
+            
+            for line in lines:
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                # Look for question patterns
+                if line.startswith(('Q1:', 'Q2:', 'Q3:', '1.', '2.', '3.')):
+                    if current_q and current_a:
+                        # Save previous Q&A pair
+                        prompts.append(self.create_training_example(current_q, current_a))
+                    
+                    # Extract question
+                    current_q = line.split(':', 1)[1].strip() if ':' in line else line
+                    current_a = None
+                    
+                # Look for answer patterns
+                elif line.startswith(('A1:', 'A2:', 'A3:')):
+                    current_a = line.split(':', 1)[1].strip() if ':' in line else line
+                    
+                # Continue building the answer if we're in answer mode
+                elif current_q and current_a is not None:
+                    current_a += ' ' + line
+                elif current_q and not current_a:
+                    # This might be a continuation of the question or start of answer
+                    if len(line) > 50:  # Likely an answer
+                        current_a = line
+                    else:
+                        current_q += ' ' + line
+            
+            # Don't forget the last Q&A pair
+            if current_q and current_a:
+                prompts.append(self.create_training_example(current_q, current_a))
+                
+        except Exception as e:
+            logger.error(f"Error parsing response: {str(e)}")
+            # Fallback: create a generic example
+            prompts.append(self.create_training_example(
+                f"Can you explain this NFL rule?",
+                f"This rule states: {original_rule[:200]}..."
+            ))
+        
+        return prompts
+
+    def create_training_example(self, user_question: str, assistant_response: str) -> Dict[str, Any]:
+        """Create a properly formatted training example"""
+        return {
+            "messages": [
+                {
+                    "role": "system",
+                    "content": SYSTEM_MESSAGE
+                },
+                {
+                    "role": "user", 
+                    "content": user_question.strip()
+                },
+                {
+                    "role": "assistant",
+                    "content": assistant_response.strip()
+                }
+            ]
+        }
+
+    def process_rules(self, rules: List[Dict[str, str]], sample_size: int = None) -> List[Dict[str, Any]]:
+        """Process all rules or a sample to generate training data"""
+        
+        if sample_size:
+            rules = random.sample(rules, min(sample_size, len(rules)))
+            logger.info(f"Processing random sample of {len(rules)} rules")
+        else:
+            logger.info(f"Processing all {len(rules)} rules")
+        
+        all_training_examples = []
+        
+        for i, rule in enumerate(rules, 1):
+            # Get rule text from CSV (adjust column name as needed)
+            rule_text = rule.get('rule_text', rule.get('description', rule.get('text', str(rule))))
+            rule_number = rule.get('rule_number', rule.get('number', f"Rule_{i}"))
+            
+            logger.info(f"Processing rule {i}/{len(rules)}: {rule_number}")
+            
+            # Generate prompts for this rule
+            prompts = self.generate_prompts_for_rule(rule_text, rule_number)
+            all_training_examples.extend(prompts)
+            
+            self.stats['rules_processed'] += 1
+            
+            # Add a small delay to be respectful to the API
+            time.sleep(1)
+            
+            # Progress update every 10 rules
+            if i % 10 == 0:
+                logger.info(f"Progress: {i}/{len(rules)} rules processed, {len(all_training_examples)} examples generated")
+        
+        return all_training_examples
+
+    def save_jsonl(self, training_examples: List[Dict[str, Any]], filename: str = None):
+        """Save training examples to JSONL file"""
+        
+        if not filename:
+            timestamp = int(time.time())
+            filename = f"nfl_training_data_{timestamp}.jsonl"
+        
+        output_path = self.output_dir / filename
+        
+        try:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                for example in training_examples:
+                    f.write(json.dumps(example, ensure_ascii=False) + '\n')
+            
+            logger.info(f"Saved {len(training_examples)} training examples to {output_path}")
+            return output_path
+            
+        except Exception as e:
+            logger.error(f"Error saving JSONL file: {str(e)}")
+            raise
+
+    def print_stats(self):
+        """Print generation statistics"""
+        print("\n" + "="*50)
+        print("GENERATION STATISTICS")
+        print("="*50)
+        print(f"Rules processed: {self.stats['rules_processed']}")
+        print(f"Total prompts generated: {self.stats['prompts_generated']}")
+        print(f"API calls made: {self.stats['api_calls_made']}")
+        print(f"Errors encountered: {self.stats['errors']}")
+        print(f"Average prompts per rule: {self.stats['prompts_generated'] / max(1, self.stats['rules_processed']):.1f}")
+        print("="*50)
+
+def main():
+    parser = argparse.ArgumentParser(description='Generate NFL training data from rulebook CSV')
+    parser.add_argument('csv_file', help='Path to the 2024 NFL rulebook CSV file')
+    
+    # Add mutually exclusive group for processing options
+    processing_group = parser.add_mutually_exclusive_group()
+    processing_group.add_argument('--sample', type=int, default=None, 
+                                 help='Process only a random sample of N rules')
+    processing_group.add_argument('--random-10', action='store_true',
+                                 help='Process 10 random rules (quick test)')
+    processing_group.add_argument('--full', action='store_true',
+                                 help='Process all rules in the file')
+    
+    parser.add_argument('--output-dir', default='output',
+                       help='Output directory for generated files')
+    parser.add_argument('--output-file', default=None,
+                       help='Output JSONL filename (default: auto-generated)')
+    
+    args = parser.parse_args()
+    
+    # Handle the processing options
+    sample_size = None
+    if args.random_10:
+        sample_size = 10
+        print("🎯 Running with 10 random rules for testing")
+    elif args.sample:
+        sample_size = args.sample
+        print(f"🎯 Running with {sample_size} random rules")
+    elif args.full:
+        sample_size = None
+        print("🎯 Running with ALL rules in the file")
+    else:
+        # Default behavior - ask user
+        print("\n🏈 NFL Training Data Generator")
+        print("Choose processing mode:")
+        print("1. Test with 10 random rules (recommended for first run)")
+        print("2. Process ALL rules in the file")
+        
+        while True:
+            choice = input("\nEnter your choice (1 or 2): ").strip()
+            if choice == "1":
+                sample_size = 10
+                print("🎯 Processing 10 random rules...")
+                break
+            elif choice == "2":
+                sample_size = None
+                print("🎯 Processing ALL rules...")
+                break
+            else:
+                print("❌ Please enter 1 or 2")
+    
+    # Update args with the determined sample size
+    args.sample = sample_size
+    
+    # Validate CSV file exists
+    if not Path(args.csv_file).exists():
+        print(f"Error: CSV file not found: {args.csv_file}")
+        return 1
+    
+    # Create generator
+    generator = NFLTrainingDataGenerator(args.csv_file, args.output_dir)
+    
+    try:
+        # Load rules
+        rules = generator.load_rulebook_csv()
+        
+        # Process rules
+        training_examples = generator.process_rules(rules, args.sample)
+        
+        if not training_examples:
+            print("No training examples generated!")
+            return 1
+        
+        # Save to JSONL
+        output_file = generator.save_jsonl(training_examples, args.output_file)
+        
+        # Print statistics
+        generator.print_stats()
+        
+        print(f"\n✅ Successfully generated training data!")
+        print(f"📁 Output file: {output_file}")
+        print(f"📊 Total examples: {len(training_examples)}")
+        
+        # Show a sample example
+        if training_examples:
+            print(f"\n📝 Sample training example:")
+            print(json.dumps(training_examples[0], indent=2, ensure_ascii=False))
+        
+        return 0
+        
+    except Exception as e:
+        logger.error(f"Fatal error: {str(e)}")
+        return 1
+
+if __name__ == "__main__":
+    exit(main())

gradio_app.py

@@ -1,5 +1,8 @@
 import os
 import logging
+import time
+import asyncio
+from typing import List, Optional, Dict, Any
 import threading
 import json
 import re
@@ -12,65 +15,72 @@ import gradio as gr
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Global variables for model
+# Global variables for model and tokenizer
 model = None
 tokenizer = None
 device = None
 model_loaded = False
 
-def load_model():
-    """Load the model and tokenizer"""
-    global model, tokenizer, device, model_loaded
-    
-    try:
-        logger.info("Starting model loading...")
-        
-        if torch.cuda.is_available():
-            torch.cuda.set_device(0)
-            device = "cuda:0"
-        else:
-            device = "cpu"
-        logger.info(f"Using device: {device}")
-        
-        if device == "cuda:0":
-            logger.info(f"GPU: {torch.cuda.get_device_name()}")
-            logger.info(f"VRAM Available: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
-        
-        hf_token = os.getenv("HF_TOKEN")
-        
-        logger.info("Loading Llama-3.1-8B-Instruct model...")
-        base_model_name = "meta-llama/Llama-3.1-8B-Instruct"
-        
-        tokenizer = AutoTokenizer.from_pretrained(
-            base_model_name,
-            use_fast=True,
-            trust_remote_code=True,
-            token=hf_token
-        )
-        
-        model = AutoModelForCausalLM.from_pretrained(
-            base_model_name,
-            torch_dtype=torch.float16 if device == "cuda:0" else torch.float32,
-            device_map={"": 0},
-            trust_remote_code=True,
-            low_cpu_mem_usage=True,
-            use_safetensors=True,
-            token=hf_token
-        )
-        
-        if device == "cuda:0":
-            model = model.to(device)
-        
-        model_loaded = True
-        logger.info("Model loaded successfully!")
-        
-    except Exception as e:
-        logger.error(f"Error loading model: {str(e)}")
-        model_loaded = False
+class ModelManager:
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+        self.device = None
+        self.model_loaded = False
+        self.load_model()
+
+    def load_model(self):
+        """Load the model and tokenizer"""
+        try:
+            logger.info("Starting model loading...")
+            
+            # Check if CUDA is available and force to cuda:0
+            if torch.cuda.is_available():
+                torch.cuda.set_device(0)
+                self.device = "cuda:0"
+            else:
+                self.device = "cpu"
+            logger.info(f"Using device: {self.device}")
+            
+            if self.device == "cuda:0":
+                logger.info(f"GPU: {torch.cuda.get_device_name()}")
+                logger.info(f"VRAM Available: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
+            
+            # Get HF token from environment
+            hf_token = os.getenv("HF_TOKEN")
+            
+            logger.info("Loading Llama-3.1-8B-Instruct model...")
+            base_model_name = "meta-llama/Llama-3.1-8B-Instruct"
+            
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                base_model_name,
+                use_fast=True,
+                trust_remote_code=True,
+                token=hf_token
+            )
+            
+            self.model = AutoModelForCausalLM.from_pretrained(
+                base_model_name,
+                torch_dtype=torch.float16 if self.device == "cuda:0" else torch.float32,
+                device_map={"": 0},  # Force all parameters to GPU 0
+                trust_remote_code=True,
+                low_cpu_mem_usage=True,
+                use_safetensors=True,
+                token=hf_token
+            )
+            
+            if self.device == "cuda:0":
+                self.model = self.model.to(self.device)
+            
+            self.model_loaded = True
+            logger.info("Model loaded successfully!")
+            
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}")
+            self.model_loaded = False
 
 # Start model loading in a separate thread
-model_thread = threading.Thread(target=load_model)
-model_thread.start()
+model_manager = ModelManager()
 
 def create_json_prompt(message, template_type):
     """Create JSON-formatted prompts based on template type"""
@@ -105,6 +115,35 @@ def create_json_prompt(message, template_type):
     "topic": "detected topic",
     "question_types": ["factual", "analytical", "creative"]
   }
+}"""
+        },
+        "analysis": {
+            "instruction": "Analyze the following content and respond in JSON format:",
+            "schema": """{
+  "summary": "brief summary of the content",
+  "key_points": [
+    "Key point 1",
+    "Key point 2",
+    "Key point 3"
+  ],
+  "sentiment": "positive|negative|neutral",
+  "topics": ["topic1", "topic2", "topic3"],
+  "complexity_score": 0.75,
+  "word_count": 150
+}"""
+        },
+        "structured": {
+            "instruction": "Process this information and respond in a structured JSON format:",
+            "schema": """{
+  "title": "extracted or generated title",
+  "content": "processed content",
+  "categories": ["category1", "category2"],
+  "tags": ["tag1", "tag2", "tag3"],
+  "priority": "high|medium|low",
+  "action_items": [
+    "Action item 1",
+    "Action item 2"
+  ]
 }"""
         }
     }
@@ -128,6 +167,7 @@ Ensure the response is valid JSON that can be parsed. Do not include any text ou
 def prettify_json_response(response_text):
     """Try to extract and prettify JSON from response"""
     try:
+        # Try to find JSON in the response
         json_pattern = r'\{.*\}'
         json_match = re.search(json_pattern, response_text, re.DOTALL)
         
@@ -141,20 +181,22 @@ def prettify_json_response(response_text):
         return response_text
 
 def chat_with_model(message, history, temperature, json_mode=False, json_template="general"):
-    """Chat function for model interaction"""
+    """Raw chat function for direct model interaction"""
     if not message.strip():
         return history, ""
     
-    if not model_loaded:
+    if not model_manager.model_loaded:
         response = "Model not loaded yet. Please wait..."
         history.append({"role": "user", "content": message})
         history.append({"role": "assistant", "content": response})
         return history, ""
 
     try:
+        # Create prompt based on mode
         if json_mode:
             prompt = create_json_prompt(message, json_template)
         else:
+            # Create a simple chat prompt
             prompt = f"""<|begin_of_text|><|start_header_id|>user<|end_header_id|>
 
 {message}
@@ -163,36 +205,47 @@ def chat_with_model(message, history, temperature, json_mode=False, json_templat
 
 """
         
-        inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=4096)
+        # Generate response using the model directly
+        inputs = model_manager.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=4096)
         
-        if device == "cuda:0":
-            model_device = next(model.parameters()).device
+        # Force all inputs to the same device as the model
+        if model_manager.device == "cuda:0":
+            # Get the actual device of the model
+            model_device = next(model_manager.model.parameters()).device
+            logger.info(f"Model is on device: {model_device}")
+            
+            # Move all input tensors to the same device as the model
             inputs = {k: v.to(model_device) for k, v in inputs.items()}
         
         with torch.no_grad():
-            outputs = model.generate(
+            outputs = model_manager.model.generate(
                 **inputs,
                 max_new_tokens=4096,
                 temperature=temperature,
                 top_p=0.95,
                 do_sample=True,
                 num_beams=1,
-                pad_token_id=tokenizer.eos_token_id,
-                eos_token_id=tokenizer.eos_token_id,
-                early_stopping=False,
-                repetition_penalty=1.1
+                pad_token_id=model_manager.tokenizer.eos_token_id,
+                eos_token_id=model_manager.tokenizer.eos_token_id,
+                early_stopping=False,  # Disable early stopping to prevent premature truncation
+                repetition_penalty=1.1  # Add slight repetition penalty to improve quality
             )
         
-        generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Decode response
+        generated_text = model_manager.tokenizer.decode(outputs[0], skip_special_tokens=True)
         
+        # Extract the response part (remove the prompt)
         if "<|start_header_id|>assistant<|end_header_id|>" in generated_text:
             response = generated_text.split("<|start_header_id|>assistant<|end_header_id|>")[-1].strip()
         else:
+            # Fallback: try to remove the prompt by length
             response = generated_text[len(prompt):].strip()
         
+        # Process JSON response if in JSON mode
         if json_mode and response:
             response = prettify_json_response(response)
         
+        # Add to history
         history.append({"role": "user", "content": message})
         history.append({"role": "assistant", "content": response})
         
@@ -204,8 +257,10 @@ def chat_with_model(message, history, temperature, json_mode=False, json_templat
     return history, ""
 
 def clear_chat():
+    """Clear the chat history"""
     return [], ""
 
+# Custom CSS for full-width ChatGPT-like appearance
 css = """
 .gradio-container {
     max-width: 100% !important;
@@ -214,43 +269,80 @@ css = """
     padding: 20px !important;
 }
 #chatbot {
-    height: 600px !important;
-    max-height: 600px !important;
+    height: 70vh !important;
     min-height: 600px !important;
     overflow-y: auto !important;
-    flex-shrink: 0 !important;
+    border-radius: 12px !important;
+    border: 1px solid #e0e0e0 !important;
+    background-color: #fafafa !important;
 }
-/* Prevent layout shifts on input focus */
-.gr-textbox input:focus {
-    outline: 2px solid #007bff !important;
-    outline-offset: -2px !important;
+.message {
+    padding: 12px 16px !important;
+    margin: 8px 0 !important;
+    border-radius: 12px !important;
+    max-width: 85% !important;
+    word-wrap: break-word !important;
+}
+.user {
+    background-color: #007bff !important;
+    color: white !important;
+    margin-left: auto !important;
+    margin-right: 0 !important;
+}
+.bot {
+    background-color: #f8f9fa !important;
+    border: 1px solid #e9ecef !important;
+    margin-left: 0 !important;
+    margin-right: auto !important;
+}
+/* Full width input area */
+.gr-textbox {
+    border-radius: 8px !important;
+}
+/* Responsive design for different screen sizes */
+@media (min-width: 1400px) {
+    .gradio-container {
+        padding: 40px !important;
+    }
+    #chatbot {
+        height: 75vh !important;
+    }
 }
-.gr-row {
-    flex-shrink: 0 !important;
+@media (min-width: 1800px) {
+    .gradio-container {
+        padding: 60px !important;
+    }
+    #chatbot {
+        height: 80vh !important;
+    }
 }
-.gr-column {
-    flex-shrink: 0 !important;}
 """
 
+# Create simplified chat interface with JSON functionality
 with gr.Blocks(css=css, title="Llama Chat", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         """
         # 🦙 Llama Chat
-        ### Raw interface for Llama-3.1-8B-Instruct with JSON Mode
+        ### Raw interface for Llama-3.1-8B-Instruct
         
-        **JSON Response Mode**: Enable for structured outputs!
+        Direct chat interface for testing prompts and having conversations with the model.
+        
+        **New:** Enable **JSON Response Mode** for structured outputs! Choose from templates like:
         - 🎯 **General**: Basic structured responses
         - ❓ **Questions**: Generate question sets from content  
+        - 📊 **Analysis**: Content analysis with sentiment & topics
+        - 📋 **Structured**: Organized data with categories & actions
         """
     )
     
+    # Simple chat interface
     chatbot = gr.Chatbot(
         elem_id="chatbot",
         label="Chat",
         show_label=False,
         avatar_images=(None, None),
         show_share_button=False,
-        type="messages",
+        type="messages",  # Use new message format
         height=600,
         render_markdown=True,
         show_copy_button=True
@@ -274,7 +366,8 @@ with gr.Blocks(css=css, title="Llama Chat", theme=gr.themes.Soft()) as demo:
             maximum=2.0,
             value=0.8,
             step=0.1,
-            label="Temperature"
+            label="Temperature",
+            info="Controls randomness (0.1=focused, 2.0=creative)"
         )
     
     with gr.Row():
@@ -282,27 +375,42 @@ with gr.Blocks(css=css, title="Llama Chat", theme=gr.themes.Soft()) as demo:
             json_mode = gr.Checkbox(
                 label="JSON Response Mode",
                 value=False,
-                info="Get structured JSON responses"
+                info="Get structured JSON responses instead of regular text"
             )
         with gr.Column(scale=3):
             json_template = gr.Dropdown(
-                choices=["general", "questions"],
+                choices=["general", "questions", "analysis", "structured"],
                 value="general",
                 label="JSON Template",
+                info="Choose the type of JSON structure you want",
                 visible=False
             )
     
+    # Event handlers
     def respond(message, history, temp, json_enabled, json_type):
         return chat_with_model(message, history, temp, json_enabled, json_type)
     
     def toggle_json_template(json_enabled):
         return gr.update(visible=json_enabled)
     
+    # Connect JSON mode toggle to template visibility
     json_mode.change(toggle_json_template, inputs=[json_mode], outputs=[json_template])
     
     msg.submit(respond, [msg, chatbot, temperature, json_mode, json_template], [chatbot, msg])
     submit_btn.click(respond, [msg, chatbot, temperature, json_mode, json_template], [chatbot, msg])
     clear_btn.click(clear_chat, outputs=[chatbot, msg])
+    
+    # Add footer
+    gr.Markdown(
+        """
+        ---
+        <div style="text-align: center; color: #666; font-size: 0.9em;">
+            Built with ❤️ using Gradio and Llama-3.1-8B-Instruct • 
+            <a href="/docs" target="_blank">API Documentation</a> •
+            JSON Mode for structured outputs
+        </div>
+        """
+    )
 
 if __name__ == "__main__":
     demo.launch(
@@ -310,4 +418,4 @@ if __name__ == "__main__":
         server_port=7860,
         share=False,
         show_error=True
-    )
+    )

requirements.txt

@@ -1,14 +1,3 @@
-fastapi>=0.115.2
-uvicorn[standard]>=0.24.0
-pydantic>=2.5.0
-torch==2.5.0
-transformers>=4.35.0
-accelerate>=0.24.0
-bitsandbytes>=0.41.0
-# llama-cpp-python>=0.2.20  # Removed to avoid compilation issues
-huggingface-hub>=0.19.0
-python-multipart>=0.0.9
-numpy>=1.24.0
-sentencepiece>=0.1.99
-protobuf>=3.20.0
-gradio>=4.44.0
+requests>=2.31.0
+pathlib
+argparse

run_nfl_generator.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+NFL Training Data Generator - Interactive Runner
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+def main():
+    print("🏈 NFL Training Data Generator")
+    print("=" * 50)
+    print("Choose processing mode:")
+    print("1. Test with 10 random rules (recommended for first run)")
+    print("2. Process ALL rules in the file")
+    print("3. Custom number of rules")
+    print("4. Exit")
+    
+    while True:
+        choice = input("\nEnter your choice (1-4): ").strip()
+        
+        if choice == "1":
+            # 10 random rules
+            cmd = [
+                sys.executable,
+                "generate_nfl_training_data.py",
+                "sample_2024_nfl_rulebook.csv",
+                "--sample", "10",
+                "--output-dir", "output_10_random"
+            ]
+            print("🎯 Processing 10 random rules...")
+            break
+            
+        elif choice == "2":
+            # All rules
+            cmd = [
+                sys.executable,
+                "generate_nfl_training_data.py", 
+                "sample_2024_nfl_rulebook.csv",
+                "--output-dir", "output_full"
+            ]
+            print("🎯 Processing ALL rules...")
+            break
+            
+        elif choice == "3":
+            # Custom number
+            try:
+                num_rules = int(input("Enter number of random rules to process: "))
+                cmd = [
+                    sys.executable,
+                    "generate_nfl_training_data.py",
+                    "sample_2024_nfl_rulebook.csv", 
+                    "--sample", str(num_rules),
+                    "--output-dir", f"output_{num_rules}_random"
+                ]
+                print(f"🎯 Processing {num_rules} random rules...")
+                break
+            except ValueError:
+                print("❌ Please enter a valid number")
+                continue
+                
+        elif choice == "4":
+            print("👋 Goodbye!")
+            return 0
+            
+        else:
+            print("❌ Please enter 1, 2, 3, or 4")
+            continue
+    
+    # Run the command
+    try:
+        print(f"\n🚀 Running command: {' '.join(cmd)}")
+        print("-" * 50)
+        
+        result = subprocess.run(cmd, check=True)
+        
+        print("\n✅ Generation completed successfully!")
+        
+        # Show generated files
+        output_dir = Path(cmd[cmd.index("--output-dir") + 1])
+        if output_dir.exists():
+            files = list(output_dir.glob("*.jsonl"))
+            if files:
+                print(f"\n📁 Generated files:")
+                for file in files:
+                    print(f"  - {file}")
+                    
+                    # Show file size and line count
+                    with open(file, 'r') as f:
+                        lines = f.readlines()
+                        print(f"    📊 {len(lines)} training examples")
+                        
+                    # Show sample content
+                    if lines:
+                        print(f"    📝 Sample content:")
+                        sample_line = lines[0][:150] + "..." if len(lines[0]) > 150 else lines[0]
+                        print(f"    {sample_line}")
+        
+        return 0
+        
+    except subprocess.CalledProcessError as e:
+        print(f"\n❌ Generation failed with exit code {e.returncode}")
+        return 1
+    except KeyboardInterrupt:
+        print(f"\n⚠️ Generation interrupted by user")
+        return 1
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {e}")
+        return 1
+
+if __name__ == "__main__":
+    exit(main())

sample_2024_nfl_rulebook.csv

@@ -0,0 +1,11 @@
+rule_number,rule_text,section,category
+1.1,"The game is played by two teams of 11 players each on a rectangular field 120 yards long and 53⅓ yards wide with goal lines 100 yards apart.",Field and Equipment,Basic Game
+1.2,"The objective of the game is to advance the ball into the opponent's end zone by running or passing plays.",Field and Equipment,Basic Game
+2.1,"A down begins when the ball is put in play and ends when the ball becomes dead. A new down begins when the ball is next put in play.",Definitions,Downs
+2.2,"The offensive team has four consecutive downs to advance the ball 10 yards. If successful, they earn a new set of four downs.",Definitions,Downs
+3.1,"A forward pass is a pass thrown from behind or on the line of scrimmage toward the opponent's goal line.",Definitions,Passing
+3.2,"Only one forward pass is permitted during each play from scrimmage, and it must be thrown from behind the line of scrimmage.",Definitions,Passing
+4.1,"A fumble is the loss of player possession of the ball during a play from scrimmage.",Ball in Play,Fumbles
+4.2,"A muffed ball is the touching of a loose ball by a player in an unsuccessful attempt to secure possession.",Ball in Play,Fumbles
+5.1,"A player is out of bounds when any part of his person touches anything other than a player or an official on or outside a boundary line.",Players and Equipment,Boundaries
+5.2,"The ball is out of bounds when it touches a boundary line or anything on or outside such line.",Players and Equipment,Boundaries