CL1 Manual
'''''''''1st practical(1a) : pca algorithm for dimensionality reduction(wine dataset)'''''''''''''
# 1. Principal Component Analysis (PCA)
# https://media.geeksforgeeks.org/wp-content/uploads/Wine.csv?utm_source=chatgpt.com
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
# Load dataset
df = pd.read_csv("Wine.csv")
# 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 1b: L D A algorithm on iris dataset''''''''''''''''''''''''''''''''''''''''''
dataset link:
https://uci-ics-mlr-prod.aws.uci.edu/dataset/53/iris?utm_source=chatgpt.com
# 8. LDA - Iris Dataset Classification
# Import required libraries
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
# 1. Load Iris Dataset
iris = load_iris()
df = pd.DataFrame(
iris.data,
columns=[
"SepalLengthCm",
"SepalWidthCm",
"PetalLengthCm",
"PetalWidthCm"
]
)
df["Species"] = iris.target_names[iris.target]
print("First five records:")
print(df.head())
print("\nDataset shape:", df.shape)
print("\nUnique Species:")
print(df["Species"].unique())
# 2. Separate Features and Target
X = df.drop("Species", axis=1)
y = df["Species"]
# 3. Split Data into Training and Testing Sets
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2,
random_state=42,
stratify=y
)
# 4. Scale the Features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 5. Apply Linear Discriminant Analysis
lda = LinearDiscriminantAnalysis(n_components=2)
X_train_lda = lda.fit_transform(X_train_scaled, y_train)
X_test_lda = lda.transform(X_test_scaled)
# 6. Train Logistic Regression Classifier
classifier = LogisticRegression()
classifier.fit(X_train_lda, y_train)
# 7. Predict Results
y_pred = classifier.predict(X_test_lda)
# 8. Evaluate Model
print("\nAccuracy:",
round(accuracy_score(y_test, y_pred) * 100, 2), "%")
print("\nClassification Report:")
print(classification_report(y_test, y_pred))
# 9. Predict a New Flower
new_flower = [[6.7, 3.0, 5.2, 2.3]]
# Scale the new flower
new_flower_scaled = scaler.transform(new_flower)
# Apply LDA
new_flower_lda = lda.transform(new_flower_scaled)
# Predict Species
predicted_species = classifier.predict(new_flower_lda)
print("\nPredicted Species:", predicted_species[0])
''''''''pactical 2(a):uberfaree.....................''''''''''''''''''''
https://www.kaggle.com/datasets/yasserh/uber-fares-dataset?resource=download
# 2. Uber Fare Prediction
# Import required libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
# 1. Load dataset from local CSV file
df = pd.read_csv("uber.csv")
print("First five records:")
print(df.head())
print("\nDataset Shape:", df.shape)
# 2. Preprocess the dataset
df.drop(columns=["Unnamed: 0", "key"],
errors="ignore", inplace=True)
df.dropna(inplace=True)
df["pickup_datetime"] = pd.to_datetime(
df["pickup_datetime"], errors="coerce", utc=True
)
df.dropna(subset=["pickup_datetime"], inplace=True)
# Extract time features
df["hour"] = df["pickup_datetime"].dt.hour
df["day"] = df["pickup_datetime"].dt.day
df["month"] = df["pickup_datetime"].dt.month
df["year"] = df["pickup_datetime"].dt.year
# Remove invalid values and coordinates outside NYC area
df = df[
(df["fare_amount"] > 0) &
(df["passenger_count"].between(1, 6)) &
(df["pickup_longitude"].between(-75, -72)) &
(df["dropoff_longitude"].between(-75, -72)) &
(df["pickup_latitude"].between(40, 42)) &
(df["dropoff_latitude"].between(40, 42))
].copy()
# 3. Calculate trip distance using Haversine formula
def distance_km(lat1, lon1, lat2, lon2):
lat1, lon1, lat2, lon2 = map(
np.radians, [lat1, lon1, lat2, lon2]
)
dlat = lat2 - lat1
dlon = lon2 - lon1
a = (
np.sin(dlat / 2) ** 2
+ np.cos(lat1) * np.cos(lat2)
* np.sin(dlon / 2) ** 2
)
return 6371 * 2 * np.arcsin(np.sqrt(a))
df["distance_km"] = distance_km(
df["pickup_latitude"],
df["pickup_longitude"],
df["dropoff_latitude"],
df["dropoff_longitude"]
)
# Remove zero-distance trips
df = df[df["distance_km"] > 0].copy()
# 4. Identify and remove outliers using IQR
print("\nRows before outlier removal:", len(df))
for col in ["fare_amount", "distance_km"]:
q1 = df[col].quantile(0.25)
q3 = df[col].quantile(0.75)
iqr = q3 - q1
lower = max(0, q1 - 1.5 * iqr)
upper = q3 + 1.5 * iqr
print(f"{col} outlier bounds: {lower:.2f} to {upper:.2f}")
df = df[df[col].between(lower, upper)].copy()
print("Rows after outlier removal:", len(df))
# 5. Correlation analysis
features = [
"fare_amount", "pickup_longitude", "pickup_latitude",
"dropoff_longitude", "dropoff_latitude",
"passenger_count", "hour", "day", "month",
"year", "distance_km"
]
plt.figure(figsize=(10, 7))
sns.heatmap(
df[features].corr(),
annot=True,
cmap="coolwarm",
fmt=".2f"
)
plt.title("Correlation Matrix")
plt.tight_layout()
plt.show()
# 6. Select features and target
X = df.drop(columns=["fare_amount", "pickup_datetime"])
y = df["fare_amount"]
# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# 7. Implement regression models
models = {
"Linear Regression": make_pipeline(
StandardScaler(),
LinearRegression()
),
"Ridge Regression": make_pipeline(
StandardScaler(),
Ridge(alpha=1.0)
),
"Lasso Regression": make_pipeline(
StandardScaler(),
Lasso(alpha=0.01, max_iter=10000)
)
}
results = []
for name, model in models.items():
model.fit(X_train, y_train)
predictions = model.predict(X_test)
r2 = r2_score(y_test, predictions)
rmse = np.sqrt(mean_squared_error(y_test, predictions))
mae = mean_absolute_error(y_test, predictions)
results.append([name, r2, rmse, mae])
# 8. Display model comparison
results_df = pd.DataFrame(
results,
columns=["Model", "R2 Score", "RMSE", "MAE"]
)
print("\nRegression Model Performance:")
print(results_df.round(4).to_string(index=False))
# 9. Plot model comparison
plt.figure(figsize=(8, 5))
plt.bar(results_df["Model"], results_df["R2 Score"])
plt.ylabel("R2 Score")
plt.title("Comparison of Regression Models")
plt.xticks(rotation=15)
plt.tight_layout()
plt.show()
# 10. Display sample predictions using the best R2 model
best_model_name = results_df.loc[
results_df["R2 Score"].idxmax(), "Model"
]
best_model = models[best_model_name]
predictions = best_model.predict(X_test)
print("\nBest Model:", best_model_name)
print("\nSample Predictions:")
comparison = pd.DataFrame({
"Actual Fare": y_test.iloc[:10].values,
"Predicted Fare": predictions[:10]
})
print(comparison.round(2))
'''''''''''''''''''practical 2b: diabetess for univariate data analysis'''''''''''''''''''''''''''''''''''''''
import pandas as pd
import warnings
warnings.filterwarnings("ignore")
# Load dataset
url = "https://raw.githubusercontent.com/plotly/datasets/master/diabetes.csv"
df = pd.read_csv(url)
# Display first five records
print("First five records:")
print(df.head())
# Display dataset shape
print("\nDataset Shape:")
print(df.shape)
# Statistical description
print("\nStatistical Description:")
print(df.describe())
# Univariate Analysis
for column in df.columns:
print("\n====================================")
print("Column Name:", column)
print("====================================")
# Frequency distribution
print("\nFrequency:")
print(df[column].value_counts())
# Mean
print("\nMean:")
print(df[column].mean())
# Median
print("\nMedian:")
print(df[column].median())
# Mode
print("\nMode:")
print(df[column].mode())
# Variance
print("\nVariance:")
print(df[column].var())
# Standard Deviation
print("\nStandard Deviation:")
print(df[column].std())
# Skewness
print("\nSkewness:")
print(df[column].skew())
# Kurtosis
print("\nKurtosis:")
print(df[column].kurt())
'''''practical 3(a):handwritten digitsss.....................''''''''''
no need to download dataset
# 3. Handwritten Digit Classification using SVM
# Import required libraries
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,
random_state=42,
stratify=y
)
# 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 the model
print("\nAccuracy:", 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])
# 9. Display actual and predicted digit images
fig, axes = plt.subplots(1, 5, figsize=(10, 3))
for i, ax in enumerate(axes):
ax.imshow(X_test[i].reshape(8, 8), cmap="gray")
ax.set_title(f"Actual: {y_test[i]}\nPredicted: {y_pred[i]}")
ax.axis("off")
plt.tight_layout()
plt.show()
''''''''''''''''''''''''''''''practical 3(b):K N N on social network add datasett '''''''''''''''''''''''''''''''''
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score
# Load dataset directly from URL
url = "https://raw.githubusercontent.com/mk-gurucharan/Classification/master/SocialNetworkAds.csv"
df = pd.read_csv(url) #give csv file name in double quotes if file is downloaded extrenally by you
# Display dataset
print("First five records:")
print(df.head())
print("\nDataset Shape:")
print(df.shape)
# Select input and output
X = df[["Age", "EstimatedSalary"]]
y = df["Purchased"]
# Split dataset
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, random_state=42, stratify=y
)
# Feature scaling
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Create KNN model
model = KNeighborsClassifier(n_neighbors=5)
# Train model
model.fit(X_train, y_train)
# Prediction
y_pred = model.predict(X_test)
# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
# Evaluation metrics
accuracy = accuracy_score(y_test, y_pred)
error = 1 - accuracy
precision = precision_score(y_test, y_pred, zero_division=0)
recall = recall_score(y_test, y_pred, zero_division=0)
# Display results
print("\nConfusion Matrix:\n", cm)
print("Accuracy:", round(accuracy * 100, 2), "%")
print("Error Rate:", round(error * 100, 2), "%")
print("Precision:", round(precision, 2))
print("Recall:", round(recall, 2))
'''''''practical 4(a):iris data set k means clustering''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
https://www.kaggle.com/datasets/uciml/iris?utm_source=chatgpt.com
# 4. K-Means Iris Clustering
# Import required libraries
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.datasets import load_iris
import warnings
warnings.filterwarnings("ignore")
# 1. Load Iris Dataset
iris = load_iris()
df = pd.DataFrame(
iris.data,
columns=iris.feature_names
)
print("First five records:")
print(df.head())
print("\nDataset shape:", df.shape)
# 2. Select numerical features
X = df.select_dtypes(include="number")
# 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.figure(figsize=(8, 5))
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
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.grid(True)
plt.show()
''''''''''''''''''''''practical 4(b):to implement k-medoids clustering algo on credit card dataset and determine optimal no of clusters using sihouette method'''''''''''''''''''''''''''
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score
from sklearn.metrics import pairwise_distances, pairwise_distances_argmin
# Load dataset directly from URL
url = "https://raw.githubusercontent.com/RAHULKASHYAP02/Credit-Card-Segmentation/master/CC%20GENERAL.csv"
df = pd.read_csv(url)
print("First five records:")
print(df.head())
print("\nDataset Shape:")
print(df.shape)
# Remove customer ID
X = df.drop(columns=["CUST_ID"], errors="ignore")
# Select numerical columns
X = X.select_dtypes(include=np.number)
# Handle missing values
X = SimpleImputer(strategy="median").fit_transform(X)
# Feature scaling
X = StandardScaler().fit_transform(X)
# Use a sample to make K-Medoids faster
rng = np.random.default_rng(42)
sample_size = min(1500, len(X))
sample_indices = rng.choice(len(X), sample_size, replace=False)
X_sample = X[sample_indices]
# K-Medoids implementation using alternate updates
def k_medoids(X, k, max_iter=30, random_state=42):
rng = np.random.default_rng(random_state)
# Calculate distance matrix
distances = pairwise_distances(X, metric="euclidean")
# Randomly select initial medoids
medoids = rng.choice(len(X), k, replace=False)
for iteration in range(max_iter):
# Assign points to nearest medoid
labels = np.argmin(distances[:, medoids], axis=1)
old_medoids = medoids.copy()
# Update medoids
for cluster in range(k):
members = np.where(labels == cluster)[0]
if len(members) == 0:
continue
cluster_distances = distances[np.ix_(members, members)]
total_distances = cluster_distances.sum(axis=1)
medoids[cluster] = members[np.argmin(total_distances)]
if np.array_equal(old_medoids, medoids):
break
labels = np.argmin(distances[:, medoids], axis=1)
return medoids, labels
# Calculate Silhouette Scores
scores = []
K = range(2, 7)
for k in K:
medoids, labels = k_medoids(
X_sample, k, random_state=42
)
score = silhouette_score(
X_sample,
labels,
sample_size=min(1000, len(X_sample)),
random_state=42
)
scores.append(score)
print("K =", k, "Silhouette Score =", round(score, 4))
# Find optimal number of clusters
best_k = list(K)[np.argmax(scores)]
print("\nOptimal Number of Clusters:", best_k)
# Plot Silhouette Scores
plt.plot(list(K), scores, marker="o")
plt.xlabel("Number of Clusters (K)")
plt.ylabel("Silhouette Score")
plt.title("Silhouette Method - K-Medoids")
plt.show()
# Final model using the sample
medoids, sample_labels = k_medoids(
X_sample, best_k, random_state=42
)
# Assign all customers to their nearest medoid
df["Cluster"] = pairwise_distances_argmin(
X, X_sample[medoids]
)
# Display cluster counts
print("\nCluster Counts:")
print(df["Cluster"].value_counts().sort_index())
# Display sample results
print("\nSample Results:")
print(df[["CUST_ID", "Cluster"]].head())
'''''''''''''practical 5(a):random foresstt---car safety
no need to download dataset
# 5. Random Forest Car Safety Classification
# Import required libraries
import warnings
warnings.filterwarnings("ignore")
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.metrics import ConfusionMatrixDisplay
# 1. Load Dataset
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/car/car.data"
columns = [
"buying", "maint", "doors", "persons",
"lug_boot", "safety", "class"
]
df = pd.read_csv(url, header=None, names=columns)
print("First five records:")
print(df.head())
print("\nDataset shape:", df.shape)
# 2. Encode Categorical Values
encoders = {}
for col in df.columns:
encoders[col] = LabelEncoder()
df[col] = encoders[col].fit_transform(df[col])
# 3. Separate Features and Target
X = df.drop("class", axis=1)
y = df["class"]
# 4. Split Dataset
x_train, x_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2,
random_state=42,
stratify=y
)
# 5. Train Random Forest Model
model = RandomForestClassifier(
n_estimators=100,
random_state=42
)
model.fit(x_train, y_train)
# 6. Predict Results
y_pred = model.predict(x_test)
# 7. Evaluate Model
print("\nAccuracy:",
round(accuracy_score(y_test, y_pred) * 100, 2), "%")
print("\nClassification Report:")
print(classification_report(
y_test,
y_pred,
labels=range(len(encoders["class"].classes_)),
target_names=encoders["class"].classes_,
zero_division=0
))
# 8. Display Confusion Matrix
ConfusionMatrixDisplay.from_predictions(
y_test,
y_pred,
display_labels=encoders["class"].classes_,
cmap="Blues"
)
plt.title("Random Forest - Car Evaluation")
plt.show()
# 9. Feature Importance
plt.figure(figsize=(8, 5))
plt.bar(X.columns, model.feature_importances_)
plt.xlabel("Features")
plt.ylabel("Importance")
plt.title("Feature Importance")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
''''''''''''''''''''''practical 5b:(may be wronggggggggggggggggg)
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix, accuracy_score
# Load digits dataset
digits = load_digits()
print(digits.DESCR)
# Display dataset information
print("Feature Names:")
print(digits.feature_names)
print("\nTarget Names:")
print(digits.target_names)
# Display first four handwritten digit images
plt.figure(figsize=(8, 4))
for i in range(4):
plt.subplot(2, 2, i + 1)
plt.imshow(digits.images[i], cmap="gray")
plt.title("Digit: " + str(digits.target[i]))
plt.axis("off")
plt.tight_layout()
plt.show()
# Convert dataset into DataFrame
df = pd.DataFrame(digits.data)
print("\nFirst five records:")
print(df.head())
# Add target column
df["target"] = digits.target
print("\nDataset with target:")
print(df.head(12))
print("\nDataset Shape:")
print(df.shape)
# Train and test data
X = df.drop("target", axis="columns")
y = df["target"]
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
# Random Forest Classifier
model = RandomForestClassifier(n_estimators=20, random_state=42)
# Train model
model.fit(X_train, y_train)
# Check accuracy
print("\nModel Accuracy:")
print(model.score(X_test, y_test))
# Predict output
y_predicted = model.predict(X_test)
# Confusion Matrix
cm = confusion_matrix(y_test, y_predicted)
print("\nConfusion Matrix:")
print(cm)
# Display confusion matrix using heatmap
plt.figure(figsize=(10, 7))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.xlabel("Predicted")
plt.ylabel("Truth")
plt.title("Confusion Matrix - Random Forest")
plt.show()
# Accuracy percentage
accuracy = accuracy_score(y_test, y_predicted)
print("Accuracy:", round(accuracy * 100, 2), "%")
'''''''''''''''practical 6(a):taxi reinforcement
(to implement reinforcement learning for an agent to explore.......................................)

# 6. Q-Learning Taxi Environment
# Import required libraries
import gymnasium as gym
import numpy as np
# 1. Create Taxi Environment
env = gym.make("Taxi-v4")
# 2. Initialize Q-table
q_table = np.zeros((
env.observation_space.n,
env.action_space.n
))
# 3. Parameters
alpha = 0.1
gamma = 0.9
epsilon = 0.1
episodes = 5000
# 4. Training
for episode in range(episodes):
state, info = env.reset()
done = False
while not done:
# Choose action
if np.random.random() < epsilon:
action = env.action_space.sample()
else:
action = np.argmax(q_table[state])
# Perform action
next_state, reward, terminated, truncated, info = env.step(action)
done = terminated or truncated
# Update Q-table
q_table[state, action] += alpha * (
reward +
gamma * np.max(q_table[next_state]) * (not terminated)
- q_table[state, action]
)
state = next_state
# 5. Testing
state, info = env.reset()
done = False
total_reward = 0
while not done:
action = np.argmax(q_table[state])
state, reward, terminated, truncated, info = env.step(action)
done = terminated or truncated
total_reward += reward
# 6. Display Results
print("Taxi task completed!")
print("Total reward:", total_reward)
env.close()
''''''''''''''''''''practical 7: sales data analysis from multiple file formatss'''''''''''''''''''''''''''''''''''''''''''''
# 7. Sales Data Analysis
# Import required libraries
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 8: INTERACTING WITH WEB API S''''''''''''''''''''''''''''''''''''
weather data,,,,,,,,,,,,,,,,,,,
# https://www.kaggle.com/datasets/sandeepshelp/weather-data-csv
# 8. Weather API Analysis
import requests
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# API configuration
API_KEY = "f4f2233b231b5891a7ecddf7a92b1d19"
CITY = "Pune"
url = "https://api.openweathermap.org/data/2.5/forecast"
params = {
"q": CITY,
"appid": API_KEY,
"units": "metric"
}
# 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()
# 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)
# 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())
# 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"
)
# Daily aggregation
df["Day"] = df["Date"].dt.date
daily = df.groupby("Day")[cols].mean()
print("\nDaily Weather Summary:\n", daily)
# 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()
# 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()
# 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()
# Save results
df.to_csv(
"weather_data.csv",
index=False
)
print("\nWeather data saved successfully.")
#
''''''''''''''''''''''''''''PRACTICAL 9: CUSTOMER CHURN IN A TELECOMMUNICATION COMPANY''''''''''
# https://www.kaggle.com/datasets/blastchar/telco-customer-churn?utm_source=chatgpt.com
# 9. Data Cleaning and Preparation
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
# 1. Import dataset
df = pd.read_csv("WA_Fn-UseC_-Telco-Customer-Churn.csv")
# 2. Explore dataset
print("First five records:")
print(df.head())
print("\nDataset shape:", df.shape)
print("\nColumn information:")
df.info()
print("\nMissing values:")
print(df.isnull().sum())
print("\nStatistical summary:")
print(df.describe(include="all"))
# 3. 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])
# 4. Remove duplicate records
df = df.drop_duplicates()
# 5. Standardize text columns
for col in df.select_dtypes(include="object").columns:
df[col] = df[col].str.strip()
# 6. Convert TotalCharges if present
if "TotalCharges" in df.columns:
df["TotalCharges"] = pd.to_numeric(
df["TotalCharges"],
errors="coerce"
)
df["TotalCharges"] = df["TotalCharges"].fillna(
df["TotalCharges"].median()
)
# 7. Detect 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
outliers = df[
(df[col] < Q1 - 1.5 * IQR) |
(df[col] > Q3 + 1.5 * IQR)
]
print(f"{col}: {len(outliers)} potential outliers")
# 8. Feature engineering
if "tenure" in df.columns:
df["TenureGroup"] = pd.cut(
df["tenure"],
bins=[-1, 12, 24, 48, np.inf],
labels=["0-12", "13-24", "25-48", "49+"]
)
# 9. Scale numerical features
scale_cols = [
c for c in ["tenure", "MonthlyCharges", "TotalCharges"]
if c in df.columns
]
if scale_cols:
scaler = StandardScaler()
df[[c + "_Scaled" for c in scale_cols]] = (
scaler.fit_transform(df[scale_cols])
)
# 10. Split dataset into training and testing sets
from sklearn.model_selection import train_test_split
X = df.drop("Churn", axis=1)
y = df["Churn"]
X_train, X_test, y_train, y_test = train_test_split(
X,
y,
test_size=0.2,
random_state=42,
stratify=y
)
print("Training data shape:", X_train.shape)
print("Testing data shape:", X_test.shape)
# 11. Export cleaned dataset
df.to_csv(
"Cleaned_Telecom_Customer_Churn.csv",
index=False
)
print("Cleaned dataset exported successfully.")
'''''''''''''''''PRACTICAL 10: DATA WRANGLING ON REAL ESTATE MARKET'''''''''''''''''''''''''
# https://www.kaggle.com/datasets/mohammadnaserian/real-estate-prices-2015
# 10. Data Wrangling - Real Estate
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: Uncomment and modify if a neighborhood dataset exists.
# 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
)
# Export cleaned and encoded datasets
df.to_csv(
"Cleaned_RealEstate_Prices.csv",
index=False
)
df_encoded.to_csv(
"Encoded_RealEstate_Prices.csv",
index=False
)
print("\nData wrangling completed successfully.")
print("Cleaned dataset saved.")
print("Encoded dataset saved.")
'''''''''''''''''''''''''''practical 11:analysing aqi tren in a city''''''''''''''''''''''''''''''''''''''
# https://www.kaggle.com/datasets/hirenvora/city-daycsv
# 11. AQI 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 12: SALES PERFORMANCE BY REGION IN A RETAIL COMPANY''''''''''''''''''''
# https://www.kaggle.com/datasets/mohammadtalib786/retail-sales-dataset?resource=download
# 12. Data Aggregation
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()
Comments
Post a Comment