app.py

"""
ULTIMATE LoRA Fine-Tuning Demo - Covers ALL Project Requirements
Group 6: Model Adaptation, Efficient Fine-Tuning & Deployment of LLMs
"""

import streamlit as st
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import PeftModel
import time
import psutil
import os

# Page configuration
st.set_page_config(
    page_title="LoRA Fine-Tuning Complete Demo",
    page_icon="🤖",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom CSS
st.markdown("""
<style>
    .main-header {
        font-size: 2.5rem;
        font-weight: bold;
        text-align: center;
        background: linear-gradient(120deg, #1f77b4, #00cc88);
        -webkit-background-clip: text;
        -webkit-text-fill-color: transparent;
        margin-bottom: 0.5rem;
    }
    .sub-header {
        text-align: center;
        color: #666;
        margin-bottom: 2rem;
        font-size: 1.1rem;
    }
    .metric-card {
        background: #f0f2f6;
        padding: 1rem;
        border-radius: 10px;
        border-left: 4px solid #1f77b4;
    }
    .model-box {
        padding: 1.5rem;
        border-radius: 10px;
        margin: 1rem 0;
        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
    }
    .base-model {
        background-color: #fff5f5;
        border-left: 4px solid #ff4b4b;
    }
    .finetuned-model {
        background-color: #f0fff4;
        border-left: 4px solid #00cc88;
    }
    .theory-box {
        background: #e8f4f8;
        padding: 1.5rem;
        border-radius: 10px;
        margin: 1rem 0;
        border-left: 4px solid #1f77b4;
    }
</style>
""", unsafe_allow_html=True)

# Title
st.markdown('<div class="main-header">🚀 Complete LoRA Fine-Tuning Demo</div>', unsafe_allow_html=True)
st.markdown('<div class="sub-header">Parameter-Efficient Fine-Tuning & Deployment Showcase</div>',
            unsafe_allow_html=True)

# Sidebar Navigation
with st.sidebar:
    st.header("📚 Navigation")
    page = st.radio(
        "Select Section:",
        ["🎯 Live Demo", "📊 Theory & Concepts", "⚙️ Technical Details", "🚀 Deployment Info"],
        label_visibility="collapsed"
    )

    st.divider()

    if page == "🎯 Live Demo":
        st.header("⚙️ Model Settings")

        device_option = st.selectbox(
            "Inference Device",
            ["Auto (GPU if available)", "Force CPU", "Force GPU"],
            help="Compare CPU vs GPU inference speed"
        )

        use_quantization = st.checkbox(
            "Use 8-bit Quantization",
            value=False,
            help="Reduces memory usage, slightly slower"
        )

        temperature = st.slider("Temperature", 0.1, 1.0, 0.3, 0.1)
        max_length = st.slider("Max Length", 50, 400, 200, 10)
        top_p = st.slider("Top P", 0.1, 1.0, 0.95, 0.05)

        st.divider()

        st.header("📊 Quick Stats")
        col1, col2 = st.columns(2)
        with col1:
            st.metric("Base Model", "82M params")
            st.metric("Adapter Size", "~3 MB")
        with col2:
            st.metric("Trainable", "0.4%")
            st.metric("Training Time", "~30 min")


# Cache model loading
@st.cache_resource
def load_models(use_quantization=False, device_option="Auto"):
    """Load base model and fine-tuned model"""

    base_model_name = "distilgpt2"
    adapter_path = "./models/lora_adapters"

    # Determine device
    if device_option == "Force CPU":
        device = "cpu"
    elif device_option == "Force GPU":
        device = "cuda" if torch.cuda.is_available() else "cpu"
    else:
        device = "cuda" if torch.cuda.is_available() else "cpu"

    with st.spinner("🔄 Loading models..."):
        # Load tokenizer
        tokenizer = AutoTokenizer.from_pretrained(base_model_name)
        tokenizer.pad_token = tokenizer.eos_token

        # Quantization config
        if use_quantization and device == "cuda":
            quantization_config = BitsAndBytesConfig(
                load_in_8bit=True,
                llm_int8_threshold=6.0
            )
            base_model = AutoModelForCausalLM.from_pretrained(
                base_model_name,
                quantization_config=quantization_config,
                device_map="auto"
            )
            finetuned_model = AutoModelForCausalLM.from_pretrained(
                base_model_name,
                quantization_config=quantization_config,
                device_map="auto"
            )
            finetuned_model = PeftModel.from_pretrained(finetuned_model, adapter_path)
        else:
            # Standard loading
            base_model = AutoModelForCausalLM.from_pretrained(base_model_name)
            finetuned_model = AutoModelForCausalLM.from_pretrained(base_model_name)
            finetuned_model = PeftModel.from_pretrained(finetuned_model, adapter_path)

            base_model.to(device)
            finetuned_model.to(device)

    return tokenizer, base_model, finetuned_model, device


def get_model_size_mb(model):
    """Calculate model size in MB"""
    param_size = sum(p.nelement() * p.element_size() for p in model.parameters())
    buffer_size = sum(b.nelement() * b.element_size() for b in model.buffers())
    return (param_size + buffer_size) / (1024 ** 2)


def generate_response(model, tokenizer, prompt, device, temperature, max_length, top_p):
    """Generate response from a model"""
    formatted_input = f"### Instruction:\n{prompt}\n\n### Code:\n"
    inputs = tokenizer(formatted_input, return_tensors="pt", padding=True)
    inputs = {k: v.to(device) for k, v in inputs.items()}

    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_length=max_length,
            temperature=temperature,
            top_p=top_p,
            do_sample=True,
            num_return_sequences=1,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=tokenizer.eos_token_id
        )

    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response


# =============================================================================
# PAGE 1: LIVE DEMO
# =============================================================================
if page == "🎯 Live Demo":
    # Load models
    try:
        tokenizer, base_model, finetuned_model, device = load_models(
            use_quantization=use_quantization if 'use_quantization' in dir() else False,
            device_option=device_option if 'device_option' in dir() else "Auto"
        )

        # Show device info
        device_emoji = "🚀" if device == "cuda" else "🐢"
        if device == "cuda":
            st.success(f"{device_emoji} Running on GPU: {torch.cuda.get_device_name(0)}")
        else:
            st.info(f"{device_emoji} Running on CPU (slower but works!)")

        # Show quantization status
        if use_quantization and device == "cuda":
            st.info("⚡ 8-bit quantization enabled - Lower memory usage!")

    except Exception as e:
        st.error(f"❌ Error loading models: {str(e)}")
        st.stop()

    # Sample prompts
    st.header("💬 Try the Demo")

    sample_prompts = [
        "Write a Python function to calculate factorial",
        "Create a function to check if a string is palindrome",
        "Write code to merge two sorted lists",
        "Implement a function to find the largest element in a list",
        "Create a Python function to check if a number is prime",
        "Write code to reverse a linked list",
        "Implement binary search algorithm in Python"
    ]

    col1, col2 = st.columns([3, 1])
    with col1:
        use_sample = st.selectbox("Select prompt or write custom:", ["Custom"] + sample_prompts)
    with col2:
        st.write("")
        st.write("")

    if use_sample == "Custom":
        user_instruction = st.text_area(
            "Enter your instruction:",
            height=100,
            placeholder="e.g., Write a Python function to sort a dictionary by values"
        )
    else:
        user_instruction = use_sample
        st.info(f"💡 Prompt: {user_instruction}")

    # Generate button
    if st.button("🚀 Generate Responses", type="primary", use_container_width=True):
        if user_instruction.strip():

            col_base, col_finetuned = st.columns(2)

            with col_base:
                st.markdown('<div class="model-box base-model">', unsafe_allow_html=True)
                st.subheader("🔴 Base Model (Untrained)")

                with st.spinner("Generating..."):
                    start_time = time.time()
                    base_response = generate_response(
                        base_model, tokenizer, user_instruction, device,
                        temperature, max_length, top_p
                    )
                    base_time = time.time() - start_time

                st.code(base_response, language="python")
                st.caption(f"⏱️ Generation time: {base_time:.3f}s")
                st.markdown('</div>', unsafe_allow_html=True)

            with col_finetuned:
                st.markdown('<div class="model-box finetuned-model">', unsafe_allow_html=True)
                st.subheader("🟢 Fine-tuned Model (+ LoRA)")

                with st.spinner("Generating..."):
                    start_time = time.time()
                    finetuned_response = generate_response(
                        finetuned_model, tokenizer, user_instruction, device,
                        temperature, max_length, top_p
                    )
                    finetuned_time = time.time() - start_time

                st.code(finetuned_response, language="python")
                st.caption(f"⏱️ Generation time: {finetuned_time:.3f}s")
                st.markdown('</div>', unsafe_allow_html=True)

            # Performance Analysis
            st.divider()
            st.subheader("📊 Performance Analysis")

            col1, col2, col3, col4 = st.columns(4)

            with col1:
                st.metric("Base Response", f"{len(base_response.split())} words")
            with col2:
                st.metric("Fine-tuned Response", f"{len(finetuned_response.split())} words")
            with col3:
                speed_diff = ((base_time - finetuned_time) / base_time) * 100
                st.metric("Speed Difference", f"{speed_diff:+.1f}%")
            with col4:
                st.metric("Device", device.upper())

            st.success("✅ Notice: Base model produces gibberish, fine-tuned generates actual Python code!")

        else:
            st.warning("⚠️ Please enter an instruction!")

# =============================================================================
# PAGE 2: THEORY & CONCEPTS
# =============================================================================
elif page == "📊 Theory & Concepts":
    st.header("📚 Theory & Key Concepts")

    tab1, tab2, tab3, tab4 = st.tabs([
        "🎓 Pre-training vs Fine-tuning",
        "🔧 LoRA & PEFT",
        "⚡ Training vs Inference",
        "📏 Trade-offs"
    ])

    with tab1:
        st.markdown('<div class="theory-box">', unsafe_allow_html=True)
        st.subheader("Pre-training vs Fine-tuning")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("### 🏗️ Pre-training")
            st.markdown("""
            - **Task**: Learn general language understanding
            - **Data**: Massive unlabeled text (billions of tokens)
            - **Cost**: Extremely expensive ($$$$$)
            - **Time**: Weeks to months
            - **Example**: GPT, BERT, LLaMA training
            - **Goal**: General purpose model
            """)

        with col2:
            st.markdown("### 🎯 Fine-tuning")
            st.markdown("""
            - **Task**: Adapt to specific domain/task
            - **Data**: Smaller labeled dataset (thousands)
            - **Cost**: Much cheaper ($$)
            - **Time**: Hours to days
            - **Example**: Code generation, Q&A, summarization
            - **Goal**: Specialized model
            """)

        st.divider()

        st.markdown("### 📊 Our Project: Transfer Learning")
        st.info("""
        **We started with**: Pre-trained `distilgpt2` (general language model)  
        **We fine-tuned on**: Python code instructions (5000 samples)  
        **Result**: Model now generates Python code instead of general text!

        This is **Transfer Learning** - leveraging pre-trained knowledge for new tasks.
        """)
        st.markdown('</div>', unsafe_allow_html=True)

    with tab2:
        st.markdown('<div class="theory-box">', unsafe_allow_html=True)
        st.subheader("LoRA: Low-Rank Adaptation")

        col1, col2 = st.columns([1, 1])

        with col1:
            st.markdown("### 🔴 Full Fine-tuning (Expensive)")
            st.markdown("""
            ```
            Total Parameters: 82M
            Trainable: 82M (100%)
            Memory: High
            Time: Long
            GPU: Required (expensive)
            Checkpoint: 320 MB
            ```
            **Problems**:
            - ❌ Expensive GPUs needed
            - ❌ Long training time
            - ❌ Large model checkpoints
            - ❌ Risk of catastrophic forgetting
            """)

        with col2:
            st.markdown("### 🟢 LoRA Fine-tuning (Efficient)")
            st.markdown("""
            ```
            Total Parameters: 82M
            Trainable: 295K (0.36%)
            Memory: Low
            Time: Fast
            GPU: Optional (Colab free tier OK)
            Checkpoint: 3 MB
            ```
            **Advantages**:
            - ✅ Train on free GPUs
            - ✅ Fast training (~30 min)
            - ✅ Tiny adapter files
            - ✅ Preserve base model knowledge
            """)

        st.divider()

        st.markdown("### 🧮 How LoRA Works")
        st.markdown("""
        Instead of updating all weights `W`, LoRA adds small adapter matrices:

        ```
        W_new = W_frozen + ΔW
        where ΔW = B × A  (low-rank decomposition)
        ```

        **Our Configuration**:
        - `r = 16` (rank - controls adapter capacity)
        - `alpha = 32` (scaling factor)
        - Target modules: Attention layers only
        - Result: 99.6% fewer trainable parameters!
        """)
        st.markdown('</div>', unsafe_allow_html=True)

    with tab3:
        st.markdown('<div class="theory-box">', unsafe_allow_html=True)
        st.subheader("Training vs Inference")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("### 🏋️ Training Phase")
            st.markdown("""
            **What happens**:
            - Forward pass through model
            - Calculate loss (prediction error)
            - Backward propagation (gradients)
            - Update weights (only LoRA adapters)

            **Requirements**:
            - GPU highly recommended
            - More memory needed
            - Longer time
            - Batch processing

            **Our Training**:
            - Dataset: 5000 Python code examples
            - Time: ~30 minutes (Colab T4 GPU)
            - Memory: ~8 GB VRAM
            - Output: 3 MB adapter file
            """)

        with col2:
            st.markdown("### 🚀 Inference Phase")
            st.markdown("""
            **What happens**:
            - Load base model + adapters
            - Forward pass only (no backprop)
            - Generate predictions
            - No weight updates

            **Requirements**:
            - CPU works (slower)
            - GPU faster (optional)
            - Less memory
            - Real-time response

            **Our Deployment**:
            - Works on: CPU or GPU
            - Load time: ~10-30 seconds
            - Inference: ~1-3 seconds per response
            - Memory: ~2 GB RAM
            """)

        st.markdown('</div>', unsafe_allow_html=True)

    with tab4:
        st.markdown('<div class="theory-box">', unsafe_allow_html=True)
        st.subheader("Trade-offs & Optimization")

        st.markdown("### ⚖️ Key Trade-offs")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("#### 📏 Model Size vs Accuracy")
            st.markdown("""
            **Larger models**:
            - ✅ Better accuracy
            - ✅ More capacity
            - ❌ Slower inference
            - ❌ More memory

            **Smaller models**:
            - ✅ Faster inference
            - ✅ Less memory
            - ❌ Lower accuracy
            - ❌ Less capacity
            """)

        with col2:
            st.markdown("#### ⚡ Speed vs Quality")
            st.markdown("""
            **Higher quality**:
            - More parameters
            - Longer sequences
            - Lower temperature
            - ❌ Slower

            **Higher speed**:
            - Fewer parameters
            - Shorter sequences
            - Quantization
            - ❌ Potentially lower quality
            """)

        st.divider()

        st.markdown("### 🔢 Quantization")
        st.markdown("""
        **What**: Reduce precision of model weights (32-bit → 8-bit)

        **Benefits**:
        - 75% less memory usage
        - Faster inference on some hardware
        - Enables larger models on limited hardware

        **Cost**:
        - Slight accuracy loss (~1-2%)
        - Requires calibration

        **Try it**: Enable "8-bit quantization" in the sidebar on Demo page!
        """)

        st.markdown('</div>', unsafe_allow_html=True)

# =============================================================================
# PAGE 3: TECHNICAL DETAILS
# =============================================================================
elif page == "⚙️ Technical Details":
    st.header("⚙️ Technical Implementation")

    col1, col2 = st.columns(2)

    with col1:
        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
        st.markdown("### 📦 Model Architecture")
        st.markdown("""
        **Base Model**: distilgpt2
        - Type: Causal Language Model
        - Parameters: 82M
        - Layers: 6 transformer blocks
        - Hidden size: 768
        - Attention heads: 12
        - Vocabulary: 50,257 tokens
        """)
        st.markdown('</div>', unsafe_allow_html=True)

        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
        st.markdown("### 🔧 LoRA Configuration")
        st.markdown("""
        ```python
        LoraConfig(
            r=16,                    # Rank
            lora_alpha=32,           # Scaling
            target_modules=["c_attn"], # Attention only
            lora_dropout=0.05,
            task_type="CAUSAL_LM"
        )
        ```

        **Trainable Parameters**: 294,912 (0.36%)
        **Adapter Size**: ~3 MB
        """)
        st.markdown('</div>', unsafe_allow_html=True)

    with col2:
        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
        st.markdown("### 📊 Dataset")
        st.markdown("""
        **Name**: Python Code Instructions (18k Alpaca)
        **Source**: `iamtarun/python_code_instructions_18k_alpaca`
        **Used**: 5000 samples
        - Training: 4500 samples
        - Validation: 500 samples

        **Format**:
        ```
        Instruction: Write Python code for X
        Code: def function()...
        ```
        """)
        st.markdown('</div>', unsafe_allow_html=True)

        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
        st.markdown("### 🏋️ Training Hyperparameters")
        st.markdown("""
        ```python
        Epochs: 4
        Batch size: 2 (per device)
        Gradient accumulation: 4
        Learning rate: 3e-4
        Max sequence length: 512
        Optimizer: AdamW
        Scheduler: Linear warmup
        ```

        **Training Time**: ~30 minutes (T4 GPU)
        **Final Loss**: ~2.5
        """)
        st.markdown('</div>', unsafe_allow_html=True)

    st.divider()

    st.markdown("### 🛠️ Tools & Libraries Used")

    col1, col2, col3 = st.columns(3)

    with col1:
        st.markdown("""
        **Training**:
        - 🤗 Transformers
        - 🎯 PEFT (LoRA)
        - 🚀 Accelerate
        - 📊 Datasets
        - 🔥 PyTorch
        """)

    with col2:
        st.markdown("""
        **Deployment**:
        - 🌐 Streamlit
        - 🤗 Hugging Face Hub
        - ⚡ bitsandbytes (quantization)
        - 💾 safetensors
        """)

    with col3:
        st.markdown("""
        **Infrastructure**:
        - 📓 Google Colab (training)
        - 💻 Local deployment
        - ☁️ Hugging Face Spaces (optional)
        - 🔒 Git LFS (model versioning)
        """)

# =============================================================================
# PAGE 4: DEPLOYMENT INFO
# =============================================================================
else:  # Deployment Info
    st.header("🚀 Deployment Options")

    tab1, tab2, tab3 = st.tabs(["💻 Local", "☁️ Cloud", "📊 Comparison"])

    with tab1:
        st.markdown('<div class="theory-box">', unsafe_allow_html=True)
        st.markdown("### 💻 Local Deployment (Current)")

        st.markdown("""
        **Advantages**:
        - ✅ Full control
        - ✅ No API costs
        - ✅ Data privacy
        - ✅ Works offline
        - ✅ Fast iteration

        **Requirements**:
        - Python 3.8+
        - 2-4 GB RAM
        - Optional: NVIDIA GPU

        **Setup**:
        ```bash
        pip install streamlit transformers peft torch
        streamlit run app.py
        ```

        **Best for**: Development, testing, demos
        """)
        st.markdown('</div>', unsafe_allow_html=True)

    with tab2:
        st.markdown('<div class="theory-box">', unsafe_allow_html=True)
        st.markdown("### ☁️ Cloud Deployment")

        st.markdown("#### 🤗 Hugging Face Spaces (Recommended)")
        st.markdown("""
        **Features**:
        - ✅ Free tier available
        - ✅ Auto-deploys from Git
        - ✅ Public URL
        - ✅ No server management
        - ✅ Built-in CI/CD

        **Setup**:
        1. Create account on huggingface.co
        2. Create new Space (Streamlit)
        3. Upload: app.py, requirements.txt, models/
        4. Auto-deploys!

        **URL**: `https://huggingface.co/spaces/YOUR_USERNAME/lora-demo`
        """)

        st.divider()

        st.markdown("#### Other Options")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("""
            **Streamlit Cloud**:
            - Free for public apps
            - GitHub integration
            - Easy deployment
            - Resource limits
            """)

        with col2:
            st.markdown("""
            **AWS/GCP/Azure**:
            - Full control
            - Scalable
            - More expensive
            - Requires devops
            """)

        st.markdown('</div>', unsafe_allow_html=True)

    with tab3:
        st.markdown('<div class="theory-box">', unsafe_allow_html=True)
        st.markdown("### 📊 Deployment Comparison")

        comparison_data = {
            "Feature": ["Cost", "Setup Time", "Control", "Scalability", "Maintenance", "Best For"],
            "Local": ["Free", "5 mins", "Full", "Limited", "Manual", "Development"],
            "HF Spaces": ["Free", "10 mins", "Medium", "Auto", "Minimal", "Demos"],
            "Cloud (AWS)": ["$$$", "1-2 hours", "Full", "High", "Manual", "Production"]
        }

        st.table(comparison_data)

        st.divider()

        st.markdown("### 🎯 CPU vs GPU Inference")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("""
            **CPU Inference**:
            - Speed: 2-5 seconds/response
            - Cost: $0 (uses existing hardware)
            - Memory: ~2 GB RAM
            - Best for: Low-traffic apps, development
            """)

        with col2:
            st.markdown("""
            **GPU Inference**:
            - Speed: 0.5-2 seconds/response
            - Cost: $0.50-2/hour (cloud)
            - Memory: ~4-8 GB VRAM
            - Best for: High-traffic, real-time apps
            """)

        st.info("💡 **Tip**: Start with CPU deployment, upgrade to GPU only if needed!")

        st.markdown('</div>', unsafe_allow_html=True)

# Footer
st.divider()
st.markdown("""
<div style="text-align: center; color: #666; padding: 1rem;">
    <p><strong>🎓 Group 6: Model Adaptation, Efficient Fine-Tuning & Deployment of LLMs</strong></p>
    <p>Built with Streamlit • Transformers • PEFT • PyTorch</p>
</div>
""", unsafe_allow_html=True)