¿Cómo entrenar un modelo para predecir ángulos / mapas?

¿Qué es un modelo para predecir córners y tarjetas en el fútbol?

Un modelo para predecir córners y tarjetas en el fútbol es un algoritmo formalizado que evalúa, basado en estadísticas históricas y actuales del partido, cuántos tiros de esquina y sanciones disciplinarias (tarjetas amarillas y rojas) ocurrirán en el juego. Tales modelos se construyen más a menudo en dos formatos: regresión (prediciendo el número exacto de eventos) y probabilístico (evaluando las posibilidades de que el total de córners o tarjetas supere un valor dado). Un modelo de calidad tiene en cuenta los estilos de los equipos, la fuerza de los oponentes, el contexto del torneo e incluso la dinámica del partido.

En tareas aplicadas, predecir córners y tarjetas se utiliza para varios propósitos. Los analistas de clubes y las plataformas de medios los utilizan para estadísticas avanzadas y visualizaciones. Las casas de apuestas y los jugadores profesionales comparan las predicciones del modelo con las cuotas de los corredores de apuestas para encontrar mercados subvalorados. Los proveedores de datos y las startups deportivas integran tales cálculos directamente en sus productos, utilizando un flujo confiable de datos de partidos, por ejemplo, a través de la API de eventos deportivos disponible en el servicio. api-sport.pro.

Es importante entender que el modelo no «adivina» el futuro al azar. Se basa en grandes volúmenes de datos estructurados: estadísticas detalladas del partido, eventos en vivo, información sobre torneos y equipos. Cuanto más rica y limpia sea la fuente de datos, más estables y precisas serán las predicciones. Por lo tanto, la base técnica clave de cualquier modelo que prediga córners y tarjetas es una fuente confiable de estadísticas con documentación clara y un formato de respuesta predecible.

¿Qué datos se necesitan para un modelo que predice córners y tarjetas en el fútbol?

Para construir un modelo funcional para predecir córners y tarjetas, se requiere un historial de partidos con estadísticas detalladas post-partido. El nivel mínimo incluye el número total de córners para ambos equipos, el número de tarjetas amarillas y rojas, el número de faltas y fuera de juego. Sin embargo, para aumentar la precisión, vale la pena agregar indicadores más detallados: posesión del balón, tiros a puerta, el número de ataques peligrosos, centros y acciones en el tercio final. En muchas API, estos indicadores están disponibles a través del bloque de estadísticas de partidos extendidas, donde cada métrica tiene su propia clave.

Además de los eventos en sí, el contexto es críticamente importante para los modelos. Es deseable tener información sobre el torneo y su nivel, la ronda actual, el estado de local o visitante del equipo, la fecha y hora del partido, la ciudad y el estadio donde se lleva a cabo el partido. Es útil agregar la forma del equipo (resultados de partidos recientes), valores promedio de córners y tarjetas para la temporada, frecuencia de faltas y el estilo de juego de los oponentes. Tales datos permiten que el algoritmo entienda que, por ejemplo, un derbi en la parte alta de la tabla y un partido de colistas al final de la temporada generan perfiles diferentes en términos de disciplina y córners.

Se debe prestar especial atención a los datos en vivo si se planea predecir córners y tarjetas en tiempo real. En este caso, se necesitarán el minuto actual del partido, el marcador, información sobre las tarjetas ya mostradas y el número de córners, así como el flujo de eventos (faltas, ataques peligrosos, tarjetas rojas). En las API de eventos deportivos, estos datos suelen presentarse como un array de eventos en vivo con tipos de eventos y un bloque separado de estadísticas por períodos de partido (ALL, 1ST, 2ND). Es la combinación de estadísticas pre-partido y en vivo la que hace que el modelo sea verdaderamente útil en la práctica.

API para eventos deportivos para obtener estadísticas sobre córners y tarjetas.

Para entrenar el modelo para predecir córners y tarjetas, el primer paso es organizar una recolección de datos estable. Esto se facilita por API de eventos deportivos, que proporciona información estructurada sobre partidos de fútbol a través de solicitudes HTTP. El endpoint básico para fútbol en la documentación se ve como /v2/fútbol/partidos y devuelve una lista de partidos con el campo estadísticasDelPartido, donde se contienen métricas clave: posesión del balón, tiros, faltas, córners (clave tiros de esquina), tarjetas amarillas (clave tarjetas amarillas) y otros indicadores.

Para obtener estadísticas completas de un partido específico, se utiliza el endpoint. /v2/fútbol/partidos/{matchId}. En la respuesta, se devuelve un objeto de coincidencia, que incluye un array estadísticasDelPartido para diferentes períodos (TODOS, 1RO, 2DO), así como un array eventosEnVivo. A través de eventosEnVivo puedes extraer la cronología de tarjetas, ya que cada tarjeta viene como un evento con un tipo tarjeta, equipo (local/visitante) y tiempo en minutos. Si es necesario, para detallar eventos, también puedes usar la ruta /v2/fútbol/partidos/{matchId}/eventos, que devuelve el registro completo de eventos por separado de la información principal del partido.

A continuación se muestra un ejemplo de una solicitud simple en Python que llama a la API, recupera partidos para una fecha específica y extrae estadísticas básicas sobre córners y tarjetas amarillas. Se utiliza una clave de API para la autorización, que se puede obtener en la cuenta personal. después de registrarse en la plataforma.

import requests
API_KEY = "ВАШ_API_КЛЮЧ"
BASE_URL = "https://api.api-sport.ru/v2/football/matches"
params = {
    "date": "2025-09-03"  # нужная дата в формате YYYY-MM-DD
}
headers = {
    "Authorization": API_KEY
}
response = requests.get(BASE_URL, params=params, headers=headers)
response.raise_for_status()
data = response.json()
for match in data.get("matches", []):
    stats_all = next(
        (s for s in match.get("matchStatistics", []) if s.get("period") == "ALL"),
        None,
    )
    if not stats_all:
        continue
    corners = None
    yellow_cards = None
    for group in stats_all.get("groups", []):
        for item in group.get("statisticsItems", []):
            if item.get("key") == "cornerKicks":
                corners = (item.get("homeValue"), item.get("awayValue"))
            if item.get("key") == "yellowCards":
                yellow_cards = (item.get("homeValue"), item.get("awayValue"))
    print(match["id"], "угловые:", corners, "желтые карты:", yellow_cards)

Cómo recopilar y preparar datos de la API para entrenar un modelo que prediga córners y tarjetas.

Después de haber dominado los endpoints básicos, el siguiente paso es la recopilación masiva de datos históricos. Esto se suele hacer por temporada o torneo: utilizando los endpoints de categoría y torneo, obtienes una lista de competiciones y temporadas, y luego para cada temporada, recopilas todos los partidos a través de /v2/fútbol/partidos con filtros torneo_id, temporada_id o por rango de fechas. El objetivo es crear una tabla donde cada fila corresponda a un partido, y las columnas contengan características y variables objetivo, como el número total de córners y tarjetas por equipos.

En la etapa de preparación, es importante llevar los datos a un formato unificado. Los indicadores estadísticos de estadísticasDelPartido deben ser cuidadosamente desglosados: para cada clave de interés (por ejemplo, tiros de esquina, tarjetas amarillas, faltas, totalDisparosALaPortería, posesiónDelBalón) crear campos numéricos separados. Si estás utilizando eventos en vivo de /eventos or eventosEnVivo, entonces para cada tarjeta, se pueden calcular características adicionales: el minuto de la primera tarjeta amarilla, si hay tarjetas rojas, el número de tarjetas antes del minuto 60, y así sucesivamente. El conjunto de datos final se almacena convenientemente en una base de datos o en formato CSV/Parquet, para que pueda ser cargado rápidamente en herramientas de aprendizaje automático más tarde.

A continuación se muestra un ejemplo de un script de Python que itera sobre una lista de IDs de partidos, crea una plantilla para el futuro conjunto de entrenamiento y la guarda en CSV. En un proyecto real, lo complementarías con bucles sobre temporadas, registro y manejo de errores, pero la estructura básica seguirá siendo similar.

import csv
import requests
API_KEY = "ВАШ_API_КЛЮЧ"
BASE_URL = "https://api.api-sport.ru/v2/football/matches/{}"
HEADERS = {"Authorization": API_KEY}
match_ids = [14570728, 14586240]  # список заранее собранных ID матчей
with open("matches_corners_cards.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow([
        "match_id", "tournament_id", "season_id",
        "home_corners", "away_corners",
        "home_yellow", "away_yellow",
        "home_fouls", "away_fouls",
        "home_shots", "away_shots",
    ])
    for mid in match_ids:
        resp = requests.get(BASE_URL.format(mid), headers=HEADERS)
        resp.raise_for_status()
        match = resp.json()
        stats_all = next(
            (s for s in match.get("matchStatistics", []) if s.get("period") == "ALL"),
            None,
        )
        if not stats_all:
            continue
        metrics = {"cornerKicks": (0, 0), "yellowCards": (0, 0), "fouls": (0, 0), "totalShotsOnGoal": (0, 0)}
        for group in stats_all.get("groups", []):
            for item in group.get("statisticsItems", []):
                key = item.get("key")
                if key in metrics:
                    metrics[key] = (item.get("homeValue"), item.get("awayValue"))
        writer.writerow([
            match["id"],
            match["tournament"]["id"],
            match["season"]["id"],
            *metrics["cornerKicks"],
            *metrics["yellowCards"],
            *metrics["fouls"],
            *metrics["totalShotsOnGoal"],
        ])

Cómo entrenar un modelo de aprendizaje automático para predecir córners y tarjetas en el fútbol.

Después de preparar el conjunto de datos, puedes proceder a la construcción del modelo. En la práctica, es conveniente dividir la tarea en varias subtareas. Para los córners, a menudo se utilizan modelos de regresión que predicen el número de córners para cada equipo o el total general. Para las tarjetas, tanto la regresión (número de tarjetas amarillas y rojas) como la clasificación funcionan bien: la probabilidad de que haya más de un cierto umbral de tarjetas en el partido (por ejemplo, un total de más de 4.5). Los algoritmos típicos incluyen regresión lineal y logística, bosques aleatorios, aumento de gradiente (XGBoost, LightGBM), así como redes neuronales si el volumen de datos es grande.

Antes del entrenamiento, el conjunto de datos se divide en muestras de entrenamiento y prueba considerando el tiempo: es importante que el modelo aprenda de partidos más antiguos y se pruebe en los más recientes, de lo contrario habrá una «filtración» de información futura. Las características numéricas se normalizan o estandarizan si es necesario, y las categóricas (torneo, país, esquema táctico) se codifican utilizando codificación one-hot o codificación de objetivo. Como variables objetivo, puedes usar tanto valores exactos (por ejemplo, el número total de córners para equipos locales y visitantes) como etiquetas binarias (total más/menos de 9.5 córners, presencia de una tarjeta roja, etc.).

A continuación se muestra un ejemplo simplificado de entrenamiento de un modelo de regresión para predecir el número total de córners en un partido utilizando la biblioteca scikit-learn. Se asume que ya has creado una tabla con características y una columna objetivo. total_corners basado en los datos subidos desde api-sport.pro.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
# Загрузка подготовленного датасета
data = pd.read_csv("matches_corners_cards_features.csv")
FEATURES = [
    "home_avg_corners", "away_avg_corners",
    "home_avg_fouls", "away_avg_fouls",
    "home_avg_yellow", "away_avg_yellow",
    "home_shots", "away_shots",
]
TARGET = "total_corners"
X = data[FEATURES]
y = data[TARGET]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, shuffle=False  # временное разбиение: обучение на старых матчах
)
model = RandomForestRegressor(
    n_estimators=300,
    max_depth=8,
    random_state=42,
    n_jobs=-1,
)
model.fit(X_train, y_train)
preds = model.predict(X_test)
mae = mean_absolute_error(y_test, preds)
print("MAE по тоталу угловых:", mae)

Cómo evaluar la precisión de un modelo que predice córners y tarjetas basado en estadísticas de fútbol.

La evaluación del modelo es una etapa crítica que muestra si las predicciones se pueden confiar en condiciones reales. Para fines numéricos (número de córners, número de tarjetas), las métricas MAE (error absoluto medio) y RMSE (raíz del error cuadrático medio) son populares. Miden el error promedio de predicción en «eventos»: cuánto se equivoca típicamente el modelo en el número de córners o tarjetas. Para modelos probabilísticos que generan las posibilidades de superar un total determinado o recibir una tarjeta roja, generalmente se utilizan ROC-AUC, logloss y Brier score. Estas métricas ayudan a entender qué tan bien clasifica el modelo los resultados y cuán calibradas están sus probabilidades.

Es importante evaluar el modelo no solo por métricas globales, sino también por su estabilidad a lo largo del tiempo y segmentos. Por ejemplo, se puede verificar la calidad por separado para las ligas principales y divisiones inferiores, para partidos de favoritos y desvalidos, por temporadas. Otro paso obligatorio es un pseudo-backtest: reproducir la secuencia cronológica de partidos, donde en cada paso se utiliza solo la información que estaba disponible en el momento del partido. Esto es especialmente importante si planeas usar datos en vivo y suscripciones WebSocket para actualizar probabilidades en tiempo real en el futuro.

A continuación se muestra un ejemplo de cálculo de métricas básicas para un modelo que predice el número total de córners y un modelo binario que evalúa la probabilidad de que se muestren más de 4.5 tarjetas en un partido. Tal análisis ayudará a entender qué tan adecuado es el modelo para su uso práctico en paneles analíticos o integración con la línea del corredor a través del campo oddsBase en las respuestas de la API.

from sklearn.metrics import mean_absolute_error, mean_squared_error, roc_auc_score, brier_score_loss
import numpy as np
# y_true_corners, y_pred_corners — фактический и предсказанный тотал угловых
# y_true_cards_binary, y_pred_cards_proba — факт (0/1) и вероятность тотала карт > 4.5
mae = mean_absolute_error(y_true_corners, y_pred_corners)
rmse = mean_squared_error(y_true_corners, y_pred_corners, squared=False)
auc = roc_auc_score(y_true_cards_binary, y_pred_cards_proba)
brier = brier_score_loss(y_true_cards_binary, y_pred_cards_proba)
print(f"MAE угловых: {mae:.3f}")
print(f"RMSE угловых: {rmse:.3f}")
print(f"ROC-AUC по тоталу карт > 4.5: {auc:.3f}")
print(f"Brier score по картам: {brier:.3f}")

Cómo utilizar un modelo que predice córners y tarjetas en apuestas deportivas y análisis.

La aplicación práctica del modelo de predicción de córners y tarjetas depende directamente de la calidad y relevancia de los datos. En análisis deportivos, tales modelos están integrados en tableros y reportes: muestran el número esperado de córners y tarjetas en los próximos partidos, construyen distribuciones de probabilidad para totales y visualizan comparaciones de estilo de equipo. Para plataformas de medios y aficionados, esta es una oportunidad para ofrecer a la audiencia estadísticas más profundas que solo el marcador y los goles esperados. Dentro de clubes y academias, tales cálculos ayudan a analizar la disciplina del equipo, tendencias en faltas y riesgos de expulsiones en escenarios de juego específicos.

En apuestas y gestión de riesgos, el modelo sirve como base para evaluar las cuotas «justas». Al comparar las probabilidades predichas con la línea del corredor obtenida a través del campo oddsBase en las respuestas de la API, se pueden encontrar discrepancias y determinar apuestas de valor para los mercados de córners y tarjetas. Las empresas de apuestas y los traders utilizan tales modelos para la fijación automatizada de cuotas y el ajuste dinámico de la línea basado en datos en vivo. Aquí, los puntos finales en vivo y el desarrollo de infraestructura hacia WebSocket, así como el uso de módulos de IA, son particularmente útiles, lo que la plataforma api-sport.pro planea expandir.

Técnicamente, la integración se ve así: tu aplicación solicita periódicamente datos sobre partidos próximos y actuales a través de la API, los sustituye en el modelo entrenado y guarda los resultados en su propia base de datos o los almacena en caché. Luego, sobre estas predicciones, construyes una interfaz: un feed de partidos con esquinas y tarjetas esperadas, destacando juegos potencialmente «calientes», señales para los traders. Para lanzar tal contorno, es suficiente organizar el acceso y obtener una clave en la cuenta personal., después de lo cual puedes conectar el modelo de predicción de esquinas y tarjetas a cualquier producto, desde un panel de análisis interno hasta un servicio de apuestas público.