Upload 9 files

src/.streamlit/config.toml

@@ -0,0 +1,11 @@
+[global]
+developmentMode = false
+
+[browser]
+gatherUsageStats = false
+
+[theme]
+primaryColor = "#FF6B6B"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730" 

src/DEPLOYMENT.md

@@ -0,0 +1,168 @@
+# 🚀 Deployment Guide: Hugging Face Spaces
+
+## Quick Start (5 minutes)
+
+### Step 1: Prepare Your Repository
+1. **Create a GitHub repository** with your project files
+2. **Upload all files** from this directory to your GitHub repo
+3. **Make sure you have**:
+   - `app.py` (main Streamlit app)
+   - `fine.py` (AI tutor implementation)
+   - `requirements.txt` (dependencies)
+   - `README.md` (documentation)
+
+### Step 2: Create Hugging Face Space
+1. **Go to** [huggingface.co/spaces](https://huggingface.co/spaces)
+2. **Click** "Create new Space"
+3. **Fill in the details**:
+   - **Owner**: Your HF username
+   - **Space name**: `ai-programming-tutor`
+   - **License**: Choose appropriate license
+   - **SDK**: Select **Streamlit**
+   - **Python version**: 3.10
+4. **Click** "Create Space"
+
+### Step 3: Connect Your Repository
+1. **In your Space settings**, go to "Repository" tab
+2. **Select** "GitHub repository"
+3. **Choose** your GitHub repository
+4. **Set the main file** to `app.py`
+5. **Click** "Save"
+
+### Step 4: Upload Your Fine-tuned Model
+1. **In your Space**, go to "Files" tab
+2. **Create a folder** called `model`
+3. **Upload your fine-tuned model files**:
+   - `model-00001-of-00006.safetensors`
+   - `model-00002-of-00006.safetensors`
+   - `model-00003-of-00006.safetensors`
+   - `model-00004-of-00006.safetensors`
+   - `model-00005-of-00006.safetensors`
+   - `model-00006-of-00006.safetensors`
+   - `config.json`
+   - `tokenizer.json`
+   - `tokenizer.model`
+   - `tokenizer_config.json`
+   - `special_tokens_map.json`
+   - `generation_config.json`
+
+### Step 5: Update Model Path
+1. **Edit** `app.py` in your Space
+2. **Change the model path** to:
+   ```python
+   model_path = "./model"  # Path to uploaded model
+   ```
+3. **Save** the changes
+
+### Step 6: Deploy
+1. **Your Space will automatically build** and deploy
+2. **Wait for the build to complete** (5-10 minutes)
+3. **Your app will be live** at: `https://huggingface.co/spaces/YOUR_USERNAME/ai-programming-tutor`
+
+## 🎯 Advanced Configuration
+
+### Hardware Settings
+- **CPU**: Default (sufficient for inference)
+- **GPU**: T4 (recommended for faster inference)
+- **Memory**: 16GB+ (required for 7B model)
+
+### Environment Variables
+Add these in your Space settings:
+```
+TOKENIZERS_PARALLELISM=false
+DATASETS_DISABLE_MULTIPROCESSING=1
+```
+
+### Custom Domain (Optional)
+1. **In Space settings**, go to "Settings" tab
+2. **Enable** "Custom domain"
+3. **Add your domain** (e.g., `tutor.yourdomain.com`)
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+**Issue**: Model not loading
+- **Solution**: Check model path and file structure
+- **Debug**: Look at Space logs in "Settings" → "Logs"
+
+**Issue**: Out of memory
+- **Solution**: Upgrade to GPU hardware
+- **Alternative**: Use demo mode
+
+**Issue**: Build fails
+- **Solution**: Check `requirements.txt` for missing dependencies
+- **Debug**: Review build logs
+
+### Performance Optimization
+
+1. **Enable GPU** in Space settings
+2. **Use model quantization** for faster inference
+3. **Implement caching** for repeated requests
+4. **Add rate limiting** to prevent abuse
+
+## 📊 Monitoring
+
+### Usage Analytics
+- **View usage** in Space settings
+- **Monitor performance** with built-in metrics
+- **Track user engagement** through logs
+
+### Cost Management
+- **Free tier**: 16 hours/month GPU time
+- **Pro tier**: $9/month for unlimited GPU
+- **Enterprise**: Custom pricing
+
+## 🌐 Sharing Your App
+
+### Public Access
+1. **Set Space to public** in settings
+2. **Share the URL** with users
+3. **Add to HF Spaces showcase**
+
+### Embedding
+```html
+<iframe
+  src="https://huggingface.co/spaces/YOUR_USERNAME/ai-programming-tutor"
+  width="100%"
+  height="800px"
+  frameborder="0"
+></iframe>
+```
+
+## 🔒 Security Considerations
+
+1. **Input validation** for code submissions
+2. **Rate limiting** to prevent abuse
+3. **Content filtering** for inappropriate code
+4. **User authentication** (optional)
+
+## 📈 Scaling
+
+### For High Traffic
+1. **Upgrade to Pro tier** for unlimited GPU
+2. **Implement caching** with Redis
+3. **Use load balancing** for multiple instances
+4. **Monitor performance** and optimize
+
+### For Production Use
+1. **Add user authentication**
+2. **Implement logging** and analytics
+3. **Set up monitoring** and alerts
+4. **Create backup** and recovery procedures
+
+## 🎉 Success!
+
+Your AI Programming Tutor is now live and accessible to students worldwide! 
+
+**Next steps**:
+1. **Test thoroughly** with different code examples
+2. **Gather user feedback** and iterate
+3. **Share with your target audience**
+4. **Monitor usage** and improve based on data
+
+## 📞 Support
+
+- **Hugging Face Docs**: [docs.huggingface.co](https://docs.huggingface.co)
+- **Spaces Documentation**: [huggingface.co/docs/hub/spaces](https://huggingface.co/docs/hub/spaces)
+- **Community Forum**: [discuss.huggingface.co](https://discuss.huggingface.co) 

src/HF_SPACES_DEPLOYMENT.md

@@ -0,0 +1,109 @@
+# 🚀 Hugging Face Spaces Deployment Guide
+
+## 📋 **Files for HF Spaces Deployment**
+
+### **Required Files:**
+- ✅ **`app.py`** - Main Streamlit app (shows detailed errors)
+- ✅ **`streamlit_app.py`** - Alternative full-featured app
+- ✅ **`fine.py`** - Fine-tuned model components
+- ✅ **`requirements.txt`** - Python dependencies
+- ✅ **`packages.txt`** - System dependencies
+- ✅ **`.streamlit/config.toml`** - Streamlit configuration
+
+## 🎯 **Deployment Steps**
+
+### **Step 1: Create HF Space**
+1. Go to https://huggingface.co/spaces
+2. Click "Create new Space"
+3. **Name**: `ai-programming-tutor`
+4. **SDK**: **Streamlit**
+5. **License**: MIT
+6. **Visibility**: Public or Private
+
+### **Step 2: Upload Files**
+
+#### **Option A: Connect GitHub (Recommended)**
+1. Click "Connect to GitHub"
+2. Select your repository: `TomoriFarouk/GenAI-For-Programming-Language`
+3. HF Spaces will automatically sync all files
+
+#### **Option B: Manual Upload**
+Upload these files to your Space:
+- `app.py` (main app)
+- `streamlit_app.py` (alternative)
+- `fine.py` (model components)
+- `requirements.txt`
+- `packages.txt`
+- `.streamlit/config.toml`
+
+### **Step 3: Choose Your App**
+
+#### **Use `app.py` (Recommended for HF Spaces)**
+- ✅ **Simple and reliable** - 34 lines
+- ✅ **Shows detailed errors** - no demo fallback
+- ✅ **Public model support** - no authentication needed
+- ✅ **Fast loading** - minimal dependencies
+
+#### **Use `streamlit_app.py` (Full Featured)**
+- ✅ **More features** - tabs, student levels
+- ✅ **Detailed error reporting** - step-by-step debugging
+- ✅ **Better UI** - comprehensive interface
+- ✅ **More complex** - 283 lines
+
+## 🔍 **Error Reporting Features**
+
+### **What You'll See:**
+- ✅ **Model status** in sidebar
+- ✅ **Step-by-step loading** progress
+- ✅ **Full error details** in code blocks
+- ✅ **No demo fallback** - shows actual errors
+- ✅ **Clear debugging info** - helps fix issues
+
+### **Common Error Messages:**
+- ❌ **"Fine-tuned model not available"** → Check `fine.py` import
+- ❌ **"Model loading failed"** → Check model path and files
+- ❌ **"Error generating feedback"** → Check model functionality
+
+## 🌐 **Public Model Setup**
+
+### **Make Your Model Public:**
+1. Go to: https://huggingface.co/FaroukTomori/codellama-7b-programming-education
+2. Click **"Settings"** tab
+3. Change **"Repository visibility"** to **Public**
+4. Click **"Save"**
+
+### **Benefits:**
+- ✅ **No authentication required**
+- ✅ **Works immediately**
+- ✅ **Easy to share**
+- ✅ **No token management**
+
+## 🧪 **Testing Your Deployment**
+
+### **After Deployment:**
+1. **Visit your Space URL**
+2. **Check model status** in sidebar
+3. **Enter some code** and click "Analyze"
+4. **Look for detailed error messages** if something fails
+
+### **Expected Results:**
+- ✅ **"Fine-tuned model available"**
+- ✅ **"Using public model - no authentication required"**
+- ✅ **AI-powered feedback** from your model
+
+## 💡 **Troubleshooting**
+
+### **If Model Doesn't Load:**
+1. **Check error messages** - they're now detailed
+2. **Verify model is public** on HF Model Hub
+3. **Check model path** matches your actual model
+4. **Look at import errors** in sidebar
+
+### **If App Doesn't Start:**
+1. **Check requirements.txt** - all dependencies included
+2. **Verify file structure** - all files uploaded
+3. **Check HF Spaces logs** - shows startup errors
+
+---
+
+**Status**: 🚀 Ready for HF Spaces deployment with detailed error reporting! 

src/README_HF_SPACES.md

@@ -0,0 +1,53 @@
+# AI Programming Tutor - Hugging Face Spaces Deployment
+
+## 🚀 Quick Start
+
+This is a simplified version of the AI Programming Tutor designed to work reliably on Hugging Face Spaces.
+
+### Files for Deployment:
+
+- **`app.py`** - Super simple version (20 lines) - **RECOMMENDED**
+- **`streamlit_app.py`** - Full featured version (109 lines)
+- **`requirements.txt`** - Only Streamlit dependency
+- **`.streamlit/config.toml`** - Minimal configuration
+
+### Deployment Steps:
+
+1. **Upload to Hugging Face Spaces**
+   - Create new Space
+   - Choose "Streamlit" as SDK
+   - Upload these files
+
+2. **Use `app.py` for guaranteed success**
+   - Only 20 lines of code
+   - No complex dependencies
+   - Works immediately
+
+3. **Alternative: Use `streamlit_app.py`**
+   - More features and better UI
+   - Tabbed interface
+   - Still minimal and reliable
+
+### Features:
+
+- ✅ **Code Analysis**: Enter Python code for feedback
+- ✅ **Strengths & Weaknesses**: Identify what's good and what needs improvement
+- ✅ **Step-by-Step Improvements**: Clear guidance on how to improve
+- ✅ **Learning Points**: Key concepts to understand
+- ✅ **Comprehension Questions**: Test your understanding
+- ✅ **Code Fixes**: See improved versions
+
+### Demo Mode:
+
+The app currently runs in demo mode, providing structured educational feedback without requiring the fine-tuned model. This ensures it works immediately on Hugging Face Spaces.
+
+### Future Enhancement:
+
+To add the fine-tuned model:
+1. Upload model to Hugging Face Model Hub
+2. Add HF_TOKEN to Spaces secrets
+3. Update the app to use the model
+
+---
+
+**Status**: ✅ Ready for deployment on Hugging Face Spaces 

src/config.py

@@ -0,0 +1,127 @@
+"""
+Configuration file for the Generative AI Programming Education project
+"""
+
+import os
+from pathlib import Path
+
+# Model Configuration
+MODEL_CONFIG = {
+    # Path to your fine-tuned CodeLlama-7B model
+    # Hugging Face Model Hub
+    "model_path": "TomoriFarouk/codellama-7b-programming-education",
+
+    # Model generation parameters
+    "max_new_tokens": 512,
+    "temperature": 0.7,
+    "do_sample": True,
+    "top_p": 0.9,
+    "top_k": 50,
+
+    # Input processing
+    "max_input_length": 2048,
+    "truncation": True,
+
+    # Device configuration
+    "device_map": "auto",
+    "torch_dtype": "float16",
+    "trust_remote_code": True
+}
+
+# Dataset Configuration (for reference)
+DATASET_CONFIG = {
+    "code_review_dataset": "path/to/your/code_review_dataset",
+    "code_feedback_dataset": "path/to/your/code_feedback_dataset",
+    "training_data_format": "json",  # or "csv", "txt"
+}
+
+# Educational Levels
+STUDENT_LEVELS = {
+    "beginner": {
+        "description": "Students new to programming",
+        "feedback_style": "explanatory",
+        "include_basics": True,
+        "complexity_threshold": "low"
+    },
+    "intermediate": {
+        "description": "Students with basic programming knowledge",
+        "feedback_style": "balanced",
+        "include_basics": False,
+        "complexity_threshold": "medium"
+    },
+    "advanced": {
+        "description": "Students with strong programming background",
+        "feedback_style": "technical",
+        "include_basics": False,
+        "complexity_threshold": "high"
+    }
+}
+
+# Feedback Types
+FEEDBACK_TYPES = [
+    "syntax",
+    "logic",
+    "optimization",
+    "style",
+    "explanation",
+    "comprehensive_review",
+    "educational_guidance"
+]
+
+# Learning Objectives
+LEARNING_OBJECTIVES = [
+    "syntax",
+    "basic_python",
+    "control_flow",
+    "loops",
+    "variables",
+    "code_cleanliness",
+    "algorithms",
+    "complexity",
+    "optimization",
+    "naming_conventions",
+    "readability",
+    "code_analysis",
+    "best_practices",
+    "learning",
+    "improvement"
+]
+
+# Logging Configuration
+LOGGING_CONFIG = {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "file": "programming_education_ai.log"
+}
+
+# Ethical Safeguards
+ETHICAL_CONFIG = {
+    "prevent_over_reliance": True,
+    "encourage_learning": True,
+    "provide_explanations": True,
+    "suggest_alternatives": True,
+    "promote_best_practices": True
+}
+
+
+def get_model_path():
+    """Get the model path from environment variable or config"""
+    return os.getenv("FINETUNED_MODEL_PATH", MODEL_CONFIG["model_path"])
+
+
+def validate_config():
+    """Validate the configuration settings"""
+    model_path = get_model_path()
+    if not os.path.exists(model_path):
+        print(f"Warning: Model path does not exist: {model_path}")
+        print("Please update the model_path in config.py or set FINETUNED_MODEL_PATH environment variable")
+        return False
+    return True
+
+
+if __name__ == "__main__":
+    print("Configuration loaded successfully!")
+    print(f"Model path: {get_model_path()}")
+    print(f"Student levels: {list(STUDENT_LEVELS.keys())}")
+    print(f"Feedback types: {FEEDBACK_TYPES}")
+    validate_config()

src/diagnostic_app.py

@@ -0,0 +1,169 @@
+"""
+Diagnostic App - Find out why the full model isn't working
+"""
+
+import streamlit as st
+import os
+import sys
+
+st.set_page_config(
+    page_title="Model Diagnostic",
+    page_icon="🔍",
+    layout="wide"
+)
+
+st.title("🔍 Model Diagnostic Tool")
+st.markdown("### Let's find out why your full model isn't working!")
+
+# Diagnostic section
+st.header("📊 System Diagnostics")
+
+# Check 1: Python environment
+st.subheader("1. Python Environment")
+st.write(f"**Python Version:** {sys.version}")
+st.write(f"**Working Directory:** {os.getcwd()}")
+
+# Check 2: Required packages
+st.subheader("2. Required Packages")
+try:
+    import streamlit
+    st.success(f"✅ Streamlit: {streamlit.__version__}")
+except ImportError as e:
+    st.error(f"❌ Streamlit: {e}")
+
+try:
+    import torch
+    st.success(f"✅ PyTorch: {torch.__version__}")
+except ImportError as e:
+    st.error(f"❌ PyTorch: {e}")
+
+try:
+    import transformers
+    st.success(f"✅ Transformers: {transformers.__version__}")
+except ImportError as e:
+    st.error(f"❌ Transformers: {e}")
+
+try:
+    import accelerate
+    st.success(f"✅ Accelerate: {accelerate.__version__}")
+except ImportError as e:
+    st.error(f"❌ Accelerate: {e}")
+
+# Check 3: Fine-tuned model components
+st.subheader("3. Fine-tuned Model Components")
+try:
+    from fine import ProgrammingEducationAI, ComprehensiveFeedback
+    st.success("✅ Fine-tuned model components imported successfully")
+    MODEL_AVAILABLE = True
+except Exception as e:
+    st.error(f"❌ Fine-tuned model components failed: {e}")
+    MODEL_AVAILABLE = False
+
+# Check 4: Environment variables
+st.subheader("4. Environment Variables")
+HF_TOKEN = None  # Using public model
+st.success("✅ Using public model - no HF_TOKEN required")
+st.info("💡 Public models don't need authentication tokens")
+
+# Check 5: Model path
+st.subheader("5. Model Path Configuration")
+model_path = "FaroukTomori/codellama-7b-programming-education"
+st.write(f"**Current model path:** {model_path}")
+st.info("💡 Make sure this matches your actual model name on Hugging Face")
+
+# Check 6: File structure
+st.subheader("6. File Structure")
+current_dir = os.getcwd()
+st.write(f"**Current directory:** {current_dir}")
+
+files = os.listdir(current_dir)
+st.write("**Files in current directory:**")
+for file in files:
+    if file.endswith('.py'):
+        st.write(f"  📄 {file}")
+
+# Check 7: Fine.py file
+st.subheader("7. Fine.py File Analysis")
+fine_path = os.path.join(current_dir, "fine.py")
+if os.path.exists(fine_path):
+    st.success("✅ fine.py exists")
+    file_size = os.path.getsize(fine_path)
+    st.write(f"**File size:** {file_size:,} bytes")
+
+    # Check if it has the required classes
+    try:
+        with open(fine_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            if "class ProgrammingEducationAI" in content:
+                st.success("✅ ProgrammingEducationAI class found")
+            else:
+                st.error("❌ ProgrammingEducationAI class not found")
+
+            if "class ComprehensiveFeedback" in content:
+                st.success("✅ ComprehensiveFeedback class found")
+            else:
+                st.error("❌ ComprehensiveFeedback class not found")
+    except Exception as e:
+        st.error(f"❌ Error reading fine.py: {e}")
+else:
+    st.error("❌ fine.py not found")
+
+# Check 8: Model files
+st.subheader("8. Model Files")
+models_dir = os.path.join(current_dir, "models")
+if os.path.exists(models_dir):
+    st.success("✅ models directory exists")
+    model_files = os.listdir(models_dir)
+    st.write("**Model files:**")
+    for file in model_files:
+        st.write(f"  📁 {file}")
+else:
+    st.warning("⚠️ models directory not found")
+
+# Summary and recommendations
+st.header("🎯 Summary & Recommendations")
+
+if MODEL_AVAILABLE:
+    st.success("🎉 Everything looks good! Your public model should work.")
+    st.info("💡 Try using the full app now.")
+else:
+    st.error("❌ Fine-tuned model components are not available")
+    st.markdown("""
+    **Possible causes:**
+    1. `fine.py` file is missing or corrupted
+    2. Required dependencies are not installed
+    3. Import error in `fine.py`
+    
+    **Solutions:**
+    1. Make sure `fine.py` exists and is complete
+    2. Install missing dependencies: `pip install torch transformers accelerate`
+    3. Check for syntax errors in `fine.py`
+    """)
+
+# Test model loading
+st.header("🧪 Test Model Loading")
+
+if st.button("🚀 Test Model Loading"):
+    if MODEL_AVAILABLE:
+        with st.spinner("Testing model loading..."):
+            try:
+                model_path = "FaroukTomori/codellama-7b-programming-education"
+                ai_tutor = ProgrammingEducationAI(model_path)
+                st.success("✅ Model class instantiated successfully")
+
+                # Try to load the model
+                try:
+                    ai_tutor.load_model()
+                    st.success("✅ Model loaded successfully!")
+                except Exception as e:
+                    st.error(f"❌ Model loading failed: {e}")
+                    st.info(
+                        "💡 This usually means the model isn't uploaded to HF Model Hub yet")
+
+            except Exception as e:
+                st.error(f"❌ Model instantiation failed: {e}")
+    else:
+        st.error("❌ Cannot test - model components not available")
+
+st.markdown("---")
+st.info("💡 **Next Steps:** Fix the issues above, then try the main app again!")

src/example_usage.py

@@ -0,0 +1,186 @@
+"""
+Example Usage of the Comprehensive Educational Feedback System
+"""
+
+from fine import ProgrammingEducationAI
+import json
+
+
+def main():
+    print("🎓 Comprehensive Educational Feedback System")
+    print("=" * 60)
+
+    # Initialize the system
+    # Update this path to your actual fine-tuned model
+    model_path = r"C:\Users\farou\OneDrive - Aston University\finetunning"
+    ai_tutor = ProgrammingEducationAI(model_path)
+
+    try:
+        # Load the model
+        print("Loading fine-tuned model...")
+        ai_tutor.load_model()
+        print("✅ Model loaded successfully!")
+
+        # Example 1: Beginner student code
+        print("\n" + "="*60)
+        print("EXAMPLE 1: BEGINNER STUDENT")
+        print("="*60)
+
+        beginner_code = """
+def find_duplicates(numbers):
+    x = []
+    for i in range(len(numbers)):
+        for j in range(i+1, len(numbers)):
+            if numbers[i] == numbers[j]:
+                x.append(numbers[i])
+    return x
+
+result = find_duplicates([1, 2, 3, 2, 4, 5, 3])
+print(result)
+"""
+
+        print("Student Code:")
+        print(beginner_code)
+
+        feedback = ai_tutor.generate_comprehensive_feedback(
+            beginner_code, "beginner")
+        display_comprehensive_feedback(feedback)
+
+        # Example 2: Intermediate student code
+        print("\n" + "="*60)
+        print("EXAMPLE 2: INTERMEDIATE STUDENT")
+        print("="*60)
+
+        intermediate_code = """
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n-1) + fibonacci(n-2)
+
+# Calculate first 10 Fibonacci numbers
+for i in range(10):
+    print(fibonacci(i))
+"""
+
+        print("Student Code:")
+        print(intermediate_code)
+
+        feedback = ai_tutor.generate_comprehensive_feedback(
+            intermediate_code, "intermediate")
+        display_comprehensive_feedback(feedback)
+
+        # Example 3: Advanced student code
+        print("\n" + "="*60)
+        print("EXAMPLE 3: ADVANCED STUDENT")
+        print("="*60)
+
+        advanced_code = """
+class DataProcessor:
+    def __init__(self, data):
+        self.data = data
+    
+    def process(self):
+        result = []
+        for item in self.data:
+            if item > 0:
+                result.append(item * 2)
+        return result
+
+processor = DataProcessor([1, -2, 3, -4, 5])
+output = processor.process()
+print(output)
+"""
+
+        print("Student Code:")
+        print(advanced_code)
+
+        feedback = ai_tutor.generate_comprehensive_feedback(
+            advanced_code, "advanced")
+        display_comprehensive_feedback(feedback)
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        print(
+            "💡 Make sure to update the model_path to point to your actual fine-tuned model.")
+
+
+def display_comprehensive_feedback(feedback):
+    """Display comprehensive feedback in a formatted way"""
+
+    print("\n📊 COMPREHENSIVE FEEDBACK")
+    print("-" * 40)
+
+    # Analysis
+    print("\n✅ STRENGTHS:")
+    for i, strength in enumerate(feedback.strengths, 1):
+        print(f"   {i}. {strength}")
+
+    print("\n❌ WEAKNESSES:")
+    for i, weakness in enumerate(feedback.weaknesses, 1):
+        print(f"   {i}. {weakness}")
+
+    print("\n⚠️ ISSUES:")
+    for i, issue in enumerate(feedback.issues, 1):
+        print(f"   {i}. {issue}")
+
+    # Educational content
+    print("\n📝 STEP-BY-STEP IMPROVEMENT:")
+    for i, step in enumerate(feedback.step_by_step_improvement, 1):
+        print(f"   Step {i}: {step}")
+
+    print("\n🎓 LEARNING POINTS:")
+    for i, point in enumerate(feedback.learning_points, 1):
+        print(f"   {i}. {point}")
+
+    print(f"\n📋 REVIEW SUMMARY:")
+    print(f"   {feedback.review_summary}")
+
+    # Interactive elements
+    print(f"\n❓ COMPREHENSION QUESTION:")
+    print(f"   Q: {feedback.comprehension_question}")
+    print(f"   A: {feedback.comprehension_answer}")
+    print(f"   Explanation: {feedback.explanation}")
+
+    # Code fixes
+    print(f"\n🔧 IMPROVED CODE:")
+    print(feedback.improved_code)
+
+    print(f"\n💡 FIX EXPLANATION:")
+    print(f"   {feedback.fix_explanation}")
+
+    # Metadata
+    print(f"\n📊 METADATA:")
+    print(f"   Student Level: {feedback.student_level}")
+    print(f"   Learning Objectives: {', '.join(feedback.learning_objectives)}")
+    print(
+        f"   Estimated Time to Improve: {feedback.estimated_time_to_improve}")
+
+
+def save_feedback_to_json(feedback, filename):
+    """Save feedback to JSON file for later analysis"""
+    feedback_dict = {
+        "code_snippet": feedback.code_snippet,
+        "student_level": feedback.student_level,
+        "strengths": feedback.strengths,
+        "weaknesses": feedback.weaknesses,
+        "issues": feedback.issues,
+        "step_by_step_improvement": feedback.step_by_step_improvement,
+        "learning_points": feedback.learning_points,
+        "review_summary": feedback.review_summary,
+        "comprehension_question": feedback.comprehension_question,
+        "comprehension_answer": feedback.comprehension_answer,
+        "explanation": feedback.explanation,
+        "improved_code": feedback.improved_code,
+        "fix_explanation": feedback.fix_explanation,
+        "learning_objectives": feedback.learning_objectives,
+        "estimated_time_to_improve": feedback.estimated_time_to_improve
+    }
+
+    with open(filename, 'w') as f:
+        json.dump(feedback_dict, f, indent=2)
+
+    print(f"💾 Feedback saved to {filename}")
+
+
+if __name__ == "__main__":
+    main()

src/fine.py

@@ -0,0 +1,949 @@
+"""
+Generative AI for Enhancing Programming Education
+================================================
+
+This project implements a fine-tuned CodeLlama-7B model to provide structured,
+educational code feedback for programming students.
+
+Problem Statement:
+- High dropout rates in programming education
+- Inefficient feedback loops
+- Lack of personalized learning
+- Limited instructor bandwidth
+- Current AI tools prioritize productivity over learning
+
+Solution:
+- Fine-tuned CodeLlama-7B for educational feedback
+- Structured, actionable code reviews
+- Beginner-friendly explanations
+- Personalized adaptation based on skill level
+- Educational focus with ethical safeguards
+
+Author: [Your Name]
+Date: [Current Date]
+"""
+
+import re
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+import logging
+import json
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import os
+import gc
+import torch
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+# --- Critical Environment Setup (Must be before imports) ---
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["DATASETS_DISABLE_MULTIPROCESSING"] = "1"
+
+# Clear any existing CUDA cache (only if CUDA is available)
+if torch.cuda.is_available():
+    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128,garbage_collection_threshold:0.6"
+    torch.cuda.empty_cache()
+    gc.collect()
+
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def clear_cuda_cache():
+    """Clear CUDA cache and run garbage collection"""
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()
+    gc.collect()
+
+
+def get_system_memory():
+    """Get system memory information"""
+    try:
+        import psutil
+        memory = psutil.virtual_memory()
+        print(
+            f"System RAM: {memory.used / (1024**3):.1f}GB / {memory.total / (1024**3):.1f}GB used ({memory.percent:.1f}%)")
+    except Exception as e:
+        print(f"Could not get system memory info: {e}")
+
+
+def get_gpu_memory():
+    """Get GPU memory information (if available)"""
+    if torch.cuda.is_available():
+        try:
+            import subprocess
+            result = subprocess.run(['nvidia-smi', '--query-gpu=memory.used,memory.total', '--format=csv,nounits,noheader'],
+                                    capture_output=True, text=True)
+            lines = result.stdout.strip().split('\n')
+            for i, line in enumerate(lines):
+                used, total = map(int, line.split(', '))
+                print(
+                    f"GPU {i}: {used}MB / {total}MB used ({used/total*100:.1f}%)")
+        except Exception as e:
+            print(f"Could not get GPU memory info: {e}")
+    else:
+        print("No GPU available - using CPU only")
+
+
+@dataclass
+class CodeFeedback:
+    """Data structure for storing code feedback"""
+    code_snippet: str
+    feedback_type: str  # 'syntax', 'logic', 'optimization', 'style', 'explanation'
+    feedback_message: str
+    suggested_improvement: Optional[str] = None
+    difficulty_level: str = 'beginner'  # 'beginner', 'intermediate', 'advanced'
+    learning_objectives: List[str] = None
+
+
+@dataclass
+class ComprehensiveFeedback:
+    """Comprehensive feedback structure with all educational components"""
+    code_snippet: str
+    student_level: str
+
+    # Analysis
+    strengths: List[str]
+    weaknesses: List[str]
+    issues: List[str]
+
+    # Educational content
+    step_by_step_improvement: List[str]
+    learning_points: List[str]
+    review_summary: str
+
+    # Interactive elements
+    comprehension_question: str
+    comprehension_answer: str
+    explanation: str
+
+    # Code fixes
+    improved_code: str
+    fix_explanation: str
+
+    # Metadata
+    difficulty_level: str
+    learning_objectives: List[str]
+    estimated_time_to_improve: str
+
+
+class ProgrammingEducationAI:
+    """
+    Main class for the fine-tuned CodeLlama model for programming education
+    """
+
+    def __init__(self, model_path: str = "TomoriFarouk/codellama-7b-programming-education"):
+        """
+        Initialize the fine-tuned model and tokenizer
+
+        Args:
+            model_path: Path to your fine-tuned CodeLlama-7B model
+        """
+        self.model_path = model_path
+        self.tokenizer = None
+        self.model = None
+        self.feedback_templates = self._load_feedback_templates()
+        self.code_review_prompt_template = self._load_code_review_prompt()
+        self.code_feedback_prompt_template = self._load_code_feedback_prompt()
+        self.comprehensive_feedback_prompt = self._load_comprehensive_feedback_prompt()
+        self.comprehension_question_prompt = self._load_comprehension_question_prompt()
+        self.code_fix_prompt = self._load_code_fix_prompt()
+
+    def _load_code_review_prompt(self) -> str:
+        """Load the code review prompt template used during fine-tuning"""
+        return """You are an expert programming tutor. Review the following student code and provide educational feedback.
+
+Student Code:
+{code}
+
+Student Level: {level}
+
+Please provide:
+1. Syntax errors (if any)
+2. Logic errors (if any)
+3. Style improvements
+4. Optimization suggestions
+5. Educational explanations
+
+Feedback:"""
+
+    def _load_code_feedback_prompt(self) -> str:
+        """Load the code feedback prompt template used during fine-tuning"""
+        return """You are a helpful programming tutor. The student has written this code:
+
+{code}
+
+Student Level: {level}
+
+Provide constructive, educational feedback that helps the student learn. Focus on:
+- What they did well
+- What can be improved
+- Why the improvement matters
+- How to implement the improvement
+
+Feedback:"""
+
+    def _load_feedback_templates(self) -> Dict[str, str]:
+        """Load predefined feedback templates for different scenarios"""
+        return {
+            "syntax_error": "I notice there's a syntax issue in your code. {error_description}. "
+            "Here's what's happening: {explanation}. "
+            "Try this correction: {suggestion}",
+
+            "logic_error": "Your code has a logical issue. {problem_description}. "
+            "The problem is: {explanation}. "
+            "Consider this approach: {suggestion}",
+
+            "optimization": "Your code works, but we can make it more efficient! "
+                           "Current complexity: {current_complexity}. "
+                           "Optimized version: {optimized_complexity}. "
+                           "Here's how: {explanation}",
+
+            "style_improvement": "Great work! Here's a style tip: {tip}. "
+            "This makes your code more readable and maintainable.",
+
+            "concept_explanation": "Let me explain this concept: {concept}. "
+            "In simple terms: {simple_explanation}. "
+            "Example: {example}"
+        }
+
+    def load_model(self):
+        """
+        Load the fine-tuned model and tokenizer optimized for HF Spaces
+        """
+        try:
+            # Get HF token for private model access
+            hf_token = os.getenv("HF_TOKEN", None)
+
+            logger.info("Loading tokenizer...")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_path,
+                trust_remote_code=True,
+                token=hf_token  # Use token for private models
+            )
+
+            # Set padding token
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+                self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
+
+            logger.info(
+                f"Tokenizer loaded - Vocab size: {len(self.tokenizer)}")
+
+            # Load model optimized for HF Spaces (16GB RAM, 2 vCPU)
+            print("Loading model optimized for HF Spaces (16GB RAM, 2 vCPU)...")
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_path,
+                torch_dtype=torch.float32,
+                device_map=None,  # Force CPU for HF Spaces
+                low_cpu_mem_usage=True,
+                trust_remote_code=True,
+                offload_folder="offload",  # Offload to disk if needed
+                token=hf_token  # Use token for private models
+            )
+            # Enable gradient checkpointing for memory savings
+            self.model.gradient_checkpointing_enable()
+
+            logger.info("Fine-tuned model loaded successfully")
+            logger.info(f"Model loaded on devices: {self.model.hf_device_map}")
+
+        except Exception as e:
+            logger.error(f"Error loading fine-tuned model: {e}")
+            raise
+
+    def generate_code_review(self, code: str, student_level: str = "beginner") -> str:
+        """
+        Generate code review using the fine-tuned model
+
+        Args:
+            code: Student's code to review
+            student_level: Student's skill level
+
+        Returns:
+            Generated code review feedback
+        """
+        if not self.model or not self.tokenizer:
+            raise ValueError("Model not loaded. Call load_model() first.")
+
+        # Format the prompt using the template from fine-tuning
+        prompt = self.code_review_prompt_template.format(
+            code=code,
+            level=student_level
+        )
+
+        # Tokenize input
+        inputs = self.tokenizer(
+            prompt, return_tensors="pt", truncation=True, max_length=2048)
+
+        # Generate response
+        with torch.no_grad():
+            outputs = self.model.generate(
+                inputs.input_ids,
+                max_new_tokens=512,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+
+        # Decode response
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        # Extract only the generated part (after the prompt)
+        generated_text = response[len(prompt):].strip()
+
+        return generated_text
+
+    def generate_educational_feedback(self, code: str, student_level: str = "beginner") -> str:
+        """
+        Generate educational feedback using the fine-tuned model
+
+        Args:
+            code: Student's code to provide feedback on
+            student_level: Student's skill level
+
+        Returns:
+            Generated educational feedback
+        """
+        if not self.model or not self.tokenizer:
+            raise ValueError("Model not loaded. Call load_model() first.")
+
+        # Format the prompt using the template from fine-tuning
+        prompt = self.code_feedback_prompt_template.format(
+            code=code,
+            level=student_level
+        )
+
+        # Tokenize input
+        inputs = self.tokenizer(
+            prompt, return_tensors="pt", truncation=True, max_length=2048)
+
+        # Generate response
+        with torch.no_grad():
+            outputs = self.model.generate(
+                inputs.input_ids,
+                max_new_tokens=512,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+
+        # Decode response
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        # Extract only the generated part (after the prompt)
+        generated_text = response[len(prompt):].strip()
+
+        return generated_text
+
+    def analyze_student_code(self, code: str, student_level: str = "beginner") -> List[CodeFeedback]:
+        """
+        Analyze student code and provide educational feedback using the fine-tuned model
+
+        Args:
+            code: The student's code to analyze
+            student_level: Student's skill level ('beginner', 'intermediate', 'advanced')
+
+        Returns:
+            List of CodeFeedback objects
+        """
+        feedback_list = []
+
+        # Use fine-tuned model for comprehensive code review
+        try:
+            code_review = self.generate_code_review(code, student_level)
+            educational_feedback = self.generate_educational_feedback(
+                code, student_level)
+
+            # Create structured feedback from model output
+            feedback_list.append(CodeFeedback(
+                code_snippet=code,
+                feedback_type="comprehensive_review",
+                feedback_message=code_review,
+                difficulty_level=student_level,
+                learning_objectives=["code_analysis", "best_practices"]
+            ))
+
+            feedback_list.append(CodeFeedback(
+                code_snippet=code,
+                feedback_type="educational_guidance",
+                feedback_message=educational_feedback,
+                difficulty_level=student_level,
+                learning_objectives=["learning", "improvement"]
+            ))
+
+        except Exception as e:
+            logger.warning(
+                f"Fine-tuned model failed, falling back to rule-based analysis: {e}")
+            # Fallback to rule-based analysis if model fails
+            feedback_list = self._fallback_analysis(code, student_level)
+
+        return feedback_list
+
+    def _fallback_analysis(self, code: str, student_level: str) -> List[CodeFeedback]:
+        """Fallback analysis using rule-based methods if fine-tuned model fails"""
+        feedback_list = []
+
+        # Analyze syntax
+        syntax_feedback = self._check_syntax(code, student_level)
+        if syntax_feedback:
+            feedback_list.append(syntax_feedback)
+
+        # Analyze logic and structure
+        logic_feedback = self._check_logic(code, student_level)
+        if logic_feedback:
+            feedback_list.extend(logic_feedback)
+
+        # Check for optimization opportunities
+        optimization_feedback = self._check_optimization(code, student_level)
+        if optimization_feedback:
+            feedback_list.append(optimization_feedback)
+
+        # Provide style suggestions
+        style_feedback = self._check_style(code, student_level)
+        if style_feedback:
+            feedback_list.append(style_feedback)
+
+        return feedback_list
+
+    def _check_syntax(self, code: str, student_level: str) -> Optional[CodeFeedback]:
+        """Check for syntax errors and provide educational feedback"""
+        # This would integrate with the fine-tuned model
+        # For now, using basic pattern matching as placeholder
+
+        common_syntax_errors = {
+            r"print\s*\([^)]*\)\s*$": "Remember to add a colon after print statements in some contexts",
+            r"if\s+[^:]+$": "Don't forget the colon after your if condition",
+            r"for\s+[^:]+$": "Don't forget the colon after your for loop",
+        }
+
+        for pattern, message in common_syntax_errors.items():
+            if re.search(pattern, code):
+                return CodeFeedback(
+                    code_snippet=code,
+                    feedback_type="syntax",
+                    feedback_message=message,
+                    difficulty_level=student_level,
+                    learning_objectives=["syntax", "basic_python"]
+                )
+
+        return None
+
+    def _check_logic(self, code: str, student_level: str) -> List[CodeFeedback]:
+        """Check for logical errors and provide educational feedback"""
+        feedback_list = []
+
+        # Check for infinite loops
+        if "while True:" in code and "break" not in code:
+            feedback_list.append(CodeFeedback(
+                code_snippet=code,
+                feedback_type="logic",
+                feedback_message="This while loop will run forever! Make sure to include a break statement or condition to exit the loop.",
+                difficulty_level=student_level,
+                learning_objectives=["control_flow", "loops"]
+            ))
+
+        # Check for unused variables
+        # This is a simplified check - the actual model would be more sophisticated
+        if "x = " in code and "x" not in code.replace("x = ", ""):
+            feedback_list.append(CodeFeedback(
+                code_snippet=code,
+                feedback_type="logic",
+                feedback_message="You created variable 'x' but didn't use it. Consider removing unused variables to keep your code clean.",
+                difficulty_level=student_level,
+                learning_objectives=["variables", "code_cleanliness"]
+            ))
+
+        return feedback_list
+
+    def _check_optimization(self, code: str, student_level: str) -> Optional[CodeFeedback]:
+        """Check for optimization opportunities"""
+        # Check for nested loops that could be optimized
+        if code.count("for") > 1 and code.count("in range") > 1:
+            return CodeFeedback(
+                code_snippet=code,
+                feedback_type="optimization",
+                feedback_message="You have nested loops here. Consider if you can optimize this to O(n) instead of O(n²).",
+                suggested_improvement="Use a hashmap or set to reduce complexity",
+                difficulty_level=student_level,
+                learning_objectives=["algorithms",
+                                     "complexity", "optimization"]
+            )
+
+        return None
+
+    def _check_style(self, code: str, student_level: str) -> Optional[CodeFeedback]:
+        """Check for style improvements"""
+        # Check for meaningful variable names
+        if "x" in code or "y" in code or "z" in code:
+            return CodeFeedback(
+                code_snippet=code,
+                feedback_type="style",
+                feedback_message="Consider using more descriptive variable names instead of x, y, z. This makes your code easier to understand.",
+                difficulty_level=student_level,
+                learning_objectives=["naming_conventions", "readability"]
+            )
+
+        return None
+
+    def generate_explanation(self, concept: str, student_level: str) -> str:
+        """
+        Generate explanations for programming concepts based on student level
+
+        Args:
+            concept: The concept to explain
+            student_level: Student's skill level
+
+        Returns:
+            Explanation tailored to the student's level
+        """
+        explanations = {
+            "variables": {
+                "beginner": "Variables are like labeled boxes where you store information. Think of 'name = \"John\"' as putting \"John\" in a box labeled 'name'.",
+                "intermediate": "Variables are memory locations that store data. They have a name, type, and value. Python is dynamically typed, so the type is inferred.",
+                "advanced": "Variables in Python are references to objects in memory. They're dynamically typed and use reference counting for memory management."
+            },
+            "loops": {
+                "beginner": "Loops repeat code multiple times. 'for' loops are great when you know how many times to repeat, 'while' loops when you don't.",
+                "intermediate": "Loops control program flow. 'for' iterates over sequences, 'while' continues until a condition is False. Consider time complexity.",
+                "advanced": "Loops are fundamental control structures. Python's 'for' is actually a foreach loop. Consider iterator patterns and generator expressions."
+            }
+        }
+
+        return explanations.get(concept, {}).get(student_level, f"Explanation for {concept} at {student_level} level")
+
+    def _load_comprehensive_feedback_prompt(self) -> str:
+        """Load the comprehensive feedback prompt template"""
+        return """You are an expert programming tutor. Provide comprehensive educational feedback for the following student code.
+
+Student Code:
+{code}
+
+Student Level: {level}
+
+Please provide a detailed analysis in the following JSON format:
+
+{{
+    "strengths": ["strength1", "strength2", "strength3"],
+    "weaknesses": ["weakness1", "weakness2", "weakness3"],
+    "issues": ["issue1", "issue2", "issue3"],
+    "step_by_step_improvement": [
+        "Step 1: Description of first improvement",
+        "Step 2: Description of second improvement",
+        "Step 3: Description of third improvement"
+    ],
+    "learning_points": [
+        "Learning point 1: What the student should understand",
+        "Learning point 2: Key concept to grasp",
+        "Learning point 3: Best practice to follow"
+    ],
+    "review_summary": "A comprehensive review of the code highlighting key areas for improvement",
+    "learning_objectives": ["objective1", "objective2", "objective3"],
+    "estimated_time_to_improve": "5-10 minutes"
+}}
+
+Focus on educational value and constructive feedback that helps the student learn and improve."""
+
+    def _load_comprehension_question_prompt(self) -> str:
+        """Load the comprehension question generation prompt"""
+        return """Based on the learning points and improvements discussed, generate a comprehension question to test the student's understanding.
+
+Learning Points: {learning_points}
+Code Issues: {issues}
+Student Level: {level}
+
+Generate a question that tests understanding of the key concepts discussed. The question should be appropriate for the student's level.
+
+Format your response as JSON:
+{{
+    "question": "Your comprehension question here",
+    "answer": "The correct answer",
+    "explanation": "Detailed explanation of why this answer is correct"
+}}
+
+Make the question challenging but fair for the student's level."""
+
+    def _load_code_fix_prompt(self) -> str:
+        """Load the code fix generation prompt"""
+        return """You are an expert programming tutor. Based on the analysis and learning points, provide an improved version of the student's code.
+
+Original Code:
+{code}
+
+Issues Identified: {issues}
+Learning Points: {learning_points}
+Student Level: {level}
+
+Provide an improved version of the code that addresses the issues while maintaining educational value. Include comments to explain the improvements.
+
+Format your response as JSON:
+{{
+    "improved_code": "The improved code with comments",
+    "fix_explanation": "Detailed explanation of what was changed and why"
+}}
+
+Focus on educational improvements that help the student understand better practices."""
+
+    def adapt_feedback_complexity(self, feedback: CodeFeedback, student_level: str) -> CodeFeedback:
+        """
+        Adapt feedback complexity based on student level
+
+        Args:
+            feedback: Original feedback
+            student_level: Student's skill level
+
+        Returns:
+            Adapted feedback
+        """
+        if student_level == "beginner":
+            # Simplify language and add more examples
+            feedback.feedback_message = feedback.feedback_message.replace(
+                "O(n²)", "quadratic time (slower)"
+            ).replace(
+                "O(n)", "linear time (faster)"
+            )
+        elif student_level == "advanced":
+            # Add more technical details
+            if "optimization" in feedback.feedback_type:
+                feedback.feedback_message += " Consider the space-time tradeoff and cache locality."
+
+        return feedback
+
+    def generate_comprehensive_feedback(self, code: str, student_level: str = "beginner") -> ComprehensiveFeedback:
+        """
+        Generate comprehensive educational feedback with all components
+
+        Args:
+            code: Student's code to analyze
+            student_level: Student's skill level
+
+        Returns:
+            ComprehensiveFeedback object with all educational components
+        """
+        if not self.model or not self.tokenizer:
+            raise ValueError("Model not loaded. Call load_model() first.")
+
+        try:
+            # Step 1: Generate comprehensive analysis
+            comprehensive_analysis = self._generate_comprehensive_analysis(
+                code, student_level)
+
+            # Step 2: Generate comprehension question
+            comprehension_data = self._generate_comprehension_question(
+                comprehensive_analysis["learning_points"],
+                comprehensive_analysis["issues"],
+                student_level
+            )
+
+            # Step 3: Generate improved code
+            code_fix_data = self._generate_code_fix(
+                code,
+                comprehensive_analysis["issues"],
+                comprehensive_analysis["learning_points"],
+                student_level
+            )
+
+            # Create comprehensive feedback object
+            return ComprehensiveFeedback(
+                code_snippet=code,
+                student_level=student_level,
+                strengths=comprehensive_analysis["strengths"],
+                weaknesses=comprehensive_analysis["weaknesses"],
+                issues=comprehensive_analysis["issues"],
+                step_by_step_improvement=comprehensive_analysis["step_by_step_improvement"],
+                learning_points=comprehensive_analysis["learning_points"],
+                review_summary=comprehensive_analysis["review_summary"],
+                comprehension_question=comprehension_data["question"],
+                comprehension_answer=comprehension_data["answer"],
+                explanation=comprehension_data["explanation"],
+                improved_code=code_fix_data["improved_code"],
+                fix_explanation=code_fix_data["fix_explanation"],
+                difficulty_level=student_level,
+                learning_objectives=comprehensive_analysis["learning_objectives"],
+                estimated_time_to_improve=comprehensive_analysis["estimated_time_to_improve"]
+            )
+
+        except Exception as e:
+            logger.error(f"Error generating comprehensive feedback: {e}")
+            # Return a basic comprehensive feedback if model fails
+            return self._create_fallback_comprehensive_feedback(code, student_level)
+
+    def _generate_comprehensive_analysis(self, code: str, student_level: str) -> Dict:
+        """Generate comprehensive analysis using the fine-tuned model"""
+        prompt = self.comprehensive_feedback_prompt.format(
+            code=code,
+            level=student_level
+        )
+
+        response = self._generate_model_response(prompt)
+
+        try:
+            # Try to parse JSON response
+            import json
+            return json.loads(response)
+        except json.JSONDecodeError:
+            logger.warning("Failed to parse JSON response, using fallback")
+            return self._create_fallback_analysis(code, student_level)
+
+    def _generate_comprehension_question(self, learning_points: List[str], issues: List[str], student_level: str) -> Dict:
+        """Generate comprehension question using the fine-tuned model"""
+        prompt = self.comprehension_question_prompt.format(
+            learning_points=", ".join(learning_points),
+            issues=", ".join(issues),
+            level=student_level
+        )
+
+        response = self._generate_model_response(prompt)
+
+        try:
+            import json
+            return json.loads(response)
+        except json.JSONDecodeError:
+            logger.warning(
+                "Failed to parse comprehension question JSON, using fallback")
+            return {
+                "question": "What is the main concept you learned from this code review?",
+                "answer": "The main concept is understanding code structure and best practices.",
+                "explanation": "This question tests your understanding of the key learning points discussed."
+            }
+
+    def _generate_code_fix(self, code: str, issues: List[str], learning_points: List[str], student_level: str) -> Dict:
+        """Generate improved code using the fine-tuned model"""
+        prompt = self.code_fix_prompt.format(
+            code=code,
+            issues=", ".join(issues),
+            learning_points=", ".join(learning_points),
+            level=student_level
+        )
+
+        response = self._generate_model_response(prompt)
+
+        try:
+            import json
+            return json.loads(response)
+        except json.JSONDecodeError:
+            logger.warning("Failed to parse code fix JSON, using fallback")
+            return {
+                "improved_code": "# Improved version of your code\n# Add comments and improvements here",
+                "fix_explanation": "This is a fallback improved version. The model should provide specific improvements."
+            }
+
+    def _generate_model_response(self, prompt: str) -> str:
+        """Generate response from the fine-tuned model"""
+        inputs = self.tokenizer(
+            prompt, return_tensors="pt", truncation=True, max_length=2048)
+
+        # Move to CPU if no GPU available
+        if not torch.cuda.is_available():
+            inputs = {k: v.cpu() for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = self.model.generate(
+                inputs.input_ids,
+                max_new_tokens=512,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return response[len(prompt):].strip()
+
+    def _create_fallback_analysis(self, code: str, student_level: str) -> Dict:
+        """Create fallback analysis when model fails"""
+        return {
+            "strengths": ["Your code has a clear structure", "You're using appropriate data types"],
+            "weaknesses": ["Could improve variable naming", "Consider adding comments"],
+            "issues": ["Basic syntax and style issues"],
+            "step_by_step_improvement": [
+                "Step 1: Add descriptive variable names",
+                "Step 2: Include comments explaining your logic",
+                "Step 3: Consider code optimization"
+            ],
+            "learning_points": [
+                "Good variable naming improves code readability",
+                "Comments help others understand your code",
+                "Always consider efficiency in your solutions"
+            ],
+            "review_summary": "Your code works but could be improved with better practices.",
+            "learning_objectives": ["code_quality", "best_practices", "readability"],
+            "estimated_time_to_improve": "10-15 minutes"
+        }
+
+    def _create_fallback_comprehensive_feedback(self, code: str, student_level: str) -> ComprehensiveFeedback:
+        """Create fallback comprehensive feedback when model fails"""
+        fallback_analysis = self._create_fallback_analysis(code, student_level)
+
+        return ComprehensiveFeedback(
+            code_snippet=code,
+            student_level=student_level,
+            strengths=fallback_analysis["strengths"],
+            weaknesses=fallback_analysis["weaknesses"],
+            issues=fallback_analysis["issues"],
+            step_by_step_improvement=fallback_analysis["step_by_step_improvement"],
+            learning_points=fallback_analysis["learning_points"],
+            review_summary=fallback_analysis["review_summary"],
+            comprehension_question="What is the importance of good variable naming in programming?",
+            comprehension_answer="Good variable naming makes code more readable and maintainable.",
+            explanation="Descriptive variable names help other developers (and yourself) understand what the code does.",
+            improved_code="# Improved version\n# Add your improvements here",
+            fix_explanation="This is a fallback version. The model should provide specific improvements.",
+            difficulty_level=student_level,
+            learning_objectives=fallback_analysis["learning_objectives"],
+            estimated_time_to_improve=fallback_analysis["estimated_time_to_improve"]
+        )
+
+
+def main():
+    """Main function to demonstrate the system with fine-tuned model"""
+    print("Generative AI for Programming Education")
+    print("Using Fine-tuned CodeLlama-7B Model")
+    print("=" * 50)
+
+    # System information
+    print(f"Available GPUs: {torch.cuda.device_count()}")
+    if torch.cuda.is_available():
+        print("GPU Memory before loading:")
+        get_gpu_memory()
+    else:
+        print("System Memory before loading:")
+        get_system_memory()
+
+    # Initialize the system with your fine-tuned model path
+    # Update this path to point to your actual fine-tuned model
+    model_path = r"C:\Users\farou\OneDrive - Aston University\finetunning"
+    ai_tutor = ProgrammingEducationAI(model_path)
+
+    try:
+        # Load the fine-tuned model
+        print("Loading fine-tuned model...")
+        ai_tutor.load_model()
+        print("✓ Model loaded successfully!")
+
+        # Clear cache after loading
+        clear_cuda_cache()
+        if torch.cuda.is_available():
+            print("GPU Memory after loading:")
+            get_gpu_memory()
+        else:
+            print("System Memory after loading:")
+            get_system_memory()
+
+        # Example student code for testing
+        student_code = """
+def find_duplicates(numbers):
+    x = []
+    for i in range(len(numbers)):
+        for j in range(i+1, len(numbers)):
+            if numbers[i] == numbers[j]:
+                x.append(numbers[i])
+    return x
+
+# Test the function
+result = find_duplicates([1, 2, 3, 2, 4, 5, 3])
+print(result)
+"""
+
+        print(f"\nAnalyzing student code:\n{student_code}")
+
+        # Get feedback using fine-tuned model
+        feedback_list = ai_tutor.analyze_student_code(student_code, "beginner")
+
+        print("\n" + "="*50)
+        print("FINE-TUNED MODEL FEEDBACK:")
+        print("="*50)
+
+        for i, feedback in enumerate(feedback_list, 1):
+            print(f"\n{i}. {feedback.feedback_type.upper()}:")
+            print(f"   {feedback.feedback_message}")
+            if feedback.suggested_improvement:
+                print(f"   Suggestion: {feedback.suggested_improvement}")
+            print(
+                f"   Learning objectives: {', '.join(feedback.learning_objectives)}")
+
+        # Demonstrate direct model calls
+        print("\n" + "="*50)
+        print("DIRECT MODEL GENERATION:")
+        print("="*50)
+
+        # Code review
+        print("\n1. CODE REVIEW:")
+        code_review = ai_tutor.generate_code_review(student_code, "beginner")
+        print(code_review)
+
+        # Educational feedback
+        print("\n2. EDUCATIONAL FEEDBACK:")
+        educational_feedback = ai_tutor.generate_educational_feedback(
+            student_code, "beginner")
+        print(educational_feedback)
+
+        # Demonstrate comprehensive feedback system
+        print("\n" + "="*50)
+        print("COMPREHENSIVE EDUCATIONAL FEEDBACK SYSTEM:")
+        print("="*50)
+
+        comprehensive_feedback = ai_tutor.generate_comprehensive_feedback(
+            student_code, "beginner")
+
+        # Display comprehensive feedback
+        print("\n📊 CODE ANALYSIS:")
+        print("="*30)
+
+        print("\n✅ STRENGTHS:")
+        for i, strength in enumerate(comprehensive_feedback.strengths, 1):
+            print(f"   {i}. {strength}")
+
+        print("\n❌ WEAKNESSES:")
+        for i, weakness in enumerate(comprehensive_feedback.weaknesses, 1):
+            print(f"   {i}. {weakness}")
+
+        print("\n⚠️ ISSUES:")
+        for i, issue in enumerate(comprehensive_feedback.issues, 1):
+            print(f"   {i}. {issue}")
+
+        print("\n📝 STEP-BY-STEP IMPROVEMENT GUIDE:")
+        print("="*40)
+        for i, step in enumerate(comprehensive_feedback.step_by_step_improvement, 1):
+            print(f"   Step {i}: {step}")
+
+        print("\n🎓 LEARNING POINTS:")
+        print("="*25)
+        for i, point in enumerate(comprehensive_feedback.learning_points, 1):
+            print(f"   {i}. {point}")
+
+        print("\n📋 REVIEW SUMMARY:")
+        print("="*20)
+        print(f"   {comprehensive_feedback.review_summary}")
+
+        print("\n❓ COMPREHENSION QUESTION:")
+        print("="*30)
+        print(f"   Question: {comprehensive_feedback.comprehension_question}")
+        print(f"   Answer: {comprehensive_feedback.comprehension_answer}")
+        print(f"   Explanation: {comprehensive_feedback.explanation}")
+
+        print("\n🔧 IMPROVED CODE:")
+        print("="*20)
+        print(comprehensive_feedback.improved_code)
+
+        print("\n💡 FIX EXPLANATION:")
+        print("="*20)
+        print(f"   {comprehensive_feedback.fix_explanation}")
+
+        print("\n📊 METADATA:")
+        print("="*15)
+        print(f"   Student Level: {comprehensive_feedback.student_level}")
+        print(
+            f"   Learning Objectives: {', '.join(comprehensive_feedback.learning_objectives)}")
+        print(
+            f"   Estimated Time to Improve: {comprehensive_feedback.estimated_time_to_improve}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+        print(
+            "Make sure to update the model_path variable to point to your fine-tuned model.")
+
+
+if __name__ == "__main__":
+    main()

src/requirements.txt

@@ -0,0 +1,6 @@
+streamlit>=1.28.0
+torch>=2.0.0
+transformers>=4.30.0
+accelerate>=0.20.0
+sentencepiece>=0.1.99
+protobuf>=3.20.0