Upload 8 files

README.md

@@ -0,0 +1,66 @@
+---
+title: UFC Fight Predictor
+emoji: 🥊
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.19.2
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# UFC Fight Predictor
+
+A machine learning application that predicts UFC fight outcomes based on fighter statistics.
+
+## Model Performance
+
+- **Accuracy**: 98.9%
+- **Best Algorithm**: Logistic Regression
+- **Dataset**: 7,417 UFC fights
+- **Features**: 25 statistical indicators
+
+## Features Analyzed
+
+- Knockdown differences between fighters
+- Significant strike statistics  
+- Takedown attempts and success rates
+- Submission attempts
+- Striking accuracy
+- Weight class
+- Fight round
+- Method of victory encoding
+
+## How to Use
+
+1. **Enter fighter statistics** for both competitors
+2. **Select weight class** from dropdown
+3. **Adjust method parameter** (0-10 scale)
+4. **Click Submit** to get prediction
+
+## Output Information
+
+The model returns:
+- Predicted winner
+- Confidence percentage
+- Individual probabilities for each fighter
+- Detailed analysis
+
+## Technical Details
+
+Built with:
+- Scikit-learn for machine learning
+- Gradio for web interface
+- Pandas for data processing
+- NumPy for numerical operations
+
+## Model Validation
+
+The model was validated using:
+- Train/test split (80/20)
+- Multiple algorithm comparison
+- Cross-validation techniques
+- Comprehensive metrics (Accuracy, AUC, F1-Score)
+
+*For educational and demonstration purposes.*

app.py

@@ -0,0 +1,203 @@
+import gradio as gr
+import pickle
+import numpy as np
+import pandas as pd
+import json
+import os
+
+print("=== INICIANDO UFC PREDICTOR ===")
+
+def safe_load_pickle(filepath, default_value=None):
+    """Cargar archivos pickle de forma segura"""
+    try:
+        with open(filepath, "rb") as f:
+            return pickle.load(f)
+    except Exception as e:
+        print(f"Error cargando {filepath}: {e}")
+        return default_value
+
+def safe_load_json(filepath, default_value=None):
+    """Cargar archivos JSON de forma segura"""
+    try:
+        with open(filepath, "r") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error cargando {filepath}: {e}")
+        return default_value
+
+# Cargar modelo y preprocesadores de forma segura
+print("Cargando modelo y componentes...")
+
+model = safe_load_pickle("ufc_best_model.pkl")
+scaler = safe_load_pickle("ufc_scaler.pkl") 
+imputer = safe_load_pickle("ufc_imputer.pkl")
+metadata = safe_load_json("ufc_model_metadata.json", {})
+ranges = safe_load_json("ufc_feature_ranges.json", {})
+
+# Verificar que todo se cargó correctamente
+components_loaded = all([model is not None, scaler is not None, imputer is not None])
+if not components_loaded:
+    print("❌ ERROR: No se pudieron cargar todos los componentes del modelo")
+    raise Exception("Fallo en la carga de componentes del modelo")
+
+print("✅ Todos los componentes cargados correctamente")
+
+if metadata:
+    print(f"Modelo: {metadata.get('best_model_selected', 'N/A')}")
+    print(f"Accuracy: {metadata.get('evaluation_metrics', {}).get('accuracy', 'N/A')}")
+
+# Obtener características del modelo
+feature_columns = metadata.get('feature_columns', [])
+if not feature_columns:
+    print("⚠️ Advertencia: No se encontraron feature_columns en metadata")
+
+print(f"Características del modelo: {len(feature_columns)}")
+
+def predict_ufc_fight(
+    fighter_1_kd, fighter_1_str, fighter_1_td, fighter_1_sub,
+    fighter_2_kd, fighter_2_str, fighter_2_td, fighter_2_sub,
+    round_num, weight_class, method_encoded
+):
+    """
+    Predice el resultado de una pelea UFC
+    """
+    try:
+        # Validar entradas básicas
+        if any(pd.isna(x) for x in [fighter_1_kd, fighter_1_str, fighter_2_kd, fighter_2_str]):
+            return {"Error": "Valores de entrada inválidos o faltantes"}
+        
+        # Calcular diferencias
+        kd_diff = fighter_1_kd - fighter_2_kd
+        str_diff = fighter_1_str - fighter_2_str
+        td_diff = fighter_1_td - fighter_2_td
+        sub_diff = fighter_1_sub - fighter_2_sub
+        
+        # Calcular precisiones (evitar división por cero)
+        fighter_1_accuracy = fighter_1_str / (fighter_1_str + 10) if fighter_1_str >= 0 else 0
+        fighter_2_accuracy = fighter_2_str / (fighter_2_str + 10) if fighter_2_str >= 0 else 0
+        
+        # Crear array de entrada con las características en el orden CORRECTO
+        input_features = []
+        
+        # Añadir características en el orden esperado por el modelo
+        for feature in feature_columns:
+            if feature == 'KD_diff':
+                input_features.append(kd_diff)
+            elif feature == 'STR_diff':
+                input_features.append(str_diff)
+            elif feature == 'TD_diff':
+                input_features.append(td_diff)
+            elif feature == 'SUB_diff':
+                input_features.append(sub_diff)
+            elif feature == 'Fighter_1_KD':
+                input_features.append(fighter_1_kd)
+            elif feature == 'Fighter_2_KD':
+                input_features.append(fighter_2_kd)
+            elif feature == 'Fighter_1_STR':
+                input_features.append(fighter_1_str)
+            elif feature == 'Fighter_2_STR':
+                input_features.append(fighter_2_str)
+            elif feature == 'Fighter_1_TD':
+                input_features.append(fighter_1_td)
+            elif feature == 'Fighter_2_TD':
+                input_features.append(fighter_2_td)
+            elif feature == 'Fighter_1_SUB':
+                input_features.append(fighter_1_sub)
+            elif feature == 'Fighter_2_SUB':
+                input_features.append(fighter_2_sub)
+            elif feature == 'Fighter_1_accuracy':
+                input_features.append(fighter_1_accuracy)
+            elif feature == 'Fighter_2_accuracy':
+                input_features.append(fighter_2_accuracy)
+            elif feature == 'Round':
+                input_features.append(round_num)
+            elif feature == 'Method_encoded':
+                input_features.append(method_encoded)
+            elif feature.startswith('weight_class_'):
+                # One-hot encoding para categorías de peso
+                category_name = feature.replace('weight_class_', '')
+                input_features.append(1 if category_name == weight_class else 0)
+            else:
+                # Característica no reconocida, usar 0
+                input_features.append(0)
+                print(f"⚠️ Caracter��stica no reconocida: {feature}")
+        
+        # Convertir a numpy array
+        input_array = np.array([input_features])
+        
+        # Aplicar preprocesamiento
+        input_imputed = imputer.transform(input_array)
+        input_scaled = scaler.transform(input_imputed)
+        
+        # Hacer predicción
+        prediction = model.predict(input_scaled)[0]
+        probability = model.predict_proba(input_scaled)[0]
+        
+        # Interpretar resultados
+        if prediction == 1:
+            winner = "Fighter 1"
+            confidence = probability[1]
+            color = "#FF6B6B"  # Rojo
+        else:
+            winner = "Fighter 2" 
+            confidence = probability[0]
+            color = "#4ECDC4"  # Verde
+        
+        return {
+            "Ganador predicho": winner,
+            "Confianza": f"{confidence:.1%}",
+            "Probabilidad Fighter 1": f"{probability[1]:.1%}",
+            "Probabilidad Fighter 2": f"{probability[0]:.1%}",
+            "Análisis": f"El modelo predice que {winner} ganará con {confidence:.1%} de confianza"
+        }
+        
+    except Exception as e:
+        error_msg = f"Error en predicción: {str(e)}"
+        print(error_msg)
+        return {"Error": error_msg}
+
+# Crear interfaz Gradio
+print("Configurando interfaz Gradio...")
+
+# Definir inputs con valores por defecto razonables
+inputs = [
+    gr.Number(label="Fighter 1 - Knockdowns", value=0, minimum=0, maximum=10, step=1),
+    gr.Number(label="Fighter 1 - Golpes significativos", value=50, minimum=0, maximum=500, step=1),
+    gr.Number(label="Fighter 1 - Takedowns", value=1, minimum=0, maximum=20, step=1),
+    gr.Number(label="Fighter 1 - Intentos de sumisión", value=0, minimum=0, maximum=10, step=1),
+    gr.Number(label="Fighter 2 - Knockdowns", value=0, minimum=0, maximum=10, step=1),
+    gr.Number(label="Fighter 2 - Golpes significativos", value=45, minimum=0, maximum=500, step=1),
+    gr.Number(label="Fighter 2 - Takedowns", value=2, minimum=0, maximum=20, step=1),
+    gr.Number(label="Fighter 2 - Intentos de sumisión", value=1, minimum=0, maximum=10, step=1),
+    gr.Slider(1, 5, value=3, step=1, label="Round"),
+    gr.Dropdown(
+        choices=[
+            "Bantamweight", "Catch Weight", "Featherweight", "Flyweight",
+            "Heavyweight", "Light Heavyweight", "Lightweight", "Middleweight", "Welterweight"
+        ],
+        value="Lightweight",
+        label="Categoría de Peso"
+    ),
+    gr.Slider(0, 10, value=5, step=1, label="Método (0-10)")
+]
+
+# Crear la aplicación
+demo = gr.Interface(
+    fn=predict_ufc_fight,
+    inputs=inputs,
+    outputs="json",
+    title="UFC Fight Predictor",
+    description="Predice el resultado de peleas UFC usando Machine Learning. Modelo entrenado con datos reales.",
+    examples=[
+        [2, 120, 3, 1, 0, 80, 1, 0, 3, "Lightweight", 5],
+        [0, 80, 1, 0, 3, 150, 4, 2, 2, "Welterweight", 5],
+        [1, 100, 2, 0, 1, 95, 1, 1, 4, "Middleweight", 6]
+    ],
+    theme="default"
+)
+
+print("✅ Interfaz configurada")
+
+if __name__ == "__main__":
+    print("🚀 Iniciando aplicación...")
+    demo.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,4 @@
+scikit-learn==1.3.2
+pandas==2.1.4
+numpy==1.24.3
+gradio==4.19.2

ufc_best_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0439d5739c065b12e66cbb22e80486312975e183c18e53fddb353f633961f24f
+size 917

ufc_feature_ranges.json

@@ -0,0 +1,177 @@
+{
+  "KD_diff": {
+    "min": -3.0,
+    "max": 5.0,
+    "mean": 0.30335715248752865,
+    "std": 0.6696380391016917,
+    "type": "numeric"
+  },
+  "STR_diff": {
+    "min": -112.0,
+    "max": 312.0,
+    "mean": 14.560199541593636,
+    "std": 22.449419867501298,
+    "type": "numeric"
+  },
+  "TD_diff": {
+    "min": -11.0,
+    "max": 20.0,
+    "mean": 0.785762437643252,
+    "std": 2.3930346750438454,
+    "type": "numeric"
+  },
+  "SUB_diff": {
+    "min": -7.0,
+    "max": 10.0,
+    "mean": 0.281380612107321,
+    "std": 1.1263107348466987,
+    "type": "numeric"
+  },
+  "Fighter_1_KD": {
+    "min": 0.0,
+    "max": 5.0,
+    "mean": 0.36685991640825133,
+    "std": 0.6072616760376748,
+    "type": "numeric"
+  },
+  "Fighter_2_KD": {
+    "min": 0.0,
+    "max": 3.0,
+    "mean": 0.06350276392072267,
+    "std": 0.26811152820774914,
+    "type": "numeric"
+  },
+  "Fighter_1_STR": {
+    "min": 0.0,
+    "max": 445.0,
+    "mean": 43.114601590939735,
+    "std": 34.38830665983602,
+    "type": "numeric"
+  },
+  "Fighter_2_STR": {
+    "min": 0.0,
+    "max": 271.0,
+    "mean": 28.5544020493461,
+    "std": 26.9280732660874,
+    "type": "numeric"
+  },
+  "Fighter_1_TD": {
+    "min": 0.0,
+    "max": 21.0,
+    "mean": 1.4516650937036537,
+    "std": 1.9804506373774997,
+    "type": "numeric"
+  },
+  "Fighter_2_TD": {
+    "min": 0.0,
+    "max": 11.0,
+    "mean": 0.6659026560604018,
+    "std": 1.186385983547397,
+    "type": "numeric"
+  },
+  "Fighter_1_SUB": {
+    "min": 0.0,
+    "max": 10.0,
+    "mean": 0.5317513819603613,
+    "std": 0.939138539301686,
+    "type": "numeric"
+  },
+  "Fighter_2_SUB": {
+    "min": 0.0,
+    "max": 7.0,
+    "mean": 0.2503707698530403,
+    "std": 0.6889540600963606,
+    "type": "numeric"
+  },
+  "Fighter_1_accuracy": {
+    "min": 0.0,
+    "max": 0.978021978021978,
+    "mean": 0.7139546070716276,
+    "std": 0.19988857830200385,
+    "type": "numeric"
+  },
+  "Fighter_2_accuracy": {
+    "min": 0.0,
+    "max": 0.9644128113879004,
+    "mean": 0.6003475272273104,
+    "std": 0.25593203607262505,
+    "type": "numeric"
+  },
+  "Round": {
+    "min": 1.0,
+    "max": 5.0,
+    "mean": 2.33832456495346,
+    "std": 1.0137666795727949,
+    "type": "numeric"
+  },
+  "weight_class_Bantamweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.08534447889982473,
+    "std": 0.27941246360680766,
+    "type": "numeric"
+  },
+  "weight_class_Catch Weight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.008763651071861939,
+    "std": 0.09320955346770812,
+    "type": "numeric"
+  },
+  "weight_class_Featherweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.09572603478495348,
+    "std": 0.29423499699229244,
+    "type": "numeric"
+  },
+  "weight_class_Flyweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.042065525144937305,
+    "std": 0.20075221144095287,
+    "type": "numeric"
+  },
+  "weight_class_Heavyweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.09222057435620871,
+    "std": 0.2893565768715069,
+    "type": "numeric"
+  },
+  "weight_class_Light Heavyweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.08911959013078063,
+    "std": 0.2849354927383638,
+    "type": "numeric"
+  },
+  "weight_class_Lightweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.17365511662397196,
+    "std": 0.37883818051469625,
+    "type": "numeric"
+  },
+  "weight_class_Middleweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.13334232169340704,
+    "std": 0.33996724805867956,
+    "type": "numeric"
+  },
+  "weight_class_Welterweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.16826210057974922,
+    "std": 0.3741240936412544,
+    "type": "numeric"
+  },
+  "Method_encoded": {
+    "min": 0.0,
+    "max": 70.0,
+    "mean": 41.41000404476203,
+    "std": 24.947437131515553,
+    "type": "numeric"
+  }
+}

ufc_imputer.pkl

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

ufc_model_metadata.json

@@ -0,0 +1,77 @@
+{
+  "feature_columns": [
+    "KD_diff",
+    "STR_diff",
+    "TD_diff",
+    "SUB_diff",
+    "Fighter_1_KD",
+    "Fighter_2_KD",
+    "Fighter_1_STR",
+    "Fighter_2_STR",
+    "Fighter_1_TD",
+    "Fighter_2_TD",
+    "Fighter_1_SUB",
+    "Fighter_2_SUB",
+    "Fighter_1_accuracy",
+    "Fighter_2_accuracy",
+    "Round",
+    "weight_class_Bantamweight",
+    "weight_class_Catch Weight",
+    "weight_class_Featherweight",
+    "weight_class_Flyweight",
+    "weight_class_Heavyweight",
+    "weight_class_Light Heavyweight",
+    "weight_class_Lightweight",
+    "weight_class_Middleweight",
+    "weight_class_Welterweight",
+    "Method_encoded"
+  ],
+  "best_model_name": "Regresi\u00f3n Log\u00edstica",
+  "best_accuracy": 0.9892183288409704,
+  "best_auc": 0.9834103566773315,
+  "model_type": "LogisticRegression",
+  "input_requirements": "Ver feature_ranges.json para rangos",
+  "training_date": "2025-11-28 02:46:41",
+  "best_model_selected": "Regresi\u00f3n Log\u00edstica",
+  "comparison_results": [
+    {
+      "Modelo": "Regresi\u00f3n Log\u00edstica",
+      "Accuracy": 0.9892183288409704,
+      "AUC": 0.9834103566773315,
+      "Precision": 0.9911262798634812,
+      "Recall": 0.9979381443298969,
+      "F1-Score": 0.9945205479452055
+    },
+    {
+      "Modelo": "Random Forest",
+      "Accuracy": 0.9824797843665768,
+      "AUC": 0.9603863016945137,
+      "Precision": 0.983750846310088,
+      "Recall": 0.9986254295532646,
+      "F1-Score": 0.9911323328785812
+    },
+    {
+      "Modelo": "SVM",
+      "Accuracy": 0.9811320754716981,
+      "AUC": 0.9674842990875696,
+      "Precision": 0.9811193526635199,
+      "Recall": 1.0,
+      "F1-Score": 0.9904697072838666
+    },
+    {
+      "Modelo": "\u00c1rbol de Decisi\u00f3n",
+      "Accuracy": 0.9743935309973046,
+      "AUC": 0.8437848086266146,
+      "Precision": 0.981645139360979,
+      "Recall": 0.9924398625429554,
+      "F1-Score": 0.987012987012987
+    }
+  ],
+  "evaluation_metrics": {
+    "accuracy": 0.9892183288409704,
+    "auc": 0.9834103566773315,
+    "precision": 0.9911262798634812,
+    "recall": 0.9979381443298969,
+    "f1_score": 0.9945205479452055
+  }
+}

ufc_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76e30ff703ff64e759019a17f72b06531b6e6c1fb300026cefceb1f668edfca8
+size 1050