Upload 7 files

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/README.md

@@ -0,0 +1,185 @@
+# 🎓 Generative AI for Programming Education
+
+## 🚀 Live Demo
+**Hugging Face Spaces**: [Coming Soon - Deploy using DEPLOYMENT.md guide]
+
+## 📋 Problem Statement
+Current programming education struggles with high dropout rates, inefficient feedback loops, and a lack of personalized learning—problems exacerbated by limited instructor bandwidth. While Generative AI (e.g., Copilot, ChatGPT) can help, most tools prioritize productivity over learning, offering code solutions without explanations or tailored guidance. This risks student over-reliance without deeper comprehension.
+
+## 🎯 Solution
+To address this gap, we fine-tuned **CodeLlama-7B** to provide structured, educational code feedback—not just correct answers. Our model analyzes student code and delivers:
+
+- **Instant, actionable reviews** (e.g., "This loop can be optimized from O(n²) to O(n) using a hashmap")
+- **Beginner-friendly explanations** (e.g., "In Python, list.append() modifies the list in-place but returns None—that's why your print() shows None")
+- **Personalized adaptation** (e.g., adjusting feedback depth based on inferred skill level)
+
+Unlike generic AI tools, our system is explicitly designed for education, balancing correctness, pedagogy, and ethical safeguards against over-reliance.
+
+## ✨ Features
+
+### 🧠 **Fine-tuned CodeLlama-7B Model**
+- Trained on **code review** and **code feedback** datasets
+- **7B parameters** for comprehensive understanding
+- **Educational focus** rather than productivity optimization
+
+### 📊 **Progressive Learning Interface**
+- **5-stage educational process**:
+  1. **Code Analysis** - Strengths, weaknesses, issues
+  2. **Improvement Guide** - Step-by-step instructions
+  3. **Learning Points** - Key concepts and objectives
+  4. **Comprehension Quiz** - Test understanding
+  5. **Code Fix** - Improved solution (only after learning)
+
+### 🎓 **Educational Features**
+- **Student Level Adaptation** (Beginner/Intermediate/Advanced)
+- **Comprehension Questions** generated by the model
+- **Learning Objectives** for each feedback
+- **Step-by-step improvement guides**
+- **Algorithm complexity explanations**
+
+### 🛡️ **Ethical Safeguards**
+- **Progressive learning flow** prevents solution jumping
+- **Comprehension testing** before showing fixes
+- **Educational explanations** rather than quick answers
+- **Best practices promotion**
+
+## 🚀 **Hugging Face Spaces Deployment**
+
+### **Hardware Specifications**
+- **CPU**: 2 vCPU (virtual CPU cores)
+- **RAM**: 16 GB
+- **Plan**: FREE tier
+- **Storage**: Sufficient for model and application
+
+### **Optimization Features**
+- ✅ **16GB RAM optimization** for fine-tuned model
+- ✅ **CPU-only inference** (no GPU required)
+- ✅ **Memory management** with gradient checkpointing
+- ✅ **Demo mode** for immediate testing
+- ✅ **Progressive loading** with fallback options
+
+### **Performance Expectations**
+- **Demo Mode**: Instant response
+- **Fine-tuned Model**: 5-10 minutes initial loading
+- **Memory Usage**: Optimized for 16GB constraint
+- **Concurrent Users**: Limited by CPU cores
+
+## 🛠️ Installation & Setup
+
+### **Local Development**
+```bash
+# Clone the repository
+git clone https://github.com/TomoriFarouk/GenAI-For-Programming-Language.git
+cd GenAI-For-Programming-Language
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the application
+streamlit run app.py
+```
+
+### **Hugging Face Spaces Deployment**
+Follow the detailed guide in `DEPLOYMENT.md` for step-by-step instructions.
+
+## 📁 Project Structure
+
+```
+GenAI-For-Programming-Language/
+├── app.py                    # Main Streamlit interface (HF Spaces optimized)
+├── fine.py                   # Fine-tuned model integration
+├── config.py                 # Configuration settings
+├── requirements.txt          # Dependencies
+├── README.md                 # This file
+├── DEPLOYMENT.md            # HF Spaces deployment guide
+├── .gitignore               # Excludes model files
+├── .gitattributes           # File type configuration
+└── example_usage.py         # Usage examples
+```
+
+## 🧠 Model Architecture
+
+### **Base Model**
+- **CodeLlama-7B-Instruct-hf**
+- **7 billion parameters**
+- **Code-specific training**
+
+### **Fine-tuning Datasets**
+1. **Code Review Dataset**: Structured feedback on code quality
+2. **Code Feedback Dataset**: Educational explanations and improvements
+
+### **Training Process**
+- **LoRA fine-tuning** for efficiency
+- **Educational prompt engineering**
+- **Multi-stage feedback generation**
+
+## 🎯 Usage Examples
+
+### **Input Code**
+```python
+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
+```
+
+### **Generated Feedback**
+1. **Analysis**: Identifies O(n²) complexity, poor variable naming
+2. **Improvement Guide**: Step-by-step optimization instructions
+3. **Learning Points**: Algorithm complexity, naming conventions
+4. **Quiz**: "What is the time complexity and how to improve it?"
+5. **Code Fix**: Optimized O(n) solution with better naming
+
+## 🔧 Configuration
+
+### **Model Settings**
+- **Path**: `./model` (for HF Spaces)
+- **Device**: CPU-optimized for 16GB RAM
+- **Memory**: Gradient checkpointing enabled
+
+### **Educational Settings**
+- **Student Levels**: Beginner, Intermediate, Advanced
+- **Feedback Types**: Syntax, Logic, Optimization, Style
+- **Learning Objectives**: Comprehensive programming concepts
+
+## 🚀 Performance
+
+### **Local Environment**
+- **GPU**: Recommended for faster inference
+- **RAM**: 16GB+ recommended
+- **Storage**: 30GB+ for model files
+
+### **Hugging Face Spaces**
+- **CPU**: 2 vCPU (sufficient for inference)
+- **RAM**: 16GB (optimized for this constraint)
+- **Loading Time**: 5-10 minutes for fine-tuned model
+- **Demo Mode**: Instant response
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- **CodeLlama team** for the base model
+- **Hugging Face** for the Spaces platform
+- **Streamlit** for the web interface framework
+
+## 📞 Contact
+
+For questions or support, please open an issue on GitHub.
+
+---
+
+**🎓 Empowering programming education through AI-driven, structured learning experiences.** 

src/app.py

@@ -0,0 +1,377 @@
+"""
+AI Programming Tutor - Hugging Face Spaces Deployment
+Comprehensive Educational Feedback System
+"""
+
+import json
+from fine import ProgrammingEducationAI, ComprehensiveFeedback
+import streamlit as st
+import torch
+import os
+import gc
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+# Environment setup for HF Spaces
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128"
+os.environ["DATASETS_DISABLE_MULTIPROCESSING"] = "1"
+
+# Clear CUDA cache if available
+if torch.cuda.is_available():
+    torch.cuda.empty_cache()
+    gc.collect()
+
+
+def main():
+    st.set_page_config(
+        page_title="AI Programming Tutor",
+        page_icon="🎓",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+
+    st.title("🎓 AI Programming Tutor")
+    st.subheader("Comprehensive Educational Feedback System")
+    st.markdown("---")
+
+    # Sidebar configuration
+    with st.sidebar:
+        st.header("⚙️ Configuration")
+
+        # Model selection
+        model_option = st.selectbox(
+            "Choose Model:",
+            ["Use Demo Mode", "Use Fine-tuned Model"],
+            help="Demo mode works immediately. Fine-tuned model requires loading (5-10 minutes on HF Spaces)."
+        )
+
+        # Student level selection
+        student_level = st.selectbox(
+            "Student Level:",
+            ["beginner", "intermediate", "advanced"],
+            help="Adjusts feedback complexity and learning objectives"
+        )
+
+        # Memory info for HF Spaces
+        if st.checkbox("Show System Info"):
+            import psutil
+            memory = psutil.virtual_memory()
+            st.metric("Available RAM",
+                      f"{memory.available / (1024**3):.1f} GB")
+            st.metric("RAM Usage", f"{memory.percent}%")
+            st.metric("CPU Cores", psutil.cpu_count())
+
+        # HF Spaces specific instructions
+        st.markdown("---")
+        st.markdown("### 🚀 Hugging Face Spaces")
+        st.info("""
+        **Hardware**: 2 vCPU, 16GB RAM (FREE)
+        
+        **Recommendations**:
+        - Use Demo Mode for quick testing
+        - Fine-tuned model takes 5-10 minutes to load
+        - 16GB RAM is sufficient for your model
+        """)
+
+    # Main content area
+    col1, col2 = st.columns([1, 1])
+
+    with col1:
+        st.header("📝 Student Code Input")
+
+        # Code input
+        student_code = st.text_area(
+            "Paste your Python code here:",
+            height=300,
+            placeholder="""# Example code to test:
+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)""",
+            help="Paste your Python code here for analysis"
+        )
+
+        # Generate feedback button
+        if st.button("🎯 Generate Comprehensive Feedback", type="primary"):
+            if not student_code.strip():
+                st.warning("⚠️ Please enter some code first!")
+            else:
+                generate_feedback(student_code, student_level, model_option)
+
+    with col2:
+        st.header("📊 Feedback Results")
+
+        if 'feedback' in st.session_state:
+            display_feedback(st.session_state['feedback'])
+
+
+def generate_feedback(code: str, student_level: str, model_option: str):
+    """Generate comprehensive feedback using the AI tutor or demo mode"""
+    with st.spinner("🤖 Analyzing your code..."):
+        try:
+            if model_option == "Use Fine-tuned Model":
+                # Check if model is already loaded
+                if 'ai_tutor' not in st.session_state:
+                    with st.spinner("🚀 Loading fine-tuned model (this may take 5-10 minutes on HF Spaces)..."):
+                        try:
+                            # Use relative path for HF Spaces
+                            model_path = "./model"  # Will be updated when model is uploaded
+                            ai_tutor = ProgrammingEducationAI(model_path)
+                            ai_tutor.load_model()
+                            st.session_state['ai_tutor'] = ai_tutor
+                            st.success(
+                                "✅ Fine-tuned model loaded successfully!")
+                        except Exception as e:
+                            st.error(f"❌ Error loading model: {e}")
+                            st.info("💡 Switching to demo mode...")
+                            model_option = "Use Demo Mode"
+
+                if 'ai_tutor' in st.session_state:
+                    # Use fine-tuned model
+                    feedback = st.session_state['ai_tutor'].generate_comprehensive_feedback(
+                        code, student_level)
+                    st.session_state['feedback'] = feedback
+                    st.success("✅ Feedback generated using fine-tuned model!")
+                else:
+                    # Fallback to demo mode
+                    feedback = create_demo_feedback(code, student_level)
+                    st.session_state['feedback'] = feedback
+                    st.success("✅ Demo feedback generated as fallback!")
+            else:
+                # Demo mode
+                feedback = create_demo_feedback(code, student_level)
+                st.session_state['feedback'] = feedback
+                st.success("✅ Demo feedback generated!")
+        except Exception as e:
+            st.error(f"❌ Error generating feedback: {e}")
+            # Fallback to demo mode
+            feedback = create_demo_feedback(code, student_level)
+            st.session_state['feedback'] = feedback
+            st.success("✅ Demo feedback generated as fallback!")
+
+
+def create_demo_feedback(code: str, student_level: str) -> ComprehensiveFeedback:
+    """Create demo feedback for testing without model"""
+    return ComprehensiveFeedback(
+        code_snippet=code,
+        student_level=student_level,
+        strengths=[
+            "Your code has a clear structure and logic",
+            "You're using appropriate Python syntax",
+            "The function name is descriptive"
+        ],
+        weaknesses=[
+            "Variable names could be more descriptive",
+            "Missing comments explaining the logic",
+            "Could benefit from error handling"
+        ],
+        issues=[
+            "Using generic variable names (x, i, j)",
+            "No input validation",
+            "Nested loops could be optimized"
+        ],
+        step_by_step_improvement=[
+            "Step 1: Replace 'x' with 'duplicates' for better readability",
+            "Step 2: Add comments explaining the nested loop logic",
+            "Step 3: Consider using a set for O(n) time complexity",
+            "Step 4: Add input validation for edge cases"
+        ],
+        learning_points=[
+            "Good variable naming improves code readability and maintainability",
+            "Comments help others (and yourself) understand complex logic",
+            "Algorithm complexity matters - O(n²) vs O(n) can make a huge difference",
+            "Always consider edge cases and input validation"
+        ],
+        review_summary="Your code works correctly but could be improved with better naming, comments, and optimization. The logic is sound for a beginner level.",
+        comprehension_question="What is the time complexity of your current algorithm and how could you improve it?",
+        comprehension_answer="The current algorithm has O(n²) time complexity due to nested loops. It could be improved to O(n) using a hash set.",
+        explanation="Nested loops multiply their complexities. Using a set allows us to check for duplicates in O(1) time per element.",
+        improved_code="""def find_duplicates(numbers):
+    # Use a set for O(n) time complexity
+    duplicates = []
+    seen = set()
+    
+    for num in numbers:
+        if num in seen:
+            duplicates.append(num)
+        else:
+            seen.add(num)
+    
+    return duplicates
+
+# Test the function
+result = find_duplicates([1, 2, 3, 2, 4, 5, 3])
+print(result)""",
+        fix_explanation="The improved version uses a set to track seen numbers, reducing time complexity from O(n²) to O(n) and making the code more readable with better variable names.",
+        difficulty_level=student_level,
+        learning_objectives=["algorithm_complexity",
+                             "code_readability", "best_practices"],
+        estimated_time_to_improve="10-15 minutes"
+    )
+
+
+def display_feedback(feedback: ComprehensiveFeedback):
+    """Display comprehensive feedback in a progressive learning flow"""
+
+    # Initialize session state for tracking progress
+    if 'quiz_completed' not in st.session_state:
+        st.session_state['quiz_completed'] = False
+    if 'current_step' not in st.session_state:
+        st.session_state['current_step'] = 1
+
+    # Progress indicator
+    st.markdown("### 🎯 Learning Progress")
+    progress_bar = st.progress(0)
+
+    # Calculate progress based on current step
+    if st.session_state['current_step'] == 1:
+        progress_bar.progress(20)
+    elif st.session_state['current_step'] == 2:
+        progress_bar.progress(40)
+    elif st.session_state['current_step'] == 3:
+        progress_bar.progress(60)
+    elif st.session_state['current_step'] == 4:
+        progress_bar.progress(80)
+    elif st.session_state['current_step'] == 5:
+        progress_bar.progress(100)
+
+    # Step 1: Analysis (Always available)
+    if st.session_state['current_step'] >= 1:
+        st.markdown("### 📊 Step 1: Code Analysis")
+
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            st.markdown("#### ✅ Strengths")
+            for i, strength in enumerate(feedback.strengths, 1):
+                st.markdown(f"**{i}.** {strength}")
+
+        with col2:
+            st.markdown("#### ❌ Weaknesses")
+            for i, weakness in enumerate(feedback.weaknesses, 1):
+                st.markdown(f"**{i}.** {weakness}")
+
+        with col3:
+            st.markdown("#### ⚠️ Issues")
+            for i, issue in enumerate(feedback.issues, 1):
+                st.markdown(f"**{i}.** {issue}")
+
+        st.markdown("#### 📋 Review Summary")
+        st.info(feedback.review_summary)
+
+        if st.session_state['current_step'] == 1:
+            if st.button("✅ I understand the analysis - Continue to Step 2", type="primary"):
+                st.session_state['current_step'] = 2
+                st.rerun()
+
+    # Step 2: Improvement Guide (Available after Step 1)
+    if st.session_state['current_step'] >= 2:
+        st.markdown("---")
+        st.markdown("### 📝 Step 2: Improvement Guide")
+
+        st.markdown("#### Step-by-Step Instructions")
+        for i, step in enumerate(feedback.step_by_step_improvement, 1):
+            st.markdown(f"**Step {i}:** {step}")
+
+        st.markdown("---")
+        st.markdown(
+            f"**⏱️ Estimated time to improve:** {feedback.estimated_time_to_improve}")
+
+        if st.session_state['current_step'] == 2:
+            if st.button("✅ I understand the improvement steps - Continue to Step 3", type="primary"):
+                st.session_state['current_step'] = 3
+                st.rerun()
+
+    # Step 3: Learning Points (Available after Step 2)
+    if st.session_state['current_step'] >= 3:
+        st.markdown("---")
+        st.markdown("### 🎓 Step 3: Learning Points")
+
+        st.markdown("#### Key Concepts to Understand")
+        for i, point in enumerate(feedback.learning_points, 1):
+            st.markdown(f"**{i}.** {point}")
+
+        st.markdown("---")
+        st.markdown("#### 🎯 Learning Objectives")
+        for objective in feedback.learning_objectives:
+            st.markdown(f"• {objective}")
+
+        if st.session_state['current_step'] == 3:
+            if st.button("✅ I understand the learning points - Continue to Step 4", type="primary"):
+                st.session_state['current_step'] = 4
+                st.rerun()
+
+    # Step 4: Comprehension Quiz (Available after Step 3)
+    if st.session_state['current_step'] >= 4:
+        st.markdown("---")
+        st.markdown("### ❓ Step 4: Comprehension Check")
+
+        st.markdown(
+            "**Before you see the solution, let's test your understanding:**")
+        st.markdown(f"**Question:** {feedback.comprehension_question}")
+
+        # Quiz interface
+        user_answer = st.text_area(
+            "Your answer:",
+            placeholder="Type your answer here...",
+            height=100,
+            key="quiz_answer"
+        )
+
+        if st.button("Check My Answer", type="primary"):
+            if user_answer.strip():
+                st.markdown("**Correct Answer:**")
+                st.success(feedback.comprehension_answer)
+                st.markdown("**Explanation:**")
+                st.info(feedback.explanation)
+
+                if not st.session_state['quiz_completed']:
+                    st.session_state['quiz_completed'] = True
+                    st.session_state['current_step'] = 5
+                    st.rerun()
+            else:
+                st.warning("Please provide an answer first!")
+
+    # Step 5: Code Fix (Only available after completing quiz)
+    if st.session_state['current_step'] >= 5 and st.session_state['quiz_completed']:
+        st.markdown("---")
+        st.markdown("### 🔧 Step 5: Improved Code Solution")
+
+        st.markdown(
+            "🎉 **Congratulations! You've completed the learning process. Here's the improved version:**")
+
+        st.markdown("#### 🔧 Enhanced Version")
+        st.code(feedback.improved_code, language="python")
+
+        st.markdown("#### 💡 What Changed")
+        st.info(feedback.fix_explanation)
+
+        # Reset button for new analysis
+        if st.button("🔄 Analyze New Code", type="secondary"):
+            st.session_state['current_step'] = 1
+            st.session_state['quiz_completed'] = False
+            if 'feedback' in st.session_state:
+                del st.session_state['feedback']
+            st.rerun()
+
+    # Display metadata
+    st.markdown("---")
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Student Level", feedback.student_level.title())
+    with col2:
+        st.metric("Learning Objectives", len(feedback.learning_objectives))
+    with col3:
+        st.metric("Issues Found", len(feedback.issues))
+
+
+if __name__ == "__main__":
+    main()

src/config.py

@@ -0,0 +1,126 @@
+"""
+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
+    "model_path": "./model",  # For Hugging Face Spaces deployment
+
+    # 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/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,945 @@
+"""
+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 = "./model"):
+        """
+        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 using optimized settings"""
+        try:
+            logger.info(f"Loading fine-tuned model from {self.model_path}")
+
+            # Load tokenizer with proper settings
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_path,
+                use_fast=True,
+                padding_side="right"
+            )
+
+            # 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
+    )
+    # 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,37 @@
+# Core ML/AI dependencies
+torch>=2.0.0
+transformers>=4.30.0
+accelerate>=0.20.0
+bitsandbytes>=0.41.0
+
+# Data processing
+numpy>=1.24.0
+pandas>=2.0.0
+datasets>=2.12.0
+
+# Utilities
+tqdm>=4.65.0
+requests>=2.31.0
+python-dotenv>=1.0.0
+psutil>=5.9.0  # For system memory monitoring
+
+# Logging and monitoring
+wandb>=0.15.0  # Optional: for experiment tracking
+tensorboard>=2.13.0  # Optional: for training monitoring
+
+# Code analysis (optional enhancements)
+ast>=0.0.2
+black>=23.0.0  # For code formatting analysis
+pylint>=2.17.0  # For code quality analysis
+
+# Web interface (optional)
+flask>=2.3.0
+streamlit>=1.25.0  # For creating a web interface
+
+# Testing
+pytest>=7.4.0
+pytest-cov>=4.1.0
+
+# Development
+jupyter>=1.0.0
+ipython>=8.14.0