Upload 4 files

app.py

@@ -0,0 +1,261 @@
+"""
+Gradio application for Game of Thrones House Prediction
+Interactive web interface for character house prediction
+Deployed on HuggingFace Spaces
+"""
+
+import gradio as gr
+import pandas as pd
+import joblib
+import json
+import os
+
+# Model paths (HuggingFace structure)
+MODEL_PATH = "model.pkl"
+FEATURE_NAMES_PATH = "feature_names.json"
+
+# Load model and features
+model = None
+feature_columns = None
+
+
+def load_model():
+    """Load the trained model and feature columns"""
+    global model, feature_columns
+    
+    if not os.path.exists(MODEL_PATH):
+        return False, f"Model not found at {MODEL_PATH}"
+    
+    try:
+        model = joblib.load(MODEL_PATH)
+        
+        # Load feature columns from JSON
+        if os.path.exists(FEATURE_NAMES_PATH):
+            with open(FEATURE_NAMES_PATH, 'r') as f:
+                feature_data = json.load(f)
+                feature_columns = feature_data.get('features', [])
+        
+        return True, "Model loaded successfully"
+    except Exception as e:
+        return False, f"Error loading model: {str(e)}"
+
+
+def preprocess_input(region, primary_role, alignment, status, species,
+                     honour, ruthlessness, intelligence, combat_skill,
+                     diplomacy, leadership, trait_loyal, trait_scheming):
+    """Preprocess input data to match training format"""
+    
+    # Create input dictionary
+    input_dict = {
+        "honour_1to5": [honour],
+        "ruthlessness_1to5": [ruthlessness],
+        "intelligence_1to5": [intelligence],
+        "combat_skill_1to5": [combat_skill],
+        "diplomacy_1to5": [diplomacy],
+        "leadership_1to5": [leadership],
+        "trait_loyal": [1 if trait_loyal else 0],
+        "trait_scheming": [1 if trait_scheming else 0],
+        "trait_strategic": [0],
+        "trait_impulsive": [0],
+        "trait_charismatic": [0],
+        "trait_vengeful": [0],
+        "feature_set_version": [1],
+        "region": [region],
+        "primary_role": [primary_role],
+        "alignment": [alignment],
+        "status": [status],
+        "species": [species]
+    }
+    
+    # Create DataFrame
+    df = pd.DataFrame(input_dict)
+    
+    # One-hot encode categorical features
+    categorical_cols = ["region", "primary_role", "alignment", "status", "species"]
+    df_encoded = pd.get_dummies(df, columns=categorical_cols, drop_first=False)
+    
+    # Align with training features
+    if feature_columns is not None:
+        # Add missing columns with 0
+        for col in feature_columns:
+            if col not in df_encoded.columns:
+                df_encoded[col] = 0
+        # Reorder columns to match training
+        df_encoded = df_encoded[feature_columns]
+    
+    return df_encoded
+
+
+def predict_house(region, primary_role, alignment, status, species,
+                 honour, ruthlessness, intelligence, combat_skill,
+                 diplomacy, leadership, trait_loyal, trait_scheming):
+    """
+    Predict house affiliation for a character
+    
+    Returns:
+        str: Prediction result with house name and confidence
+    """
+    if model is None:
+        return "❌ Error: Model not loaded. Please contact the administrator."
+    
+    try:
+        # Preprocess input
+        input_df = preprocess_input(
+            region, primary_role, alignment, status, species,
+            honour, ruthlessness, intelligence, combat_skill,
+            diplomacy, leadership, trait_loyal, trait_scheming
+        )
+        
+        # Make prediction
+        prediction = model.predict(input_df)[0]
+        
+        # Get prediction probability if available
+        result = f"🏰 **Predicted House: {prediction}**\n\n"
+        
+        if hasattr(model, 'predict_proba'):
+            proba = model.predict_proba(input_df)[0]
+            confidence = max(proba)
+            result += f"📊 Confidence: {confidence:.2%}\n\n"
+            
+            # Show top 3 probabilities
+            classes = model.classes_
+            proba_dict = dict(zip(classes, proba))
+            sorted_proba = sorted(proba_dict.items(), key=lambda x: x[1], reverse=True)[:3]
+            
+            result += "**Top 3 Predictions:**\n"
+            for house, prob in sorted_proba:
+                result += f"- {house}: {prob:.2%}\n"
+        
+        return result
+        
+    except Exception as e:
+        return f"❌ Error during prediction: {str(e)}"
+
+
+# Character attribute options
+regions = [
+    "The North", "Crownlands", "Dorne", "Essos", "Iron Islands",
+    "King's Landing", "The Reach", "The Riverlands", "The Stormlands",
+    "The Vale", "The Westerlands", "Beyond the Wall"
+]
+
+roles = [
+    "Commander", "Ruler", "Knight/Warrior", "Advisor", "Noble",
+    "Merchant/Noble", "Scholar/Healer", "Assassin/Spy", "Religious leader",
+    "Mage/Seer", "Commoner"
+]
+
+alignments = [
+    "Lawful Good", "Neutral Good", "Chaotic Good",
+    "Lawful Neutral", "True Neutral", "Chaotic Neutral",
+    "Lawful Evil", "Neutral Evil", "Chaotic Evil"
+]
+
+statuses = ["Alive", "Deceased", "Unknown/Varies"]
+
+species_list = ["Human", "Warg", "White Walker"]
+
+
+# Load model on startup
+success, message = load_model()
+if not success:
+    print(f"⚠️ Warning: {message}")
+
+
+# Create Gradio interface
+with gr.Blocks(title="Game of Thrones House Predictor", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🏰 Game of Thrones House Predictor
+        
+        Enter a character's attributes to predict which house they belong to!
+        
+        This model was trained on Game of Thrones character data using **Azure Machine Learning** with **MLFlow tracking**.
+        The Decision Tree classifier analyzes character attributes, roles, and traits to predict house affiliation.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📍 Basic Information")
+            region = gr.Dropdown(choices=regions, label="Region", value="The North")
+            primary_role = gr.Dropdown(choices=roles, label="Primary Role", value="Commander")
+            alignment = gr.Dropdown(choices=alignments, label="Alignment", value="Lawful Good")
+            status = gr.Dropdown(choices=statuses, label="Status", value="Alive")
+            species = gr.Dropdown(choices=species_list, label="Species", value="Human")
+            
+        with gr.Column():
+            gr.Markdown("### 📊 Attributes (1-5)")
+            honour = gr.Slider(minimum=1, maximum=5, step=1, value=4, label="Honour")
+            ruthlessness = gr.Slider(minimum=1, maximum=5, step=1, value=2, label="Ruthlessness")
+            intelligence = gr.Slider(minimum=1, maximum=5, step=1, value=3, label="Intelligence")
+            combat_skill = gr.Slider(minimum=1, maximum=5, step=1, value=4, label="Combat Skill")
+            diplomacy = gr.Slider(minimum=1, maximum=5, step=1, value=3, label="Diplomacy")
+            leadership = gr.Slider(minimum=1, maximum=5, step=1, value=4, label="Leadership")
+    
+    with gr.Row():
+        gr.Markdown("### 🎭 Character Traits")
+    
+    with gr.Row():
+        trait_loyal = gr.Checkbox(label="Loyal", value=True)
+        trait_scheming = gr.Checkbox(label="Scheming", value=False)
+    
+    predict_btn = gr.Button("🔮 Predict House", variant="primary", size="lg")
+    
+    output = gr.Markdown(label="Prediction Result")
+    
+    # Examples
+    gr.Markdown("### 📝 Example Characters")
+    gr.Examples(
+        examples=[
+            ["The North", "Commander", "Lawful Good", "Alive", "Human", 4, 2, 3, 4, 3, 4, True, False],
+            ["King's Landing", "Ruler", "Neutral Evil", "Deceased", "Human", 2, 5, 4, 2, 3, 3, False, True],
+            ["The Reach", "Knight/Warrior", "Lawful Neutral", "Alive", "Human", 4, 3, 2, 5, 2, 3, True, False],
+            ["Essos", "Ruler", "Chaotic Good", "Alive", "Human", 3, 4, 4, 3, 4, 5, True, False],
+            ["The Westerlands", "Noble", "Lawful Evil", "Alive", "Human", 2, 5, 5, 3, 4, 4, False, True],
+        ],
+        inputs=[region, primary_role, alignment, status, species, honour, ruthlessness, 
+                intelligence, combat_skill, diplomacy, leadership, trait_loyal, trait_scheming],
+    )
+    
+    # Connect prediction function
+    predict_btn.click(
+        fn=predict_house,
+        inputs=[region, primary_role, alignment, status, species, honour, ruthlessness,
+                intelligence, combat_skill, diplomacy, leadership, trait_loyal, trait_scheming],
+        outputs=output
+    )
+    
+    gr.Markdown(
+        """
+        ---
+        ### 📚 About This Model
+        
+        **Training Pipeline:**
+        - Data source: Game of Thrones character dataset (100 characters)
+        - Algorithm: Decision Tree Classifier (scikit-learn)
+        - Training platform: Azure Machine Learning
+        - Experiment tracking: MLFlow
+        - Pipeline: Automated data preparation, training, and model registration
+        
+        **Features Used:**
+        - **Geographic**: Region (12 regions across Westeros and Essos)
+        - **Role**: Primary character role (11 types)
+        - **Alignment**: D&D-style alignment (9 categories)
+        - **Attributes**: 6 numeric scores (honour, ruthlessness, intelligence, combat skill, diplomacy, leadership)
+        - **Traits**: Personality traits (loyal, scheming)
+        
+        **Model Performance:**
+        - Trained with stratified train/test split
+        - Metrics logged: accuracy, precision, recall, F1-score (overall and per-class)
+        - Model registered and versioned in Azure ML Model Registry
+        
+        ---
+        
+        *Developed as part of an MLOps exam project demonstrating end-to-end ML pipeline deployment.*
+        """
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

feature_names.json

@@ -0,0 +1,59 @@
+{
+  "features": [
+    "honour_1to5",
+    "ruthlessness_1to5",
+    "intelligence_1to5",
+    "combat_skill_1to5",
+    "diplomacy_1to5",
+    "leadership_1to5",
+    "trait_strategic",
+    "trait_impulsive",
+    "trait_charismatic",
+    "trait_vengeful",
+    "trait_loyal",
+    "trait_scheming",
+    "feature_set_version",
+    "region_Beyond the Wall",
+    "region_Crownlands",
+    "region_Dorne",
+    "region_Essos",
+    "region_Iron Islands",
+    "region_King's Landing",
+    "region_The North",
+    "region_The Reach",
+    "region_The Riverlands",
+    "region_The Stormlands",
+    "region_The Vale",
+    "region_The Westerlands",
+    "region_nan",
+    "primary_role_Advisor",
+    "primary_role_Assassin/Spy",
+    "primary_role_Commander",
+    "primary_role_Commoner",
+    "primary_role_Knight/Warrior",
+    "primary_role_Mage/Seer",
+    "primary_role_Merchant/Noble",
+    "primary_role_Religious leader",
+    "primary_role_Ruler",
+    "primary_role_Scholar/Healer",
+    "primary_role_nan",
+    "alignment_Chaotic Evil",
+    "alignment_Chaotic Good",
+    "alignment_Chaotic Neutral",
+    "alignment_Lawful Evil",
+    "alignment_Lawful Good",
+    "alignment_Lawful Neutral",
+    "alignment_Neutral Evil",
+    "alignment_Neutral Good",
+    "alignment_True Neutral",
+    "alignment_nan",
+    "status_Alive",
+    "status_Deceased",
+    "status_Unknown/Varies",
+    "status_nan",
+    "species_Human",
+    "species_Warg",
+    "species_White Walker",
+    "species_nan"
+  ]
+}

model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b8b934dc8aacaa830ce2ab9d817d95d9cf497d5d8b1429c7ec82bddd2f9bddf
+size 10121

requirements.txt

@@ -0,0 +1,4 @@
+gradio==4.44.0
+pandas==2.1.4
+scikit-learn==1.3.2
+joblib==1.3.2