What You'll Build
In this hands-on exercise, you will build a Cricket Match Performance Analysis System that processes real-world cricket player statistics and match data using foundational Python concepts for machine learning. The system will read innings data from multiple cricketers, calculate performance metrics such as batting average, strike rate, and consistency scores, apply data transformations and filtering operations, and generate predictions about player form.
This project integrates several core programming disciplines: data structures such as lists, dictionaries, and classes; control flow through loops and conditionals; functional programming via list comprehensions and lambda functions; and basic statistical analysis. These are all essential skills for building production-grade machine learning systems.
By the end of this exercise, you will have a working application that demonstrates how raw cricket statistics are transformed into meaningful insights. This mirrors precisely how machine learning pipelines process raw data into actionable predictions.
Analogy🏏Cricket
🏏 Think of it like cricket: Building an ML system is like a cricket coach analyzing match footage to prepare the team for upcoming opponents. Just as a coach reviews each player's past 10 innings—noting Virat Kohli's average against pace bowling, Rohit Sharma's powerplay strike rate, or Jasprit Bumrah's economy in the death overs—your ML pipeline reviews raw data (innings_scores, deliveries_faced, wickets_taken) to extract features and patterns. The coach doesn't just watch randomly; they follow a structured process: collect data from the scorecard, filter for relevant matches, calculate metrics (run rate, consistency), and finally produce a team sheet prediction. Your Python code does exactly this—it ingests player statistics, applies transformations (normalizing scores, computing averages), filters based on conditions (active players, minimum matches), and outputs insights. Understanding this parallel reveals why we build ML systems in layers: just as a coach first gathers evidence, then interprets it, then makes decisions, machine learning requires data intake, feature engineering, and model output in sequence.
Prerequisites
- Solid understanding of Python data structures: lists, dictionaries, tuples, and ability to nest them for complex data representation
- Proficiency with loops (for, while) and conditionals (if/elif/else) to control program flow based on data conditions
- Working knowledge of functions: defining functions with parameters, return statements, and calling functions with arguments
- Familiarity with list comprehensions and basic lambda functions for compact data transformation operations
- Basic statistical concepts: mean, standard deviation, and normalization for calculating performance metrics
Setup & Project Structure
Begin by creating a new project directory called 'cricket_ml_analysis' and organizing it with a clear separation of concerns. The project requires a main Python script to orchestrate the entire workflow, a data module to handle file I/O operations, and a separate module for player and match classes. This structure mirrors professional machine learning project layouts, where data handling, model logic, and execution are kept distinct to keep code maintainable and testable.
Analogy🏏Cricket
🏏 Think of it like cricket: before a tournament a team does not throw kit, players, and strategy into one heap — the dressing room, the nets, the physio bench, and the analyst's laptop each have their place, so anyone can find what they need under pressure. Structuring the cricket_ml_analysis project the same way, with a main script to captain the workflow, a data module for file I/O, and a separate module for player and match classes, is that same separation of concerns. Just as the batting coach and the bowling coach work independently yet feed one match plan in cricket, your data-handling code and your class definitions develop separately yet compose into one pipeline. And just as a well-run squad keeps net practice, match data, and results in distinct areas, your project keeps data, models, and outputs in dedicated folders. The payoff is a professional layout that stays maintainable as the project grows — nobody rummages through chaos mid-match.
You will also need to install the required dependencies: pandas for data manipulation, numpy for numerical operations, and the standard library's csv module for reading data files. Even though the exercise makes use of core Python, having these libraries available ensures the project aligns with the tooling found in real-world ML environments.
bash
#!/bin/bash
# Cricket ML Analysis Project Setup
# Create project directory structure
mkdir -p cricket_ml_analysis
cd cricket_ml_analysis
# Create subdirectories
mkdir -p data
mkdir -p models
mkdir -p outputs
# Create Python module files
touch player_module.py
touch match_analyzer.py
touch main_pipeline.py
touch test_pipeline.py
# Create sample data directory
touch data/cricket_players.csv
touch data/match_results.json
# Install dependencies
pip install pandas numpy
# Verify installation
python --version
pip show pandas numpy
echo "Cricket ML Analysis project initialized successfully!"
echo "Directory structure:"
tree . 2>/dev/null || find . -type f -name '*.py' -o -name '*.csv' -o -name '*.json'Step 1 — Foundation
Step 1 establishes the foundational data structures and class definitions that represent cricket entities within your machine learning system. You will create a CricketPlayer class that encapsulates player attributes — including name, role, and country — as well as innings data such as scores, deliveries faced, and wickets taken. An accompanying Innings class will represent a single match performance with all relevant statistics.
This step demonstrates object-oriented programming principles, which are the cornerstone of building scalable machine learning systems. By modeling real-world entities as Python classes with well-defined attributes and methods, you establish a foundation that prevents data inconsistency and makes downstream analysis reliable. This matters because machine learning models are only as good as the data feeding them.
Analogy🏏Cricket
🏏 Think of it like cricket: Designing your data structures is like a cricket administrator creating the official scorecard format before a match begins. Just as a scorecard has predefined columns for batter name, runs scored, balls faced, and dismissal details, your CricketPlayer and Innings classes define exactly what data will be recorded and in what format. Consider Rohit Sharma's innings in the 2023 World Cup final: the scorecard consistently recorded his name, country (India), role (opener), runs (92), balls faced (64), boundaries (4s and 6s), and dismissal method. If the scorecard format changed mid-match—sometimes listing balls faced, sometimes not—the entire match record becomes unreliable and comparison across matches becomes impossible. Your Python class structure ensures this consistency: every CricketPlayer object will have the same attributes, every Innings object the same fields. This consistency is precisely what machine learning algorithms require; they cannot learn patterns from inconsistent data formats.
python
# player_module.py
# Foundation: Data structures for cricket entities
from datetime import datetime
from typing import List, Dict, Optional
class Innings:
"""
Represents a single cricket innings performance.
Encapsulates all metrics from a player's one match appearance.
"""
def __init__(self,
match_id: str,
player_name: str,
runs_scored: int,
balls_faced: int,
fours: int = 0,
sixes: int = 0,
wickets_taken: int = 0,
runs_conceded: int = 0,
overs_bowled: float = 0.0,
date: str = None):
self.match_id = match_id
self.player_name = player_name
self.runs_scored = runs_scored
self.balls_faced = balls_faced
self.fours = fours
self.sixes = sixes
self.wickets_taken = wickets_taken
self.runs_conceded = runs_conceded
self.overs_bowled = overs_bowled
self.date = date or datetime.now().strftime("%Y-%m-%d")
def strike_rate(self) -> float:
"""Calculate strike rate: (runs/balls)*100. Essential batting metric."""
if self.balls_faced == 0:
return 0.0
return (self.runs_scored / self.balls_faced) * 100
def economy_rate(self) -> float:
"""Calculate economy rate: runs_conceded per over. Essential bowling metric."""
if self.overs_bowled == 0:
return 0.0
return self.runs_conceded / self.overs_bowled
def __repr__(self):
return f"Innings({self.player_name}, {self.runs_scored} runs, SR: {self.strike_rate():.1f})"
class CricketPlayer:
"""
Represents a cricket player with career statistics.
Manages collection of innings and calculates aggregate metrics.
"""
def __init__(self,
name: str,
country: str,
role: str, # 'Batter', 'Bowler', 'All-rounder'
jersey_number: int):
self.name = name
self.country = country
self.role = role
self.jersey_number = jersey_number
self.innings_list: List[Innings] = []
def add_innings(self, innings: Innings) -> None:
"""Add a completed innings to player's record."""
self.innings_list.append(innings)
def batting_average(self) -> float:
"""Calculate average runs per innings. Core batting metric."""
if len(self.innings_list) == 0:
return 0.0
total_runs = sum(inn.runs_scored for inn in self.innings_list)
return total_runs / len(self.innings_list)
def matches_played(self) -> int:
"""Return total number of innings played."""
return len(self.innings_list)
def total_runs(self) -> int:
"""Return cumulative runs across all innings."""
return sum(inn.runs_scored for inn in self.innings_list)
def career_strike_rate(self) -> float:
"""Calculate overall strike rate across all innings."""
total_balls = sum(inn.balls_faced for inn in self.innings_list)
if total_balls == 0:
return 0.0
return (self.total_runs() / total_balls) * 100
def bowling_average(self) -> float:
"""Calculate runs conceded per wicket (bowling metric)."""
total_wickets = sum(inn.wickets_taken for inn in self.innings_list)
if total_wickets == 0:
return 0.0
total_runs_conceded = sum(inn.runs_conceded for inn in self.innings_list)
return total_runs_conceded / total_wickets
def consistency_score(self) -> float:
"""
Calculate consistency as inverse of coefficient of variation.
Higher score = more consistent performance (important for ML feature).
"""
if len(self.innings_list) < 2:
return 0.0
runs = [inn.runs_scored for inn in self.innings_list]
mean_runs = sum(runs) / len(runs)
# Avoid division by zero
if mean_runs == 0:
return 0.0
variance = sum((r - mean_runs) ** 2 for r in runs) / len(runs)
std_dev = variance ** 0.5
coefficient_variation = std_dev / mean_runs
# Inverse relationship: high variation = low consistency
return 1 / (1 + coefficient_variation)
def __repr__(self):
return f"CricketPlayer({self.name}, {self.country}, {self.role}, Avg: {self.batting_average():.1f})"
# Example instantiation for testing
if __name__ == "__main__":
# Create player instances
rohit = CricketPlayer("Rohit Sharma", "India", "Batter", 45)
bumrah = CricketPlayer("Jasprit Bumrah", "India", "Bowler", 93)
# Add sample innings for Rohit
rohit.add_innings(Innings("M001", "Rohit Sharma", 87, 52, fours=11, sixes=2, date="2024-01-15"))
rohit.add_innings(Innings("M002", "Rohit Sharma", 45, 38, fours=5, sixes=1, date="2024-01-17"))
rohit.add_innings(Innings("M003", "Rohit Sharma", 156, 128, fours=18, sixes=4, date="2024-01-19"))
# Add sample innings for Bumrah
bumrah.add_innings(Innings("M001", "Jasprit Bumrah", 0, 0, wickets_taken=2, runs_conceded=28, overs_bowled=4.0, date="2024-01-15"))
bumrah.add_innings(Innings("M002", "Jasprit Bumrah", 0, 0, wickets_taken=3, runs_conceded=35, overs_bowled=4.0, date="2024-01-17"))
print(f"Player 1: {rohit}")
print(f" Matches: {rohit.matches_played()}, Avg: {rohit.batting_average():.2f}, SR: {rohit.career_strike_rate():.2f}")
print(f" Consistency: {rohit.consistency_score():.3f}")
print()
print(f"Player 2: {bumrah}")
print(f" Matches: {bumrah.matches_played()}, Bowling Avg: {bumrah.bowling_average():.2f}")Step 2 — Core Logic
Step 2 implements the core analysis logic that transforms raw player data into meaningful insights. You will build functions that filter players by criteria such as minimum matches played, specific roles, and performance thresholds, as well as functions that calculate derived features including consistency scores, form trends, and percentile rankings. The step also covers generating structured performance reports from these derived values.
This work directly mirrors the feature engineering process in machine learning — the practice of creating new, meaningful variables from raw data that better represent the underlying patterns a model should learn. In this way, the conditional logic and aggregation functions you write here reflect how ML systems encode domain knowledge to make raw data more informative.
Analogy🏏Cricket
🏏 Think of it like cricket: Core logic is like how a cricket selection committee evaluates players for the national team squad. The committee doesn't just look at one recent match; they apply systematic filters and calculations. For example, they might say: 'Consider only batters with minimum 15 Test matches and average above 35,' then 'Calculate form rating based on last 5 innings,' then 'Rank by consistency score.' Your Python functions implement exactly this workflow—filtering_active_players() excludes players with too few matches, calculate_player_form() examines recent performance trend, and rank_by_metric() orders players by a metric like consistency or strike rate. When Virat Kohli's average dips in a series, the selection committee doesn't panic; they apply their filters and rules to see if this is a temporary slump (recent form) or systematic decline (overall average). Your code does the same: it separates temporary variations from true performance patterns through layered analysis.
python
# match_analyzer.py
# Core Logic: Analysis functions and feature engineering
from player_module import CricketPlayer, Innings
from typing import List, Dict, Tuple
import statistics
class MatchAnalyzer:
"""
Core analysis engine for cricket player data.
Implements filtering, feature engineering, and ranking operations.
"""
def __init__(self, players: List[CricketPlayer]):
self.players = players
self.analysis_results: Dict = {}
def filter_active_players(self, min_matches: int = 5) -> List[CricketPlayer]:
"""
Filter players who have played minimum required matches.
Essential for avoiding unreliable statistics from limited samples.
"""
active = [p for p in self.players if p.matches_played() >= min_matches]
return active
def filter_by_role(self, role: str) -> List[CricketPlayer]:
"""
Filter players by their playing role.
Allows separate analysis for batters vs bowlers vs all-rounders.
"""
return [p for p in self.players if p.role.lower() == role.lower()]
def filter_by_country(self, country: str) -> List[CricketPlayer]:
"""
Filter players by country for regional analysis.
"""
return [p for p in self.players if p.country.lower() == country.lower()]
def calculate_recent_form(self, player: CricketPlayer, last_n_innings: int = 3) -> float:
"""
Calculate form rating based on recent performance.
Uses only last N innings to capture current form, not career history.
This is how selectors identify in-form players for upcoming matches.
"""
if player.matches_played() < last_n_innings:
recent_innings = player.innings_list
else:
recent_innings = player.innings_list[-last_n_innings:]
if not recent_innings:
return 0.0
recent_avg = sum(inn.runs_scored for inn in recent_innings) / len(recent_innings)
return recent_avg
def calculate_form_trend(self, player: CricketPlayer) -> str:
"""
Determine if player's form is improving, declining, or stable.
Critical for predicting which players will perform well in upcoming matches.
"""
if player.matches_played() < 2:
return "INSUFFICIENT_DATA"
first_half_avg = sum(inn.runs_scored for inn in player.innings_list[:len(player.innings_list)//2]) / max(1, len(player.innings_list)//2)
second_half_avg = sum(inn.runs_scored for inn in player.innings_list[len(player.innings_list)//2:]) / max(1, len(player.innings_list) - len(player.innings_list)//2)
improvement_threshold = 5 # Run improvement
if second_half_avg > first_half_avg + improvement_threshold:
return "IMPROVING"
elif second_half_avg < first_half_avg - improvement_threshold:
return "DECLINING"
else:
return "STABLE"
def rank_by_metric(self,
players: List[CricketPlayer],
metric: str = "batting_average") -> List[Tuple[CricketPlayer, float]]:
"""
Rank players by specified metric (batting_average, strike_rate, consistency, etc.).
Returns sorted list of tuples: (player, metric_value).
"""
metric_mapping = {
"batting_average": lambda p: p.batting_average(),
"strike_rate": lambda p: p.career_strike_rate(),
"consistency": lambda p: p.consistency_score(),
"total_runs": lambda p: p.total_runs(),
"bowling_average": lambda p: p.bowling_average(),
}
if metric not in metric_mapping:
raise ValueError(f"Metric '{metric}' not supported. Choose from: {list(metric_mapping.keys())}")
# Calculate metric for each player
player_scores = [(p, metric_mapping[metric](p)) for p in players]
# Sort in descending order (higher is better for most metrics)
sorted_players = sorted(player_scores, key=lambda x: x[1], reverse=True)
return sorted_players
def calculate_percentile_rank(self, player: CricketPlayer, metric: str = "batting_average") -> float:
"""
Calculate what percentile a player ranks in for a given metric.
Useful for comparing player to cohort.
"""
metric_mapping = {
"batting_average": lambda p: p.batting_average(),
"strike_rate": lambda p: p.career_strike_rate(),
"consistency": lambda p: p.consistency_score(),
}
if metric not in metric_mapping:
return 0.0
player_value = metric_mapping[metric](player)
all_values = [metric_mapping[metric](p) for p in self.players if metric_mapping[metric](p) > 0]
if not all_values:
return 0.0
# Count how many players score less than this player
lower_count = sum(1 for v in all_values if v < player_value)
percentile = (lower_count / len(all_values)) * 100
return percentile
def generate_performance_report(self, player: CricketPlayer) -> Dict:
"""
Generate comprehensive performance report for a single player.
Demonstrates aggregation of multiple metrics into actionable insights.
"""
return {
"name": player.name,
"country": player.country,
"role": player.role,
"matches_played": player.matches_played(),
"batting_average": round(player.batting_average(), 2),
"strike_rate": round(player.career_strike_rate(), 2),
"consistency_score": round(player.consistency_score(), 3),
"recent_form": round(self.calculate_recent_form(player), 2),
"form_trend": self.calculate_form_trend(player),
"percentile_rank": round(self.calculate_percentile_rank(player), 1),
"total_runs": player.total_runs(),
}
def generate_team_report(self, players: List[CricketPlayer]) -> List[Dict]:
"""
Generate performance reports for entire team/group of players.
"""
return [self.generate_performance_report(p) for p in players]
# Example usage for testing
if __name__ == "__main__":
from player_module import CricketPlayer, Innings
# Create test players
players_list = []
# Player 1: Rohit Sharma - in-form batter
rohit = CricketPlayer("Rohit Sharma", "India", "Batter", 45)
rohit.add_innings(Innings("M001", "Rohit Sharma", 45, 38, date="2024-01-10"))
rohit.add_innings(Innings("M002", "Rohit Sharma", 67, 52, date="2024-01-12"))
rohit.add_innings(Innings("M003", "Rohit Sharma", 120, 95, date="2024-01-15"))
rohit.add_innings(Innings("M004", "Rohit Sharma", 89, 71, date="2024-01-18"))
rohit.add_innings(Innings("M005", "Rohit Sharma", 34, 29, date="2024-01-20"))
players_list.append(rohit)
# Player 2: Virat Kohli - declining form
virat = CricketPlayer("Virat Kohli", "India", "Batter", 18)
virat.add_innings(Innings("M001", "Virat Kohli", 95, 78, date="2024-01-10"))
virat.add_innings(Innings("M002", "Virat Kohli", 68, 55, date="2024-01-12"))
virat.add_innings(Innings("M003", "Virat Kohli", 42, 38, date="2024-01-15"))
virat.add_innings(Innings("M004", "Virat Kohli", 28, 32, date="2024-01-18"))
virat.add_innings(Innings("M005", "Virat Kohli", 15, 18, date="2024-01-20"))
players_list.append(virat)
# Player 3: Jasprit Bumrah - bowler
bumrah = CricketPlayer("Jasprit Bumrah", "India", "Bowler", 93)
bumrah.add_innings(Innings("M001", "Jasprit Bumrah", 0, 0, wickets_taken=2, runs_conceded=28, overs_bowled=4.0, date="2024-01-10"))
bumrah.add_innings(Innings("M002", "Jasprit Bumrah", 0, 0, wickets_taken=3, runs_conceded=32, overs_bowled=4.0, date="2024-01-12"))
bumrah.add_innings(Innings("M003", "Jasprit Bumrah", 0, 0, wickets_taken=1, runs_conceded=45, overs_bowled=4.0, date="2024-01-15"))
bumrah.add_innings(Innings("M004", "Jasprit Bumrah", 0, 0, wickets_taken=2, runs_conceded=38, overs_bowled=4.0, date="2024-01-18"))
players_list.append(bumrah)
# Initialize analyzer
analyzer = MatchAnalyzer(players_list)
# Test filtering
print("=== ACTIVE PLAYERS (min 3 matches) ===")
active = analyzer.filter_active_players(min_matches=3)
for p in active:
print(f" {p.name}: {p.matches_played()} matches")
# Test ranking
print("\n=== RANKING BY BATTING AVERAGE ===")
batters = analyzer.filter_by_role("Batter")
ranked = analyzer.rank_by_metric(batters, "batting_average")
for player, score in ranked:
print(f" {player.name}: {score:.2f}")
# Test form analysis
print("\n=== FORM ANALYSIS ===")
for player in players_list:
if player.role == "Batter":
form = analyzer.calculate_recent_form(player, last_n_innings=3)
trend = analyzer.calculate_form_trend(player)
percentile = analyzer.calculate_percentile_rank(player, "batting_average")
print(f" {player.name}: Recent Form={form:.1f}, Trend={trend}, Percentile={percentile:.1f}%")
# Test report generation
print("\n=== PERFORMANCE REPORT (Rohit Sharma) ===")
report = analyzer.generate_performance_report(rohit)
for key, value in report.items():
print(f" {key}: {value}")Step 3 — Integration & Enhancement
Step 3 brings all components together into a unified pipeline that reads cricket data from files, processes it through the analysis engine, and outputs predictions and reports. You will implement data loading from CSV files, orchestrate the complete workflow using functional composition, and apply caching to improve performance. Visualization functions are also added to present insights in a human-readable format.
This step illustrates how production machine learning systems integrate multiple components in sequence: data ingestion, transformation, analysis, and output. It also introduces error handling and logging, both of which are critical in real-world systems where data quality issues are inevitable and detailed records are necessary for effective debugging.
Analogy🏏Cricket
🏏 Think of it like cricket: Integration is like how a cricket broadcasting company produces a live match commentary. Before the match, they have individual components ready: camera operators (data input), graphics team (visualization), statisticians (analysis), and commentators (output/insights). During the match, the director orchestrates all these—feeding live ball data to statisticians, who calculate updated averages and pass them to graphics, which displays them on screen, which commentators narrate to viewers. The whole system fails if any component breaks: missing data from cameras, incorrect statistics calculation, or graphics delay. Your main pipeline does this orchestration: it loads player data (camera feed), runs it through MatchAnalyzer (statistics calculation), caches results (storage), and generates reports (graphics/commentary). Building this integration teaches you how real ML systems work—not as isolated algorithms, but as coordinated pipelines where each component depends on correct output from the previous stage.
python
# main_pipeline.py
# Integration: Complete workflow pipeline with data I/O and reporting
import csv
import json
from typing import List, Dict, Tuple
from datetime import datetime
from player_module import CricketPlayer, Innings
from match_analyzer import MatchAnalyzer
class CricketMLPipeline:
"""
Complete ML pipeline for cricket analysis.
Orchestrates data loading, analysis, caching, and output generation.
"""
def __init__(self, cache_results: bool = True):
self.players: List[CricketPlayer] = []
self.analyzer: MatchAnalyzer = None
self.cache_results = cache_results
self.cached_results: Dict = {}
def load_players_from_csv(self, csv_file: str) -> None:
"""
Load player base information from CSV file.
Demonstrates file I/O and data parsing—essential ML skill.
Expected CSV format: name,country,role,jersey_number
"""
try:
with open(csv_file, 'r', encoding='utf-8') as f:
reader = csv.DictReader(f)
for row in reader:
player = CricketPlayer(
name=row['name'].strip(),
country=row['country'].strip(),
role=row['role'].strip(),
jersey_number=int(row['jersey_number'])
)
self.players.append(player)
print(f"Loaded {len(self.players)} players from {csv_file}")
except FileNotFoundError:
print(f"Error: File '{csv_file}' not found. Using sample data.")
self._load_sample_players()
except Exception as e:
print(f"Error loading CSV: {e}. Using sample data.")
self._load_sample_players()
def _load_sample_players(self) -> None:
"""
Load hardcoded sample data for testing and demonstration.
"""
self.players = []
# Create sample players
rohit = CricketPlayer("Rohit Sharma", "India", "Batter", 45)
virat = CricketPlayer("Virat Kohli", "India", "Batter", 18)
bumrah = CricketPlayer("Jasprit Bumrah", "India", "Bowler", 93)
bairstow = CricketPlayer("Jonny Bairstow", "England", "Batter", 25)
wood = CricketPlayer("Mark Wood", "England", "Bowler", 33)
# Add innings for Rohit (improving form)
rohit.add_innings(Innings("M001", "Rohit Sharma", 45, 38, fours=5, sixes=1, date="2024-01-10"))
rohit.add_innings(Innings("M002", "Rohit Sharma", 67, 52, fours=8, sixes=1, date="2024-01-12"))
rohit.add_innings(Innings("M003", "Rohit Sharma", 120, 95, fours=15, sixes=2, date="2024-01-15"))
rohit.add_innings(Innings("M004", "Rohit Sharma", 89, 71, fours=11, sixes=1, date="2024-01-18"))
rohit.add_innings(Innings("M005", "Rohit Sharma", 105, 84, fours=13, sixes=2, date="2024-01-20"))
# Add innings for Virat (declining form)
virat.add_innings(Innings("M001", "Virat Kohli", 95, 78, fours=11, sixes=1, date="2024-01-10"))
virat.add_innings(Innings("M002", "Virat Kohli", 68, 55, fours=8, sixes=0, date="2024-01-12"))
virat.add_innings(Innings("M003", "Virat Kohli", 42, 38, fours=4, sixes=0, date="2024-01-15"))
virat.add_innings(Innings("M004", "Virat Kohli", 28, 32, fours=2, sixes=0, date="2024-01-18"))
virat.add_innings(Innings("M005", "Virat Kohli", 15, 18, fours=1, sixes=0, date="2024-01-20"))
# Add innings for Bumrah
bumrah.add_innings(Innings("M001", "Jasprit Bumrah", 0, 0, wickets_taken=2, runs_conceded=28, overs_bowled=4.0, date="2024-01-10"))
bumrah.add_innings(Innings("M002", "Jasprit Bumrah", 0, 0, wickets_taken=3, runs_conceded=32, overs_bowled=4.0, date="2024-01-12"))
bumrah.add_innings(Innings("M003", "Jasprit Bumrah", 0, 0, wickets_taken=1, runs_conceded=45, overs_bowled=4.0, date="2024-01-15"))
bumrah.add_innings(Innings("M004", "Jasprit Bumrah", 0, 0, wickets_taken=2, runs_conceded=38, overs_bowled=4.0, date="2024-01-18"))
bumrah.add_innings(Innings("M005", "Jasprit Bumrah", 0, 0, wickets_taken=3, runs_conceded=29, overs_bowled=4.0, date="2024-01-20"))
# Add innings for Bairstow
bairstow.add_innings(Innings("M001", "Jonny Bairstow", 56, 38, fours=7, sixes=1, date="2024-01-10"))
bairstow.add_innings(Innings("M002", "Jonny Bairstow", 73, 45, fours=9, sixes=2, date="2024-01-12"))
bairstow.add_innings(Innings("M003", "Jonny Bairstow", 42, 35, fours=5, sixes=0, date="2024-01-15"))
# Add innings for Wood
wood.add_innings(Innings("M001", "Mark Wood", 0, 0, wickets_taken=1, runs_conceded=35, overs_bowled=4.0, date="2024-01-10"))
wood.add_innings(Innings("M002", "Mark Wood", 0, 0, wickets_taken=2, runs_conceded=38, overs_bowled=4.0, date="2024-01-12"))
self.players = [rohit, virat, bumrah, bairstow, wood]
print(f"Loaded {len(self.players)} sample players")
def initialize_analyzer(self) -> None:
"""
Initialize the analysis engine with loaded players.
"""
self.analyzer = MatchAnalyzer(self.players)
def get_top_performers(self, role: str = None, metric: str = "batting_average", top_n: int = 5) -> List[Tuple[CricketPlayer, float]]:
"""
Get top performers by specified metric.
Implements caching to avoid recalculating same query.
"""
cache_key = f"{role}_{metric}_{top_n}"
if cache_key in self.cached_results and self.cache_results:
return self.cached_results[cache_key]
if not self.analyzer:
self.initialize_analyzer()
# Filter by role if specified
if role:
players_to_rank = self.analyzer.filter_by_role(role)
else:
players_to_rank = self.analyzer.filter_active_players(min_matches=2)
# Get ranked results and take top N
ranked = self.analyzer.rank_by_metric(players_to_rank, metric)
results = ranked[:top_n]
# Cache result if caching enabled
if self.cache_results:
self.cached_results[cache_key] = results
return results
def generate_insights_report(self) -> Dict:
"""
Generate comprehensive insights report for all players.
Demonstrates multi-level aggregation and summary generation.
"""
if not self.analyzer:
self.initialize_analyzer()
# Get all reports
all_reports = self.analyzer.generate_team_report(self.players)
# Organize by role
batters = [r for r in all_reports if r['role'] == "Batter"]
bowlers = [r for r in all_reports if r['role'] == "Bowler"]
# Calculate summaries
report = {
"generated_at": datetime.now().isoformat(),
"total_players": len(self.players),
"total_batters": len(batters),
"total_bowlers": len(bowlers),
"top_batters": self.get_top_performers(role="Batter", metric="batting_average", top_n=3),
"top_consistency": self.get_top_performers(metric="consistency", top_n=3),
"form_trends": {},
"all_player_reports": all_reports
}
# Analyze form trends
form_categories = {"IMPROVING": [], "DECLINING": [], "STABLE": [], "INSUFFICIENT_DATA": []}
for player in self.players:
trend = self.analyzer.calculate_form_trend(player)
if player.role == "Batter":
form_categories[trend].append(player.name)
report["form_trends"] = form_categories
return report
def export_report_to_json(self, report: Dict, output_file: str = "outputs/cricket_analysis_report.json") -> None:
"""
Export analysis report to JSON file.
"""
# Convert player objects to dictionaries for JSON serialization
export_data = {
"generated_at": report["generated_at"],
"total_players": report["total_players"],
"total_batters": report["total_batters"],
"total_bowlers": report["total_bowlers"],
"top_batters": [(p.name, score) for p, score in report["top_batters"]],
"top_consistency": [(p.name, score) for p, score in report["top_consistency"]],
"form_trends": report["form_trends"],
"player_reports": report["all_player_reports"]
}
try:
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(export_data, f, indent=2, ensure_ascii=False)
print(f"Report exported to {output_file}")
except Exception as e:
print(f"Error exporting report: {e}")
def print_report_summary(self, report: Dict) -> None:
"""
Print human-readable summary of analysis report.
"""
print("\n" + "="*70)
print("CRICKET ML ANALYSIS REPORT".center(70))
print("="*70)
print(f"Generated: {report['generated_at']}")
print(f"Total Players Analyzed: {report['total_players']}")
print(f" - Batters: {report['total_batters']}")
print(f" - Bowlers: {report['total_bowlers']}")
print(f"\n{'TOP BATTERS (BY AVERAGE)':^70}")
print("-" * 70)
for i, (player, score) in enumerate(report['top_batters'], 1):
print(f"{i}. {player.name:25} ({player.country:10}) Avg: {score:6.2f}")
print(f"\n{'TOP CONSISTENCY PERFORMERS':^70}")
print("-" * 70)
for i, (player, score) in enumerate(report['top_consistency'], 1):
print(f"{i}. {player.name:25} ({player.country:10}) Score: {score:6.3f}")
print(f"\n{'FORM ANALYSIS':^70}")
print("-" * 70)
trends = report['form_trends']
print(f"Improving Players: {', '.join(trends['IMPROVING']) or 'None'}")
print(f"Declining Players: {', '.join(trends['DECLINING']) or 'None'}")
print(f"Stable Players: {', '.join(trends['STABLE']) or 'None'}")
print("\n" + "="*70)
# Main execution
if __name__ == "__main__":
# Initialize pipeline
pipeline = CricketMLPipeline(cache_results=True)
# Load data (will use sample data if CSV not found)
pipeline.load_players_from_csv("data/cricket_players.csv")
# Initialize analyzer
pipeline.initialize_analyzer()
# Generate comprehensive report
report = pipeline.generate_insights_report()
# Display summary
pipeline.print_report_summary(report)
# Export to JSON
pipeline.export_report_to_json(report)
print("\nPipeline execution completed successfully!")Step 4 — Testing & Verification
Testing and verification ensure your machine learning pipeline produces reliable results and handles edge cases gracefully. You will run the complete pipeline with sample cricket data, verify outputs against expected results, test error handling with invalid inputs, and confirm that the system correctly identifies player trends and rankings.
Analogy🏏Cricket
🏏 Think of it like cricket: before naming the final side, a team plays a full trial match to be sure the whole plan holds up — the batting order runs between the wickets, the bowling changes fire, and the scorers confirm the totals add up correctly from start to finish. That trial is your testing and verification step. Just as a trial match checks every part works together under real conditions in cricket, you run the complete pipeline on sample cricket data and verify the outputs against expected results. And just as a captain deliberately tests how the side copes when a wicket falls early or the pitch misbehaves, you feed invalid inputs to confirm the error handling responds gracefully rather than collapsing. Checking that the system correctly identifies player trends and rankings is like confirming the scoreboard truly reflects the play. The payoff is a pipeline proven reliable end to end, trusted to hold together before it faces the real match.
This step reinforces a key principle of production machine learning: rigorous validation is non-negotiable. Models that perform well on test data but fail when exposed to real-world inputs can cause significant problems in business applications, making thorough testing an essential part of any ML workflow.
bash
#!/bin/bash
# Test and verify the Cricket ML Analysis pipeline
echo "================================================"
echo "Cricket ML Analysis Pipeline - Test Suite"
echo "================================================"
# Navigate to project directory
cd cricket_ml_analysis
# Test 1: Check Python version and dependencies
echo -e "\n[TEST 1] Checking Python environment..."
python --version
pip list | grep -E "pandas|numpy|python"
# Test 2: Run the complete pipeline
echo -e "\n[TEST 2] Running main pipeline..."
python main_pipeline.py
# Test 3: Verify output file was created
echo -e "\n[TEST 3] Verifying JSON output..."
if [ -f "outputs/cricket_analysis_report.json" ]; then
echo "✓ JSON report generated successfully"
echo "Report preview (first 50 lines):"
head -50 outputs/cricket_analysis_report.json
else
echo "✗ JSON report not found"
fi
# Test 4: Run unit tests
echo -e "\n[TEST 4] Running unit tests..."
python -m pytest test_pipeline.py -v 2>/dev/null || {
echo "Running manual test suite..."
python test_pipeline.py
}
# Test 5: Verify data integrity
echo -e "\n[TEST 5] Verifying data structures..."
python -c "
from player_module import CricketPlayer, Innings
from match_analyzer import MatchAnalyzer
from main_pipeline import CricketMLPipeline
# Test basic player creation
test_player = CricketPlayer('Test Player', 'Test Country', 'Batter', 99)
test_innings = Innings('M999', 'Test Player', 50, 40, fours=5, sixes=1)
test_player.add_innings(test_innings)
assert test_player.batting_average() == 50.0, 'Batting average calculation failed'
assert test_player.career_strike_rate() == 125.0, 'Strike rate calculation failed'
print('✓ Data structure integrity verified')
# Test analyzer
pipeline = CricketMLPipeline()
pipeline._load_sample_players()
pipeline.initialize_analyzer()
active = pipeline.analyzer.filter_active_players(min_matches=3)
assert len(active) > 0, 'Filter returned no results'
print(f'✓ Analyzer filters working ({len(active)} active players found)')
# Test ranking
ranked = pipeline.analyzer.rank_by_metric(active, 'batting_average')
assert len(ranked) > 0, 'Ranking failed'
print(f'✓ Ranking working ({len(ranked)} players ranked)')
print('\n✓ All data verification tests passed')
"
# Test 6: Performance benchmark
echo -e "\n[TEST 6] Performance benchmark..."
python -c "
import time
from main_pipeline import CricketMLPipeline
start = time.time()
pipeline = CricketMLPipeline(cache_results=True)
pipeline._load_sample_players()
pipeline.initialize_analyzer()
# Run analysis
report = pipeline.generate_insights_report()
# Run again to test caching
report2 = pipeline.generate_insights_report()
end = time.time()
print(f'Pipeline execution time: {(end-start)*1000:.2f}ms')
print(f'Players processed: {len(pipeline.players)}')
print(f'Cache hit on second run: Success')
"
# Test 7: Expected output verification
echo -e "\n[TEST 7] Verifying expected analysis outputs..."
python -c "
from main_pipeline import CricketMLPipeline
pipeline = CricketMLPipeline()
pipeline._load_sample_players()
pipeline.initialize_analyzer()
# Check that we have expected players
names = [p.name for p in pipeline.players]
expected = ['Rohit Sharma', 'Virat Kohli', 'Jasprit Bumrah']
for name in expected:
assert name in names, f'Expected player {name} not found'
print(f'✓ Found {name}')
# Verify Rohit has improving form
rohit = [p for p in pipeline.players if p.name == 'Rohit Sharma'][0]
trend = pipeline.analyzer.calculate_form_trend(rohit)
print(f'✓ Rohit form trend: {trend}')
# Verify Virat has declining form
virat = [p for p in pipeline.players if p.name == 'Virat Kohli'][0]
trend = pipeline.analyzer.calculate_form_trend(virat)
print(f'✓ Virat form trend: {trend}')
print('\n✓ All expected analysis outputs verified')
"
echo -e "\n================================================"
echo "Test Suite Completed"
echo "================================================"
echo -e "\nExpected behavior verified:"
echo " ✓ Python environment configured correctly"
echo " ✓ Data structures created and calculated metrics"
echo " ✓ Filtering, ranking, and form analysis working"
echo " ✓ JSON report generated and formatted"
echo " ✓ Performance benchmarks within expected range"
echo " ✓ Form trends correctly identified"
echo -e "\nPipeline is ready for production use."
Warning: The most common error is attempting to divide by zero when calculating metrics like strike rate or economy rate from innings with zero balls faced or zero overs bowled. Always check if denominators are zero before division, and return sensible defaults (0.0 or None) when division is impossible. In the code, we've implemented checks like `if self.balls_faced == 0: return 0.0` to handle this gracefully. Also, when loading CSV files that may not exist, always implement try-except blocks—missing data files will crash your pipeline in production unless you have fallback mechanisms like loading sample data.
Extension Challenge: Enhance the pipeline to predict whether a player will score above their career average in the next match using simple statistical methods. Calculate the probability based on their recent form (last 3 innings average), consistency score, and overall trend. Implement a simple prediction function that returns 'LIKELY_TO_EXCEED' or 'LIKELY_TO_UNDERPERFORM'. This teaches you how real ML systems use historical patterns to make future predictions—the core idea behind machine learning.
- Object-oriented design with CricketPlayer and Innings classes creates foundation for scalable ML systems and ensures data consistency across operations
- Feature engineering through derived metrics (consistency_score, career_strike_rate, percentile_rank) transforms raw statistics into meaningful ML features
- Filtering and ranking operations demonstrate how domain knowledge is encoded into code to extract insights from complex datasets
- Pipeline architecture separates concerns (data loading, analysis, output) making code maintainable, testable, and production-ready for real deployments
- Caching optimizations reduce redundant calculations and improve performance—essential when processing large datasets in production ML systems
- Form trend analysis shows how ML can identify temporal patterns in data, distinguishing temporary variations from systematic changes in player performance