AdryanAzul commited on
Commit
72a3423
·
verified ·
1 Parent(s): 1cde1ff

Publish Football Match Prediction release

Browse files
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!")