CL1
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
Post a Comment