CL1

 


CL1 Manual



Practical No:1 PCA

 


import pandas as pd

import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler

from sklearn.decomposition import PCA


# Load dataset

url = "https://media.geeksforgeeks.org/wp-content/uploads/Wine.csv"

df = pd.read_csv(url)


print("First five records:")

print(df.head())


# Separate features and target

X = df.drop("Customer_Segment", axis=1)

y = df["Customer_Segment"]


# Standardize features

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)


# Apply PCA

pca = PCA()

X_pca = pca.fit_transform(X_scaled)


# Plot cumulative explained variance

variance = pca.explained_variance_ratio_

cumulative_variance = variance.cumsum()


plt.plot(range(1, len(variance) + 1),

         cumulative_variance, marker="o")


plt.xlabel("Number of Principal Components")

plt.ylabel("Cumulative Explained Variance")

plt.title("PCA - Explained Variance")

plt.grid(True)

plt.show()


# Reduce to two components

pca2 = PCA(n_components=2)

X_reduced = pca2.fit_transform(X_scaled)


# Display results

print("Original Dataset Shape:", X.shape)

print("Reduced Dataset Shape:", X_reduced.shape)


print("Explained Variance Ratio:",

      pca2.explained_variance_ratio_)


print("Total Variance Retained:",

      pca2.explained_variance_ratio_.sum())


# Visualize PCA results

for segment in sorted(y.unique()):

    idx = (y == segment).values


    plt.scatter(

        X_reduced[idx, 0],

        X_reduced[idx, 1],

        label=f"Segment {segment}"

    )


plt.xlabel("Principal Component 1")

plt.ylabel("Principal Component 2")

plt.title("PCA on Wine Dataset")

plt.legend()

plt.grid(True)

plt.show()




#Practical 2 – AQI (Air Quality Index) Visualization

import warnings

warnings.filterwarnings("ignore")


import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns


# 1. Load dataset

df = pd.read_csv("city_day.csv")


print("First five records:")

print(df.head())


print("\nDataset Information:")

df.info()


print("\nMissing Values:")

print(df.isnull().sum())


# 2. Identify columns

df.columns = df.columns.str.strip()


date_col = next((c for c in df.columns

                 if c.lower() in ["date", "datetime", "timestamp"]), None)


aqi_col = next((c for c in df.columns

                if c.lower() == "aqi"), None)


if date_col is None or aqi_col is None:

    raise ValueError("Dataset must contain Date and AQI columns.")


df[date_col] = pd.to_datetime(df[date_col], errors="coerce")

df[aqi_col] = pd.to_numeric(df[aqi_col], errors="coerce")


df = df.dropna(subset=[date_col, aqi_col]).sort_values(date_col)


# Find pollutant columns

pollutants = [

    c for c in df.columns

    if c.lower().replace(" ", "") in ["pm2.5", "pm25", "pm10", "co"]

]


for col in pollutants:

    df[col] = pd.to_numeric(df[col], errors="coerce")


print("\nCleaned Data:")

print(df.head())


# 3. AQI trend line plot

plt.figure(figsize=(10, 5))

plt.plot(df[date_col], df[aqi_col], marker="o")


plt.title("AQI Trend Over Time")

plt.xlabel("Date")

plt.ylabel("AQI")

plt.xticks(rotation=45)

plt.grid(True)

plt.tight_layout()

plt.show()


# 4. Individual pollutant trends

for col in pollutants:

    plt.figure(figsize=(9, 4))

    plt.plot(df[date_col], df[col], marker="o")


    plt.title(col + " Trend Over Time")

    plt.xlabel("Date")

    plt.ylabel(col + " Level")

    plt.xticks(rotation=45)

    plt.grid(True)

    plt.tight_layout()

    plt.show()


# 5. Bar plot: Average AQI by date

daily_aqi = df.groupby(df[date_col].dt.date)[aqi_col].mean()


daily_aqi.plot(kind="bar", figsize=(10, 5))


plt.title("Average AQI by Date")

plt.xlabel("Date")

plt.ylabel("Average AQI")

plt.xticks(rotation=45)

plt.tight_layout()

plt.show()


# 6. Box plot of pollutant distributions

if pollutants:

    df[pollutants].plot(

        kind="box",

        figsize=(9, 5),

        grid=True

    )


    plt.title("Pollutant Level Distribution")

    plt.ylabel("Concentration")

    plt.tight_layout()

    plt.show()


# 7. Scatter plots: AQI vs pollutants

for col in pollutants:

    plt.figure(figsize=(7, 4))


    plt.scatter(df[col], df[aqi_col], alpha=0.7)


    plt.title("AQI vs " + col)

    plt.xlabel(col + " Level")

    plt.ylabel("AQI")

    plt.grid(True)

    plt.tight_layout()

    plt.show()


# 8. Correlation heatmap

numeric_cols = [aqi_col] + pollutants


if len(numeric_cols) > 1:

    plt.figure(figsize=(7, 5))


    sns.heatmap(

        df[numeric_cols].corr(),

        annot=True,

        cmap="coolwarm",

        fmt=".2f"

    )


    plt.title("AQI and Pollutant Correlation")

    plt.tight_layout()

    plt.show()


print("\nAQI visualization completed successfully.")



#Practical 3 – Sales Data Analysis


import warnings

warnings.filterwarnings("ignore")


import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns


# 1. Create sample sales dataset

data = {

    "OrderID": [101, 102, 103, 104, 105, 106],

    "Product": ["Laptop", "Mobile", "Tablet", "Laptop", "Mobile", "Tablet"],

    "Category": ["Electronics", "Electronics", "Electronics",

                 "Electronics", "Electronics", "Electronics"],

    "Quantity": [2, 3, 1, 2, None, 4],

    "Price": [50000, 15000, 20000, 50000, 15000, 20000],

    "Customer": ["A", "B", "C", "A", "D", "E"]

}


df = pd.DataFrame(data)


# 2. Save data in CSV, Excel and JSON formats

df.to_csv("sales.csv", index=False)

df.to_excel("sales.xlsx", index=False)

df.to_json("sales.json", orient="records", indent=4)


# 3. Load data from different formats

csv_data = pd.read_csv("sales.csv")

excel_data = pd.read_excel("sales.xlsx")

json_data = pd.read_json("sales.json")


print("CSV Data:\n", csv_data.head())

print("\nExcel Data:\n", excel_data.head())

print("\nJSON Data:\n", json_data.head())


# 4. Explore data quality

print("\nMissing Values:\n", csv_data.isnull().sum())

print("\nDuplicate Rows:", csv_data.duplicated().sum())


print("\nDataset Information:")

csv_data.info()


# 5. Combine datasets into one DataFrame

sales = pd.concat(

    [csv_data, excel_data, json_data],

    ignore_index=True

)


# 6. Clean data

sales = sales.drop_duplicates()


sales["Quantity"] = sales["Quantity"].fillna(

    sales["Quantity"].median()

)


sales["Product"] = sales["Product"].str.strip().str.title()

sales["Customer"] = sales["Customer"].str.strip()


# 7. Transform data

sales["TotalSales"] = sales["Quantity"] * sales["Price"]


print("\nCleaned Data:\n", sales.head())


# 8. Descriptive statistics

print("\nDescriptive Statistics:")

print(sales[["Quantity", "Price", "TotalSales"]].describe())


print("\nTotal Sales:", sales["TotalSales"].sum())


print("Average Order Value:",

      round(sales["TotalSales"].mean(), 2))


# 9. Product-wise sales

product_sales = sales.groupby("Product")["TotalSales"].sum()


print("\nProduct-wise Sales:\n", product_sales)


# 10. Bar chart

product_sales.plot(

    kind="bar",

    title="Product-wise Sales",

    ylabel="Total Sales",

    xlabel="Product"

)


plt.tight_layout()

plt.show()


# 11. Pie chart

product_sales.plot(

    kind="pie",

    autopct="%1.1f%%",

    title="Product Sales Distribution"

)


plt.ylabel("")

plt.tight_layout()

plt.show()


# 12. Box plot

sns.boxplot(x=sales["TotalSales"])


plt.title("Sales Distribution")

plt.xlabel("Total Sales")

plt.tight_layout()

plt.show()


# 13. Save cleaned dataset

sales.to_csv("cleaned_sales.csv", index=False)


print("\nCleaned dataset saved successfully.")




Practical 4 – K-Means Clustering on Iris Dataset


import pandas as pd

import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler

from sklearn.cluster import KMeans

import warnings

warnings.filterwarnings("ignore")


# 1. Load dataset

df = pd.read_csv("Iris.csv")


print("First five records:")

print(df.head())


print("\nDataset shape:", df.shape)


# 2. Select numerical features

X = df.select_dtypes(include="number")

X = X.drop(columns=["Id"], errors="ignore")


# 3. Standardize data

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)


# 4. Elbow Method

wcss = []


for k in range(1, 11):

    model = KMeans(n_clusters=k, random_state=42, n_init=10)

    model.fit(X_scaled)

    wcss.append(model.inertia_)


# 5. Plot elbow graph

plt.plot(range(1, 11), wcss, marker="o")


plt.xlabel("Number of Clusters (K)")

plt.ylabel("WCSS")

plt.title("Elbow Method for Iris Dataset")

plt.xticks(range(1, 11))

plt.grid(True)

plt.show()


# 6. Apply K-Means with 3 clusters

kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)


df["Cluster"] = kmeans.fit_predict(X_scaled)


print("\nCluster counts:")

print(df["Cluster"].value_counts().sort_index())


print("\nDataset with cluster labels:")

print(df.head())


# 7. Visualize clusters using two features

plt.figure(figsize=(8, 5))


plt.scatter(

    X_scaled[:, 2],

    X_scaled[:, 3],

    c=df["Cluster"],

    cmap="viridis"

)


plt.xlabel("Petal Length (standardized)")

plt.ylabel("Petal Width (standardized)")

plt.title("K-Means Clustering on Iris Dataset")


plt.colorbar(label="Cluster")

plt.show()



Practical 5 – SVM (Support Vector Machine) Digit Classification


import matplotlib.pyplot as plt

from sklearn.datasets import load_digits

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import make_pipeline

from sklearn.svm import SVC

from sklearn.metrics import accuracy_score, classification_report

from sklearn.metrics import ConfusionMatrixDisplay


# 1. Load handwritten digits dataset

digits = load_digits()


X = digits.data

y = digits.target


print("Dataset shape:", X.shape)

print("Classes:", set(y))


# 2. Display sample images

fig, axes = plt.subplots(1, 5, figsize=(10, 3))


for i, ax in enumerate(axes):

    ax.imshow(digits.images[i], cmap="gray")

    ax.set_title(f"Digit: {y[i]}")

    ax.axis("off")


plt.show()


# 3. Split the dataset

X_train, X_test, y_train, y_test = train_test_split(

    X, y,

    test_size=0.2,

    stratify=y,

    random_state=42

)


# 4. Create and train SVM model

model = make_pipeline(

    StandardScaler(),

    SVC(kernel="rbf", C=10, gamma="scale")

)


model.fit(X_train, y_train)


# 5. Predict digits

y_pred = model.predict(X_test)


# 6. Evaluate model

print("Accuracy:", round(accuracy_score(y_test, y_pred) * 100, 2), "%")


print("\nClassification Report:")

print(classification_report(y_test, y_pred))


# 7. Display confusion matrix

ConfusionMatrixDisplay.from_predictions(

    y_test,

    y_pred,

    cmap="Blues"

)


plt.title("SVM Digit Classification")

plt.show()


# 8. Display sample predictions

print("\nSample Predictions:")


for i in range(10):

    print("Actual:", y_test[i], "| Predicted:", y_pred[i])



Practical 6 – Data Aggregation Using Pandas


import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns


# 1. Import dataset

df = pd.read_csv("retail_sales_dataset.csv")


# Clean column names

df.columns = df.columns.str.strip()


# 2. Explore dataset

print(df.head())

print(df.info())

print(df.describe())


print("Columns:", df.columns.tolist())


# 3. Aggregate sales by product category

category_sales = df.groupby("Product Category")["Total Amount"].sum()


print("\nTotal Sales by Product Category:")

print(category_sales)


# 4. Visualize sales

category_sales.plot(

    kind="bar",

    title="Sales by Product Category"

)


plt.ylabel("Total Sales")

plt.tight_layout()

plt.show()


# 5. Identify top-performing category

print("\nTop Performing Category:")

print(category_sales.idxmax(), category_sales.max())


# 6. Aggregate by gender and product category

sales_group = df.pivot_table(

    index="Gender",

    columns="Product Category",

    values="Total Amount",

    aggfunc="sum",

    fill_value=0

)


print("\nSales by Gender and Category:")

print(sales_group)


# 7. Stacked bar plot

sales_group.plot(kind="bar", stacked=True)


plt.title("Sales by Gender and Product Category")

plt.ylabel("Total Sales")

plt.tight_layout()

plt.show()



Practical 7 – Weather API Data Analysis


import requests

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns


# 1. API Configuration

API_KEY = "YOUR_API_KEY"

CITY = "Pune"


url = "https://api.openweathermap.org/data/2.5/forecast"


params = {

    "q": CITY,

    "appid": API_KEY,

    "units": "metric"

}


# 2. Retrieve Weather Data

response = requests.get(url, params=params, timeout=20)


if response.status_code != 200:

    print("API Error:", response.status_code, response.text)


else:

    data = response.json()


    # 3. Extract Weather Attributes

    records = []


    for item in data["list"]:

        records.append({

            "Date": item["dt_txt"],

            "Temperature": item["main"].get("temp"),

            "Humidity": item["main"].get("humidity"),

            "WindSpeed": item["wind"].get("speed"),

            "Precipitation": item.get("rain", {}).get("3h", 0)

        })


    df = pd.DataFrame(records)


    # 4. Clean and Preprocess Data

    df["Date"] = pd.to_datetime(df["Date"], errors="coerce")


    cols = ["Temperature", "Humidity", "WindSpeed", "Precipitation"]


    df[cols] = df[cols].apply(pd.to_numeric, errors="coerce")


    df = df.dropna(

        subset=["Date", "Temperature", "Humidity", "WindSpeed"]

    )


    print("Weather Data:\n", df.head())


    # 5. Statistical Analysis

    print("\nWeather Statistics:\n", df[cols].describe())


    print("\nAverage Temperature:",

          round(df["Temperature"].mean(), 2), "°C")


    print("Maximum Temperature:",

          df["Temperature"].max(), "°C")


    print("Minimum Temperature:",

          df["Temperature"].min(), "°C")


    # 6. Daily Aggregation

    df["Day"] = df["Date"].dt.date


    daily = df.groupby("Day")[cols].mean()


    print("\nDaily Weather Summary:\n", daily)


    # 7. Temperature Line Plot

    plt.figure(figsize=(10, 5))


    plt.plot(df["Date"], df["Temperature"], marker="o")


    plt.title("Temperature Forecast for " + CITY)

    plt.xlabel("Date and Time")

    plt.ylabel("Temperature (°C)")


    plt.xticks(rotation=45)

    plt.tight_layout()

    plt.show()


    # 8. Humidity and Wind Speed

    daily[["Humidity", "WindSpeed"]].plot(

        kind="bar",

        figsize=(10, 5)

    )


    plt.title("Daily Humidity and Wind Speed")

    plt.tight_layout()

    plt.show()


    # 9. Correlation Heatmap

    plt.figure(figsize=(7, 5))


    sns.heatmap(

        df[cols].corr(),

        annot=True,

        cmap="coolwarm",

        fmt=".2f"

    )


    plt.title("Weather Attribute Correlation")

    plt.tight_layout()

    plt.show()


    # 10. Save Results

    df.to_csv("weather_data.csv", index=False)


    print("\nWeather data saved successfully.")


Practical 8 – Data Wrangling on Real Estate Dataset


import pandas as pd

import numpy as np


# 1. Import dataset

df = pd.read_csv("RealEstate_Prices.csv")


print("First five records:")

print(df.head())


print("\nDataset shape:", df.shape)


# Clean column names

df.columns = (

    df.columns.str.strip()

    .str.lower()

    .str.replace(r"[^a-z0-9]+", "_", regex=True)

    .str.strip("_")

)


print("\nCleaned columns:", df.columns.tolist())


# 2. Handle missing values

for col in df.columns:

    if df[col].isnull().any():

        if pd.api.types.is_numeric_dtype(df[col]):

            df[col] = df[col].fillna(df[col].median())

        else:

            mode = df[col].mode()

            if not mode.empty:

                df[col] = df[col].fillna(mode[0])


print("\nMissing values:")

print(df.isnull().sum())


# 3. Merge additional dataset if available

# Example:

# extra = pd.read_csv("Neighborhood_Data.csv")

# extra.columns = extra.columns.str.strip().str.lower()

# df = df.merge(extra, on="neighborhood", how="left")


# 4. Filter and subset data

if "sale_price" in df.columns:

    df = df[df["sale_price"] > 0]


if "property_type" in df.columns:

    print("\nProperty types:")

    print(df["property_type"].value_counts())


# 5. Encode categorical variables

categorical_cols = df.select_dtypes(

    include=["object", "category"]

).columns.tolist()


df_encoded = pd.get_dummies(

    df,

    columns=categorical_cols,

    dtype=int

)


print("\nEncoded dataset:")

print(df_encoded.head())


# 6. Aggregate data

if "neighborhood" in df.columns and "sale_price" in df.columns:

    print("\nAverage sale price by neighborhood:")

    print(

        df.groupby("neighborhood")["sale_price"]

        .mean().sort_values(ascending=False)

    )


if "property_type" in df.columns and "sale_price" in df.columns:

    print("\nAverage price by property type:")

    print(df.groupby("property_type")["sale_price"].mean())


# 7. Detect and handle outliers using IQR

numeric_cols = df.select_dtypes(include=np.number).columns


for col in numeric_cols:

    Q1 = df[col].quantile(0.25)

    Q3 = df[col].quantile(0.75)


    IQR = Q3 - Q1


    lower = Q1 - 1.5 * IQR

    upper = Q3 + 1.5 * IQR


    count = ((df[col] < lower) | (df[col] > upper)).sum()


    print(f"{col}: {count} potential outliers")


    # Cap extreme values instead of deleting records

    df[col] = df[col].clip(lower=lower, upper=upper)













Comments

Popular posts from this blog

TE ANN Practical

CL1 Practical

DS Lab Practical