K-Means

Introdução

O objetivo desta etapa foi aplicar o algoritmo K-Means Clustering sobre a base de partidas de futebol da Premier League.
Diferente dos modelos anteriores (Árvore de Decisão e KNN), o K-Means é um algoritmo não supervisionado, ou seja, não utiliza a variável-alvo durante o treinamento.
A proposta aqui é identificar padrões ocultos nos dados a partir de estatísticas das partidas — como posse de bola, passes, chances criadas, público e estádio — e verificar como esses agrupamentos se relacionam com os resultados reais (class).

Para fins de visualização, os dados foram reduzidos para duas dimensões via PCA, permitindo a representação gráfica dos clusters e seus centróides.

Base de dados

A base de dados utilizada neste projeto contém informações de partidas de futebol, totalizando 1140 linhas e 40 colunas. Entre as variáveis estão posse de bola, número de passes e chances criadas.
A variável alvo escolhida é a coluna class, que indica o resultado da partida (vitória do mandante, empate ou vitória do visitante).

Exploração dos Dados

A seguir foi feita uma análise do significado e composição de cada coluna presente na base, com a finalidade de identificar possíveis problemas a serem tratados posteriormente. As visualizações e estatísticas descritivas ajudam a compreender a natureza dos dados e orientar decisões de pré-processamento e modelagem.

Pré-processamento

Após a exploração inicial da base, foram aplicados procedimentos de pré-processamento para preparar os dados para o treinamento do modelo.
Entre as etapas realizadas estão:

• Conversão de tipos: variáveis originalmente em texto com valores numéricos (como attendance) foram transformadas em formato numérico.
• Tratamento de valores categóricos: colunas como stadium, Home Team e Away Team foram mantidas como categóricas, sendo posteriormente convertidas em variáveis numéricas por meio de técnicas de codificação.
• Remoção de colunas irrelevantes ou redundantes: colunas de identificação e de tempo (date, clock, links), bem como estatísticas que representam vazamento de informação do resultado (ex.: Goals Home, Away Goals), foram descartadas do conjunto de treino.
• Separação entre features e target: as variáveis explicativas (X) foram definidas a partir de aproximadamente dez colunas relevantes da base, enquanto a variável alvo (y) é a coluna class.
• Divisão em treino e teste: o conjunto de dados foi dividido em duas partes, garantindo estratificação do alvo para manter o equilíbrio das classes.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn import tree
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
from io import StringIO
from sklearn.preprocessing import LabelEncoder

label_encoder = LabelEncoder()

df = pd.read_csv("./src/mydata.csv")

# Excluir as colunas não desejadas
df = df.drop(columns= ["date", "clock", "links", "Goals Home", "Away Goals", "home_shots", "away_shots", "home_on", "away_on",
                        "home_off", "away_off", "home_blocked", "away_blocked", "home_corners", "away_corners", 
                        "home_offside", "away_offside", "home_tackles", "away_tackles", "home_duels", "away_duels",
                        "home_saves", "away_saves", "home_fouls", "away_fouls", "home_yellow", "away_yellow",
                        "home_red", "away_red"])

# Label encoding dos estadios em texto
df["stadium"] = label_encoder.fit_transform(df["stadium"])

# Transformar resultado do jogo times em números
df["class"] = df["class"].replace({'h':0, 'd': 1, 'a':2})

# Transforma o públido de string para número
df["attendance"] = df["attendance"].str.replace(',', '').astype(int)

print(df.sample(frac=.01).to_markdown(index=False))

Divisão dos Dados

Com a base pré-processada, realizou-se a divisão entre conjuntos de treinamento e teste.
O objetivo dessa etapa é garantir que o modelo seja avaliado em dados que ele nunca viu durante o treinamento, permitindo uma medida mais confiável de sua capacidade de generalização.

Foi utilizada a função train_test_split da biblioteca scikit-learn, com os seguintes critérios:
- 70% dos dados destinados ao treinamento, para que o modelo aprenda os padrões da base;
- 30% dos dados destinados ao teste, para avaliar o desempenho em novos exemplos;
- Estratificação pelo alvo (class), garantindo que a proporção entre vitórias do mandante, empates e vitórias do visitante fosse mantida em ambos os conjuntos;
- Random State fixado, assegurando reprodutibilidade na divisão.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn import tree
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
from io import StringIO
from sklearn.preprocessing import LabelEncoder

label_encoder = LabelEncoder()

df = pd.read_csv("./src/mydata.csv")

# Excluir as colunas não desejadas
df = df.drop(columns= ["date", "clock", "links", "Goals Home", "Away Goals", "home_shots", "away_shots", "home_on", "away_on",
                        "home_off", "away_off", "home_blocked", "away_blocked", "home_corners", "away_corners", 
                        "home_offside", "away_offside", "home_tackles", "away_tackles", "home_duels", "away_duels",
                        "home_saves", "away_saves", "home_fouls", "away_fouls", "home_yellow", "away_yellow",
                        "home_red", "away_red"])

# Label encoding dos estadios em texto
df["stadium"] = label_encoder.fit_transform(df["stadium"])

# Transformar resultado do jogo times em números
df["class"] = df["class"].replace({'h':0, 'd': 1, 'a':2})

# Transforma o públido de string para número
df["attendance"] = df["attendance"].str.replace(',', '').astype(int)

# Variáveis independentes (features)
x = df[[
    "stadium", "attendance",
    "Home Team", "Away Team",
    "home_possessions", "away_possessions",
    "home_pass", "away_pass",
    "home_chances", "away_chances"
]]

# Variável dependente (alvo)
y = df["class"]

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=27, stratify=y)

Treinamento do Modelo

O modelo foi treinado com 3 clusters, em referência às três classes possíveis do resultado da partida: vitória do mandante, empate e vitória do visitante.

Após o pré-processamento (padronização das variáveis numéricas e transformação das categóricas em dummies), o algoritmo K-Means foi aplicado sobre os dados transformados.
Em seguida, os dados foram projetados em duas dimensões com PCA para permitir a visualização gráfica.

Na figura abaixo é possível observar a formação dos três clusters identificados pelo algoritmo e seus respectivos centróides (em vermelho):

import base64
from io import BytesIO
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("./src/mydata.csv")

num_cols = [
    "attendance",
    "home_possessions", "away_possessions",
    "home_pass", "away_pass",
    "home_chances", "away_chances",
]
cat_cols = ["stadium", "Home Team", "Away Team"]

df["attendance"] = (
    df["attendance"].astype(str).str.replace(r"[^0-9]", "", regex=True).replace("", "0").astype(float)
)
for c in num_cols:
    df[c] = pd.to_numeric(df[c], errors="coerce").fillna(df[c].median())

X_cat = pd.get_dummies(
    df[cat_cols].astype(str).apply(lambda s: s.str.strip()),
    drop_first=False, dtype=int
)

scaler = StandardScaler()
X_num = df[num_cols].copy()
X_num[num_cols] = scaler.fit_transform(X_num[num_cols])

X = pd.concat([X_num, X_cat], axis=1).values

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)

kmeans = KMeans(n_clusters=3, init="k-means++", max_iter=300, n_init=10, random_state=42)
labels = kmeans.fit_predict(X_pca)

plt.figure(figsize=(12, 10))
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=labels, cmap="viridis", s=50)
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
            c="red", marker="*", s=220, label="Centroids")
plt.title("K-Means Clustering (Football Matches) - PCA 2D")
plt.xlabel("PCA 1")
plt.ylabel("PCA 2")
plt.legend()

buf = BytesIO()
plt.savefig(buf, format="png", transparent=True, bbox_inches="tight")
buf.seek(0)
img_base64 = base64.b64encode(buf.read()).decode("utf-8")
html_img = f'<img src="data:image/png;base64,{img_base64}" alt="KMeans clustering" />'
print(html_img)

Esse resultado mostra que o algoritmo conseguiu dividir os dados em agrupamentos distintos, mas com fronteiras de separação difusas, já que as estatísticas utilizadas não garantem divisões claras entre os diferentes resultados das partidas.

Avaliação do Modelo

Para avaliar a qualidade do clustering, os rótulos de clusters foram mapeados para as classes reais (class) por meio de um voto majoritário dentro de cada grupo.
Dessa forma, foi possível calcular métricas de classificação mesmo em um cenário originalmente não supervisionado.

O modelo obteve uma acurácia aproximada de 47.92%, com a seguinte matriz de confusão:

import pandas as pd
from sklearn.metrics import accuracy_score, confusion_matrix
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

df = pd.read_csv("./src/mydata.csv")

num_cols = [
    "attendance",
    "home_possessions", "away_possessions",
    "home_pass", "away_pass",
    "home_chances", "away_chances",
]
cat_cols = ["stadium", "Home Team", "Away Team"]
target = "class"

df["attendance"] = (
    df["attendance"]
      .astype(str)
      .str.replace(r"[^0-9]", "", regex=True)
      .replace("", "0")
      .astype(float)
)
for c in num_cols:
    df[c] = pd.to_numeric(df[c], errors="coerce")
    df[c] = df[c].fillna(df[c].median())

X_cat = pd.get_dummies(
    df[cat_cols].astype(str).apply(lambda s: s.str.strip()),
    drop_first=False, dtype=int
)

scaler = StandardScaler()
X_num = df[num_cols].copy()
X_num[num_cols] = scaler.fit_transform(X_num[num_cols])

X = pd.concat([X_num, X_cat], axis=1).values
y_map = {"h": 0, "d": 1, "a": 2}
y = df[target].astype(str).str.strip().map(y_map).astype(int).values

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

pca = PCA(n_components=2)
X_train_pca = pca.fit_transform(X_train)

kmeans = KMeans(n_clusters=3, init="k-means++", max_iter=300, n_init=10, random_state=42)
labels = kmeans.fit_predict(X_train_pca)

cluster_map = {}
classes = np.unique(y_train)
for c in np.unique(labels):
    mask = labels == c
    if mask.sum() == 0:
        cluster_map[c] = classes[0]
        continue
    counts = np.bincount(y_train[mask], minlength=classes.max()+1)
    majority = counts.argmax()
    cluster_map[c] = majority

y_pred_train = np.array([cluster_map[c] for c in labels])
acc = accuracy_score(y_train, y_pred_train)
cm = confusion_matrix(y_train, y_pred_train, labels=np.sort(classes))

cm_df = pd.DataFrame(
    cm,
    index=[f"Classe Real {cls}" for cls in np.sort(classes)],
    columns=[f"Classe Pred {cls}" for cls in np.sort(classes)]
)

print(f"Acurácia: {acc*100:.2f}%")
print("<br>Matriz de Confusão:")
print(cm_df.to_html(index=True))

As observações principais são:

• O algoritmo conseguiu capturar alguns padrões nas vitórias do mandante (Classe 0) e visitante (Classe 2), mas ainda houve bastante confusão entre elas.
• A classe de empate (Classe 1) foi a mais difícil de identificar, refletindo sua baixa frequência no dataset e a sobreposição natural entre variáveis.
• A visualização em 2D reforça essa dificuldade, mostrando que as fronteiras entre grupos são pouco definidas.

Relatório Final

O experimento com K-Means evidenciou os desafios de aplicar técnicas não supervisionadas no domínio esportivo:

• Exploração: foram utilizadas variáveis contextuais (estádio, público) e estatísticas gerais (posse, passes, chances), previamente normalizadas e transformadas em numéricas.
• Treinamento: o K-Means gerou 3 clusters, interpretados como padrões de desempenho relacionados ao resultado da partida.
• Avaliação: ao comparar clusters com classes reais, a acurácia foi de ~47.9%, valor semelhante aos modelos supervisionados, mas com maiores limitações na interpretação.

Alguns pontos importantes emergem da análise: - O K-Means não tem acesso direto às classes, e portanto os agrupamentos não correspondem necessariamente a vitórias, empates ou derrotas.
- A sobreposição natural dos dados mostra que estatísticas gerais de jogo não são suficientes para definir fronteiras claras entre resultados.
- O futebol continua sendo altamente imprevisível, com variáveis externas (clima, arbitragem, forma dos jogadores, estratégia) que não estão refletidas na base.

Conclusão

O uso do K-Means neste projeto demonstrou o potencial dos algoritmos não supervisionados para explorar padrões em conjuntos de dados complexos, mas também reforçou suas limitações frente a tarefas de previsão.
A acurácia de ~47.9% mostra que, mesmo quando os clusters são posteriormente relacionados às classes reais, o modelo não consegue separar bem as situações de vitória, empate e derrota.

Assim como nos experimentos anteriores, o aprendizado principal não está apenas no valor numérico da métrica, mas no entendimento de que nem todo fenômeno pode ser descrito por padrões lineares ou consistentes.
Esse resultado abre espaço para trabalhos futuros, como o uso de modelos híbridos (combinando supervisionados e não supervisionados) ou a incorporação de variáveis mais ricas, como desempenho de jogadores, estatísticas avançadas e fatores contextuais adicionais.