⚽ Football Analytics Data Lake

AI-Powered Scouting System with Machine Learning

🎯 Complete end-to-end data engineering pipeline for football analytics

Web Scraping → Data Lake → ETL → Machine Learning → Business Intelligence

Features • Architecture • ML Pipeline • Quick Start • Documentation

📖 Table of Contents

Overview
Key Features
Data Architecture
Technology Stack
Machine Learning Pipeline
AI Football Scout
Data Collection Scripts
ETL & Enrichment Pipeline
Project Structure
Quick Start
Datasets Reference
Power BI Integration
Scripts Reference
Jupyter Notebooks
Skills Demonstrated
Documentation
Contributing
License

🎯 Overview

Football Analytics Data Lake is a complete end-to-end data engineering and machine learning project designed for professional football analytics. The system integrates multiple data sources, implements a robust ETL pipeline, applies advanced machine learning techniques, and delivers actionable insights through business intelligence tools.

🏆 Project Highlights

86,930+ player statistics from 30 years of football history (1995-2025)
3,200+ team performance records across major European leagues
553 current squad compositions from 16 top-tier clubs
Automated web scraping from FBref and Transfermarkt
Machine learning clustering for player and team profiling
AI-powered transfer recommendations using cosine similarity
Power BI dashboards with interactive visualizations

🎯 Business Use Cases

Transfer Market Intelligence - Identify optimal player-team matches based on tactical compatibility
Tactical Analysis - Cluster teams by playing style and identify strategic patterns
Player Profiling - Categorize players into performance archetypes using unsupervised learning
Performance Benchmarking - Compare players and teams against historical data
Scouting Automation - Generate shortlists of compatible players for specific team needs

✨ Key Features

🤖 AI Football Scout

Advanced machine learning system for transfer recommendations:

K-Means Clustering with grid search optimization (2-15 clusters tested)
Player Vectorization using 20+ statistical features
Team Vectorization via squad composition aggregation
Cosine Similarity matching for player-team compatibility
Contextual Scoring combining statistical fit (40%) + tactical alignment (60%)
PCA Visualization for 2D cluster mapping

📊 Comprehensive Data Coverage

86,930 player records (1995-2025)
- Performance metrics (goals, assists, xG, xA)
- Per-90-minute statistics (normalized for playing time)
- Progression metrics (carries, passes, receptions)
- Expected metrics (xG, npxG, xAG)
3,206 team records (1995-2025)
- Aggregate team performance
- Season-by-season tracking
- Multi-league coverage
553 squad compositions (2025-26 season)
- 16 top European clubs
- Player positions and ages
- Market valuations
- 5 major leagues (EPL, La Liga, Bundesliga, Serie A, Ligue 1)

🔄 Automated Data Pipeline

Web Scraping - BeautifulSoup4 + Requests with rate limiting
Data Validation - Schema enforcement and quality checks
ETL Processing - Pandas-based transformations
Enrichment Layer - Feature engineering and aggregation
ML Processing - Clustering, vectorization, PCA
BI Export - Normalized CSVs for Power BI

🎯 Tactical Profiling

Player Clusters - Performance-based archetypes (6-8 profiles)
Team Clusters - Tactical style categories (4 styles)
- Posse e Controle (Possession-based)
- Pressão Alta (High-pressing)
- Transição Rápida (Counter-attack)
- Equilíbrio Tático (Balanced)

📈 Power BI Ready

Normalized CSV exports with proper data types
Pre-configured relationships for data modeling
Dashboard-ready visualizations
Interactive scatter plots with PCA coordinates

🏗️ Data Architecture

📂 Three-Layer Architecture

┌─────────────────────────────────────────────────────────────┐
│                    RAW LAYER (Bronze)                       │
│  Unprocessed data from sources - preserved in original form │
├─────────────────────────────────────────────────────────────┤
│  ├── matches/         - Match JSON files (40+ games)        │
│  ├── metadata/        - Player biographical data            │
│  ├── squads/          - Team rosters (19 CSV files)         │
│  └── transfermarkt/   - Transfer market enrichment          │
└─────────────────────────────────────────────────────────────┘
                          ↓ ETL Pipeline
┌─────────────────────────────────────────────────────────────┐
│                 PROCESSED LAYER (Silver)                    │
│   Cleaned, normalized, and consolidated datasets            │
├─────────────────────────────────────────────────────────────┤
│  ├── players_complete_1995_2025.csv   (86,930 records)     │
│  ├── teams_complete_1995_2025.csv     (3,206 records)      │
│  └── squads_complete.csv              (553 records)        │
└─────────────────────────────────────────────────────────────┘
                          ↓ ML Pipeline
┌─────────────────────────────────────────────────────────────┐
│                  ENRICHED LAYER (Gold)                      │
│   ML-processed data with clusters, vectors, and insights    │
├─────────────────────────────────────────────────────────────┤
│  ├── players_clustered.csv            (86,930 + clusters)  │
│  ├── transfer_recommendations.csv     (Top matches)        │
│  ├── clusters_metadata.csv            (Cluster profiles)   │
│  ├── players_pca_viz.csv              (2D coordinates)     │
│  └── teams_pca_viz.csv                (2D coordinates)     │
└─────────────────────────────────────────────────────────────┘
                          ↓ BI Layer
                    Power BI Dashboards

🔄 Data Flow

Ingestion - Web scraping from FBref (stats) + Transfermarkt (squads)
Validation - Schema checks, null handling, data type enforcement
Normalization - Standardization, deduplication, consolidation
Enrichment - Feature engineering, aggregation, derived metrics
ML Processing - Clustering, vectorization, similarity calculation
Visualization - PCA projection, cluster assignment, BI exports

🛠️ Technology Stack

Languages & Core

Python 3.13.1 - Primary programming language
Virtual Environment (.venv) - Isolated dependency management

Data Processing

Pandas 2.2.3 - DataFrame operations, ETL transformations
NumPy 2.1.3 - Numerical computing, array operations
CSV/JSON - Data serialization formats

Web Scraping

BeautifulSoup4 4.12+ - HTML parsing
Requests - HTTP library for web requests
lxml - Fast XML/HTML parser
Rate Limiting - 2-3 second delays between requests

Machine Learning

scikit-learn 1.5.2 - ML algorithms and preprocessing
- KMeans - Clustering algorithm
- StandardScaler - Feature normalization
- PCA - Dimensionality reduction for visualization
- cosine_similarity - Player-team matching
- silhouette_score - Cluster quality evaluation

Business Intelligence

Power BI Desktop - Interactive dashboards
CSV Exports - Normalized data tables with relationships

Development Tools

Git - Version control
Jupyter Notebook - Interactive data analysis
VS Code - IDE
Markdown - Documentation

Data Sources

FBref - Player and team statistics (1995-2025)
Transfermarkt - Squad compositions, market values

🧠 Machine Learning Pipeline

1️⃣ Feature Engineering

Player Features (20+ metrics):

player_features = [
    # Production Metrics
    'Performance_Gls', 'Performance_Ast', 'Performance_G+A',
    
    # Expected Metrics (xG Model)
    'Expected_xG', 'Expected_npxG', 'Expected_xAG', 'Expected_npxG+xAG',
    
    # Per-90 Minutes (Normalized for Playing Time)
    'Per_90_Minutes_Gls', 'Per_90_Minutes_Ast', 'Per_90_Minutes_G+A',
    'Per_90_Minutes_xG', 'Per_90_Minutes_xAG', 'Per_90_Minutes_xG+xAG',
    'Per_90_Minutes_npxG', 'Per_90_Minutes_npxG+xAG',
    
    # Progression Metrics (Ball Advancement)
    'Progression_PrgC',  # Progressive Carries
    'Progression_PrgP',  # Progressive Passes
    'Progression_PrgR',  # Progressive Receptions
    
    # Volume Metrics
    'Playing_Time_MP', 'Playing_Time_Starts', 'Playing_Time_90s'
]

2️⃣ Player Clustering (K-Means)

# Grid Search for Optimal K
k_range = range(2, 16)
best_k = optimize_clusters_grid_search(player_data, k_range)

# StandardScaler Normalization
scaler = StandardScaler()
player_scaled = scaler.fit_transform(player_features)

# KMeans Clustering
kmeans = KMeans(n_clusters=best_k, random_state=42, n_init=10)
player_clusters = kmeans.fit_predict(player_scaled)

# Silhouette Score Validation
score = silhouette_score(player_scaled, player_clusters)

Output: 6-8 player archetypes based on performance profiles

3️⃣ Team Vectorization (Aggregation)

# Engineering Decision: Team vector = average of player vectors
team_vector = mean(player_vectors[squad_players])

# Why this approach?
# - Captures squad composition, not just team stats
# - Represents tactical DNA through player profiles
# - Enables player-team compatibility matching

Not using raw team stats - using squad composition aggregation provides better tactical profiling.

4️⃣ Team Clustering (Tactical Styles)

# Team features focus on STYLE, not production
team_features = [
    'Performance_Gls', 'Performance_Ast',      # Output
    'Expected_xG', 'Expected_xAG',             # Quality
    'Progression_PrgC', 'Progression_PrgP',    # Progression
    'Per_90_Minutes_Gls', 'Per_90_Minutes_xG'  # Efficiency
]

# K=4 clusters (validated via silhouette score)
team_clusters = KMeans(n_clusters=4).fit_predict(team_scaled)

Clusters:

Cluster 0: Posse e Controle (Possession-based teams)
Cluster 1: Pressão Alta (High-pressing, aggressive)
Cluster 2: Transição Rápida (Counter-attacking teams)
Cluster 3: Equilíbrio Tático (Balanced approach)

5️⃣ Transfer Recommendations (Cosine Similarity)

from sklearn.metrics.pairwise import cosine_similarity

# Calculate similarity between player vector and team vector
similarity_matrix = cosine_similarity(
    player_vectors,
    team_vectors
)

# Contextual Scoring (Hybrid Approach)
contextual_score = (
    0.4 * vector_similarity +      # Statistical match
    0.6 * tactical_fit_score       # Cluster compatibility
)

# Rank top 7 players per team
top_recommendations = sorted(scores, reverse=True)[:7]

Why 40/60 split?

Vector similarity captures statistical compatibility
Tactical fit ensures playing style alignment
Weighted toward tactics to prioritize strategic fit

6️⃣ PCA Visualization (Dimensionality Reduction)

from sklearn.decomposition import PCA

# Reduce 20+ dimensions to 2D for visualization
pca = PCA(n_components=2)
pca_coords = pca.fit_transform(player_scaled)

# Normalize to 0-100 scale for interpretability
pca_x = 100 * (coords[:, 0] - min) / (max - min)
pca_y = 100 * (coords[:, 1] - min) / (max - min)

Output: 2D scatter plot coordinates for Power BI visualizations

Explained Variance:

Players: ~66% (20 features → 2 components)
Teams: ~94% (11 features → 2 components)

🎯 AI Football Scout

System Architecture

The AI Football Scout is an end-to-end machine learning system for transfer market intelligence:

Input: Player Stats (86,930 records) + Squad Data (553 records)
   ↓
Feature Selection (20+ metrics)
   ↓
Normalization (StandardScaler)
   ↓
Player Clustering (K-Means, k=6-8)
   ↓
Team Vectorization (Squad Aggregation)
   ↓
Team Clustering (K-Means, k=4)
   ↓
Similarity Calculation (Cosine)
   ↓
Contextual Scoring (40% stats + 60% tactics)
   ↓
Output: Transfer Recommendations (Top 7 per team)

How It Works

Step 1: Player Profiling

Each player is represented as a 20-dimensional vector based on:

Offensive contribution (goals, assists, xG)
Efficiency (per-90 metrics)
Progression ability (carries, passes, receptions)
Expected performance (xG models)

player_vector = [
    2.1,   # Per_90_Gls
    1.8,   # Per_90_Ast
    3.2,   # Per_90_xG
    ...    # (20 total features)
]

Step 2: Player Clustering

K-Means groups similar players into 6-8 archetypes:

Cluster	Profile	Characteristics
0	Centroavante Clássico	High goals, low assists, target striker
1	Médio Criativo	High assists, progressive passes, playmaker
2	Lateral Ofensivo	High progressive carries, crosses
3	Volante Defensivo	Low offensive stats, high tackles
...	...	...

Step 3: Team Vectorization

Teams are represented by averaging their squad's player vectors:

# Example: Real Madrid (2025-26 squad)
squad_players = ['Bellingham', 'Vinicius Jr', 'Rodrygo', 'Mbappé', ...]
team_vector_real_madrid = mean([
    player_vector['Bellingham'],  # Already at Real Madrid since 2023
    player_vector['Vinicius Jr'],
    player_vector['Rodrygo'],
    player_vector['Mbappé'],
    ...
])

Why this approach?

Captures tactical DNA through player composition
Enables direct player-team compatibility comparison
More accurate than using raw team statistics

Step 4: Team Tactical Clustering

Teams are clustered into 4 tactical styles based on playing approach:

# Cluster assignment examples:
'Manchester City'  → Cluster 0 (Posse e Controle)
'Liverpool'        → Cluster 1 (Pressão Alta)
'Real Madrid'      → Cluster 2 (Transição Rápida)
'Bayern Munich'    → Cluster 3 (Equilíbrio Tático)

Step 5: Compatibility Matching

For each player-team pair, calculate:

# Statistical similarity (cosine distance in feature space)
vector_similarity = cosine_similarity(player_vector, team_vector)

# Tactical fit (do player and team clusters align?)
tactical_fit = cluster_compatibility_matrix[player_cluster][team_cluster]

# Final score (weighted combination)
match_score = 0.4 * vector_similarity + 0.6 * tactical_fit

Step 6: Recommendations

Output top 7 players per team, ranked by match score:

team,player,position,age,current_club,match_score,player_cluster,team_cluster
Manchester City,De Bruyne,CM,33,Manchester City,0.8934,1,0
Liverpool,Salah,RW,32,Liverpool,0.8821,0,1
Barcelona,Lewandowski,ST,36,Barcelona,0.8165,0,2

Example Output

Query: Best transfers for Liverpool

System Response:

🎯 Top 5 Transfer Recommendations for Liverpool (Pressão Alta)

🟢 Salah         | RW  | 32y | Liverpool          | 92.15% match ✅ Current
🟢 Saka          | RW  | 23y | Arsenal            | 88.34% match
🟢 Foden         | AM  | 24y | Manchester City    | 87.92% match
🟡 Martinelli    | LW  | 23y | Arsenal            | 82.45% match
🟡 Kudus         | AM  | 24y | West Ham           | 79.88% match

Legend:
🟢 = Excellent fit (>85%)
🟡 = Good fit (70-85%)
🔵 = Moderate fit (60-70%)
✅ = Already at club (validates model accuracy)

Historical Validation:

The system successfully predicted transfers that later occurred:

Bellingham to Real Madrid (2023) - Model scored 89% compatibility
System matched professional scouts' decisions - Validates algorithmic approach

Key Metrics

Accuracy: Silhouette scores > 0.45 (good cluster separation)
Coverage: 86,930 players analyzed across 30 years
Speed: Full pipeline runs in <2 minutes
Interpretability: PCA visualizations + cluster profiles

📥 Data Collection Scripts

`fetch_team_squads.py`

Purpose: Scrape individual team squad compositions from Transfermarkt

Technology:

BeautifulSoup4 for HTML parsing
Requests for HTTP requests
Rate limiting (2-3s delays)

Features:

Hardcoded team ID lookup for 16 major clubs
Fallback search functionality
Market value extraction (€50.00m → 50.0)
Position and age parsing

Usage:

python scripts/fetch_team_squads.py --team "Manchester City" --season 2025

Output:

Individual CSV: datalake/raw/squads/manchester_city_2025_squad.csv
Schema: team, season, player_name, position, age, nationality, market_value

Key Functions:

def search_team_transfermarkt(team_name):
    """Lookup team ID from hardcoded dictionary or search"""
    
def get_team_squad(team_id, season):
    """Parse squad table from Transfermarkt HTML"""
    
def clean_market_value(value_str):
    """Convert '€50.00m' to float 50.0"""

URL Pattern:

https://www.transfermarkt.com/{team}/kader/verein/{id}/saison_id/{year}/plus/1

`generate_squads_database.py`

Purpose: Batch orchestrator for scraping multiple leagues/teams

Features:

Multi-league support (EPL, La Liga, Bundesliga, Serie A, Ligue 1)
Batch processing for 16 top teams
Automatic consolidation into single CSV
League attribution

Usage:

python scripts/generate_squads_database.py --leagues "all" --seasons "2025"

Configuration:

TOP_TEAMS = {
    'Premier League': ['Manchester City', 'Liverpool', 'Arsenal'],
    'La Liga': ['Real Madrid', 'Barcelona', 'Atlético Madrid'],
    'Bundesliga': ['Bayern Munich', 'Borussia Dortmund', 'RB Leipzig'],
    'Serie A': ['Inter', 'Juventus', 'AC Milan'],
    'Ligue 1': ['PSG', 'Monaco', 'Marseille', 'Lyon']
}

Output:

19 individual squad CSVs in datalake/raw/squads/
Consolidated datalake/processed/squads_complete.csv (553 records)

Pipeline:

1. scrape_team_squad(team, season)
   ↓
2. save_to_csv(raw/squads/{team}_{season}_squad.csv)
   ↓
3. consolidate_squads()
   ↓
4. add_league_attribution()
   ↓
5. save_to_csv(processed/squads_complete.csv)

`generate_pca_visualization.py`

Purpose: Generate 2D PCA coordinates for cluster visualization in Power BI

ML Techniques:

PCA (Principal Component Analysis) for dimensionality reduction
K-Means clustering for team tactical styles
Feature normalization (0-100 scale)

Features:

Player PCA: 20 features → 2D (66% variance explained)
Team PCA: 11 features → 2D (94% variance explained)
Automatic cluster assignment
Normalized coordinates for interpretability

Usage:

python scripts/generate_pca_visualization.py

Output:

datalake/processed/enriched/players_pca_viz.csv (195,560 records)
- Columns: player, Club, pos, age, pca_x, pca_y, player_cluster, goals, assists
datalake/processed/enriched/teams_pca_viz.csv (120 records)
- Columns: team, pca_x, pca_y, team_cluster, cluster_name, avg_goals, avg_xG

Normalization:

# Convert PCA values to 0-100 scale
pca_normalized = 100 * (pca_values - min) / (max - min)

🔄 ETL & Enrichment Pipeline

Raw Layer → Processed Layer

Script: merge_normalize_players_teams.py

Transformations:

Schema Validation - Enforce column types, handle nulls
Deduplication - Remove duplicate player-season records
Normalization - Standardize team names, position codes
Consolidation - Merge multiple source files
Typing - Convert strings to numeric where appropriate

Input: Multiple raw CSV files per season Output: players_complete_1995_2025.csv, teams_complete_1995_2025.csv

Processed Layer → Enriched Layer

Script: clusterization

Pipeline:

1. Load processed data
2. Feature selection (20+ metrics)
3. StandardScaler normalization
4. Grid search for optimal K (players)
5. K-Means clustering (players)
6. Team vector calculation (squad aggregation)
7. K-Means clustering (teams, k=4)
8. Cosine similarity matrix
9. Contextual scoring (40/60 split)
10. Top-N recommendations per team
11. PCA visualization prep
12. Save enriched CSVs

Outputs:

players_clustered.csv - Player profiles with cluster IDs
transfer_recommendations.csv - Top matches per team
clusters_metadata.csv - Cluster characteristics
squad_compatibility.csv - Current squad analysis
cluster_balance.csv - Over/under-representation

Enrichment Features

Player Enrichment:

Historical career tracking (multi-season)

datalake/
├── datalake/
│   ├── raw/                    # Source data
│   │   ├── matches/           # Match JSON files (40+ games)
│   │   ├── metadata/          # Player biographical data
│   │   ├── squads/            # Team rosters (16 teams)
│   │   └── transfermarkt/     # Transfer market data
│   └── processed/
│       ├── players_complete_1995_2025.csv
│       ├── teams_complete_1995_2025.csv
│       ├── squads_complete.csv
│       └── enriched/          # Individual player datasets
│
├── scripts/
│   ├── clusterization                  # AI Scout (main)
│   ├── fetch_team_squads.py
│   ├── generate_squads_database.py
│   └── enrich_player_complete.py
│
├── notebooks/
│   └── ai_football_scout.ipynb        # Interactive ML
│
└── docs/
    ├── ARCHITECTURE.md
    ├── DATA_SOURCES.md
    └── POWERBI_GUIDE.md

🚀 Quick Start

1. Installation

# Clone repository
git clone https://github.com/yourusername/football-analytics-datalake.git
cd football-analytics-datalake

# Create virtual environment
python -m venv .venv
.venv\Scripts\activate  # Windows

# Install dependencies
pip install -r requirements.txt

2. Run AI Football Scout

# Python script
python scripts/clusterization

# Jupyter Notebook (interactive)
jupyter notebook notebooks/ai_football_scout.ipynb

3. Generate Squad Data

# All 5 major leagues (2025-26)
python scripts/generate_squads_database.py --leagues "all" --seasons "2025"

# Single team
python scripts/fetch_team_squads.py --team "Manchester City" --season 2025

🤖 AI Football Scout

How It Works

Player Clustering (K-Means)
- 36 features: goals, assists, xG, progression, per-90 metrics
- Grid search for optimal clusters (2-15 tested)
- Silhouette score optimization
- Result: 6-8 player profiles
Team Vectorization
- Team vector = average of player vectors from squad
- Captures tactical DNA of each team
Transfer Recommendations
- Cosine similarity between player and team vectors
- Contextual scoring: 40% vector + 60% tactical fit
- Output: Top 7 compatible players per team

Example Output

🎯 Top 5 Transfers for Liverpool (using historical data):

🟢 Salah         | RW  | 32y | Liverpool          | 0.9215 ✅
🟢 Saka          | RW  | 23y | Arsenal            | 0.8834
🟡 Foden         | AM  | 24y | Manchester City    | 0.8792

Historical Validation: System predicted Bellingham → Real Madrid (89% match) in 2022-23 data. Transfer completed Summer 2023 ✅

📊 Datasets

File	Records	Description
`players_complete_1995_2025.csv`	86,930	Full player stats
`teams_complete_1995_2025.csv`	8,450+	Team stats
`squads_complete.csv`	553	Current rosters
`players_clustered.csv`	86,930	ML clustering

📈 Power BI Integration

Import CSVs → Get Data → Text/CSV
Create Relationships:
- transfer_recommendations[player_cluster] → clusters_metadata[cluster_id]
Build Visuals:
- Scatter Plot (Age × Match Score)
- Matrix (Top transfers per team)
- Cluster Map (PCA 2D)

See docs/POWERBI_GUIDE.md for details.

🛠️ Tech Stack

Data: Pandas, NumPy
ML: scikit-learn (KMeans, StandardScaler, cosine similarity)
Scraping: BeautifulSoup4, Requests
Viz: Jupyter, Power BI
Sources: FBref, Transfermarkt

🎓 Skills Demonstrated

Data Engineering:

ETL pipelines
Web scraping with rate limiting
Data normalization

Machine Learning:

Unsupervised learning (K-Means)
Grid search hyperparameter tuning
Vector similarity
Feature engineering (36 features)

Software Engineering:

Modular architecture
Documentation
Version control

📄 License

MIT License - see LICENSE

⭐ Star this repo if you found it helpful!

_{Built with ❤️ for football analytics}

Name		Name	Last commit message	Last commit date
datalake		datalake
docs		docs
notebooks		notebooks
scripts		scripts
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
PROJECT_ORGANIZATION.md		PROJECT_ORGANIZATION.md
README.md		README.md
requirements.txt		requirements.txt

Latest commit

History

Folders and files

Repository files navigation

⚽ Football Analytics Data Lake

AI-Powered Scouting System with Machine Learning

🎯 Complete end-to-end data engineering pipeline for football analytics

📖 Table of Contents

🎯 Overview

🏆 Project Highlights

🎯 Business Use Cases

✨ Key Features

🤖 AI Football Scout

📊 Comprehensive Data Coverage

🔄 Automated Data Pipeline

🎯 Tactical Profiling

📈 Power BI Ready

🏗️ Data Architecture

📂 Three-Layer Architecture

🔄 Data Flow

🛠️ Technology Stack

Languages & Core

Data Processing

Web Scraping

Machine Learning

Business Intelligence

Development Tools

Data Sources

🧠 Machine Learning Pipeline

1️⃣ Feature Engineering

2️⃣ Player Clustering (K-Means)

3️⃣ Team Vectorization (Aggregation)

4️⃣ Team Clustering (Tactical Styles)

5️⃣ Transfer Recommendations (Cosine Similarity)

6️⃣ PCA Visualization (Dimensionality Reduction)

🎯 AI Football Scout

System Architecture

How It Works

Step 1: Player Profiling

Step 2: Player Clustering

Step 3: Team Vectorization

Step 4: Team Tactical Clustering

Step 5: Compatibility Matching

Step 6: Recommendations

Example Output

Key Metrics

📥 Data Collection Scripts

fetch_team_squads.py

generate_squads_database.py

generate_pca_visualization.py

🔄 ETL & Enrichment Pipeline

Raw Layer → Processed Layer

Processed Layer → Enriched Layer

Enrichment Features

🚀 Quick Start

1. Installation

2. Run AI Football Scout

3. Generate Squad Data

🤖 AI Football Scout

How It Works

Example Output

📊 Datasets

📈 Power BI Integration

🛠️ Tech Stack

🎓 Skills Demonstrated

📄 License

About

Resources

Contributing

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

`fetch_team_squads.py`

`generate_squads_database.py`

`generate_pca_visualization.py`