sppu-mlpracticals 0.1.0__tar.gz

sppu_mlpracticals-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: sppu-mlpracticals
+Version: 0.1.0
+Summary: Python practicals for SPPU AI and Data Science students
+Author: Abhijeet Upadhye
+License-Expression: MIT
+Keywords: machine-learning,python,SPPU,AI,data-science
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

sppu_mlpracticals-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sppu-mlpracticals"
+version = "0.1.0"
+description = "Python practicals for SPPU AI and Data Science students"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    { name = "Abhijeet Upadhye" }
+]
+keywords = ["machine-learning", "python", "SPPU", "AI", "data-science"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

sppu_mlpracticals-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sppu_mlpracticals-0.1.0/src/mlpracticals/__init__.py

@@ -0,0 +1,5 @@
+from .core import get, list_practicals
+
+__version__ = "0.1.0"
+
+__all__ = ["get", "list_practicals"]

sppu_mlpracticals-0.1.0/src/mlpracticals/core.py

@@ -0,0 +1,42 @@
+from importlib import import_module
+
+
+PRACTICALS = {
+    "ml1a": "PCA on Wine Dataset",
+    "ml1b": "LDA on Iris Dataset",
+    "ml2a": "Uber Fare Regression",
+    "ml2b": "Diabetes Regression Analysis",
+    "ml3a": "SVM on Handwritten Digits",
+    "ml3b": "KNN on Social Network Ads",
+    "ml4a": "K-Means Clustering on Iris Dataset",
+    "ml4b": "K-Medoids Clustering on Credit Card Dataset",
+    "ml5a": "Random Forest on Car Safety Dataset",
+    "ml5b": "Ensemble Learning on Iris Dataset",
+    "ml6a": "Maze Reinforcement Learning",
+    "ml6b": "Taxi Reinforcement Learning",
+    "dmv1": "Data Loading, Storage and File Formats",
+    "dmv2": "Weather Data Analysis using OpenWeatherMap API",
+    "dmv3": "Data Cleaning and Preparation",
+    "dmv4": "Data Wrangling on Real Estate Market",
+    "dmv5": "Data Visualization using Matplotlib",
+    "dmv6": "Data Aggregation on Retail Sales Data",
+    "dmv7": "Time Series Data Analysis on Stock Market Data",
+}
+
+
+def get(practical_id):
+    key = str(practical_id).strip().lower()
+
+    if key not in PRACTICALS:
+        raise ValueError(
+            f"Practical '{practical_id}' not found. "
+            f"Available practicals: {', '.join(PRACTICALS.keys())}"
+        )
+
+    module = import_module(f".practicals.{key[0:3]}{key[3].upper()}", package="mlpracticals")
+
+    return module.PRACTICAL
+
+
+def list_practicals():
+    return PRACTICALS.copy()

sppu_mlpracticals-0.1.0/src/mlpracticals/practicals/dmv1.py

@@ -0,0 +1,96 @@
+PRACTICAL = {
+    "id": "dmv1",
+    "title": "Data Integration, Cleaning, Analysis and Visualization",
+
+    "aim": """
+To integrate data from CSV, Excel and JSON files,
+perform data cleaning and analysis, and visualize
+category-wise sales using Python.
+""",
+
+    "theory": """
+Data Integration is the process of combining data
+collected from different sources into a single dataset.
+Python Pandas provides functions to read data from
+different file formats such as CSV, Excel and JSON.
+
+Data Cleaning is performed to improve data quality
+by removing missing values and duplicate records.
+Pandas provides dropna() to remove missing values
+and drop_duplicates() to remove duplicate records.
+
+Data Transformation involves modifying existing data
+or creating new columns for further analysis. In this
+practical, a TotalSales column is created by multiplying
+Quantity and Price.
+
+Data Analysis is used to understand the dataset and
+extract useful information. Functions such as head(),
+describe() and sum() help display records, statistical
+information and total sales.
+
+Grouping is performed using the groupby() function.
+It groups records based on a particular column and
+calculates the total sales for each category.
+
+Data Visualization is the graphical representation
+of data. Matplotlib is used to create a bar chart
+that displays sales for different categories.
+This makes it easier to compare category-wise sales.
+""",
+
+    "formula": """
+Total Sales:
+
+TotalSales = Quantity × Price
+
+Category-wise Sales:
+
+Category Sales = Σ TotalSales
+
+Overall Sales:
+
+Total Sales = Σ TotalSales
+""",
+
+    "algorithm": [
+        "Import Pandas and Matplotlib libraries.",
+        "Load CSV, Excel and JSON files.",
+        "Combine all datasets using the concat() function.",
+        "Remove missing values and duplicate records.",
+        "Create a TotalSales column using Quantity and Price.",
+        "Display the first five records using head().",
+        "Display statistical information using describe().",
+        "Calculate the overall sales using sum().",
+        "Group sales records by Category using groupby().",
+        "Create a bar chart to visualize category-wise sales.",
+        "Display the bar chart."
+    ],
+
+    "code": '''
+import pandas as pd
+import matplotlib.pyplot as plt
+
+csv = pd.read_csv("sales.csv")
+excel = pd.read_excel("sales.xlsx")
+json = pd.read_json("sales.json")
+
+sales = pd.concat([csv, excel, json], ignore_index=True)
+
+sales = sales.dropna().drop_duplicates()
+
+sales["TotalSales"] = sales["Quantity"] * sales["Price"]
+
+print(sales.head())
+print(sales.describe())
+
+print("Total Sales:", sales["TotalSales"].sum())
+
+category_sales = sales.groupby("Category")["TotalSales"].sum()
+print(category_sales)
+
+category_sales.plot(kind="bar", title="Sales by Category")
+plt.ylabel("Total Sales")
+plt.show()
+'''
+}

sppu_mlpracticals-0.1.0/src/mlpracticals/practicals/dmv2.py

@@ -0,0 +1,105 @@
+PRACTICAL = {
+    "id": "dmv2",
+    "title": "Weather Data Analysis using OpenWeatherMap API",
+
+    "aim": """
+To retrieve weather data from the OpenWeatherMap API,
+perform data processing and analyze weather conditions
+using Python and visualize the results.
+""",
+
+    "theory": """
+A Web API (Application Programming Interface) allows
+applications to communicate and exchange data over
+the internet.
+
+OpenWeatherMap is a weather service that provides
+real-time weather information through its API.
+It provides information such as temperature, humidity,
+wind speed and weather conditions.
+
+The Requests library is used to send HTTP requests
+to the API and retrieve weather data in JSON format.
+
+The JSON response is converted into a Python dictionary
+and relevant weather attributes are extracted.
+
+Pandas is used to organize and process the retrieved
+weather information. Data analysis is performed to
+calculate temperature statistics and examine weather
+conditions.
+
+Matplotlib is used to visualize weather attributes
+through bar charts. These visualizations make it easier
+to understand and compare weather conditions.
+""",
+
+    "formula": """
+Average Temperature:
+
+Average = Sum of Temperatures / Number of Records
+
+Temperature Conversion:
+
+Celsius = Kelvin - 273.15
+""",
+
+    "algorithm": [
+        "Import Requests, Pandas and Matplotlib libraries.",
+        "Register on OpenWeatherMap and obtain an API key.",
+        "Enter the city name and API key.",
+        "Send a request to the OpenWeatherMap API.",
+        "Retrieve weather information in JSON format.",
+        "Extract temperature, humidity and wind speed.",
+        "Convert temperature from Kelvin to Celsius.",
+        "Store the weather information in a DataFrame.",
+        "Calculate average temperature and display weather details.",
+        "Create bar charts to visualize weather attributes."
+    ],
+
+    "code": '''
+import requests
+import pandas as pd
+import matplotlib.pyplot as plt
+
+api_key = "YOUR_API_KEY"
+city = "Pune"
+
+url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"
+
+response = requests.get(url)
+data = response.json()
+
+if response.status_code == 200:
+    temperature = data["main"]["temp"] - 273.15
+    humidity = data["main"]["humidity"]
+    wind_speed = data["wind"]["speed"]
+    weather = data["weather"][0]["description"]
+
+    df = pd.DataFrame({
+        "City": [city],
+        "Temperature": [temperature],
+        "Humidity": [humidity],
+        "Wind Speed": [wind_speed],
+        "Weather": [weather]
+    })
+
+    print(df)
+
+    print("Average Temperature:", df["Temperature"].mean())
+    print("Maximum Temperature:", df["Temperature"].max())
+    print("Minimum Temperature:", df["Temperature"].min())
+
+    df[["Temperature", "Humidity", "Wind Speed"]].plot(
+        kind="bar",
+        figsize=(8, 5),
+        title="Weather Analysis"
+    )
+
+    plt.ylabel("Values")
+    plt.show()
+
+else:
+    print("Error:", data["message"])
+'''
+}

sppu_mlpracticals-0.1.0/src/mlpracticals/practicals/dmv3.py

@@ -0,0 +1,163 @@
+PRACTICAL = {
+    "id": "dmv3",
+    "title": "Data Cleaning and Preparation on Customer Churn Dataset",
+
+    "aim": """
+To clean and prepare the Telecom Customer Churn dataset
+by handling missing values, removing duplicates, treating
+outliers, performing feature engineering, scaling data
+and splitting it into training and testing datasets.
+""",
+
+    "theory": """
+Data Cleaning is the process of identifying and correcting
+errors, missing values, duplicate records and inconsistencies
+in a dataset. It improves data quality and makes the data
+suitable for further analysis.
+
+The Telecom Customer Churn dataset contains customer
+information such as gender, tenure, monthly charges,
+contract type and churn status. Churn indicates whether
+a customer has discontinued the company's services.
+
+Data Exploration is performed using functions such as
+head(), info() and isnull().sum() to understand the
+structure and identify missing values.
+
+Missing values can be handled using mean, median or mode
+imputation. Duplicate records are removed using the
+drop_duplicates() function.
+
+Data Transformation involves converting columns into
+appropriate data types and standardizing inconsistent
+categorical values.
+
+Outlier Detection identifies unusually high or low values.
+The Interquartile Range (IQR) method can be used to detect
+outliers in numerical columns.
+
+Feature Engineering is the process of creating new
+features from existing columns. In this practical, a
+TenureGroup column is created based on customer tenure.
+
+Data Encoding converts categorical values into numerical
+representations using one-hot encoding.
+
+Feature Scaling brings numerical features to a similar
+scale using StandardScaler.
+
+Finally, the dataset is divided into training and testing
+sets using train_test_split(). The cleaned dataset is
+also exported as a CSV file for future analysis.
+""",
+
+    "formula": """
+Interquartile Range:
+
+IQR = Q3 - Q1
+
+Lower Bound:
+
+Q1 - 1.5 × IQR
+
+Upper Bound:
+
+Q3 + 1.5 × IQR
+
+Standardization:
+
+Z = (X - μ) / σ
+
+Where:
+X = Original value
+μ = Mean
+σ = Standard deviation
+""",
+
+    "algorithm": [
+        "Import the required Python libraries.",
+        "Load the Telecom_Customer_Churn.csv dataset.",
+        "Explore the dataset using head(), info() and describe().",
+        "Identify and handle missing values.",
+        "Remove duplicate records.",
+        "Convert columns into appropriate data types.",
+        "Standardize categorical values.",
+        "Detect and handle outliers using the IQR method.",
+        "Create a new feature called TenureGroup.",
+        "Encode categorical columns using one-hot encoding.",
+        "Scale numerical features using StandardScaler.",
+        "Split the dataset into training and testing sets.",
+        "Export the cleaned dataset as a CSV file."
+    ],
+
+    "code": '''
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+
+df = pd.read_csv("Telecom_Customer_Churn.csv")
+
+print(df.head())
+print(df.info())
+print(df.isnull().sum())
+
+df = df.drop_duplicates()
+
+df = df.replace(" ", pd.NA)
+
+df["TotalCharges"] = pd.to_numeric(
+    df["TotalCharges"], errors="coerce"
+)
+
+df["TotalCharges"] = df["TotalCharges"].fillna(
+    df["TotalCharges"].median()
+)
+
+df = df.fillna(df.mode().iloc[0])
+
+for col in df.select_dtypes(include="object").columns:
+    df[col] = df[col].str.strip().str.lower()
+
+for col in ["tenure", "MonthlyCharges", "TotalCharges"]:
+    Q1 = df[col].quantile(0.25)
+    Q3 = df[col].quantile(0.75)
+    IQR = Q3 - Q1
+
+    df[col] = df[col].clip(
+        lower=Q1 - 1.5 * IQR,
+        upper=Q3 + 1.5 * IQR
+    )
+
+df["TenureGroup"] = pd.cut(
+    df["tenure"],
+    bins=[-1, 12, 36, 72],
+    labels=["New", "Medium", "Long"]
+)
+
+df["Churn"] = df["Churn"].map({"no": 0, "yes": 1})
+
+df = df.drop(columns=["customerID"], errors="ignore")
+
+df = pd.get_dummies(df, drop_first=True, dtype=int)
+
+X = df.drop("Churn", axis=1)
+y = df["Churn"]
+
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X_scaled, y, test_size=0.2, random_state=42,
+    stratify=y
+)
+
+cleaned_data = pd.DataFrame(X_scaled, columns=X.columns)
+cleaned_data["Churn"] = y.values
+
+cleaned_data.to_csv("Cleaned_Customer_Churn.csv", index=False)
+
+print("Training Data:", X_train.shape)
+print("Testing Data:", X_test.shape)
+print("Cleaned dataset saved successfully.")
+'''
+}

sppu_mlpracticals-0.1.0/src/mlpracticals/practicals/dmv4.py

@@ -0,0 +1,153 @@
+PRACTICAL = {
+    "id": "dmv4",
+    "title": "Data Wrangling on Real Estate Market",
+
+    "aim": """
+To perform data wrangling on real estate data by cleaning
+column names, handling missing values, filtering records,
+encoding categorical variables, aggregating data and
+identifying outliers using Python.
+""",
+
+    "theory": """
+Data Wrangling is the process of cleaning, transforming
+and organizing raw data into a structured format suitable
+for analysis and further processing.
+
+The Real Estate dataset contains information about
+properties, including location, property type, area,
+number of bedrooms and sale prices.
+
+Data Importing is performed using Pandas read_csv()
+to load the dataset into a DataFrame.
+
+Column Cleaning involves removing unnecessary spaces
+and special characters from column names to make them
+consistent and easy to use.
+
+Missing values are handled using methods such as
+dropna() and fillna(). Numerical missing values can
+be replaced with the median, while categorical missing
+values can be replaced with the mode.
+
+Data Filtering is used to select records based on
+specific conditions such as property type, location
+or sale price.
+
+Categorical Encoding converts text-based values into
+numerical values. One-hot encoding creates separate
+columns for different categories.
+
+Data Aggregation groups records using groupby() and
+calculates summary statistics such as average property
+prices for different locations.
+
+Outlier Detection identifies unusually high or low
+property prices using the Interquartile Range (IQR)
+method.
+
+These operations help prepare real estate data for
+accurate analysis and future machine learning models.
+""",
+
+    "formula": """
+Interquartile Range:
+
+IQR = Q3 - Q1
+
+Lower Bound:
+
+Q1 - 1.5 × IQR
+
+Upper Bound:
+
+Q3 + 1.5 × IQR
+
+Average Property Price:
+
+Average = Total Property Prices / Number of Properties
+""",
+
+    "algorithm": [
+        "Import the required Python libraries.",
+        "Load the RealEstate_Prices.csv dataset.",
+        "Display the first five records and dataset information.",
+        "Clean column names by removing spaces and special characters.",
+        "Identify and handle missing values.",
+        "Remove duplicate records.",
+        "Filter properties based on specific conditions.",
+        "Encode categorical variables using one-hot encoding.",
+        "Group properties by neighborhood and calculate average prices.",
+        "Identify and handle outliers using the IQR method.",
+        "Display the processed dataset and aggregated results."
+    ],
+
+    "code": '''
+import pandas as pd
+
+df = pd.read_csv("RealEstate_Prices.csv")
+
+print(df.head())
+print(df.info())
+print(df.isnull().sum())
+
+df.columns = (
+    df.columns.str.strip()
+    .str.replace(" ", "_")
+    .str.replace(r"[^a-zA-Z0-9_]", "", regex=True)
+)
+
+df = df.drop_duplicates()
+
+for col in df.select_dtypes(include="number").columns:
+    df[col] = df[col].fillna(df[col].median())
+
+for col in df.select_dtypes(include="object").columns:
+    df[col] = df[col].fillna(df[col].mode()[0])
+
+print("Cleaned Data:")
+print(df.head())
+
+print("Filtered Properties:")
+filtered = df[df["Sale_Price"] > 100000]
+print(filtered.head())
+
+df = pd.get_dummies(df, drop_first=True, dtype=int)
+
+print("Encoded Data:")
+print(df.head())
+
+original = pd.read_csv("RealEstate_Prices.csv")
+original.columns = (
+    original.columns.str.strip()
+    .str.replace(" ", "_")
+    .str.replace(r"[^a-zA-Z0-9_]", "", regex=True)
+)
+
+original["Sale_Price"] = pd.to_numeric(
+    original["Sale_Price"], errors="coerce"
+)
+
+print("Average Price by Neighborhood:")
+print(original.groupby("Neighborhood")["Sale_Price"].mean())
+
+Q1 = original["Sale_Price"].quantile(0.25)
+Q3 = original["Sale_Price"].quantile(0.75)
+IQR = Q3 - Q1
+
+lower = Q1 - 1.5 * IQR
+upper = Q3 + 1.5 * IQR
+
+df_clean = original[
+    (original["Sale_Price"] >= lower) &
+    (original["Sale_Price"] <= upper)
+]
+
+print("Data After Removing Outliers:")
+print(df_clean.head())
+
+df_clean.to_csv("Cleaned_RealEstate.csv", index=False)
+
+print("Cleaned dataset saved successfully.")
+'''
+}