Upload 8 files

README.md

@@ -1,13 +1,44 @@
 ---
-title: UFC
-emoji: 😻
-colorFrom: gray
-colorTo: pink
+title: UFC Fight Predictor
+colorFrom: blue
+colorTo: gray
 sdk: gradio
-sdk_version: 6.0.1
+sdk_version: 3.44.0
 app_file: app.py
 pinned: false
-license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# UFC Fight Predictor
+
+Predict UFC fight outcomes using Machine Learning.
+
+## Model Information
+
+- **Accuracy**: 99%
+- **Algorithm**: Logistic Regression
+- **Features**: Knockdowns, significant strikes, takedowns, submissions
+- **Dataset**: 1,400+ real UFC fights
+
+## How to Use
+
+1. Enter statistics for both fighters
+2. Select weight class
+3. Adjust fight method parameter
+4. Click Submit to get prediction
+
+## Model Features
+
+The model analyzes:
+- Statistical differences between fighters
+- Striking efficiency
+- Weight class
+- Fight round
+
+## Output
+
+The model returns:
+- Predicted winner
+- Probabilities for each fighter
+- Confidence level
+
+Developed for data analysis and machine learning demonstration.

app.py

@@ -0,0 +1,150 @@
+import gradio as gr
+import pickle
+import numpy as np
+import pandas as pd
+import json
+
+print("🚀 Cargando modelo UFC Predictor...")
+
+# Cargar modelo y preprocesadores
+try:
+    with open("ufc_best_model.pkl", "rb") as f:
+        model = pickle.load(f)
+    
+    with open("ufc_scaler.pkl", "rb") as f:
+        scaler = pickle.load(f)
+        
+    with open("ufc_imputer.pkl", "rb") as f:
+        imputer = pickle.load(f)
+        
+    with open("ufc_model_metadata.json", "r") as f:
+        metadata = json.load(f)
+        
+    with open("ufc_feature_ranges.json", "r") as f:
+        ranges = json.load(f)
+        
+    print("✅ Modelo y archivos cargados correctamente")
+    print(f"🏆 Modelo: {metadata['best_model_name']}")
+    print(f"📊 Accuracy: {metadata['best_accuracy']:.4f}")
+    
+except Exception as e:
+    print(f"❌ Error cargando archivos: {e}")
+    raise e
+
+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 basado en las estadísticas
+    """
+    try:
+        # 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
+        fighter_1_accuracy = fighter_1_str / (fighter_1_str + 10)
+        fighter_2_accuracy = fighter_2_str / (fighter_2_str + 10)
+        
+        # Crear array de entrada en el orden CORRECTO
+        input_features = [
+            kd_diff, str_diff, td_diff, sub_diff,  # Diferencias
+            fighter_1_kd, fighter_2_kd,            # KDs individuales
+            fighter_1_str, fighter_2_str,          # Golpes
+            fighter_1_td, fighter_2_td,            # Takedowns
+            fighter_1_sub, fighter_2_sub,          # Submissions
+            fighter_1_accuracy, fighter_2_accuracy, # Precisiones
+            round_num,                             # Round
+            method_encoded                         # Método codificado
+        ]
+        
+        # Añadir one-hot encoding para weight_class
+        weight_classes = [
+            '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'
+        ]
+        
+        for wc in weight_classes:
+            input_features.append(1 if wc == f"weight_class_{weight_class}" else 0)
+        
+        # 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]
+            explanation = f"Fighter 1 tiene {confidence:.1%} de probabilidad de ganar"
+        else:
+            winner = "Fighter 2" 
+            confidence = probability[0]
+            explanation = f"Fighter 2 tiene {confidence:.1%} de probabilidad de ganar"
+        
+        return {
+            "🏆 Ganador predicho": winner,
+            "📈 Confianza": f"{confidence:.1%}",
+            "🥊 Probabilidad Fighter 1": f"{probability[1]:.1%}",
+            "🥊 Probabilidad Fighter 2": f"{probability[0]:.1%}",
+            "💡 Análisis": explanation
+        }
+        
+    except Exception as e:
+        return {"❌ Error": f"Error en predicción: {str(e)}"}
+
+# Crear interfaz Gradio
+print("🎨 Creando interfaz Gradio...")
+
+# Definir inputs
+inputs = [
+    gr.Number(label="Fighter 1 - Knockdowns", value=0, minimum=0, maximum=10),
+    gr.Number(label="Fighter 1 - Golpes significativos", value=50, minimum=0, maximum=500),
+    gr.Number(label="Fighter 1 - Takedowns", value=1, minimum=0, maximum=20),
+    gr.Number(label="Fighter 1 - Intentos de sumisión", value=0, minimum=0, maximum=10),
+    gr.Number(label="Fighter 2 - Knockdowns", value=0, minimum=0, maximum=10),
+    gr.Number(label="Fighter 2 - Golpes significativos", value=45, minimum=0, maximum=500),
+    gr.Number(label="Fighter 2 - Takedowns", value=2, minimum=0, maximum=20),
+    gr.Number(label="Fighter 2 - Intentos de sumisión", value=1, minimum=0, maximum=10),
+    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 (encoded) - 0-10 scale")
+]
+
+# 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 basado en estadísticas de los peleadores. Modelo entrenado con accuracy del 99%",
+    examples=[
+        [2, 120, 3, 1, 0, 80, 1, 0, 3, "Lightweight", 5],  # Fighter 1 favorito
+        [0, 80, 1, 0, 3, 150, 4, 2, 2, "Welterweight", 5]   # Fighter 2 favorito
+    ]
+)
+
+print("✅ Interfaz creada. Iniciando...")
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+scikit-learn==1.3.0
+pandas==2.0.3
+numpy==1.24.3
+gradio==3.44.0

ufc_best_model.pkl

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

ufc_feature_ranges.json

@@ -0,0 +1,152 @@
+{
+  "KD_diff": {
+    "min": -3.0,
+    "max": 5.0,
+    "mean": 0.30335715248752865,
+    "dtype": "float64"
+  },
+  "STR_diff": {
+    "min": -112.0,
+    "max": 312.0,
+    "mean": 14.560199541593636,
+    "dtype": "float64"
+  },
+  "TD_diff": {
+    "min": -11.0,
+    "max": 20.0,
+    "mean": 0.785762437643252,
+    "dtype": "float64"
+  },
+  "SUB_diff": {
+    "min": -7.0,
+    "max": 10.0,
+    "mean": 0.281380612107321,
+    "dtype": "float64"
+  },
+  "Fighter_1_KD": {
+    "min": 0.0,
+    "max": 5.0,
+    "mean": 0.36685991640825133,
+    "dtype": "float64"
+  },
+  "Fighter_2_KD": {
+    "min": 0.0,
+    "max": 3.0,
+    "mean": 0.06350276392072267,
+    "dtype": "float64"
+  },
+  "Fighter_1_STR": {
+    "min": 0.0,
+    "max": 445.0,
+    "mean": 43.114601590939735,
+    "dtype": "float64"
+  },
+  "Fighter_2_STR": {
+    "min": 0.0,
+    "max": 271.0,
+    "mean": 28.5544020493461,
+    "dtype": "float64"
+  },
+  "Fighter_1_TD": {
+    "min": 0.0,
+    "max": 21.0,
+    "mean": 1.4516650937036537,
+    "dtype": "float64"
+  },
+  "Fighter_2_TD": {
+    "min": 0.0,
+    "max": 11.0,
+    "mean": 0.6659026560604018,
+    "dtype": "float64"
+  },
+  "Fighter_1_SUB": {
+    "min": 0.0,
+    "max": 10.0,
+    "mean": 0.5317513819603613,
+    "dtype": "float64"
+  },
+  "Fighter_2_SUB": {
+    "min": 0.0,
+    "max": 7.0,
+    "mean": 0.2503707698530403,
+    "dtype": "float64"
+  },
+  "Fighter_1_accuracy": {
+    "min": 0.0,
+    "max": 0.978021978021978,
+    "mean": 0.7139546070716276,
+    "dtype": "float64"
+  },
+  "Fighter_2_accuracy": {
+    "min": 0.0,
+    "max": 0.9644128113879004,
+    "mean": 0.6003475272273104,
+    "dtype": "float64"
+  },
+  "Round": {
+    "min": 1.0,
+    "max": 5.0,
+    "mean": 2.33832456495346,
+    "dtype": "float64"
+  },
+  "weight_class_Bantamweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.08534447889982473,
+    "dtype": "bool"
+  },
+  "weight_class_Catch Weight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.008763651071861939,
+    "dtype": "bool"
+  },
+  "weight_class_Featherweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.09572603478495348,
+    "dtype": "bool"
+  },
+  "weight_class_Flyweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.042065525144937305,
+    "dtype": "bool"
+  },
+  "weight_class_Heavyweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.09222057435620871,
+    "dtype": "bool"
+  },
+  "weight_class_Light Heavyweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.08911959013078063,
+    "dtype": "bool"
+  },
+  "weight_class_Lightweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.17365511662397196,
+    "dtype": "bool"
+  },
+  "weight_class_Middleweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.13334232169340704,
+    "dtype": "bool"
+  },
+  "weight_class_Welterweight": {
+    "min": 0.0,
+    "max": 1.0,
+    "mean": 0.16826210057974922,
+    "dtype": "bool"
+  },
+  "Method_encoded": {
+    "min": 0.0,
+    "max": 70.0,
+    "mean": 41.41000404476203,
+    "dtype": "int64"
+  }
+}

ufc_imputer.pkl

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

ufc_model_metadata.json

@@ -0,0 +1,35 @@
+{
+  "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"
+}

ufc_scaler.pkl

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