scikit-lab-kit 0.1.0__tar.gz

scikit_lab_kit-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: scikit-lab-kit
+Version: 0.1.0
+Summary: Numbered DAML (scikit-learn) practicals: steps, code and short explanation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# scikit-lab-kit
+
+Numbered viewer for the DAML practicals (steps, code and a short explanation), shown in **red**.
+Type a number to show a practical, `m` to show the menu, `0` to exit.
+
+## Install
+```
+python -m pip install scikit-lab-kit
+```
+
+## Run
+```
+python -m scikit_lab
+```
+or in IDLE / Python:
+```python
+import scikit_lab
+scikit_lab.main()
+```
+
+## Menu
+| No. | Practical |
+|-----|-----------|
+| 1 | Data cleaning - missing values |
+| 2 | Data cleaning - noisy data (outliers) |
+| 3 | Data cleaning on a dataset (loan credit) |
+| 4 | Preprocessing - correlation and contingency table |
+| 5 | Exploratory data analysis (EDA) |
+| 6 | Decision tree |
+| 7 | Comparing classification models |
+| 8 | Classification improvement (bagging, boosting) |
+| 9 | Clustering (K-Means, hierarchical) |
+| 10 | Association - Apriori (groceries) |
+| 11 | Association - Apriori (own dataset) |
+| 12 | FP-Tree association |
+| 13 | Classifiers explanation (PCA, SVM, Random Forest) |
+| 14 | Principal Component Analysis (PCA) |
+
+This package only displays text; it does not run the practical code.

scikit_lab_kit-0.1.0/README.md

@@ -0,0 +1,39 @@
+# scikit-lab-kit
+
+Numbered viewer for the DAML practicals (steps, code and a short explanation), shown in **red**.
+Type a number to show a practical, `m` to show the menu, `0` to exit.
+
+## Install
+```
+python -m pip install scikit-lab-kit
+```
+
+## Run
+```
+python -m scikit_lab
+```
+or in IDLE / Python:
+```python
+import scikit_lab
+scikit_lab.main()
+```
+
+## Menu
+| No. | Practical |
+|-----|-----------|
+| 1 | Data cleaning - missing values |
+| 2 | Data cleaning - noisy data (outliers) |
+| 3 | Data cleaning on a dataset (loan credit) |
+| 4 | Preprocessing - correlation and contingency table |
+| 5 | Exploratory data analysis (EDA) |
+| 6 | Decision tree |
+| 7 | Comparing classification models |
+| 8 | Classification improvement (bagging, boosting) |
+| 9 | Clustering (K-Means, hierarchical) |
+| 10 | Association - Apriori (groceries) |
+| 11 | Association - Apriori (own dataset) |
+| 12 | FP-Tree association |
+| 13 | Classifiers explanation (PCA, SVM, Random Forest) |
+| 14 | Principal Component Analysis (PCA) |
+
+This package only displays text; it does not run the practical code.

scikit_lab_kit-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scikit-lab-kit"
+version = "0.1.0"
+description = "Numbered DAML (scikit-learn) practicals: steps, code and short explanation"
+readme = "README.md"
+requires-python = ">=3.9"
+
+[project.scripts]
+scikit-lab = "scikit_lab.viewer:main"
+
+[tool.setuptools.packages.find]
+include = ["scikit_lab*"]
+
+[tool.setuptools.package-data]
+scikit_lab = ["practicals/*.txt"]

scikit_lab_kit-0.1.0/scikit_lab/__init__.py

@@ -0,0 +1,3 @@
+from .viewer import main
+
+__all__ = ["main"]

scikit_lab_kit-0.1.0/scikit_lab/__main__.py

@@ -0,0 +1,4 @@
+from .viewer import main
+
+if __name__ == "__main__":
+    main()

scikit_lab_kit-0.1.0/scikit_lab/practicals/01_data_cleaning_missing_values.txt

@@ -0,0 +1,72 @@
+PRACTICAL 1: DATA CLEANING - MISSING VALUES
+
+STEPS:
+1. Install the libraries:  pip install pandas scikit-learn
+2. Keep the data.csv file in the same folder as the program.
+3. Load the csv file into a DataFrame and print the columns.
+4. Find the missing values (count, any-missing rows, all-missing rows).
+5. Fill the missing values (Name -> "Unknown", City -> forward/backward fill, Marks -> mean).
+6. Scale the Marks column using Min-Max and Z-score scaling.
+7. Print the statistics of Marks (mean, median, max, min).
+8. Drop the rows with missing values and save the cleaned data to student_cleaned.csv.
+
+CODE:
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler, StandardScaler
+try:
+    df = pd.read_csv("data.csv")
+    print("Columns detected in csv file:", df.columns.tolist())
+except Exception as e:
+    print(f"Error loading csv file: {e}")
+    exit()
+print("\nOriginal DataFrame:")
+print(df)
+print("\nMissing Values Summary:")
+print(df.isna().sum())
+print("\nRows with Any missing values:")
+print(df[df.isna().any(axis=1)])
+print("\nRows with ALL missing values:")
+print(df[df.isna().all(axis=1)])
+print("\n################ FILL MISSING DATA ###################")
+if "Name" in df.columns:
+    df["Name"] = df["Name"].fillna("Unknown")
+if "City" in df.columns:
+    df["City"] = df["City"].ffill().bfill()
+if 'Dob' in df.columns:
+    df['Dob'] = df['Dob'].fillna('1900-01-01')
+if 'Marks' in df.columns:
+    df['Marks'] = pd.to_numeric(df['Marks'], errors='coerce')
+    df['Marks'] = df['Marks'].fillna(df['Marks'].mean())
+print("\nDataFrame After Filling Missing Values:")
+print(df)
+if 'Marks' in df.columns and not df['Marks'].isna().all():
+    # Min-Max Scaling
+    scaler = MinMaxScaler()
+    df['Marks_MINMAX'] = scaler.fit_transform(df[['Marks']])
+    zscaler = StandardScaler()
+    df['Marks_ZSCORE'] = zscaler.fit_transform(df[['Marks']])
+    print("\nDataFrame with Scaled Marks:")
+    print(df[['Name', 'Roll_no', 'Marks', 'Marks_MINMAX', 'Marks_ZSCORE']])
+else:
+    print("\nNo valid Marks column available for scaling")
+if 'Marks' in df.columns:
+    print("\nMarks Statistics:")
+    print(f"Mean: {df['Marks'].mean():.2f}")
+    print(f"Median: {df['Marks'].median():.2f}")
+    print(f"Max: {df['Marks'].max():.2f}")
+    print(f"Min: {df['Marks'].min():.2f}")
+df_clean = df.dropna(how='any')
+print("\nDataFrame after dropping rows with ANY missing values:")
+print(df_clean)
+df_clean_all = df.dropna(how='all')
+print("\nDataFrame after dropping rows with ALL missing values:")
+print(df_clean_all)
+df.to_csv('student_cleaned.csv', index=False)
+print("\nCleaned data saved to 'student_cleaned.csv'")
+
+EXPLANATION:
+- The program reads the student csv and uses isna() to show how many values are missing in each column.
+- Missing Name is filled with "Unknown", City is filled from the neighbouring rows and Marks with the column mean.
+- MinMaxScaler brings Marks into the range 0-1 and StandardScaler converts it to a Z-score.
+- dropna(how='any') removes rows with any gap, dropna(how='all') removes only completely empty rows.
+- The final cleaned data is saved to student_cleaned.csv.

scikit_lab_kit-0.1.0/scikit_lab/practicals/02_data_cleaning_noisy_data.txt

@@ -0,0 +1,69 @@
+PRACTICAL 2: DATA CLEANING - NOISY DATA
+
+STEPS:
+1. Install the libraries:  pip install pandas numpy matplotlib
+2. Load noisy_data.csv (with the date column) and strip the spaces from the column names.
+3. Draw a boxplot of price to see the outliers before cleaning.
+4. Convert the date column to the dd-mm-yy format.
+5. Find the outliers of price and quantity with the IQR method and replace them with NaN.
+6. Draw the boxplot again after cleaning.
+7. Save the cleaned data to a csv file and print its shape and first 5 rows.
+
+CODE:
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+def load_and_clean_data():
+    try:
+        df=pd.read_csv('/content/sample_data/noisy_data.csv',parse_dates=['date'])
+        print('column detected succesfully')
+    except:
+        print('error finding file')
+    df.columns=df.columns.str.strip()
+    return df
+print("Loading Data...")
+df=load_and_clean_data()
+print("\nOg Data (5 rows )")
+print(df.head())
+plt.figure(figsize=(6, 4))
+plt.boxplot(df['price'])
+plt.title("Boxplot - Product Prices (Before Cleaning)")
+plt.ylabel("Price ($)")
+plt.tight_layout()
+plt.show()
+print("\nConverting date format...")
+df['date'] = pd.to_datetime(df['date'], format='%d-%m-%y')
+print("\n Identifying and Removing Outliers..")
+def remove_outliers(column):
+    column=pd.to_numeric(column,errors='coerce')
+    Q1=column.quantile(0.25)
+    Q3=column.quantile(0.75)
+    IQR=Q3-Q1
+    lower=Q1-1.5*IQR
+    upper=Q3+1.5*IQR
+    print(f"\nColumn statistics:Q1={Q1},Q3={Q3},IQR={IQR}")
+    print(f"Outlier bounds: lower={lower}, upper={upper}")
+    return column.apply(lambda x: np.nan if (x < lower or x > upper) else x)
+price_no_outliers = remove_outliers(df['price'])
+quantity_no_outliers = remove_outliers(df['quantity'])
+df = df.assign(price=price_no_outliers, quantity=quantity_no_outliers)
+plt.figure(figsize=(6, 4))
+plt.boxplot(df['price'].dropna())
+plt.title("Boxplot - Product Prices (After Cleaning)")
+plt.ylabel("Price ($)")
+plt.tight_layout()
+plt.show()
+cleaned_file_path = "/content/sample_data/cleaned_sales_data.csv"
+df.to_csv(cleaned_file_path, index=False)
+print("\nCleaning complete!")
+print(f"Cleaned data saved to: {cleaned_file_path}")
+print(f"\nFinal cleaned data shape: {df.shape}")
+print("\nPreview of Cleaned Data (first 5 rows):")
+print(df.head())
+
+EXPLANATION:
+- Noisy data means values that are wrong or far away from the rest (outliers), for example a very high price.
+- The boxplot before cleaning shows the outliers as points outside the whiskers.
+- remove_outliers() calculates Q1, Q3 and IQR and treats values below Q1-1.5*IQR or above Q3+1.5*IQR as outliers.
+- The outliers are replaced with NaN, so the boxplot after cleaning is without the extreme points.
+- The cleaned dataset is saved to cleaned_sales_data.csv.

scikit_lab_kit-0.1.0/scikit_lab/practicals/03_data_cleaning_on_dataset.txt

@@ -0,0 +1,70 @@
+PRACTICAL 3: DATA CLEANING ON DATASET (LOAN CREDIT SCORE)
+
+Dataset taken: Loan_Credit_Score (loan_credit_dataset_240_rows_with_outliers.csv)
+
+STEPS:
+1. Install the libraries:  pip install pandas numpy matplotlib
+2. Load the loan credit dataset and view head(), info() and describe().
+3. Check the missing values, duplicate rows and data types.
+4. Draw a boxplot of each numeric column (before removing outliers).
+5. Remove the outliers of each column using the IQR method.
+6. Draw the boxplots again (after removing outliers).
+
+CODE:
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+df=pd.read_csv('/content/sample_data/loan_credit_dataset_240_rows_with_outliers.csv')
+print(df.head())
+print(df.info())
+print(df.describe())
+print(df.isnull().sum()) #missing value
+print("Duplicate rows:",df.duplicated().sum()) #duplicate values
+print(df.dtypes)
+#finding outliers in data
+print("Before removing outliers:")
+columns = [
+    "AnnualIncome",
+    "CreditScore",
+    "LoanAmount",
+    "DebtToIncomeRatio",
+    "EmploymentYears"
+]
+for col in columns:
+    plt.figure(figsize=(6,4))
+    plt.boxplot(df[col])
+    plt.title(f"Box Plot of {col}")
+    plt.ylabel(col)
+    plt.grid(True)
+    plt.show()
+print("identifying and removing outliers")
+def remove_outliers(column):
+    Q1=column.quantile(0.25)
+    Q3=column.quantile(0.75)
+    IQR=Q3-Q1
+    lower=Q1-1.5*IQR
+    upper=Q3+1.5*IQR
+    print(f"\nColumn statistics:Q1={Q1},Q3={Q3},IQR={IQR}")
+    print(f"Outlier bounds: lower={lower}, upper={upper}")
+    return column.apply(lambda x: np.nan if (x < lower or x > upper) else x)
+for col in columns:
+    df[col] = remove_outliers(df[col])
+print("After removing outliers:")
+for col in columns:
+    plt.figure(figsize=(6,4))
+    plt.boxplot(df[col].dropna())
+    plt.title(f"Box Plot of {col}")
+    plt.ylabel(col)
+    plt.grid(True)
+    plt.show()
+
+EXPLANATION:
+- The first part inspects the dataset: shape of data, statistics, missing values, duplicates and data types.
+- Five numeric columns (income, credit score, loan amount, debt-to-income ratio, employment years) are checked for outliers.
+- Boxplots drawn before cleaning show the extreme values in each column.
+- remove_outliers() uses the IQR rule (Q1-1.5*IQR, Q3+1.5*IQR) and replaces the outliers with NaN.
+- The boxplots after cleaning show the same columns without the extreme values.
+
+OUTPUT:
+Before removing outliers: box plots with outlier points.
+After removing outliers: box plots with the outliers removed.

scikit_lab_kit-0.1.0/scikit_lab/practicals/04_preprocessing_contingency.txt

@@ -0,0 +1,42 @@
+PRACTICAL 4: DATA PREPROCESSING - CORRELATION AND CONTINGENCY TABLE
+
+STEPS:
+1. Install the libraries:  pip install pandas seaborn matplotlib scipy
+2. Load Match.csv and select only the numeric columns.
+3. Calculate the correlation matrix and draw it as a heatmap.
+4. Create a contingency table of Toss_Decision against Match_Winner_Id.
+5. Apply the Chi-square test on the table (statistic, p-value, degrees of freedom, expected frequencies).
+6. If p-value < 0.05 the variables are dependent, otherwise they are independent.
+
+CODE:
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from scipy.stats import chi2_contingency
+df=pd.read_csv("Match.csv")
+num_df=df.select_dtypes(include=["int64","float64"])
+correlation_matrix=num_df.corr()
+print("correlation matrix:\n",correlation_matrix)
+plt.figure(figsize=(10,8))
+sns.heatmap(correlation_matrix,annot=True,cmap="coolwarm",fmt=".2f")
+plt.title("correlation matrix")
+plt.show()
+if 'Toss_Decision' in df.columns:
+  contingency_table=pd.crosstab(df['Toss_Decision'],df['Match_Winner_Id'])
+  print("Contigency Table:\n",contingency_table)
+  chi2,p,dof,expected=chi2_contingency(contingency_table)
+  print(f"\nChi-square Statistic: {chi2}")
+  print(f"P-value: {p}")
+  print(f"Degrees of Freedom: {dof}")
+  print("Expected Frequencies:\n",expected)
+  if p< 0.05:
+    print("\n Variables are dependent (reject H0)")
+  else:
+    print("\nVariables are independent (fail to reject H0) ")
+
+EXPLANATION:
+- corr() finds how strongly every pair of numeric columns is related (+1 strong positive, -1 strong negative, 0 none).
+- The heatmap shows the correlation matrix with colours, so the related columns are easy to spot.
+- pd.crosstab() builds a contingency table that counts matches for each toss decision and match winner.
+- chi2_contingency() tests whether the two categorical variables are related.
+- If the p-value is below 0.05 the variables are dependent (H0 rejected), otherwise they are independent.

scikit_lab_kit-0.1.0/scikit_lab/practicals/05_eda.txt

@@ -0,0 +1,252 @@
+PRACTICAL 5: EXPLORATORY DATA ANALYSIS (EDA)
+
+STEPS:
+1. Install the libraries:  pip install pandas numpy seaborn matplotlib
+2. Load Match.csv.
+3. For every numeric column find mean, median, mode, skewness and kurtosis and tell the type of skew.
+4. Plot the venue-wise wins of the teams at the top 10 venues (bar plot).
+5. Plot the toss decision frequency (bar plot).
+6. Map the team ids to team names and plot the home ground wins (pie chart).
+7. Plot the venue-wise wins (scatter plot), winning margin by toss decision (box plot and violin plot).
+8. Plot the frequency of win types (line plot) and winner by toss decision (swarm plot).
+9. Plot the home wins as a donut chart and venue, toss decision and win type as a 3D scatter plot.
+
+CODE:
+from math import isclose
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+df=pd.read_csv("Match.csv")
+num_cols=df.select_dtypes(include=[np.number]).columns
+for col in num_cols:
+  mean_val=df[col].mean()
+  meadian_val=df[col].median()
+  mode_val=df[col].mode().iloc[0]
+  skew_val=df[col].skew()
+  kurtosis_val=df[col].kurtosis()
+  print(f"Mean of {col}: {mean_val}")
+  print(f"Median of {col}: {meadian_val}")
+  print(f"Mode of {col}: {mode_val}")
+  print(f"Skewness of {col}: {skew_val}")
+  print(f"Kurtosis of {col}: {kurtosis_val}")
+  print("\n")
+  if np.isclose(skew_val,0,atol=0.1):
+    print("Data is symmetric")
+  elif skew_val>0:
+    print("Data is positively skewed")
+  else:
+    print("Data is negatively skewed")
+  print("-"*70)
+venue_wins = (
+    df.groupby(['Venue_Name', 'Match_Winner_Id'])
+      .size()
+      .reset_index(name='Wins')
+)
+# Select top 10 venues by number of matches
+top_venues = df['Venue_Name'].value_counts().head(10).index
+venue_wins = venue_wins[venue_wins['Venue_Name'].isin(top_venues)]
+plt.figure(figsize=(14,7))
+sns.barplot(
+    data=venue_wins,
+    x='Venue_Name',
+    y='Wins',
+    hue='Match_Winner_Id'
+)
+plt.xticks(rotation=45, ha='right')
+plt.title('Venue Advantage: Wins by Team at Top Venues')
+plt.xlabel('Venue')
+plt.ylabel('Number of Wins')
+plt.tight_layout()
+plt.show()
+toss_counts = df['Toss_Decision'].value_counts()
+toss_counts.plot(
+    kind='bar',
+    color=['skyblue', 'orange'],
+    figsize=(6,5)
+)
+plt.title('Frequency of Toss Decisions')
+plt.xlabel('Toss Decision')
+plt.ylabel('Number of Matches')
+for i, v in enumerate(toss_counts):
+    plt.text(i, v + 2, str(v), ha='center')
+plt.show()
+team_id_name_pairs = pd.concat([
+    df[['Opponent_Team_Id', 'Team name']].rename(columns={'Opponent_Team_Id': 'Team_ID', 'Team name': 'Team_Name'}),
+    df[['Opponent_Team_Id', 'OpponentTeam name']].rename(columns={'Opponent_Team_Id': 'Team_ID', 'OpponentTeam name': 'Team_Name'}),
+    df[['Match_Winner_Id', 'Team name']].rename(columns={'Match_Winner_Id': 'Team_ID', 'Team name': 'Team_Name'}),
+    df[['Match_Winner_Id', 'OpponentTeam name']].rename(columns={'Match_Winner_Id': 'Team_ID', 'OpponentTeam name': 'Team_Name'})
+]).drop_duplicates().dropna(subset=['Team_ID', 'Team_Name'])
+team_map = team_id_name_pairs.groupby('Team_ID')['Team_Name'].first()
+# Add winner name column
+df['Match_Winner_Id'] = df['Match_Winner_Id'].map(team_map)
+# Home wins
+home_wins = df[df['OpponentTeam name'] == df['Match_Winner_Id']]
+home_win_counts = home_wins['OpponentTeam name'].value_counts()
+plt.figure(figsize=(8,8))
+plt.pie(
+    home_win_counts,
+    labels=home_win_counts.index,
+    autopct='%1.1f%%',
+    startangle=90
+)
+plt.title('Home Ground Wins by Team')
+plt.axis('equal')
+plt.show()
+venue_wins = (
+    df.groupby(['Venue_Name', 'Match_Winner_Id'])
+      .size()
+      .reset_index(name='Wins')
+)
+# Top 10 venues
+top_venues = df['Venue_Name'].value_counts().head(10).index
+venue_wins = venue_wins[venue_wins['Venue_Name'].isin(top_venues)]
+# Convert venue names to numeric positions
+venue_positions = {venue: i for i, venue in enumerate(top_venues)}
+venue_wins['Venue_Pos'] = venue_wins['Venue_Name'].map(venue_positions)
+# Convert 'Match_Winner_Id' (team names) to numerical categories for plotting
+venue_wins['Team_Numeric_ID'], unique_teams = pd.factorize(venue_wins['Match_Winner_Id'])
+# Scatter Plot
+plt.figure(figsize=(14,7))
+scatter = plt.scatter(
+    venue_wins['Venue_Pos'],
+    venue_wins['Wins'],
+    s=120,
+    c=venue_wins['Team_Numeric_ID'], # Use numerical IDs for coloring
+    cmap='tab20',
+    alpha=0.8
+)
+plt.xticks(
+    range(len(top_venues)),
+    top_venues,
+    rotation=45,
+    ha='right'
+)
+plt.xlabel('Venue')
+plt.ylabel('Number of Wins')
+plt.title('Venue-wise Wins by Teams (Scatter Plot)')
+# Create a custom colorbar to show team names
+cbar = plt.colorbar(scatter, ticks=range(len(unique_teams)))
+cbar.set_ticklabels(unique_teams)
+cbar.set_label('Match Winner Team')
+plt.tight_layout()
+plt.show()
+plt.figure(figsize=(8,6))
+sns.boxplot(
+    data=df,
+    x='Toss_Decision',
+    y='Won_By',
+    palette='Set2'
+)
+plt.title('Winning Margin by Toss Decision')
+plt.xlabel('Toss Decision')
+plt.ylabel('Winning Margin')
+plt.show()
+win_counts = df['Win_Type'].value_counts().sort_index()
+plt.figure(figsize=(8,5))
+plt.plot(
+    win_counts.index,
+    win_counts.values,
+    marker='o',
+    linewidth=2
+)
+plt.title('Frequency of Win Types')
+plt.xlabel('Win Type')
+plt.ylabel('Number of Matches')
+plt.grid(True)
+plt.show()
+plt.figure(figsize=(8,6))
+sns.violinplot(
+    data=df,
+    x='Toss_Decision',
+    y='Won_By',
+    inner='quartile'
+)
+plt.title('Winning Margin by Toss Decision')
+plt.xlabel('Toss Decision')
+plt.ylabel('Winning Margin')
+plt.show()
+plt.figure(figsize=(10,6))
+sns.swarmplot(
+    data=df,
+    x='Toss_Decision',
+    y='Match_Winner_Id',
+    size=5
+)
+plt.title('Match Winner IDs by Toss Decision')
+plt.xlabel('Toss Decision')
+plt.ylabel('Match Winner ID')
+plt.show()
+team_id_name_pairs = pd.concat([
+    df[['Opponent_Team_Id', 'Team name']].rename(columns={'Opponent_Team_Id': 'Team_ID', 'Team name': 'Team_Name'}),
+    df[['Opponent_Team_Id', 'OpponentTeam name']].rename(columns={'Opponent_Team_Id': 'Team_ID', 'OpponentTeam name': 'Team_Name'}),
+    df[['Match_Winner_Id', 'Team name']].rename(columns={'Match_Winner_Id': 'Team_ID', 'Team name': 'Team_Name'}),
+    df[['Match_Winner_Id', 'OpponentTeam name']].rename(columns={'Match_Winner_Id': 'Team_ID', 'OpponentTeam name': 'Team_Name'})
+]).drop_duplicates().dropna(subset=['Team_ID', 'Team_Name'])
+team_map = team_id_name_pairs.groupby('Team_ID')['Team_Name'].first()
+# Map winner IDs to team names
+df['Match_Winner_Name'] = df['Match_Winner_Id'].map(team_map)
+# Home wins
+home_wins = df[df['OpponentTeam name'] == df['Match_Winner_Name']]
+home_win_counts = home_wins['OpponentTeam name'].value_counts()
+plt.figure(figsize=(9,9))
+plt.pie(
+    home_win_counts,
+    labels=home_win_counts.index,
+    autopct='%1.1f%%',
+    startangle=90,
+    pctdistance=0.8,
+    wedgeprops=dict(width=0.4, edgecolor='white')
+)
+plt.text(
+    0, 0,
+    "Home\nWins",
+    ha='center',
+    va='center',
+    fontsize=16,
+    fontweight='bold'
+)
+plt.title('Home Ground Wins by Team', fontsize=16, fontweight='bold')
+plt.axis('equal')
+plt.tight_layout()
+plt.show()
+df['Venue_Code'] = df['Venue_Name'].astype('category').cat.codes
+df['Toss_Code'] = df['Toss_Decision'].astype('category').cat.codes
+df['WinType_Code'] = df['Win_Type'].astype('category').cat.codes
+# Create 3D Scatter Plot
+fig = plt.figure(figsize=(12,8))
+ax = fig.add_subplot(111, projection='3d')
+scatter = ax.scatter(
+    df['Venue_Code'],
+    df['Toss_Code'],
+    df['WinType_Code'],
+    c=df['WinType_Code'],      # Color by Win Type
+    cmap='viridis',
+    s=40,
+    alpha=0.7
+)
+ax.set_title('3D Scatter Plot of Venue, Toss Decision and Win Type')
+ax.set_xlabel('Venue')
+ax.set_ylabel('Toss Decision')
+ax.set_zlabel('Win Type')
+# Show original category names on axes
+venue_labels = df['Venue_Name'].astype('category').cat.categories
+toss_labels = df['Toss_Decision'].astype('category').cat.categories
+win_labels = df['Win_Type'].astype('category').cat.categories
+# Limit x-axis labels to avoid clutter (top 10 venues)
+ax.set_xticks(range(min(10, len(venue_labels))))
+ax.set_xticklabels(venue_labels[:10], rotation=45, ha='right')
+ax.set_yticks(range(len(toss_labels)))
+ax.set_yticklabels(toss_labels)
+ax.set_zticks(range(len(win_labels)))
+ax.set_zticklabels(win_labels)
+plt.colorbar(scatter, ax=ax, label='Win Type Code')
+plt.tight_layout()
+plt.show()
+
+EXPLANATION:
+- The first loop gives the mean, median, mode, skewness and kurtosis of every numeric column and tells if the data is symmetric, positively or negatively skewed.
+- Bar, pie and donut charts show the categorical counts: wins at the top venues, toss decisions and home ground wins.
+- A team-id to team-name map is built so the charts show names instead of ids.
+- Box plot and violin plot compare the winning margin for each toss decision, the swarm plot shows each winner individually.
+- The line plot shows win-type frequency and the 3D scatter plot shows venue, toss decision and win type together.