Publish Football Match Prediction release
Browse files- README.md +177 -0
- data/dados_preparados.csv +0 -0
- modelo_rf.pkl +3 -0
- reports/resultado_simulacao_titulo.csv +21 -0
- requirements.txt +5 -0
- scaler.pkl +3 -0
- src/extract.py +94 -0
- src/preProcess.py +95 -0
- src/simulation.py +143 -0
README.md
ADDED
|
@@ -0,0 +1,177 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
---
|
| 2 |
+
language:
|
| 3 |
+
- pt
|
| 4 |
+
library_name: scikit-learn
|
| 5 |
+
tags:
|
| 6 |
+
- tabular-classification
|
| 7 |
+
- random-forest
|
| 8 |
+
- football
|
| 9 |
+
- sports-analytics
|
| 10 |
+
- monte-carlo
|
| 11 |
+
---
|
| 12 |
+
|
| 13 |
+
# Football Match Prediction & Monte Carlo Simulation
|
| 14 |
+
|
| 15 |
+
Modelo de classificação baseado em **Random Forest** (`scikit-learn`) para prever o resultado de partidas de futebol (vitória do mandante, empate ou vitória do visitante) e estimar probabilidades de título de uma liga nacional por meio de **Simulação de Monte Carlo**.
|
| 16 |
+
|
| 17 |
+
## Objetivo da Previsão
|
| 18 |
+
|
| 19 |
+
Estimar as probabilidades $P(\text{Mandante}), P(\text{Empate}), P(\text{Visitante})$ para partidas de futebol a partir da força média dos elencos titulares e do histórico de confronto direto, utilizando essas probabilidades para simular as rodadas finais de um campeonato e calcular a probabilidade de título de cada clube.
|
| 20 |
+
|
| 21 |
+
## Origem dos Dados
|
| 22 |
+
|
| 23 |
+
* **Fonte original:** *European Soccer Database* (publicado originalmente no Kaggle por Hugo Mathien), contendo dados históricos de partidas, ligas, clubes e atributos de jogadores (baseados em avaliações do EA Sports FIFA).
|
| 24 |
+
* **Recorte no repositório:** O arquivo `data/dados_preparados.csv` (~2,32 MiB) contém apenas os metadados das partidas e as 3 features agregadas extraídas do banco SQLite original (`database.sqlite`, não incluído neste repositório devido ao tamanho de ~298,6 MB).
|
| 25 |
+
|
| 26 |
+
## Descrição do Dataset
|
| 27 |
+
|
| 28 |
+
* **Total de partidas extraídas:** `25.979`
|
| 29 |
+
* **Partidas válidas após remoção de nulos (`dropna`):** `25.221` (758 partidas sem rating completo de jogadores foram removidas)
|
| 30 |
+
* **Período:** `2008-07-18` a `2016-05-25` (`8` temporadas: `2008/2009` a `2015/2016`)
|
| 31 |
+
* **Cobertura:** `11` ligas europeias (*Belgium Jupiler League*, *England Premier League*, *France Ligue 1*, *Germany 1. Bundesliga*, *Italy Serie A*, *Netherlands Eredivisie*, *Poland Ekstraklasa*, *Portugal Liga ZON Sagres*, *Scotland Premier League*, *Spain LIGA BBVA*, *Switzerland Super League*)
|
| 32 |
+
* **Distribuição da variável-alvo (após limpeza):**
|
| 33 |
+
* Classe `0` (Vitória do Mandante): `11.550` (`45,79%`)
|
| 34 |
+
* Classe `1` (Empate): `6.404` (`25,39%`)
|
| 35 |
+
* Classe `2` (Vitória do Visitante): `7.267` (`28,81%`)
|
| 36 |
+
|
| 37 |
+
## Variáveis Utilizadas
|
| 38 |
+
|
| 39 |
+
As features devem ser fornecidas exatamente na seguinte ordem e formato numérico (`float`):
|
| 40 |
+
|
| 41 |
+
1. `home_overall_rating`: média do `overall_rating` dos 11 jogadores titulares do time mandante.
|
| 42 |
+
2. `away_overall_rating`: média do `overall_rating` dos 11 jogadores titulares do time visitante.
|
| 43 |
+
3. `hist_goal_diff`: saldo de gols acumulado em confrontos diretos anteriores entre os dois times, sempre na perspectiva do mandante atual (`0` quando é o primeiro confronto registrado).
|
| 44 |
+
|
| 45 |
+
**Variável-alvo (`target`):**
|
| 46 |
+
* `0`: Vitória do mandante (`home_team_goal > away_team_goal`)
|
| 47 |
+
* `1`: Empate (`home_team_goal == away_team_goal`)
|
| 48 |
+
* `2`: Vitória do visitante (`home_team_goal < away_team_goal`)
|
| 49 |
+
|
| 50 |
+
## Engenharia de Atributos
|
| 51 |
+
|
| 52 |
+
* **Rating da equipe:** Para cada partida, os 11 titulares de cada equipe (`home_player_1..11` e `away_player_1..11`) são desempilhados e cruzados com a média de `overall_rating` do jogador na tabela `Player_Attributes`, gerando a média da equipe.
|
| 53 |
+
* **Saldo histórico do confronto (`hist_goal_diff`):** Calculado em ordem cronológica dentro de cada par de times (`matchup`), acumulando o saldo de gols apenas das partidas **anteriores** à partida atual e ajustando o sinal conforme o mando de campo.
|
| 54 |
+
|
| 55 |
+
## Pré-processamento
|
| 56 |
+
|
| 57 |
+
* Remoção de linhas com valores nulos em `home_overall_rating` ou `away_overall_rating`.
|
| 58 |
+
* Ordenação cronológica por `date`.
|
| 59 |
+
* **Divisão temporal estrita:**
|
| 60 |
+
* **Treino:** temporadas anteriores a `2015/2016` (`21.895` partidas).
|
| 61 |
+
* **Teste:** temporada `2015/2016` (`3.326` partidas).
|
| 62 |
+
* **Padronização:** `StandardScaler` ajustado **exclusivamente** no conjunto de treino (`mean_ = [70.5358, 70.4748, -0.2023]`, `scale_ = [5.3208, 5.3084, 5.7843]`) e encapsulado em `Pipeline` durante a validação cruzada.
|
| 63 |
+
|
| 64 |
+
## Arquitetura e Parâmetros do Modelo
|
| 65 |
+
|
| 66 |
+
* **Algoritmo:** `RandomForestClassifier` (`scikit-learn`)
|
| 67 |
+
* **Hiperparâmetros:** `n_estimators=100`, `max_depth=5`, `random_state=42`
|
| 68 |
+
* **Importância das features (`feature_importances_`):**
|
| 69 |
+
* `home_overall_rating`: `0.3965`
|
| 70 |
+
* `away_overall_rating`: `0.3630`
|
| 71 |
+
* `hist_goal_diff`: `0.2405`
|
| 72 |
+
|
| 73 |
+
## Estratégia de Treinamento e Avaliação
|
| 74 |
+
|
| 75 |
+
* Validação cruzada `5-fold` com `Pipeline([('scaler', StandardScaler()), ('clf', RandomForestClassifier(...))])` no conjunto de treino (`< 2015/2016`).
|
| 76 |
+
* Avaliação final fora da amostra (*out-of-time*) na temporada `2015/2016` (`3.326` partidas), preservando a separação temporal em relação à simulação de Monte Carlo.
|
| 77 |
+
* O script `src/preProcess.py` também treina e reporta um modelo de *gradient boosting* (`XGBClassifier` quando `xgboost` está instalado, ou `HistGradientBoostingClassifier` como fallback) apenas para comparação; o artefato salvo para inferência e simulação é o `modelo_rf.pkl`.
|
| 78 |
+
|
| 79 |
+
## Métricas Reais Obtidas
|
| 80 |
+
|
| 81 |
+
* **Validação Cruzada (5-fold, Random Forest - Treino):** Acurácia `0.5211 (+/- 0.0064)`
|
| 82 |
+
* **Conjunto de Teste (`>= 2015/2016`, `3.326` partidas):**
|
| 83 |
+
* **Random Forest (artefato publicado `modelo_rf.pkl`):**
|
| 84 |
+
* Acurácia global: `0.49`
|
| 85 |
+
* Classe `0` (Mandante, `1.459` jogos): `precision=0.48`, `recall=0.88`, `f1-score=0.63`
|
| 86 |
+
* Classe `1` (Empate, `855` jogos): `precision=0.00`, `recall=0.00`, `f1-score=0.00`
|
| 87 |
+
* Classe `2` (Visitante, `1.012` jogos): `precision=0.50`, `recall=0.33`, `f1-score=0.39`
|
| 88 |
+
* **XGBoost (comparação em treino/teste, não serializado):**
|
| 89 |
+
* Acurácia global: `0.47` (`macro avg f1=0.38`, conseguindo recall `0.08` na classe de empates).
|
| 90 |
+
|
| 91 |
+
## Explicação da Simulação de Monte Carlo
|
| 92 |
+
|
| 93 |
+
O script `src/simulation.py` avalia a temporada `2015/2016` da **England Premier League** (`380` partidas):
|
| 94 |
+
|
| 95 |
+
1. Calcula a pontuação real acumulada nas primeiras `280` partidas (28 rodadas: 3 pontos por vitória, 1 por empate).
|
| 96 |
+
2. Para as últimas `100` partidas (10 rodadas finais), obtém as probabilidades $[P(0), P(1), P(2)]$ via `modelo_rf.predict_proba(scaler.transform(X_restantes))`.
|
| 97 |
+
3. Executa `1.000` simulações independentes (`np.random.default_rng(42)`), sorteando o resultado de cada jogo restante de acordo com suas probabilidades previstas.
|
| 98 |
+
4. Ao final de cada iteração, contabiliza o time com maior pontuação como campeão daquela simulação.
|
| 99 |
+
|
| 100 |
+
## Resultados de Probabilidade de Título
|
| 101 |
+
|
| 102 |
+
Resultados registrados em `reports/resultado_simulacao_titulo.csv` (soma total = `100.0%`):
|
| 103 |
+
|
| 104 |
+
| Time | Probabilidade de Campeão (%) |
|
| 105 |
+
| :--- | :---: |
|
| 106 |
+
| Leicester City | 45.0% |
|
| 107 |
+
| Manchester City | 26.5% |
|
| 108 |
+
| Tottenham Hotspur | 17.4% |
|
| 109 |
+
| Arsenal | 8.7% |
|
| 110 |
+
| Manchester United | 2.4% |
|
| 111 |
+
| Demais 15 clubes da liga | 0.0% |
|
| 112 |
+
|
| 113 |
+
## Limitações Metodológicas
|
| 114 |
+
|
| 115 |
+
1. **Média global de rating dos jogadores:** Em `src/extract.py`, `PlayerLatestRating` calcula `AVG(overall_rating)` sobre toda a tabela `Player_Attributes` por jogador, sem filtrar apenas registros anteriores à data de cada partida.
|
| 116 |
+
2. **Previsão de empates no Random Forest:** Com `max_depth=5` e desbalanceamento natural da classe `1` (empates), o classificador não prevê a classe `1` como classe majoritária (`predict`), embora atribua probabilidades não nulas via `predict_proba` (usadas na simulação de Monte Carlo).
|
| 117 |
+
3. **Critério de desempate na simulação:** Como o modelo não prevê placar exato de gols, o desempate em cada universo simulado considera apenas a pontuação total (`max`), sem saldo de gols.
|
| 118 |
+
4. **Dependência do SQLite para metadados na simulação:** `src/simulation.py` lê os nomes de ligas e times diretamente de `database.sqlite` (ou `database.zip`). Para reproduzir `simulation.py` do zero, é necessário obter o *European Soccer Database* (`database.sqlite`).
|
| 119 |
+
|
| 120 |
+
## Instruções para Carregar o Modelo e Realizar Previsões
|
| 121 |
+
|
| 122 |
+
```python
|
| 123 |
+
import joblib
|
| 124 |
+
import pandas as pd
|
| 125 |
+
|
| 126 |
+
modelo = joblib.load("modelo_rf.pkl")
|
| 127 |
+
scaler = joblib.load("scaler.pkl")
|
| 128 |
+
|
| 129 |
+
# Ordem obrigatória das features:
|
| 130 |
+
# ['home_overall_rating', 'away_overall_rating', 'hist_goal_diff']
|
| 131 |
+
amostra = pd.DataFrame(
|
| 132 |
+
[[70.67, 68.83, 0.0]],
|
| 133 |
+
columns=["home_overall_rating", "away_overall_rating", "hist_goal_diff"],
|
| 134 |
+
)
|
| 135 |
+
|
| 136 |
+
amostra_escalada = scaler.transform(amostra)
|
| 137 |
+
classe_prevista = modelo.predict(amostra_escalada)[0]
|
| 138 |
+
probabilidades = modelo.predict_proba(amostra_escalada)[0]
|
| 139 |
+
|
| 140 |
+
print("Classe prevista (0=Mandante, 1=Empate, 2=Visitante):", classe_prevista)
|
| 141 |
+
print("Probabilidades [Mandante, Empate, Visitante]:", probabilidades.round(4))
|
| 142 |
+
```
|
| 143 |
+
|
| 144 |
+
## Instruções para Reproduzir o Treinamento e a Simulação
|
| 145 |
+
|
| 146 |
+
1. Instale as dependências:
|
| 147 |
+
```bash
|
| 148 |
+
pip install -r requirements.txt
|
| 149 |
+
```
|
| 150 |
+
2. Para reproduzir o treinamento a partir de `data/dados_preparados.csv`, execute `src/preProcess.py` a partir da raiz onde `dados_preparados.csv` estiver acessível.
|
| 151 |
+
3. Para reproduzir a extração (`src/extract.py`) e a simulação completa (`src/simulation.py`), é necessário possuir o arquivo `database.sqlite` (European Soccer Database) na pasta de execução.
|
| 152 |
+
|
| 153 |
+
## Dependências e Versões
|
| 154 |
+
|
| 155 |
+
Versões testadas no ambiente de validação:
|
| 156 |
+
|
| 157 |
+
* Python `3.12`
|
| 158 |
+
* `scikit-learn==1.8.0`
|
| 159 |
+
* `pandas==2.3.1`
|
| 160 |
+
* `numpy==2.3.2`
|
| 161 |
+
* `joblib==1.5.3`
|
| 162 |
+
* `xgboost==3.4.1`
|
| 163 |
+
|
| 164 |
+
> **Atenção:** Artefatos `.pkl` serializados com `scikit-learn==1.8.0` devem ser carregados preferencialmente na mesma versão do `scikit-learn` para evitar avisos ou incompatibilidades de desserialização.
|
| 165 |
+
|
| 166 |
+
## Licença e Atribuições
|
| 167 |
+
|
| 168 |
+
* **Dados:** Os dados em `data/dados_preparados.csv` são derivados do *European Soccer Database* (Hugo Mathien, Kaggle — originalmente disponibilizado sob licença **CC0: Public Domain**).
|
| 169 |
+
* **Código e artefatos do modelo:** Não há arquivo `LICENSE` específico definido no repositório original; recomenda-se definir explicitamente a licença do código antes de uso comercial.
|
| 170 |
+
|
| 171 |
+
## Uso de Ferramentas de IA
|
| 172 |
+
|
| 173 |
+
Ferramentas de assistência por IA (Antigravity / Gemini) foram utilizadas exclusivamente para:
|
| 174 |
+
* Auditoria técnica e metodológica do pipeline original;
|
| 175 |
+
* Correção do cálculo de `hist_goal_diff` e da divisão temporal/escalonamento sem vazamento entre treino e teste;
|
| 176 |
+
* Execução dos testes de carregamento, inferência e reprodução da simulação;
|
| 177 |
+
* Preparação da estrutura de publicação (`huggingface_release/`) e redação deste Model Card.
|
data/dados_preparados.csv
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
modelo_rf.pkl
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:a1ddcac5e4eb3cfee630a83289557d7f0278e69491d8e918c09b9bc8e6fdb85e
|
| 3 |
+
size 585713
|
reports/resultado_simulacao_titulo.csv
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
Time;Probabilidade_Campeao_%
|
| 2 |
+
Leicester City;45.0
|
| 3 |
+
Manchester City;26.5
|
| 4 |
+
Tottenham Hotspur;17.4
|
| 5 |
+
Arsenal;8.7
|
| 6 |
+
Manchester United;2.4
|
| 7 |
+
Everton;0.0
|
| 8 |
+
Bournemouth;0.0
|
| 9 |
+
Chelsea;0.0
|
| 10 |
+
Stoke City;0.0
|
| 11 |
+
West Bromwich Albion;0.0
|
| 12 |
+
Norwich City;0.0
|
| 13 |
+
Newcastle United;0.0
|
| 14 |
+
West Ham United;0.0
|
| 15 |
+
Aston Villa;0.0
|
| 16 |
+
Southampton;0.0
|
| 17 |
+
Watford;0.0
|
| 18 |
+
Sunderland;0.0
|
| 19 |
+
Swansea City;0.0
|
| 20 |
+
Crystal Palace;0.0
|
| 21 |
+
Liverpool;0.0
|
requirements.txt
ADDED
|
@@ -0,0 +1,5 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
pandas>=2.0.0
|
| 2 |
+
numpy>=1.24.0
|
| 3 |
+
scikit-learn>=1.3.0
|
| 4 |
+
joblib>=1.3.0
|
| 5 |
+
xgboost>=2.0.0
|
scaler.pkl
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:481b7297b63d2c0ca1aa242d98613e96c6d8b9ff1e57a1541d40cdd27f8b40ec
|
| 3 |
+
size 943
|
src/extract.py
ADDED
|
@@ -0,0 +1,94 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import os
|
| 2 |
+
import sqlite3
|
| 3 |
+
import zipfile
|
| 4 |
+
import pandas as pd
|
| 5 |
+
import numpy as np
|
| 6 |
+
|
| 7 |
+
print("--- INICIANDO PARTE 1: EXTRAÇÃO E ENGENHARIA DE DADOS ---")
|
| 8 |
+
|
| 9 |
+
# 1. Garante que database.sqlite exista (extraindo de database.zip se necessário)
|
| 10 |
+
if not os.path.exists('database.sqlite') and os.path.exists('database.zip'):
|
| 11 |
+
print("Extraindo 'database.sqlite' a partir de 'database.zip'...")
|
| 12 |
+
with zipfile.ZipFile('database.zip', 'r') as zf:
|
| 13 |
+
zf.extract('database.sqlite')
|
| 14 |
+
|
| 15 |
+
# Conexão ao banco de dados
|
| 16 |
+
conn = sqlite3.connect('database.sqlite')
|
| 17 |
+
|
| 18 |
+
# 2. Query de Habilidades (Rating Médio)
|
| 19 |
+
# Criamos dinamicamente as strings para desempilhar (unpivot) os 11 jogadores
|
| 20 |
+
home_unpivot = " UNION ALL ".join([f"SELECT match_api_id, home_team_api_id as team_id, home_player_{i} as player_id FROM Match" for i in range(1, 12)])
|
| 21 |
+
away_unpivot = " UNION ALL ".join([f"SELECT match_api_id, away_team_api_id as team_id, away_player_{i} as player_id FROM Match" for i in range(1, 12)])
|
| 22 |
+
|
| 23 |
+
query_rating = f"""
|
| 24 |
+
WITH AllPlayers AS (
|
| 25 |
+
{home_unpivot}
|
| 26 |
+
UNION ALL
|
| 27 |
+
{away_unpivot}
|
| 28 |
+
),
|
| 29 |
+
PlayerLatestRating AS (
|
| 30 |
+
SELECT player_api_id, AVG(overall_rating) as avg_rating
|
| 31 |
+
FROM Player_Attributes
|
| 32 |
+
GROUP BY player_api_id
|
| 33 |
+
)
|
| 34 |
+
SELECT
|
| 35 |
+
ap.match_api_id,
|
| 36 |
+
ap.team_id,
|
| 37 |
+
AVG(plr.avg_rating) as team_overall_rating
|
| 38 |
+
FROM AllPlayers ap
|
| 39 |
+
LEFT JOIN PlayerLatestRating plr ON ap.player_id = plr.player_api_id
|
| 40 |
+
GROUP BY ap.match_api_id, ap.team_id
|
| 41 |
+
"""
|
| 42 |
+
|
| 43 |
+
print("1/4 Extraindo ratings dos jogadores (isso pode levar alguns segundos)...")
|
| 44 |
+
df_ratings = pd.read_sql_query(query_rating, conn)
|
| 45 |
+
|
| 46 |
+
# 3. Extraindo Partidas (AGORA INCLUINDO SEASON E LEAGUE_ID)
|
| 47 |
+
print("2/4 Extraindo histórico de partidas...")
|
| 48 |
+
query_matches = """
|
| 49 |
+
SELECT match_api_id, season, league_id, date, home_team_api_id, away_team_api_id, home_team_goal, away_team_goal
|
| 50 |
+
FROM Match
|
| 51 |
+
ORDER BY date ASC
|
| 52 |
+
"""
|
| 53 |
+
df_matches = pd.read_sql_query(query_matches, conn)
|
| 54 |
+
conn.close()
|
| 55 |
+
|
| 56 |
+
# 4. Criando Variável Alvo (Target)
|
| 57 |
+
print("3/4 Calculando variável alvo e saldo histórico...")
|
| 58 |
+
condicoes = [
|
| 59 |
+
(df_matches['home_team_goal'] > df_matches['away_team_goal']),
|
| 60 |
+
(df_matches['home_team_goal'] == df_matches['away_team_goal']),
|
| 61 |
+
(df_matches['home_team_goal'] < df_matches['away_team_goal'])
|
| 62 |
+
]
|
| 63 |
+
df_matches['target'] = np.select(condicoes, [0, 1, 2], default=-1)
|
| 64 |
+
|
| 65 |
+
# 5. Saldo de Gols Histórico do Confronto Direto (antes de cada partida, orientado ao mandante)
|
| 66 |
+
team_a = np.minimum(df_matches['home_team_api_id'], df_matches['away_team_api_id'])
|
| 67 |
+
team_b = np.maximum(df_matches['home_team_api_id'], df_matches['away_team_api_id'])
|
| 68 |
+
df_matches['matchup'] = list(zip(team_a, team_b))
|
| 69 |
+
|
| 70 |
+
df_matches['home_goal_diff'] = df_matches['home_team_goal'] - df_matches['away_team_goal']
|
| 71 |
+
is_team_a_home = df_matches['home_team_api_id'] == team_a
|
| 72 |
+
canonical_diff = np.where(is_team_a_home, df_matches['home_goal_diff'], -df_matches['home_goal_diff'])
|
| 73 |
+
df_matches['_canonical_diff'] = canonical_diff
|
| 74 |
+
|
| 75 |
+
# Soma acumulada apenas dentro do mesmo confronto, excluindo a partida atual
|
| 76 |
+
cum_before = df_matches.groupby('matchup')['_canonical_diff'].cumsum() - df_matches['_canonical_diff']
|
| 77 |
+
df_matches['hist_goal_diff'] = np.where(is_team_a_home, cum_before, -cum_before)
|
| 78 |
+
|
| 79 |
+
# 6. Mesclando médias aos jogos
|
| 80 |
+
print("4/4 Mesclando dados e limpando tabela final...")
|
| 81 |
+
df_matches = df_matches.merge(df_ratings, left_on=['match_api_id', 'home_team_api_id'], right_on=['match_api_id', 'team_id'], how='left')\
|
| 82 |
+
.rename(columns={'team_overall_rating': 'home_overall_rating'}).drop('team_id', axis=1)
|
| 83 |
+
|
| 84 |
+
df_matches = df_matches.merge(df_ratings, left_on=['match_api_id', 'away_team_api_id'], right_on=['match_api_id', 'team_id'], how='left')\
|
| 85 |
+
.rename(columns={'team_overall_rating': 'away_overall_rating'}).drop('team_id', axis=1)
|
| 86 |
+
|
| 87 |
+
# Selecionando colunas finais (Com season e league_id fundamentais para a Parte 3)
|
| 88 |
+
df_final = df_matches[['match_api_id', 'season', 'league_id', 'date', 'home_team_api_id', 'away_team_api_id',
|
| 89 |
+
'home_overall_rating', 'away_overall_rating', 'hist_goal_diff', 'target']]
|
| 90 |
+
|
| 91 |
+
# 7. Salvando arquivo base
|
| 92 |
+
df_final.to_csv('dados_preparados.csv', index=False)
|
| 93 |
+
print("\n=== SUCESSO! ===")
|
| 94 |
+
print("Arquivo 'dados_preparados.csv' gerado com as novas colunas.")
|
src/preProcess.py
ADDED
|
@@ -0,0 +1,95 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import pandas as pd
|
| 2 |
+
from sklearn.model_selection import cross_val_score
|
| 3 |
+
from sklearn.pipeline import Pipeline
|
| 4 |
+
from sklearn.preprocessing import StandardScaler
|
| 5 |
+
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier
|
| 6 |
+
from sklearn.metrics import classification_report
|
| 7 |
+
import joblib
|
| 8 |
+
|
| 9 |
+
try:
|
| 10 |
+
import xgboost as xgb
|
| 11 |
+
HAS_XGBOOST = True
|
| 12 |
+
except ImportError:
|
| 13 |
+
HAS_XGBOOST = False
|
| 14 |
+
|
| 15 |
+
print("--- INICIANDO PARTE 2: PRÉ-PROCESSAMENTO E MODELAGEM ---")
|
| 16 |
+
|
| 17 |
+
# 1. Carregando os dados
|
| 18 |
+
try:
|
| 19 |
+
df_final = pd.read_csv('dados_preparados.csv')
|
| 20 |
+
except FileNotFoundError:
|
| 21 |
+
print("ERRO: Arquivo 'dados_preparados.csv' não encontrado. Rode a Parte 1 (extract.py) primeiro.")
|
| 22 |
+
raise SystemExit(1)
|
| 23 |
+
|
| 24 |
+
# 2. Pré-processamento
|
| 25 |
+
df_clean = df_final.dropna().copy()
|
| 26 |
+
df_clean = df_clean.sort_values('date').reset_index(drop=True)
|
| 27 |
+
|
| 28 |
+
print(f"Total de partidas antes da limpeza: {len(df_final)}")
|
| 29 |
+
print(f"Total de partidas após limpeza (sem nulos): {len(df_clean)}")
|
| 30 |
+
|
| 31 |
+
# Separar Features (X) e Target (y)
|
| 32 |
+
# NOTA: Selecionamos apenas as métricas de habilidade e histórico.
|
| 33 |
+
# As colunas 'season' e 'league_id' ficam de fora do treino.
|
| 34 |
+
features = ['home_overall_rating', 'away_overall_rating', 'hist_goal_diff']
|
| 35 |
+
|
| 36 |
+
# 3. Divisão Temporal de Treino e Teste (evita vazamento da temporada 2015/2016 usada na simulação)
|
| 37 |
+
TEMPORADA_SIMULACAO = '2015/2016'
|
| 38 |
+
df_train = df_clean[df_clean['season'] < TEMPORADA_SIMULACAO]
|
| 39 |
+
df_test = df_clean[df_clean['season'] >= TEMPORADA_SIMULACAO]
|
| 40 |
+
|
| 41 |
+
X_train, y_train = df_train[features], df_train['target']
|
| 42 |
+
X_test, y_test = df_test[features], df_test['target']
|
| 43 |
+
|
| 44 |
+
print(f"Partidas de treino (temporadas < {TEMPORADA_SIMULACAO}): {len(X_train)}")
|
| 45 |
+
print(f"Partidas de teste (temporadas >= {TEMPORADA_SIMULACAO}): {len(X_test)}")
|
| 46 |
+
|
| 47 |
+
# Escalonamento ajustado APENAS no conjunto de treino (evita data leakage)
|
| 48 |
+
scaler = StandardScaler()
|
| 49 |
+
X_train_scaled = scaler.fit_transform(X_train)
|
| 50 |
+
X_test_scaled = scaler.transform(X_test)
|
| 51 |
+
|
| 52 |
+
# 4. Treinamento e Avaliação: Random Forest
|
| 53 |
+
print("\nTreinando Random Forest...")
|
| 54 |
+
rf_pipeline = Pipeline([
|
| 55 |
+
('scaler', StandardScaler()),
|
| 56 |
+
('clf', RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)),
|
| 57 |
+
])
|
| 58 |
+
|
| 59 |
+
# Validação Cruzada sem vazamento no conjunto de treino
|
| 60 |
+
cv_scores = cross_val_score(rf_pipeline, X_train, y_train, cv=5, scoring='accuracy')
|
| 61 |
+
print(f"Acurácia na Validação Cruzada (RF - Treino): {cv_scores.mean():.4f} (+/- {cv_scores.std() * 2:.4f})")
|
| 62 |
+
|
| 63 |
+
# Ajuste final e predição no conjunto de teste
|
| 64 |
+
rf_model = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
|
| 65 |
+
rf_model.fit(X_train_scaled, y_train)
|
| 66 |
+
y_pred_rf = rf_model.predict(X_test_scaled)
|
| 67 |
+
|
| 68 |
+
print("\nRelatório de Classificação (Random Forest - Teste):")
|
| 69 |
+
# zero_division=0 oculta os warnings caso o modelo não preveja alguma classe
|
| 70 |
+
print(classification_report(y_test, y_pred_rf, zero_division=0))
|
| 71 |
+
|
| 72 |
+
# 5. Treinamento e Avaliação: Boosting (XGBoost se disponível, senão HistGradientBoosting)
|
| 73 |
+
if HAS_XGBOOST:
|
| 74 |
+
print("\nTreinando XGBoost...")
|
| 75 |
+
boost_model = xgb.XGBClassifier(
|
| 76 |
+
eval_metric='mlogloss',
|
| 77 |
+
random_state=42,
|
| 78 |
+
)
|
| 79 |
+
boost_name = "XGBoost"
|
| 80 |
+
else:
|
| 81 |
+
print("\nXGBoost não instalado; treinando HistGradientBoostingClassifier (scikit-learn)...")
|
| 82 |
+
boost_model = HistGradientBoostingClassifier(random_state=42)
|
| 83 |
+
boost_name = "HistGradientBoosting"
|
| 84 |
+
|
| 85 |
+
boost_model.fit(X_train_scaled, y_train)
|
| 86 |
+
y_pred_boost = boost_model.predict(X_test_scaled)
|
| 87 |
+
|
| 88 |
+
print(f"\nRelatório de Classificação ({boost_name} - Teste):")
|
| 89 |
+
print(classification_report(y_test, y_pred_boost, zero_division=0))
|
| 90 |
+
|
| 91 |
+
# 6. Salvando os artefatos para a Parte 3
|
| 92 |
+
print("\nSalvando o modelo e o escalonador para uso na Simulação...")
|
| 93 |
+
joblib.dump(rf_model, 'modelo_rf.pkl')
|
| 94 |
+
joblib.dump(scaler, 'scaler.pkl')
|
| 95 |
+
print("Arquivos 'modelo_rf.pkl' e 'scaler.pkl' gerados com sucesso!")
|
src/simulation.py
ADDED
|
@@ -0,0 +1,143 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import os
|
| 2 |
+
import zipfile
|
| 3 |
+
import pandas as pd
|
| 4 |
+
import numpy as np
|
| 5 |
+
import sqlite3
|
| 6 |
+
import joblib
|
| 7 |
+
|
| 8 |
+
print("--- INICIANDO PARTE 3: SIMULAÇÃO DE MONTE CARLO ---")
|
| 9 |
+
|
| 10 |
+
# ---------------------------------------------------------
|
| 11 |
+
# 1. Carregar Dados e Artefatos (Modelos)
|
| 12 |
+
# ---------------------------------------------------------
|
| 13 |
+
try:
|
| 14 |
+
df_final = pd.read_csv('dados_preparados.csv')
|
| 15 |
+
df_clean = df_final.dropna().copy()
|
| 16 |
+
rf_model = joblib.load('modelo_rf.pkl')
|
| 17 |
+
scaler = joblib.load('scaler.pkl')
|
| 18 |
+
except FileNotFoundError as e:
|
| 19 |
+
print(f"ERRO: Arquivo {e.filename} não encontrado. Rode as Partes 1 e 2 primeiro.")
|
| 20 |
+
exit()
|
| 21 |
+
|
| 22 |
+
# ---------------------------------------------------------
|
| 23 |
+
# === CONFIGURAÇÕES DA SIMULAÇÃO ===
|
| 24 |
+
# ---------------------------------------------------------
|
| 25 |
+
LIGA_ALVO = 'England Premier League'
|
| 26 |
+
TEMPORADA_ALVO = '2015/2016'
|
| 27 |
+
RODADAS_RESTANTES = 10
|
| 28 |
+
JOGOS_POR_RODADA = 10
|
| 29 |
+
N_SIMULACOES = 1000
|
| 30 |
+
RANDOM_SEED = 42
|
| 31 |
+
|
| 32 |
+
TOTAL_JOGOS_SIMULAR = RODADAS_RESTANTES * JOGOS_POR_RODADA
|
| 33 |
+
|
| 34 |
+
# ---------------------------------------------------------
|
| 35 |
+
# 2. Conectar ao banco para metadados (IDs e Nomes)
|
| 36 |
+
# ---------------------------------------------------------
|
| 37 |
+
if not os.path.exists('database.sqlite') and os.path.exists('database.zip'):
|
| 38 |
+
print("Extraindo 'database.sqlite' a partir de 'database.zip'...")
|
| 39 |
+
with zipfile.ZipFile('database.zip', 'r') as zf:
|
| 40 |
+
zf.extract('database.sqlite')
|
| 41 |
+
|
| 42 |
+
conn = sqlite3.connect('database.sqlite')
|
| 43 |
+
|
| 44 |
+
# Descobrir o ID da Liga dinamicamente com base na configuração
|
| 45 |
+
query_league = f"SELECT id FROM League WHERE name = '{LIGA_ALVO}'"
|
| 46 |
+
league_id = pd.read_sql_query(query_league, conn).iloc[0, 0]
|
| 47 |
+
|
| 48 |
+
query_teams = "SELECT team_api_id, team_long_name FROM Team"
|
| 49 |
+
team_dict = dict(pd.read_sql_query(query_teams, conn).values)
|
| 50 |
+
conn.close()
|
| 51 |
+
|
| 52 |
+
# ---------------------------------------------------------
|
| 53 |
+
# 3. Filtragem Estrita: Liga e Temporada Escolhidas
|
| 54 |
+
# ---------------------------------------------------------
|
| 55 |
+
df_liga = df_clean[(df_clean['league_id'] == league_id) & (df_clean['season'] == TEMPORADA_ALVO)].copy()
|
| 56 |
+
df_liga = df_liga.sort_values('date')
|
| 57 |
+
|
| 58 |
+
print(f"Total de jogos processados da temporada {TEMPORADA_ALVO}: {len(df_liga)}")
|
| 59 |
+
|
| 60 |
+
if len(df_liga) <= TOTAL_JOGOS_SIMULAR:
|
| 61 |
+
raise ValueError(
|
| 62 |
+
f"Jogos insuficientes ({len(df_liga)}) para simular os últimos {TOTAL_JOGOS_SIMULAR} jogos."
|
| 63 |
+
)
|
| 64 |
+
|
| 65 |
+
# Separando usando a matemática calculada
|
| 66 |
+
jogos_realizados = df_liga.iloc[:-TOTAL_JOGOS_SIMULAR]
|
| 67 |
+
jogos_restantes = df_liga.iloc[-TOTAL_JOGOS_SIMULAR:]
|
| 68 |
+
|
| 69 |
+
# Lista de todos os times que participaram
|
| 70 |
+
lista_times = pd.concat([df_liga['home_team_api_id'], df_liga['away_team_api_id']]).unique()
|
| 71 |
+
|
| 72 |
+
# ... O resto do código (Passo 4 em diante) continua exatamente igual,
|
| 73 |
+
# ---------------------------------------------------------
|
| 74 |
+
# 4. Montar a Tabela de Pontuação Atual (Até a rodada 28)
|
| 75 |
+
# ---------------------------------------------------------
|
| 76 |
+
pontos_atuais = {team: 0 for team in lista_times}
|
| 77 |
+
|
| 78 |
+
for _, row in jogos_realizados.iterrows():
|
| 79 |
+
if row['target'] == 0:
|
| 80 |
+
pontos_atuais[row['home_team_api_id']] += 3
|
| 81 |
+
elif row['target'] == 1:
|
| 82 |
+
pontos_atuais[row['home_team_api_id']] += 1
|
| 83 |
+
pontos_atuais[row['away_team_api_id']] += 1
|
| 84 |
+
elif row['target'] == 2:
|
| 85 |
+
pontos_atuais[row['away_team_api_id']] += 3
|
| 86 |
+
|
| 87 |
+
# ---------------------------------------------------------
|
| 88 |
+
# 5. Gerar Probabilidades com o Modelo RF
|
| 89 |
+
# ---------------------------------------------------------
|
| 90 |
+
features = ['home_overall_rating', 'away_overall_rating', 'hist_goal_diff']
|
| 91 |
+
# Usamos o scaler treinado na Parte 2 para não enviesar os dados
|
| 92 |
+
X_restantes = scaler.transform(jogos_restantes[features])
|
| 93 |
+
probs = rf_model.predict_proba(X_restantes)
|
| 94 |
+
|
| 95 |
+
# ---------------------------------------------------------
|
| 96 |
+
# 6. Executar a Simulação de Monte Carlo
|
| 97 |
+
# ---------------------------------------------------------
|
| 98 |
+
rng = np.random.default_rng(RANDOM_SEED)
|
| 99 |
+
contagem_titulos = {team: 0 for team in lista_times}
|
| 100 |
+
|
| 101 |
+
print(f"\nSimulando {N_SIMULACOES} finais de campeonato alternativos...")
|
| 102 |
+
|
| 103 |
+
for _ in range(N_SIMULACOES):
|
| 104 |
+
# Precisamos zerar o "universo" a cada iteração, voltando os pontos para a rodada 28
|
| 105 |
+
pontos_sim = pontos_atuais.copy()
|
| 106 |
+
|
| 107 |
+
for i, (_, jogo) in enumerate(jogos_restantes.iterrows()):
|
| 108 |
+
# O modelo joga os dados (Sorteio viciado pelas probabilidades)
|
| 109 |
+
res = rng.choice([0, 1, 2], p=probs[i])
|
| 110 |
+
|
| 111 |
+
if res == 0:
|
| 112 |
+
pontos_sim[jogo['home_team_api_id']] += 3
|
| 113 |
+
elif res == 1:
|
| 114 |
+
pontos_sim[jogo['home_team_api_id']] += 1
|
| 115 |
+
pontos_sim[jogo['away_team_api_id']] += 1
|
| 116 |
+
else:
|
| 117 |
+
pontos_sim[jogo['away_team_api_id']] += 3
|
| 118 |
+
|
| 119 |
+
# Ao final da temporada simulada, consagra o campeão daquele universo
|
| 120 |
+
campeao_id = max(pontos_sim, key=pontos_sim.get)
|
| 121 |
+
contagem_titulos[campeao_id] += 1
|
| 122 |
+
|
| 123 |
+
# ---------------------------------------------------------
|
| 124 |
+
# 7. Processar Resultados e Exportar CSV
|
| 125 |
+
# ---------------------------------------------------------
|
| 126 |
+
lista_ranking = []
|
| 127 |
+
for t_id, vitorias in contagem_titulos.items():
|
| 128 |
+
lista_ranking.append({
|
| 129 |
+
'Time': team_dict.get(t_id, f"ID {t_id}"),
|
| 130 |
+
'Probabilidade_Campeao_%': round((vitorias / N_SIMULACOES) * 100, 2)
|
| 131 |
+
})
|
| 132 |
+
|
| 133 |
+
df_ranking = pd.DataFrame(lista_ranking).sort_values(by='Probabilidade_Campeao_%', ascending=False)
|
| 134 |
+
|
| 135 |
+
# Exportando o CSV com codificação segura para o Excel (utf-8-sig)
|
| 136 |
+
df_ranking.to_csv('resultado_simulacao_titulo.csv', index=False, sep=';', encoding='utf-8-sig')
|
| 137 |
+
|
| 138 |
+
print("\n=== RANKING FINAL: PROBABILIDADE DE TÍTULO ===")
|
| 139 |
+
# Exibe apenas os times que tiveram chance matemática de ser campeões
|
| 140 |
+
print(df_ranking[df_ranking['Probabilidade_Campeao_%'] > 0].to_string(index=False))
|
| 141 |
+
|
| 142 |
+
print("\n=== SUCESSO! ===")
|
| 143 |
+
print("Arquivo 'resultado_simulacao_titulo.csv' salvo com sucesso na sua pasta!")
|