Upload 5 files

app/__init__.py

@@ -0,0 +1,18 @@
+"""
+Multilingual Question Answering System
+App package initialization
+"""
+
+__version__ = "1.0.0"
+__author__ = "Praanshull Verma"
+
+from .model_loader import ModelLoader
+from .inference import QAInference
+from .utils import calculate_confidence, format_answer
+
+__all__ = [
+    "ModelLoader",
+    "QAInference", 
+    "calculate_confidence",
+    "format_answer"
+]

app/inference.py

@@ -0,0 +1,116 @@
+"""
+Inference Module
+Handles question answering predictions
+"""
+
+import torch
+from typing import Tuple
+
+
+class QAInference:
+    """Handles question answering inference"""
+    
+    def __init__(self, model, tokenizer, device):
+        """
+        Initialize QA Inference
+        
+        Args:
+            model: Loaded model
+            tokenizer: Loaded tokenizer
+            device: Torch device
+        """
+        self.model = model
+        self.tokenizer = tokenizer
+        self.device = device
+        
+    def answer_question(
+        self, 
+        question: str, 
+        context: str, 
+        language: str = "English",
+        max_length: int = 64
+    ) -> Tuple[str, str]:
+        """
+        Generate answer for given question and context
+        
+        Args:
+            question: Question text
+            context: Context/passage text
+            language: "English" or "German"
+            max_length: Maximum answer length
+            
+        Returns:
+            Tuple of (answer, response_info)
+        """
+        if not question.strip() or not context.strip():
+            return "⚠️ Please provide both a question and context!", ""
+        
+        try:
+            # Configure language
+            if language == "English":
+                self.tokenizer.src_lang = "en_XX"
+                self.tokenizer.tgt_lang = "en_XX"
+                lang_code = self.tokenizer.lang_code_to_id["en_XX"]
+            else:
+                self.tokenizer.src_lang = "de_DE"
+                self.tokenizer.tgt_lang = "de_DE"
+                lang_code = self.tokenizer.lang_code_to_id["de_DE"]
+            
+            self.model.config.forced_bos_token_id = lang_code
+            
+            # Prepare input
+            input_text = f"question: {question} context: {context}"
+            inputs = self.tokenizer(
+                input_text,
+                max_length=256,
+                truncation=True,
+                return_tensors="pt"
+            ).to(self.device)
+            
+            # Generate answer
+            self.model.eval()
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=max_length,
+                    num_beams=4,
+                    early_stopping=True,
+                    forced_bos_token_id=lang_code
+                )
+            
+            answer = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Calculate confidence
+            confidence = self._calculate_confidence(answer, context)
+            
+            # Format response info
+            response_info = f"""
+### 📊 Response Details
+- **Language**: {language}
+- **Answer Length**: {len(answer.split())} words
+- **Confidence**: {confidence}
+- **Model**: mBART-large-50 + LoRA
+            """
+            
+            return answer, response_info
+            
+        except Exception as e:
+            return f"❌ Error: {str(e)}", ""
+    
+    def _calculate_confidence(self, answer: str, context: str) -> str:
+        """
+        Calculate answer confidence (simple heuristic)
+        
+        Args:
+            answer: Generated answer
+            context: Input context
+            
+        Returns:
+            Confidence level string
+        """
+        if len(answer.split()) < 2:
+            return "Low"
+        elif answer.lower() in context.lower():
+            return "High"
+        else:
+            return "Medium"

app/interface.py

@@ -0,0 +1,207 @@
+"""
+Gradio Interface Module
+Defines the web interface layout and interactions
+"""
+
+import gradio as gr
+from .utils import create_performance_chart, create_metrics_table, get_example
+
+
+# Custom CSS
+CUSTOM_CSS = """
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+.header {
+    text-align: center;
+    padding: 20px;
+    background: linear-gradient(90deg, #3498db, #e74c3c);
+    color: white;
+    border-radius: 10px;
+    margin-bottom: 20px;
+}
+"""
+
+
+def create_interface(inference_engine):
+    """
+    Create Gradio interface
+    
+    Args:
+        inference_engine: QAInference instance
+        
+    Returns:
+        Gradio Blocks interface
+    """
+    
+    with gr.Blocks() as demo:
+        
+        # Header
+        gr.Markdown("""
+        <div class="header">
+            <h1>🌍 Multilingual Question Answering System</h1>
+            <p>Fine-tuned mBART-large with LoRA on SQuAD (English) and XQuAD (German)</p>
+            <p><i>Supporting English 🇬🇧 and German 🇩🇪</i></p>
+        </div>
+        """)
+        
+        with gr.Tabs():
+            
+            # Tab 1: Question Answering
+            with gr.Tab("❓ Ask Questions"):
+                
+                gr.Markdown("""### Enter your question and provide context for the model to extract the answer from:
+💡 Tips for Best Results:
+- ✅ Keep context under 300 words
+- ✅ Make sure the answer is explicitly stated in the context
+- ✅ Use clear, direct questions
+- ❌ Avoid questions requiring reasoning across multiple sentences
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        language_choice = gr.Radio(
+                            choices=["English", "German"],
+                            value="English",
+                            label="🌐 Select Language",
+                            info="Choose the language for your question and context"
+                        )
+                        
+                        question_input = gr.Textbox(
+                            label="📝 Question",
+                            placeholder="Enter your question here...",
+                            lines=2
+                        )
+                        
+                        context_input = gr.Textbox(
+                            label="📄 Context",
+                            placeholder="Provide the context/passage containing the answer...",
+                            lines=6
+                        )
+                        
+                        with gr.Row():
+                            submit_btn = gr.Button("🔍 Get Answer", variant="primary", size="lg")
+                            clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                        
+                        gr.Markdown("### 💡 Try Examples:")
+                        example_type = gr.Radio(
+                            choices=["General Knowledge", "Historical", "Scientific"],
+                            value="General Knowledge",
+                            label="Example Type"
+                        )
+                        load_example_btn = gr.Button("📥 Load Example")
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 🎯 Answer")
+                        answer_output = gr.Textbox(
+                            label="Model Answer",
+                            lines=3,
+                            interactive=False
+                        )
+                        response_details = gr.Markdown("")
+                
+                # Button actions
+                submit_btn.click(
+                    fn=inference_engine.answer_question,
+                    inputs=[question_input, context_input, language_choice],
+                    outputs=[answer_output, response_details]
+                )
+                
+                clear_btn.click(
+                    fn=lambda: ("", "", ""),
+                    outputs=[question_input, context_input, answer_output]
+                )
+                
+                load_example_btn.click(
+                    fn=get_example,
+                    inputs=[example_type, language_choice],
+                    outputs=[question_input, context_input]
+                )
+            
+            # Tab 2: Performance Metrics
+            with gr.Tab("📊 Performance Metrics"):
+                gr.Markdown("""
+                ### Model Performance Analysis
+                Evaluation results on SQuAD (English) and XQuAD (German) test sets
+                """)
+                
+                performance_plot = gr.Plot(
+                    value=create_performance_chart(),
+                    label="Performance Comparison"
+                )
+                
+                gr.Markdown("### 📋 Detailed Metrics Table")
+                metrics_df = create_metrics_table()
+                metrics_table = gr.Dataframe(
+                    value=metrics_df,
+                    label="Performance Metrics by Language"
+                )
+                
+                gr.Markdown("""
+                ### 🔑 Key Insights
+                
+                ✅ **German Performance**: 107.2% of English performance (Avg EM+F1)
+                - BLEU: 43.12 vs 37.79 (+5.33 points)
+                - F1 Score: 0.6580 vs 0.6329 (+0.025)
+                - Exact Match: 48.74% vs 43.60% (+5.14%)
+                
+                ✅ **Strong Transfer Learning**: Model successfully adapted to German with limited data
+                
+                ✅ **Training Details**:
+                - Base Model: facebook/mbart-large-50-many-to-many-mmt
+                - Fine-tuning: LoRA (r=8, alpha=32)
+                - English Training: 20,000 samples from SQuAD
+                - German Training: ~950 samples from XQuAD
+                - Total Training Time: ~2.5 hours on T4 GPU
+                """)
+            
+            # Tab 3: About
+            with gr.Tab("ℹ️ About"):
+                gr.Markdown("""
+                # Multilingual Question Answering System
+                
+                ## 🎯 Project Overview
+                This is a state-of-the-art multilingual question answering system that can extract answers from context in both English and German.
+                
+                ## 🛠️ Architecture
+                - **Base Model**: mBART-large-50-many-to-many-mmt (610M parameters)
+                - **Fine-tuning Method**: LoRA (Low-Rank Adaptation)
+                - **Trainable Parameters**: 1.77M (0.29% of total)
+                - **Training Data**:
+                  - English: Stanford Question Answering Dataset (SQuAD)
+                  - German: Cross-lingual Question Answering Dataset (XQuAD)
+                
+                ## 🚀 Key Features
+                - ✅ Bilingual support (English & German)
+                - ✅ Fast inference (<1 second per query)
+                - ✅ Memory-efficient with LoRA
+                - ✅ High accuracy (>0.65 F1 score on both languages)
+                
+                ## 📈 Performance Highlights
+                - Achieved 48.74% exact match on German with minimal training data
+                - BLEU score of 43.12 on German (better than English baseline)
+                - Successfully demonstrated positive transfer learning across languages
+                
+                ## ⚠️ Known Limitations
+                - Long contexts (>500 words) may affect performance
+                - Complex multi-hop reasoning questions may fail
+                - Limited to extractive QA (answer must be in context)
+                
+                ## 👨‍💻 Author
+                Praanshull Verma
+                - GitHub: Praanshull
+                
+                ## 📄 License
+                MIT License
+                """)
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        <div style="text-align: center; padding: 10px;">
+            <p>Built with ❤️ using HuggingFace Transformers, PEFT, and Gradio</p>
+            <p><i>Last Updated: December 2025</i></p>
+        </div>
+        """)
+    
+    return demo

app/model_loader.py

@@ -0,0 +1,78 @@
+"""
+Model Loading Module
+Handles loading mBART + LoRA model from disk
+"""
+
+import torch
+import gc
+from pathlib import Path
+from transformers import MBart50TokenizerFast, MBartForConditionalGeneration
+from peft import PeftModel
+
+
+class ModelLoader:
+    """Handles model and tokenizer loading"""
+    
+    def __init__(self, model_path: str = None):
+        """
+        Initialize ModelLoader
+        
+        Args:
+            model_path: Path to saved model directory
+        """
+        self.model_path = model_path or "models/multilingual_model"
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.tokenizer = None
+        
+    def load(self):
+        """Load model and tokenizer from disk"""
+        print(f"🔧 Loading model from: {self.model_path}")
+        
+        # Clear memory
+        torch.cuda.empty_cache()
+        gc.collect()
+        
+        try:
+            # Load tokenizer
+            print("⏳ Loading tokenizer...")
+            self.tokenizer = MBart50TokenizerFast.from_pretrained(self.model_path)
+            print("✅ Tokenizer loaded")
+            
+            # Load base model
+            print("⏳ Loading base mBART model...")
+            base_model = MBartForConditionalGeneration.from_pretrained(
+                "facebook/mbart-large-50-many-to-many-mmt"
+            )
+            print("✅ Base model loaded")
+            
+            # Load LoRA weights
+            print("⏳ Loading LoRA adapter...")
+            self.model = PeftModel.from_pretrained(base_model, self.model_path)
+            print("✅ LoRA weights loaded")
+            
+            # Move to device
+            self.model = self.model.to(self.device)
+            self.model.eval()
+            
+            print(f"\n✅ MODEL LOADED SUCCESSFULLY!")
+            print(f"💾 Device: {self.device}")
+            print(f"📊 Total parameters: {self.model.num_parameters():,}")
+            
+            return self.model, self.tokenizer
+            
+        except Exception as e:
+            print(f"\n❌ ERROR LOADING MODEL: {str(e)}")
+            raise
+    
+    def get_model_info(self):
+        """Get model information"""
+        if self.model is None:
+            return None
+            
+        return {
+            "device": str(self.device),
+            "parameters": self.model.num_parameters(),
+            "model_path": self.model_path,
+            "base_model": "facebook/mbart-large-50-many-to-many-mmt"
+        }

app/utils.py

@@ -0,0 +1,170 @@
+"""
+Utility Functions
+Helper functions for the QA system
+"""
+
+import pandas as pd
+import plotly.graph_objects as go
+from typing import Dict, Tuple
+
+
+# Performance data from training
+PERFORMANCE_DATA = {
+    'English': {
+        'BLEU': 37.79,
+        'ROUGE-1': 0.6282,
+        'ROUGE-2': 0.3710,
+        'ROUGE-L': 0.6272,
+        'Exact Match': 0.4360,
+        'F1 Score': 0.6329,
+        'Avg (EM+F1)': 0.5344
+    },
+    'German': {
+        'BLEU': 43.12,
+        'ROUGE-1': 0.6646,
+        'ROUGE-2': 0.4064,
+        'ROUGE-L': 0.6622,
+        'Exact Match': 0.4874,
+        'F1 Score': 0.6580,
+        'Avg (EM+F1)': 0.5727
+    }
+}
+
+
+def calculate_confidence(answer: str, context: str) -> str:
+    """
+    Calculate answer confidence level
+    
+    Args:
+        answer: Generated answer
+        context: Input context
+        
+    Returns:
+        Confidence level: "High", "Medium", or "Low"
+    """
+    if len(answer.split()) < 2:
+        return "Low"
+    elif answer.lower() in context.lower():
+        return "High"
+    else:
+        return "Medium"
+
+
+def format_answer(answer: str, language: str, confidence: str) -> str:
+    """
+    Format answer with metadata
+    
+    Args:
+        answer: Generated answer
+        language: Language used
+        confidence: Confidence level
+        
+    Returns:
+        Formatted string with answer details
+    """
+    return f"""
+### 📊 Response Details
+- **Language**: {language}
+- **Answer Length**: {len(answer.split())} words
+- **Confidence**: {confidence}
+- **Model**: mBART-large-50 + LoRA
+    """
+
+
+def create_performance_chart() -> go.Figure:
+    """
+    Create interactive performance comparison chart
+    
+    Returns:
+        Plotly figure object
+    """
+    metrics = ['BLEU', 'ROUGE-L', 'Exact Match', 'F1 Score']
+    
+    english_scores = [
+        PERFORMANCE_DATA['English']['BLEU'] / 100,
+        PERFORMANCE_DATA['English']['ROUGE-L'],
+        PERFORMANCE_DATA['English']['Exact Match'],
+        PERFORMANCE_DATA['English']['F1 Score']
+    ]
+    
+    german_scores = [
+        PERFORMANCE_DATA['German']['BLEU'] / 100,
+        PERFORMANCE_DATA['German']['ROUGE-L'],
+        PERFORMANCE_DATA['German']['Exact Match'],
+        PERFORMANCE_DATA['German']['F1 Score']
+    ]
+    
+    fig = go.Figure(data=[
+        go.Bar(name='English', x=metrics, y=english_scores, marker_color='#3498db'),
+        go.Bar(name='German', x=metrics, y=german_scores, marker_color='#e74c3c')
+    ])
+    
+    fig.update_layout(
+        title='Model Performance Comparison: English vs German',
+        xaxis_title='Metrics',
+        yaxis_title='Score',
+        yaxis_range=[0, 1],
+        barmode='group',
+        template='plotly_white',
+        height=400,
+        font=dict(size=12)
+    )
+    
+    return fig
+
+
+def create_metrics_table() -> pd.DataFrame:
+    """
+    Create detailed metrics table
+    
+    Returns:
+        Pandas DataFrame with metrics
+    """
+    df = pd.DataFrame(PERFORMANCE_DATA).T
+    df = df.round(4)
+    return df
+
+
+def get_example(example_type: str, language: str) -> Tuple[str, str]:
+    """
+    Get example question and context
+    
+    Args:
+        example_type: Type of example ("General Knowledge", "Historical", "Scientific")
+        language: "English" or "German"
+        
+    Returns:
+        Tuple of (question, context)
+    """
+    examples = {
+        "English": {
+            "General Knowledge": (
+                "What is the capital of France?",
+                "Paris is the capital and most populous city of France. It has an area of 105 square kilometres and a population of 2,165,423 residents."
+            ),
+            "Historical": (
+                "When was the Eiffel Tower built?",
+                "The Eiffel Tower was constructed from 1887 to 1889 as the entrance arch to the 1889 World's Fair."
+            ),
+            "Scientific": (
+                "What is the largest planet in our solar system?",
+                "Jupiter is the largest planet in our solar system. It is a gas giant with a mass more than two and a half times that of all the other planets combined."
+            )
+        },
+        "German": {
+            "General Knowledge": (
+                "Was ist die Hauptstadt von Deutschland?",
+                "Berlin ist die Hauptstadt und größte Stadt Deutschlands mit etwa 3,7 Millionen Einwohnern."
+            ),
+            "Historical": (
+                "Wann wurde der Berliner Fernsehturm gebaut?",
+                "Der Berliner Fernsehturm wurde zwischen 1965 und 1969 erbaut und ist eines der bekanntesten Wahrzeichen Berlins."
+            ),
+            "Scientific": (
+                "Was ist der größte Planet in unserem Sonnensystem?",
+                "Jupiter ist der größte Planet in unserem Sonnensystem. Er ist ein Gasriese mit einer Masse, die mehr als zweieinhalb Mal so groß ist wie die aller anderen Planeten zusammen."
+            )
+        }
+    }
+    
+    return examples[language][example_type]