ImpactMeter Technical Design & Methodology

This document describes the current ImpactMeter scoring logic implemented in this repository.

Definition of Impact

Impact represents the overall contribution of a player to the match outcome, considering not only raw performance but also match context and pressure.

In cricket, traditional statistics such as runs scored or wickets taken do not always capture how important a performance was within the match situation. ImpactMeter addresses this by combining performance metrics with contextual factors.

Conceptual Definition

Impact = Performance x Match Context x Game Situation

Performance
Direct statistical contribution such as runs scored, strike rate, wickets taken, or economy rate.

Match Context
The phase of the match (powerplay, middle overs, death overs), team situation, and opposition conditions.

Game Situation / Pressure
The difficulty of the moment in the game, including required run rate, wickets lost, and remaining overs.

Impact Score

The final Impact Score is normalized to a 0-100 scale, where:

The score is calculated on a rolling window of the last 10 innings, with higher weight given to recent performances to reflect current player form.

One-Line Definition

Impact is a context-aware measure of how much a player's performance influences the outcome of a match.

1. Problem

Traditional cricket metrics (average, strike rate, wickets) often miss the full match story because they do not directly encode context and pressure.

ImpactMeter addresses this by combining performance with match situation.

Core goal:

Impact = Performance x Match Context x Game Situation

2. Data Pipeline

Raw IPL JSON
      ↓
Ball-by-ball dataset
      ↓
Feature Engineering
      ↓
Rule-Based Impact Calculation
      ↓
Rule-Based Impact Score (baseline)
  ↓
Random Forest ML Model
  ↓
ML-Assisted Impact Score (0-100)
      ↓
Rolling last 10 innings

ImpactMeter primarily uses a rule-based scoring system for interpretability, with an additional machine learning layer to learn deeper patterns from historical match data.

2.1 System Architecture

Data Layer
IPL ball-by-ball dataset

Feature Engineering Layer
Context + pressure features

Impact Modeling Layer
Rule-based scoring engine
Random Forest ML predictor

Analytics Layer
Player impact scoring
Feature importance extraction

Visualization Layer
Interactive dashboard
Impact gauge, role-based stats, trend charts

3. Impact Score Calculation

Impact score is computed using transparent weighted scoring logic.

Impact Score =
0.4 x Performance Score
+ 0.35 x Context Score
+ 0.25 x Pressure Score

Then normalize to a common scale:

Impact Score is normalized to a 0-100 scale using min-max scaling.

For hackathon evaluation, the final score is centered so 50 represents a neutral baseline, computed on a rolling last 10 innings window with recency weighting, and updated after each completed match (batch update, not real-time).

Where:

Performance Score

Measures direct cricket contribution.

Example inputs:

• Runs Scored
• Strike Rate
• Boundaries
• Wickets Taken
• Economy Rate

Context Score

Captures match situation.

Example inputs:

• Match phase (powerplay / middle / death)
• Opposition strength
• Team score context

Pressure Score

Reflects difficulty of the situation.

Example conceptual formula:

Pressure = Required Run Rate x Wickets Lost Factor x Overs Remaining Factor

4. Model Explainability

A rule-based baseline was chosen to maintain transparency and interpretability of the impact score.

Each component of the score can be directly traced to cricket performance metrics, making the system easy to understand for analysts and non-technical users.

This level of explainability is useful for both technical reviewers and cricket analysts.

5. Rolling Impact

Final player form signal uses recent-match weighting.

Final Impact = Weighted average of last 10 matches

Recent matches receive higher weight.

Example weights:

• Match10 -> weight 1.0
• Match9 -> weight 0.9
• Match8 -> weight 0.8

This helps ImpactMeter capture current form, not just long-term average.

6. Role-Aware Evaluation

ImpactMeter evaluates players differently based on role.

Batters are evaluated using batting metrics such as runs, strike rate, and boundaries.

Bowlers are evaluated using bowling metrics such as wickets, economy rate, and dot ball percentage.

All-rounders are evaluated using a balanced combination of batting and bowling metrics.

This prevents bowlers from being incorrectly evaluated using batting-only statistics.

This directly addresses role-mismatch issues in player evaluation.

7. System Extensions

ImpactMeter extends its transparent rule-based scoring system with an ML-assisted layer to compute player impact using performance, match context, and pressure indicators.

This hybrid approach combines:

• explainability from rule-based scoring
• pattern learning from machine learning models

8. ML-Assisted Impact Prediction Layer

ImpactMeter keeps the current rule-based system as the baseline and adds an ML-assisted layer.

Ball-by-ball data
      ↓
Feature Engineering
      ↓
Rule-Based Impact Score (baseline)
      ↓
Random Forest Model
      ↓
ML Impact Score

The ML layer does not replace the rule-based system but augments it by validating feature importance and learning non-linear relationships between context, pressure, and player performance.

Rule-based scoring provides interpretability, while ML learns hidden non-linear patterns from context and performance data.

Demo line:

"The ML score acts as a data-driven validation layer for the rule-based cricket knowledge model."

The rule-based score remains the primary impact metric, while the ML layer provides additional analytical insight and helps validate the relative importance of cricket performance features.

9. ML-Based Implementation Details

The current ML-assisted module is implemented with Random Forest regression using engineered match features.

Target Variable

Proxy target used for supervised learning:

impact_target = (runs_scored * 0.6) + (strike_rate * 0.3) + (wickets_taken * 30) - (economy_rate * 1.5) + (dot_ball_percentage * 0.2)

Model Features

• runs_scored
• strike_rate
• wickets_taken
• economy_rate
• dot_ball_percentage

Normalization

Model predictions use fixed scaling to 0-100 via clipping (np.clip(prediction, 0, 100)) to keep ML scores stable across dataset changes without dataset min-max normalization.

A post-prediction calibration step aligns ML scores with rule-based scores by shrinking extreme deltas, so ML stays a data-driven validation layer instead of overpowering the baseline.

Saved Outputs

• models/ml_impact_scores.csv (player-match ML scores)
• models/ml_feature_importance.csv (feature importance percentages)

Model Explainability

Feature importance is used to show what the model relies on most, so the ML layer remains interpretable during demos and reviews.

10. Practical Applications

ImpactMeter can support several real-world cricket analytics tasks:

Player Form Tracking
Identify players currently performing well using rolling impact scores.

Auction & Scouting Analytics
Compare players using context-aware impact metrics instead of raw averages.

Match Strategy Analysis
Evaluate which players perform better under high-pressure situations.

Role-Based Player Evaluation
Assess batters, bowlers, and all-rounders using role-specific metrics.