IPL WIN PROBABILITY PREDICTION

A Major Project Report

Submitted in partial fulfillment of the requirements for the award of the degree of
Bachelor of Engineering
in
Computer Science and Engineering

By

G.YASHASWI 2456-21-733-148
P.LIKITHA 2456-21-733-178
P.MEGHANA 2456-21-733-179

Under the guidance of

Ms.B.Aruna

Assistant Professor

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

Gokaraju Lailavathi Womens Engineering College
Accredited by NBA & NAAC
(Affiliated to Osmania University, Approved by AICTE)
Nizampet, Hyderabad-500090
(2024-2025)

I
 Department of Computer Science and Engineering
Gokaraju Lailavathi Womens Engineering College
Accredited by NBA & NAAC
(Affiliated to Osmania University, Approved by AICTE)
Nizampet, Hyderabad-500090 (2024-
2025)

CERTIFICATE
This is to Certify that A Mini Project report entitled “IPL Win
Probability Prediction” is being submitted by G.Yashaswi (2456-21-
733-148), P.Likitha(2456-21-733-178),P.Meghana(2456-21-733-179) in
partial fulfillment of the requirement of the award for the degree of
Bachelor of Engineering in “Computer Science and Engineering” O.U.,
Hyderabad during the year 2024-2025 is a record of bonafide work carried
out by them under my guidance. The results presented in this project have
been verified and are found to be satisfactory.

Project Guide H.O.D

Ms.B.Aruna Dr. Padmalaya Nayak

Assistant Professor Professor & Head,

Dept. of CSE Dept. of CSE

External Examiner(s)

II
 Department of Computer Science and Engineering
Gokaraju Lailavathi Womens Engineering College
Accredited by NBA & NAAC
(Affiliated to Osmania University, Approved by AICTE)
Nizampet, Hyderabad-500090
(2023-2024)

DECLARATION

We, G.Yashaswi bearing Ht.No. 2456-21-733-148, P.Likitha bearing Ht.No. 2456- 21-
733-178 and P.Meghana bearing Ht.No. 2456-21-733-179 hereby certify that the major
project entitled “IPL Win Probability Prediction” is submitted in the partial
fulfilment of the required for the award of the degree of Bachelor of Engineering in
Computer Science and Engineering.
This is a record work carried out by us under the guidance of Ms.B.Aruna, Gokaraju
Lailavathi Womens Engineering College, Nizampet. The results embodied in this
report have not been reproduced/copied from any source. The results embodied in this
report have not been submitted to any other university or institute for the award of any
other degree or diploma.

G.Yashaswi 2456-21-733-148
P.Likitha 2456-21-733-178
P.Meghana 2456-21-733-179

III
 ACKNOWLEDGEMENT

It is our privilege and pleasure to express my profound sense of respect, gratitude and indebtedness to
our guide Ms.B.Aruna , Department of Computer Science and Engineering, Gokaraju Lailavathi
Womens Engineering College, for her inspiration, guidance, cogent discussion, constructive criticisms
and encouragement throughout this dissertation work.

We express our sincere thanks to Project Coordinator Ms.K.S Niraja, Assistant Professor, Department
of Computer Science and Engineering, Gokaraju Lailavathi Womens Engineering College, for her
valuable suggestions and constant helping in completing the work.

We express our sincere thanks to Dr. A. Sai Hanuman, Principal, Gokaraju Lailavathi Womens
Engineering College, Nizampet, Hyderabad, for his encouragement and constant help.

We extend our sincere thanks to all the teaching and non-teaching staff of Computer Science and
Engineering Department for their support and encouragement.

Last but not least, we wish to acknowledge my friends and family members for giving moral strength
moral strength and helping us to complete this dissertation.

IV
 ABSTRACT

The Indian Premier League (IPL) is one of the most-viewed cricket leagues globally where the destiny of a match
can reverse in a matter of a few deliveries. The prediction of a team's winning chance during an in-progress IPL
match needs precise analysis of many dynamic variables including the score so far, wickets left, and performance
over by over.
The project seeks to create a real-time, data-driven predictive model to predict the win likelihood of teams in the
course of an IPL match. It utilizes past IPL match data and machine learning algorithms to offer accurate,
situational forecasts that are dynamic with respect to match development.

Key Features:

Predictive Modeling:
Deployment of supervised machine learning algorithms (e.g., Logistic Regression, Random Forest, or Gradient
Boosting) trained on historical IPL match data to calculate real-time win probabilities.

Real-Time Prediction Engine:

The model will recompute predictions ball-by-ball or over-by-over, responding to shifting match situations and
providing spectators and analysts with a greater understanding of match dynamics.

Interactive User Interface:

An intuitive, easy-to-use web interface (constructed using frameworks such as Streamlit or Flask) enabling users to:
Input match conditions of current score, overs remaining, wickets, etc.
.

V
 CONTENTS

Chapter-1 INTRODUCTION........................................................................................1
1.1 MOTIVATION......................................................................................................................................1

1.2 PROBLEM STATEMENT....................................................................................................................1

1.3 PROJECT OBJECTIVE.........................................................................................................................1

Chapter-2 LITERATURE SURVEY.............................................................................2

2.1 EXISTING SYSTEM……………………………………………………………………….3

2.2 LIMITATIONS OF EXISTING SYSTEM.............................................................................4

Chapter-3 SOFTWARE REQUIREMENT SPECIFICATION...................................5

3.1 SOFTWARE REQUIREMENTS……………………………………………………………5

3.2 HARDWARE REQUIREMENTS...........................................................................................5

3.3 FUNCTIONAL REQUIREMENTS………………………………………………………..5

3.4 NON-FUNCTIONAL REQUIREMENTS…………………………………………………..6

Chapter-4 SYSTEM DESIGN........................................................................................7

4.1 SYSTEM DESIGN.................................................................................................................7

4.2 PROPOSED METHODOLOGY............................................................................................8

4.3 UML DESIGN………………………………………………………………………………..9

4.3.1 CLASS DIAGRAM………………………………………………………………………11

4.3.2 USECASE DIAGRAM……………………………………………………………….....12

4.3.3 COMPONENT DIAGRAM……………………………………………………………..13

4.3.4 SEQUENCE DIAGRAM………………………………………………………………...14

4.3.5 ACTIVITY DIAGRAM...................................................................................................15

VI
 4.4 TECHNOLOGY DESCRIPTION.....................................................................................16

Chapter-5 IMPLEMENTATION...............................................................................17
5.1 IMPLEMENTATION.......................................................................................................17

5.2 MODULES.......................................................................................................................17

5.3 EXECUTABLE CODE....................................................................................................19

Chapter-6 TESTING…………………………………………………………………23

6.1 TESTING DEFINATION................................................................................................23

6.2 UNIT TESTING................................................................................................................23
6.3 INTEGRATION TESTING..............................................................................................24

Chapter-7 RESULTS.....................................................................................................25

Chapter-8 CONCLUSION.............................................................................................27

8.1 CONCLUSION.................................................................................................................27
8.2 FUTURE SCOPE...............................................................................................................27

REFERENCES….............................................................................................................27

PLAGIARISM CHECKER RESULT….......................................................................28

VI
 PAGE
SNO. LIST OF FIGURES NO.
8
4.2.1 Proposed Methodology

4.3.1 UML Hierarchy Diagrams 10

4.3.1.1 Class Diagram 11

4.3.2.1 Use Case Diagram 12

4.3.3.1 Component Diagram 13

4.3.4.1 Sequence Diagram 14

4.3.5.1 Activity Diagram 15

7.1 Results 25

VIII
 CHAPTER-1

INTRODUCTION

1.1 MOTIVATION
The Indian Premier League (IPL), cricket is a game full of excitement and surprise. In only a few balls,
momentum of a game can change drastically, providing excitement for supporters and a difficult challenge
for analysts. The demand for devices capable of delivering live insights has grown dramatically as live
match tracking, fantasy leagues, and real-time sports analytics have become more widely used. Traditional
scoreboards display runs, overs, and wickets, yet they do not provide a full picture of which side has a
greater probability of winning during the course of the game. Real-time win probability projections can give
insight into how viewers consume cricket, how networks broadcast it, and how commentators understand it.

1.2 PROBLEM STATEMENT

The Indian Premier League (IPL) is one of the most exciting and fiercely competitive T20 cricket
tournaments in the world. With every ball having the potential to change the course of the game, predicting
match outcomes in real-time can be both fascinating and valuable — not just for broadcasters and analysts,
but also for fans watching the action unfold. This project aims to build a machine learning-based system that
can predict the win probability of a team during a live IPL match. By using real-time match data — like the
number of overs bowled, runs scored, wickets lost, and the target set — the system will update its
predictions as the game progresses.

1.3 PROJECT OBJECTIVE

Utilizing machine learning, this project aims to develop a real-time win probability predictor for IPL
contests. To determine the likelihood of each team winning, the system gathers real-time match inputs
including target score, overs left, wickets in hand, and current score. Based on past IPL data, the model is
developed and combined into a user-friendly platform, enabling users to specify match circumstances and
get rapid predictions. This tool hopes to boost analyst support, improve fan involvement, and show in sports
the power of data analytics.

1
1
 CHAPTER-2
LITERATURE SURVEY
Using statistical models and machine learning methods, numerous research and practical applications have
investigated winning percentage forecast in cricket as well as other sports. These works lay a good groundwork for
the construction of predictive models grounded on match dynamics.

Applications

Broadcast and Media Intergration:

To visually depict win possibilities, improving storytelling and game coverage, can be incorporated into mobile
applications or live television graphics.

Live Match Analysis:

Offers real-time match progress insights to assist commentators and analysts in understanding turning points and
critical events according on data-driven projections.

Audience Interaction:
By letting viewers track their team's win probability throughout the game, it improves the viewing experience and
layers interactive and analytic match watching.

11
2.2Benefits
Decision Support in Real Time:
Offers quick insights on match momentum, therefore assisting users in grasping how particular events (like a
boundary or wicket) influence win prospects.

Improved Visitor Experience:

Adds a dynamic, data-driven layer to match viewing to make cricket more participatory and interesting for
supporters.

Data-Driven Narration:
Permits broadcasters and commentators to support their opinions with live win probabilities, hence making their
debates more insightful and impartial.

2.3 Challenges and Considerations

Data completeness and quality:
Particularly for earlier seasons, historical IPL information could have inaccurate or missing records. For exact
model training, the data must be clean, complete, and properly arranged.

Feature Selection and Engineering:

Finding the ideal combination of qualities—e.g., overs left, run rate, wickets—and greatly altering them calls for
domain knowledge of cricket and experimentation.

Dynamic character of T20 games:

T20 cricket is very erratic; unexpected changes (e.g., a single over with 20+ runs) can radically affect game results.
Model capturing of such volatility is difficult.

2.4 Recent Trends and Future Directions

Integration of Advanced Machine Learning Models
Adoption of machine learning methods, including Random Forests, Gradient Boosting, and Support Vector
Machines, has improved the correctness of win probability forecasts in cricket. These models provide more
accurate predictions by examining complicated patterns in past and real-time data.
Real-time data processing
Contemporary systems dynamically modify win probabilities by processing live match information, including ball-
by-ball updates. This real-time analysis gives fans and observers instant understanding of the current condition of
the game.

EXISTING SYSTEM
During live cricket broadcasts, this professional tool displays win chances. It forecasts results using historical data,
statistical modeling, and the present match state.
Kaggle Community Initiatives:
12
Several open-source IPL win prediction projects using machine learning algorithms such as Logistic Regression,
Decision Trees, and Random Forests abound. Probabilities are estimated in these projects using ball-by-ball or
over-by-over datasets.
LIMITATIONS OF EXISTING SYSTEM
Absence of Real-time Interaction:
Most systems, with the exception of commercial tools like CricViz, which are not publicly available—do not allow
users to enter live match data and receive on-demand real-time predictions.
Limited Public Availability:
CricViz and other sophisticated predictive technologies are closed for learning, personalizing, or public
consumption.
Fundamental Feature Use:
Many public models only give simple characteristics like total runs, overs, and wickets some thought. They
frequently disregard complex contextual information such as run rate trends, bowler strength, or pressure overs.

13
14
 CHAPTER-3

SOFTWARE REQUIREMENT SPECIFICATION

This chapter gives an overview of the software and hardware components required for our project.

3.1 SOFTWARE REQUIREMENTS:

Operating System – Windows 11
Programming Language - Python programming
Implementation Platform – Jupyter Notebook ,Google Colab,
Web Framework: Streamlit
Back-End: Python

3.2 HARDWARE REQUIREMENTS:

Intel(R) Core(TM) i3-1005G1 CPU @ 1.20GHz 1.19 GHz
Installed RAM 8.00 GB

3.3 FUNCTIONAL REQUIREMENTS

Data Preprocessing
Ingest IPL match and delivery datasets
Clean null values, extract features, encode team names

Model Training
Train models: Logistic Regression, Random Forest
Apply model stacking and Gradient Boosting

Accuracy Tracking
Evaluate model during training/testing
Record accuracy and other metrics

Win Prediction
Predict win probability using inputs: runs, overs, wickets

Web Dashboard (Streamlit)

User inputs: teams, rating, score target, overs, wickets
Display real-time win probability

Live Result Display

Show results visually and update without reloading

15
3.4 NON-FUNCTIONAL REQUIREMENTS

Efficiency

Real-time win probability projections must be generated by the system (within 1–2 seconds of user
input).To guarantee a seamless user experience under live match scenarios, the model has to load
and react effectively.

Usefulness

The user interface—Streamlit dashboard—must be simple and intuitive, needing no technical

expertise to use.Users have to be able to quickly enter match settings and grasp the expected
outcome at a glance.

Dependability

For the same inputs, the system must generate constant predictions.It should gracefully manage
boundary circumstances (e.g., overs = 0 or wickets = 10) without collapsing.

Scalability

Minimally altered, the system should be scalable to accept data from other leagues (e.g., BBL, PSL)
or future IPL seasons.The ML pipeline should allow retraining with fresh data without totally
rebuilding the system.

16
 CHAPTER-4

SYSTEM DESIGN

4.1 System Design

In this phase, the system and software design documents are prepared as per the
requirements specified in the document. This helps define overall system architecture.
There are two kinds of design documents developed in this phase:

High-Level Design (HLD)

The frontend uses Streamlit, where users input parameters like score, overs, and wickets.On the
backend, Python processes this input, performs necessary data transformations, and sends it to
the machine learning model.
The model itself is an ensemble—it combines Logistic Regression, Random Forest, and XGBoost to
make predictions.For data, the system relies on preprocessed and cleaned match and delivery
datasets.

Low-Level Design(LLD)

Frontend (Web UI): The user interface collects key match parameters:
Batting team name
Target score
Current score
Overs completed
Wickets fallen

Backend: Core logic is handled by the predict_probability() function.

This function:
Receives user input values
Constructs a feature vector formatted for the model
Calls the trained model’s .predict_proba() method for probability output

17
18
4.2. PROPOSED METHODOLOGY

Figure-4.2.1 Proposed Methodology

19
 4.3 UML Design:

Unified Modeling Language (UML) is a general purpose modeling language. The main aim of
UML is to define a standard way to visualize the way a system has been designed.

UML is not a programming language; it is rather a visual language. We use UML diagrams to
portray the behavior and structure of a system, UML helps software engineers, businessmen and
system architects with modeling, design and analysis. The Object Management Group (OMG)
adopted Unified Modeling Language as a standard in 1997. It’s been managed by OMG ever since.
International Organization for Standardization (ISO) published UML as an approved standard in
2005. UML has been revised over the years and is reviewed periodically.

Do we really need UML?

● Complex applications need collaboration and planning from multiple teams and hence require a clear
and concise way to communicate amongst them.
● Businessmen do not understand code. So UML becomes essential to communicate with non
programmer’s essential requirements, functionalities and processes of the system.
● UML is linked with object oriented design and analysis. UML makes the use of elements and forms
associations between them to form diagrams. Diagrams in UML can be broadly classified as:

The Primary goals in the design of the UML are as follows:

● Provide users a ready-to-use, expressive visual modeling Language so that they can develop and
exchange meaningful models.
● Provide extendibilityand specialization mechanisms to extend the core concepts.
● Be independent of particular programming languages and development process.
● Provide a formal basis for understanding the modeling language.
● Encourage the growth of OO tools market.
● Support higher level development concepts such as collaborations, frameworks, patterns and components.
● Integrate best practices.

20
Types of UML Diagrams:

Structural Diagrams:

Capture static aspects or structure of a system. Structural Diagrams include: Component Diagrams,
Object Diagrams, Class Diagrams and Deployment Diagrams.

Behaviour Diagrams:

Capture dynamic aspects or behaviour of the system. Behaviour diagrams include: Use Case Diagrams,
State Diagrams, Activity Diagrams and Interaction Diagrams.

The image below shows the hierarchy of diagrams according to UML

Figure-4.3.1 UML Hierarchy diagrams

21
4.3.1 CLASS DIAGRAM:
In software engineering, a class diagram in the Unified Modeling Language (UML) is a type of
static structure diagram that describes the structure of a system by showing the system's classes,
their attributes, operations (or methods), and the relationships among the classes. It explains which
class contains information.

figure-4.3.1.1 Class Diagram

22
4.3.2 USE CASE DIAGRAM
A use case diagram in the Unified Modeling Language (UML) is a type of behavioral diagram
defined by and created from a Use-case analysis. Its purpose is to present a graphical overview of
the functionality provided by a system in terms of actors, their goals (represented as usecases), and
any ependencies between those use cases.

Figure-4.3.2.1 Use Case Diagram

23
4.3.3 COMPONENT DIAGRAM:

A component diagram, also known as a UML component diagram, describes the organization and wiring
of the physical components in a system. Component diagrams are often drawn to help model
implementation details and double-check that every aspect of the system's required functions is covered
by planned development.

Figure-4.3.3.1 Component Diagram

24
4.3.4 SEQUENCE DIAGRAM:
A sequence diagram in Unified Modeling Language (UML) is a kind of interaction diagram that
shows how processes operate with one another and in what order. It is a construct of a Message
Sequence Chart. Sequence diagrams are sometimes called event diagrams, event scenarios,
and timing diagrams.

Figure-4.3.4.1 Sequence Diagram

25
4.3.5 ACTIVITY DIAGRAM:
In UML, an activity diagram is used to display the sequence of activities. Activity diagrams
show the workflow from a start point to the finish point detailing the many decision paths the
exist in the progression of events contained in the activity.

Figure-4.3.5.1 Activity Diagram

26
4.4 TECHNOLOGY DESCRIPTION

Web Development:
Web development can be made simple and efficient using Python with the help of Streamlit, a powerful
framework designed for building web applications. Streamlit allows developers to create interactive and user-
friendly interfaces entirely in Python, without needing any front-end technologies. Everything from displaying
text and charts to handling user input is done using Python code. On the back end, Python manages the logic,
data processing, and any integration with databases or machine learning models. This makes Streamlit an
excellent tool for quickly developing and deploying data-driven applications, especially for users with a
Python background.Streamlit:

Streamlit:
Streamlit is an open-source Python framework that enables data scientists and developers to quickly build
and share interactive web applications with minimal coding. It allows users to transform data scripts into
functional,visually appealing web apps using simple Python commands, without needing expertise in web
development. Streamlit offers built-in support for creating dynamic interfaces with widgets like sliders,
buttons, and dropdowns, and seamlessly integrates with popular data visualization and machine learning
libraries. Its real-time interaction capabilities, along with easy deployment options, make it a popular
choice for building dashboards, model demos, and data exploration tools.

Python:

Python is a versatile, high-level programming language known for its simplicity and readability, making it
accessible to both beginners and experienced developers. With a clear and straightforward syntax, Python
supports multiple programming paradigms including procedural, object-oriented, and functional
programming. It has a vast ecosystem of libraries and frameworks, such as NumPy, Pandas,
TensorFlow,Streamlit and Django, which make it ideal for a wide range of applications like web
development, data analysis, artificial intelligence, automation, and scientific computing.Python’s active
community and extensive documentation contribute to its status as one of the most popular programming
languages globally.

27
 CHAPTER-5

5.1 IMPLEMENTATION
Environment Setup:
You need a Python setup to build and use the IPL Win Probability Prediction System. The project works on
Windows, macOS, or Linux computers with at least 4 GB of RAM. You'll use Python (version 3.8 or
higher) as the main coding language. Key tools include Jupyter Notebook to train your model and Streamlit
to create the web interface. The project relies on Python libraries like pandas, numpy, scikit-learn,
matplotlib seaborn, xgboost, and streamlit. You can install these with pip or from a requirements.txt file. Put
your datasets (matches.csv and deliveries.csv) in a data folder inside your project directory. The folder
layout keeps data, model files, and scripts separate to make updates easier. After you train and save your
model, type "streamlit run app.py" to start the app. This opens a user-friendly interface in your browser for
real-time predictions. This setup helps you develop, test, and launch your IPL win prediction system.

Server Creation :
An Ultra-simple local server is build using Streamlit(web framework in python) to serve the IPL Win
Probability Prediction application via Web browser. Streamlit is a way to create interactive web apps directly
from Python scripts with no front- or back-end knowledge. The server is started with a command and running
locally in this example on http://localhost:8501/.
We’ll assume you have already trained the model and saved it (usually as a. pkl f f file)and the Streamlit
app (app. py) generates the GUI to input the details of the match, viz. the current score, the number of overs
completed, the number of wickets fallen and the target. The script does the work of loading my trained model
in the background, taking any user input, and then serve the predicted win probability in real-time.

5.2 MODULES:

1. Data Collection and Integration:

We gather complete data from several cricket databases and APIs. This includes detailed match info for
each ball how players are doing, what the pitch is like, weather info, and who's on each team.
28
2. Data Preprocessing
Raw data often has errors, doesn't match up, and is missing some parts. We clean up the data by taking out
stuff we don't need filling in missing info, and making number data consistent. We also change category
data into numbers that machine learning programs can use.

3. Feature Engineering:
We make new data points to better show how the game works. For instance, we figure out how players have
done how fast they score, and how well partnerships work. These new data points give the model a deeper
understanding beyond just the raw numbers.Web Interface

4.Model Training and mounding:

Multiple machine literacy models( like Random Forest, Gradient Boosting, and Logistic Retrogression) are
trained on the reused data. Their prognostications are combined using a mounding approach, where a meta-
model learns from the base models’ labors, enhancing overall vaticination delicacy.

5.Web Interface:
We develop an interactive and responsive web interface using fabrics similar as Beaker or Django. druggies
can enter match parameters like brigades, venue, and current match state to get instant palm probability
updates. The interface also visualizes the vaticination results easily.

6.Deployment
The model and web app are stationed on pall platforms like AWS or Heroku. This setup ensures the system
can handle multiple druggies contemporaneously and remain available with minimum time-out. nonstop
monitoring and updates are done to maintain performance.

7.Monitoring and Updates

After deployment, the system’s prognostications are covered against real match issues to estimate delicacy.
The model is periodically retrained with new data to acclimatize to changing platoon forms and conditions,
icing sustained trustability.

29
 5.3 EXECUTABLE

main.py

# Importing Libraries
import numpy as np
import pandas as pd
# Loading datasets
match = pd.read_csv("matches.csv")
delivery = pd.read_csv("deliveries.csv")
match.head()
match.shape
delivery.head()
delivery.shape
### Grouping by match_id and inning
total_score_df = delivery.groupby(['match_id','inning']).sum()['total_runs'].reset_index()
total_score_df = total_score_df[total_score_df['inning'] == 1]
total_score_df
### Merging by match_id
match_df = match.merge(total_score_df[['match_id','total_runs']],left_on='id',right_on='match_id')
match_df
### Currently playing IPL Teams
teams = [
'Sunrisers Hyderabad',
'Mumbai Indians',
'Royal Challengers Bangalore',
'Kolkata Knight Riders',
'Kings XI Punjab',
'Chennai Super Kings',
'Rajasthan Royals',
'Delhi Capitals'
]
match_df['team1'] = match_df['team1'].str.replace('Delhi Daredevils','Delhi Capitals')
match_df['team2'] = match_df['team2'].str.replace('Delhi Daredevils','Delhi Capitals')

match_df['team1'] = match_df['team1'].str.replace('Deccan Chargers','Sunrisers Hyderabad')

match_df['team2'] = match_df['team2'].str.replace('Deccan Chargers','Sunrisers Hyderabad')
match_df = match_df[match_df['team1'].isin(teams)]
match_df = match_df[match_df['team2'].isin(teams)]
match_df.shape
### Selecting matches where DL was not applied
match_df = match_df[match_df['dl_applied'] == 0]
### Selecting required features and merge with delivery dataset
match_df = match_df[['match_id','city','winner','total_runs']]
delivery_df = match_df.merge(delivery,on='match_id')
### Selecting only 2nd innings
delivery_df = delivery_df[delivery_df['inning'] == 2]
30
delivery_df['current_score'] = delivery_df.groupby('match_id').cumsum()['total_runs_y']
delivery_df['runs_left'] = delivery_df['total_runs_x'] - delivery_df['current_score']
delivery_df['balls_left'] = 126 - (delivery_df['over']*6 + delivery_df['ball'])
delivery_df
### Finding the wickets remaining
delivery_df['player_dismissed'] = delivery_df['player_dismissed'].fillna("0")
delivery_df['player_dismissed'] = delivery_df['player_dismissed'].apply(lambda x:x if x == "0" else "1")
delivery_df['player_dismissed'] = delivery_df['player_dismissed'].astype('int')
wickets = delivery_df.groupby('match_id').cumsum()['player_dismissed'].values
delivery_df['wickets'] = 10 - wickets
delivery_df.head()
### Calculating Current runrate
# crr = runs/overs
delivery_df['crr'] = (delivery_df['current_score']*6)/(120 - delivery_df['balls_left'])
### Calculating Required Runrate
# rrr = required runs/overs remaining
delivery_df['rrr'] = (delivery_df['runs_left']*6)/delivery_df['balls_left']
def result(row):
return 1 if row['batting_team'] == row['winner'] else 0
delivery_df['result'] = delivery_df.apply(result,axis=1)
delivery_df.head()
final_df =
delivery_df[['batting_team','bowling_team','city','runs_left','balls_left','wickets','total_runs_x','crr','rrr','result']]
### Shuffling the dataset
final_df = final_df.sample(final_df.shape[0])
final_df.sample()
### Handling Missing Values
final_df.dropna(inplace=True)
### Selecting only non-null values
final_df = final_df[final_df['balls_left'] != 0]
### X and y matrix
X = final_df.iloc[:,:-1]
y = final_df.iloc[:,-1]
### Train and test datasets
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=1)
### Converting columns with string values
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

trf = ColumnTransformer([('trf',OneHotEncoder(sparse=False,drop='first'),['batting_team','bowling_team','city'])]
,remainder='passthrough')
### Importing Classification Models
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
pipe = Pipeline(steps=[
('step1',trf),
31
 ('step2',LogisticRegression(solver='liblinear'))
])
pipe.fit(X_train,y_train)
y_pred = pipe.predict(X_test)
### Evaluating the model
from sklearn.metrics import accuracy_score
accuracy_score(y_test,y_pred)
### Predicting for the whole match
def match_progression(x_df,match_id,pipe):
match = x_df[x_df['match_id'] == match_id]
match = match[(match['ball'] == 6)]
temp_df =
match[['batting_team','bowling_team','city','runs_left','balls_left','wickets','total_runs_x','crr','rrr']].dropna()
temp_df = temp_df[temp_df['balls_left'] != 0]
result = pipe.predict_proba(temp_df)
temp_df['lose'] = np.round(result.T[0]*100,1)
temp_df['win'] = np.round(result.T[1]*100,1)
temp_df['end_of_over'] = range(1,temp_df.shape[0]+1)

target = temp_df['total_runs_x'].values[0]
runs = list(temp_df['runs_left'].values)
new_runs = runs[:]
runs.insert(0,target)
temp_df['runs_after_over'] = np.array(runs)[:-1] - np.array(new_runs)
wickets = list(temp_df['wickets'].values)
new_wickets = wickets[:]
new_wickets.insert(0,10)
wickets.append(0)
w = np.array(wickets)
nw = np.array(new_wickets)
temp_df['wickets_in_over'] = (nw - w)[0:temp_df.shape[0]]

print("Target-",target)
temp_df = temp_df[['end_of_over','runs_after_over','wickets_in_over','lose','win']]
return temp_df,target
temp_df,target = match_progression(delivery_df,74,pipe)
temp_df
import matplotlib.pyplot as plt
plt.figure(figsize=(18,8))
plt.plot(temp_df['end_of_over'],temp_df['wickets_in_over'],color='yellow',linewidth=3)
plt.plot(temp_df['end_of_over'],temp_df['win'],color='#00a65a',linewidth=4)
plt.plot(temp_df['end_of_over'],temp_df['lose'],color='red',linewidth=4)
plt.bar(temp_df['end_of_over'],temp_df['runs_after_over'])
plt.title('Target-' + str(target))
teams
delivery_df['city'].unique()
import pickle
pickle.dump(pipe,open('pipe.pkl','wb'))
32
app.py

import streamlit as st
import pickle
import pandas as pd
import base64

# Function to set background image & apply styles

def set_bg(image_file):
with open(image_file, "rb") as f:
encoded_string = base64.b64encode(f.read()).decode()

bg_css = f"""
<style>
.stApp {{
background: url("data:image/png;base64,{encoded_string}") no-repeat center center fixed;
background-size: cover;
}}

/* Make labels white for better visibility */

label, h1, h2, h3 {{
color: white !important;
font-weight: bold;
font-size: 18px;
}}

/* Make dropdown & input text black/dark gray inside the field */
.stSelectbox div div, .stNumberInput div div {{
color: black !important; /* Change to dark gray if needed */
font-weight: bold;
}}

/* Styling the button */

.stButton > button {{
background-color: #ffcc00; /* IPL yellow */
color: black;
font-size: 18px;
font-weight: bold;
border-radius: 10px;
padding: 10px;
}}

/* Improve result visibility */

.result-text {{
font-size: 24px;
font-weight: bold;
33
 text-align: center;
}}
</style>
"""
st.markdown(bg_css, unsafe_allow_html=True)

# Apply Background Image

set_bg("img.png") # Ensure "image.png" is in the same directory

# Streamlit Title
st.markdown("<h1 style='text-align: center;'>🏏 IPL Win Predictor</h1>", unsafe_allow_html=True)

# Teams & Cities List

teams = [
"Royal Challengers Bengaluru", "Mumbai Indians", "Chennai Super Kings",
"Delhi Capitals", "Gujarat Titans", "Lucknow Super Giants",
"Sunrisers Hyderabad", "Rajasthan Royals", "Punjab Kings", "Kolkata Knight Riders"
]

cities = [
'Chandigarh', 'Delhi', 'Mumbai', 'Kolkata', 'Jaipur', 'Hyderabad',
'Chennai', 'Cape Town', 'Port Elizabeth', 'Durban', 'Centurion', 'East London',
'Johannesburg', 'Kimberley', 'Bloemfontein', 'Ahmedabad', 'Cuttack', 'Nagpur',
'Dharamsala', 'Kochi', 'Indore', 'Visakhapatnam', 'Pune', 'Raipur', 'Ranchi',
'Abu Dhabi', 'Rajkot', 'Kanpur', 'Bengaluru', 'Dubai', 'Sharjah',
'Navi Mumbai', 'Lucknow', 'Guwahati', 'Mohali'
]

# Load Model
pipe = pickle.load(open('pipe.pkl', 'rb'))

# Team Selection
col1, col2 = st.columns(2)
with col1:
batting_team = st.selectbox('🏏 *Select the Batting Team*', sorted(teams))
with col2:
bowling_team = st.selectbox('🎯 *Select the Bowling Team*', sorted(teams))

# City Selection
selected_city = st.selectbox('📍 *Select Host City*', sorted(cities))

# Target Input
target = st.number_input('🎯 *Enter the Target Score*')

# Score, Overs, and Wickets Input

col3, col4, col5 = st.columns(3)
with col3:
score = st.number_input('🏏 *Current Score*')
34
with col4:
overs = st.number_input('⏳ *Overs Completed*')
with col5:
wickets = st.number_input('❌ *Wickets Lost*')

# Prediction Button
if st.button('🔮 *Predict Probability*'):
# Feature Calculation
runs_left = target - score
balls_left = 120 - (overs * 6)
wickets_left = 10 - wickets
crr = score / overs if overs > 0 else 0
rrr = (runs_left * 6) / balls_left if balls_left > 0 else 0

# Create DataFrame for Prediction

input_df = pd.DataFrame({
'batting_team': [batting_team],
'bowling_team': [bowling_team],
'city': [selected_city],
'runs_left': [runs_left],
'balls_left': [balls_left],
'wickets_left': [wickets_left],
'target_to_chase': [target],
'crr': [crr],
'rrr': [rrr]
})

# Get Prediction
result = pipe.predict_proba(input_df)
loss = result[0][0]
win = result[0][1]

# Display Results in Bold and White

st.markdown(f"<h2 class='result-text' style='color: lime;'>{batting_team} - {round(win*100)}%</h2>",
unsafe_allow_html=True)
st.markdown(f"<h2 class='result-text' style='color: red;'>{bowling_team} - {round(loss*100)}%</h2>",
unsafe_allow_html=True)

35
 CHAPTER-6

TESTING

3.1 TESTING DEFINITION:

The purpose of testing is to discover errors. Testing is the process of trying to discover every
conceivable fault or weakness in a work product. It provides a way to check the functionality of
components, sub assemblies, assemblies and/or a finished product It is the process of exercising
software with the intent of ensuring that the Software system meets its requirements and user
expectations and does not fail in an unacceptable manner. There are various types of test. Each
test type addresses a specific testing requirement.

3.2 Unit Testing

Unit testing is usually conducted as part of a combined code and unit test phase of the software
lifecycle, although it is not uncommon for coding and unit testing to be conducted as two distinct
phases.

Test strategy and approach

Field testing will be performed manually and functional tests will be written in detail.

Test objectives

1. A field entries must work properly.

2. Pages must be activated from the identified link.

3. The entry screen, messages and responses must not be delayed.

Features to be tested

1. Verify that the entries are of the correct

2. No duplicates should be allowed.

36
3.3 Integration Testing
Software integration testing is the incremental integration testing of two or more integrated software
components on a single platform to produce failures caused by interface defects.

The task of the integration test is to check that components or software applications, e.g.
components in a software system or – one step up – software applications at the company level –
interact without error.

37
 CHAPTER- 7
RESULTS
● After running the program we can see the following results

38
39
 CHAPTER-8

8.1 CONCLUSION
The IPL Win Probability Prediction project successfully demonstrates the application of machine learning in
sports analytics, providing real-time insights into match outcomes. By using key match parameters such as
the batting team, target score, current score, overs completed, and wickets fallen, the system effectively
predicts the probability of a team's victory with high accuracy.The project integrates a user-friendly web
interface and a robust backend model, enabling users to easily input match conditions and receive immediate
probabilistic outcomes. This not only enhances fan engagement during live matches but also serves as a
valuable tool for commentators, analysts, and strategists.Overall, the project showcases the power of data-
driven decision-making in cricket and highlights the broader potential of AI and machine learning in
transforming how we understand and enjoy sports.

8.2 FUTURE SCOPE

The IPL Win Probability Prediction project holds significant potential for future enhancement and real-world
application. One key area of development is the inclusion of more detailed match features, such as player-
specific statistics (e.g., form, strike rate, economy rate), pitch conditions, and venue history, which could
greatly improve prediction accuracy. Integrating live match data from external APIs would enable real-time
updates, making the tool more dynamic and engaging during ongoing matches. Advanced machine learning
techniques, such as ensemble models or deep learning architectures like LSTMs, could be employed to capture
complex patterns in match progression.

REFERENCES

• Nikhil Dhonge, Shraddha Dhole , "IPL CRICKET SCORE AND WINNING PREDICTION USING
MACHINE LEARNING TECHNIQUES, International Research Journal of Modernization in Engineering
Technology and Science
40
• Mayank Agarwal, Prof. Dr. Archana Kumar, “IPL First Innings Score Prediction Using MachineLearning
Techniques,” Department of Computer Science & Engineering,ADGITM (Affiliated to GGSIPU),Shastri
Park, Delhi, India

41
PLAGIARISM CHECKER RESULT

42
43