[Approved by AICTE, Govt. of India & Affiliated to Dr.
APJ Abdul Kalam
Technical University, Lucknow, U.P., India]
Department of Computer Science & Engineering (AI)
Lab File
Data Analytics Lab
(BADS651)
ACADEMIC SESSION 2024-25
COURSE: B. TECH (CSE-AI)
SEM: VI
Submitted to: Submitted by:
Mr. Piyush Kushwaha Yugank Singh
Assistant Professor 2201921520200
CSE(AI) Department
INDEX
Date of Date of
S. No. List of Programs Signature
Experiment Submission
To get the input from user and perform
numerical operations (MAX, MIN,
1.
AVG, SUM, SQRT, ROUND) using in
Python.
To perform data import/export (.CSV,
2. .XLS, .TXT) operations using data
frames in Python.
To get the input matrix from user and
perform Matrix addition, subtraction,
3. multiplication, inverse transpose and
division operations using vector concept
in Python.
To perform statistical operations (Mean,
4. Median, Mode and Standard deviation)
using Python.
To perform data pre-processing
5. operations i) Handling Missing data ii)
Min-Max normalization.
To perform dimensionality reduction
6. operation using PCA for Houses Data
Set.
To perform Simple Linear Regression
7. with Python.
To perform K-Means clustering
8.
operation and visualize for iris data set.
Write Python script to diagnose any
9. disease using KNN classification and
plot the results.
To perform market basket analysis using
10.
Association Rules (Apriori).
Program – 1
Aim: To get the input from user and perform numerical operations (MAX, MIN,
AVG, SUM, SQRT, ROUND) using in Python.
Program:
import math
# Function to perform all the operations
def perform_operations():
# Get a list of numbers from the user (space-separated)
user_input = input("Enter numbers separated by space: ")
# Convert the input string into a list of numbers
numbers = list(map(float, user_input.split()))
# Perform the operations
max_value = max(numbers)
min_value = min(numbers)
sum_value = sum(numbers)
avg_value = sum_value / len(numbers) if len(numbers) > 0 else 0
sqrt_values = [math.sqrt(num) for num in numbers]
rounded_values = [round(num, 2) for num in numbers]
# Display the results
print(f"Max Value: {max_value}")
print(f"Min Value: {min_value}")
print(f"Sum: {sum_value}")
print(f"Average: {avg_value}")
print(f"Square Root of each number: {sqrt_values}")
print(f"Rounded values (to 2 decimal places): {rounded_values}")
1
# Call the function
perform_operations()
Output:
2
Program – 2
Aim: To perform data import/export (.CSV, .XLS, .TXT) operations using data
frames in Python.
Program:
import pandas as pd
# Correct file paths using raw string (r"") or double backslashes (\\)
csv_path = r"D:\GL BAJAJ\DAata Analytics\customers-100.csv"
excel_path = r"D:\GL BAJAJ\DAata Analytics\Project-Management-Sample-Data.xlsx"
txt_path = r"D:\GL BAJAJ\DAata Analytics\sample-1.txt"
# Load CSV File
try:
csv_data = pd.read_csv(csv_path)
print("\nCSV Data:\n", csv_data.head()) # Show first 5 rows
except Exception as e:
print("Error loading CSV file:", e)
# Load Excel File
try:
excel_data = pd.read_excel(excel_path)
print("\nExcel Data:\n", excel_data.head()) # Show first 5 rows
except Exception as e:
print("Error loading Excel file:", e)
# Load TXT File (Tab-Separated)
try:
txt_data = pd.read_csv(txt_path, sep="\t", engine="python", on_bad_lines="skip") #
Auto-detect separator
3
print("\nTXT Data:\n", txt_data.head()) # Show first 5 rows
except Exception as e:
print("Error loading TXT file:", e)
4
Output:
5
Program – 3
Aim: To get the input matrix from user and perform Matrix addition,
subtraction, multiplication, inverse transpose and division operations using
vector concept in Python.
Program:
import numpy as np
# Function to get a matrix input from the user
def get_matrix_input():
rows = int(input("Enter number of rows for the matrix: "))
cols = int(input("Enter number of columns for the matrix: "))
print(f"Enter the elements of the {rows}x{cols} matrix (row by row):")
matrix = []
for i in range(rows):
row = list(map(float, input(f"Enter elements for row {i+1} separated by space: ").split()))
matrix.append(row)
return np.array(matrix)
# Function to perform matrix operations
def perform_operations(matrix1, matrix2):
try:
# Matrix Addition
matrix_addition = matrix1 + matrix2
print("Matrix Addition:\n", matrix_addition)
6
# Matrix Subtraction
matrix_subtraction = matrix1 - matrix2
print("Matrix Subtraction:\n", matrix_subtraction)
# Matrix Multiplication
matrix_multiplication = np.dot(matrix1, matrix2)
print("Matrix Multiplication:\n", matrix_multiplication)
# Matrix Inverse (if square matrix)
if matrix1.shape[0] == matrix1.shape[1]:
matrix_inverse = np.linalg.inv(matrix1)
print("Matrix Inverse:\n", matrix_inverse)
else:
print("Matrix 1 is not square, so inverse cannot be computed.")
# Matrix Transpose
matrix_transpose = np.transpose(matrix1)
print("Matrix Transpose:\n", matrix_transpose)
# Matrix Division (element-wise division)
matrix_division = np.divide(matrix1, matrix2)
print("Matrix Division (element-wise):\n", matrix_division)
except Exception as e:
print(f"Error during matrix operations: {e}")
# Main driver code
def main():
print("Matrix Operations")
7
# Get user input for two matrices
print("Enter the first matrix:")
matrix1 = get_matrix_input()
print("Enter the second matrix:")
matrix2 = get_matrix_input()
# Perform the operations
perform_operations(matrix1, matrix2)
# Run the program
main()
Output:
8
Program – 4
Aim: To perform statistical operations (Mean, Median, Mode and Standard
deviation) using Python.
Program:
import statistics
# Function to perform statistical operations
def perform_statistical_operations():
# Get user input for the data
data = list(map(float, input("Enter numbers separated by space: ").split()))
# Mean
mean_value = statistics.mean(data)
print(f"Mean: {mean_value}")
# Median
median_value = statistics.median(data)
print(f"Median: {median_value}")
# Mode
try:
mode_value = statistics.mode(data)
print(f"Mode: {mode_value}")
except statistics.StatisticsError:
print("Mode: No unique mode (multiple modes or no mode)")
# Standard Deviation
stdev_value = statistics.stdev(data)
9
print(f"Standard Deviation: {stdev_value}")
# Call the function
perform_statistical_operations()
Output:
10
Program – 5
Aim: To perform data pre-processing operations i) Handling Missing data ii)
Min-Max normalization.
Program:
i) Handling Missing Data in Python:
import pandas as pd
import numpy as np
# Create a sample DataFrame with missing data
data = {
'A': [1, 2, np.nan, 4, 5],
'B': [5, np.nan, 7, 8, 9],
'C': [10, 11, 12, np.nan, 14]
}
df = pd.DataFrame(data)
print("Original DataFrame with Missing Data:")
print(df)
# i. Remove rows with any missing values
df_dropna = df.dropna()
print("\nDataFrame after removing rows with missing values:")
print(df_dropna)
# ii. Fill missing values with the mean of the column
df_fill_mean = df.fillna(df.mean())
print("\nDataFrame after filling missing values with column mean:")
print(df_fill_mean)
# iii. Fill missing values with a specific value (e.g., 0)
df_fill_zero = df.fillna(0)
print("\nDataFrame after filling missing values with 0:")
print(df_fill_zero)
# iv. Forward fill missing values (using the previous value)
df_fill_forward = df.fillna(method='ffill')
print("\nDataFrame after forward filling missing values:")
11
print(df_fill_forward)
# v. Backward fill missing values (using the next value)
df_fill_backward = df.fillna(method='bfill')
print("\nDataFrame after backward filling missing values:")
print(df_fill_backward)
Output:
12
ii) Min-Max Normalization in Python:
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
# Create a sample DataFrame
data = {
'A': [1, 2, 3, 4, 5],
'B': [10, 20, 30, 40, 50],
'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)
print("Original DataFrame:")
print(df)
# Using pandas to perform Min-Max Normalization
df_min_max = (df - df.min()) / (df.max() - df.min())
print("\nDataFrame after Min-Max Normalization (using pandas):")
print(df_min_max)
# Alternatively, using scikit-learn's MinMaxScaler
scaler = MinMaxScaler()
df_scaled = pd.DataFrame(scaler.fit_transform(df), columns=df.columns)
print("\nDataFrame after Min-Max Normalization (using scikit-learn):")
print(df_scaled)
Output:
13
14
Program – 6
Aim: To perform dimensionality reduction operation using PCA for Houses Data
Set.
Program:
# Import necessary libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
# Load the dataset (Ensure the correct file path)
file_path = "D:\GL BAJAJ\DAata Analytics\House price data .xlsx" # Use raw string (r"")
df = pd.read_excel(file_path, engine="openpyxl") # Ensure openpyxl is installed
# Display the first few rows
print("Original Dataset:\n", df.head())
# Step 1: Select numerical features for PCA
numeric_features = df.select_dtypes(include=[np.number]) # Select only numeric columns
numeric_features = numeric_features.dropna() # Drop rows with missing values
# Step 2: Standardize the Data (PCA works better with scaled data)
scaler = StandardScaler()
scaled_data = scaler.fit_transform(numeric_features)
# Step 3: Apply PCA (Reduce to 2 principal components)
pca = PCA(n_components=2)
15
pca_result = pca.fit_transform(scaled_data)
# Step 4: Analyze Explained Variance
explained_variance = pca.explained_variance_ratio_ * 100
print("\nExplained Variance by Each Principal Component:", explained_variance)
# Step 5: Create a DataFrame for PCA results
pca_df = pd.DataFrame(data=pca_result, columns=["PC1", "PC2"])
print("\nPCA Transformed Data (First 5 Rows):\n", pca_df.head())
# Step 6: Plot the PCA Components
plt.figure(figsize=(8, 5))
plt.scatter(pca_result[:, 0], pca_result[:, 1], c="blue", alpha=0.5)
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.title("PCA on House Prices Dataset")
plt.grid()
plt.show()
# Step 7: Check cumulative explained variance for all components
pca_full = PCA().fit(scaled_data)
cumulative_variance = np.cumsum(pca_full.explained_variance_ratio_) * 100
# Plot cumulative explained variance
plt.figure(figsize=(8, 5))
plt.plot(range(1, len(cumulative_variance) + 1), cumulative_variance, marker="o",
linestyle="--", color="red")
plt.xlabel("Number of Principal Components")
plt.ylabel("Cumulative Explained Variance (%)")
plt.title("Cumulative Explained Variance vs. Number of Components")
16
plt.grid()
plt.show()
Output:
17
Program – 7
Aim: To perform Simple Linear Regression with Python.
Program:
# Import necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
# 1. Prepare the dataset (for this example, let's generate some data)
# Generate a simple linear dataset
np.random.seed(0)
X = 2 * np.random.rand(100, 1) # Feature: 100 random values between 0 and 2
y = 4 + 3 * X + np.random.randn(100, 1) # Target: y = 4 + 3*X + random noise
# Convert to pandas DataFrame (optional)
data = pd.DataFrame({'X': X.flatten(), 'y': y.flatten()})
# 2. Split the dataset 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)
# 3. Create the Linear Regression model
model = LinearRegression()
# 4. Train the model
model.fit(X_train, y_train)
18
# 5. Make predictions
y_pred = model.predict(X_test)
# 6. Evaluate the model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"Mean Squared Error: {mse}")
print(f"R-squared: {r2}")
# 7. Visualize the results
plt.scatter(X_test, y_test, color='blue', label='Actual data')
plt.plot(X_test, y_pred, color='red', label='Predicted line')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Simple Linear Regression')
plt.legend()
plt.show()
Output:
19
Program – 8
Aim: To perform K-Means clustering operation and visualize for iris data set
Program:
!pip install mlxtend
import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori, association_rules
# Step 1: Define the dataset (list of transactions)
dataset = [
['milk', 'bread', 'nuts', 'apple'],
['milk', 'bread', 'nuts'],
['milk', 'bread'],
['milk', 'bread', 'apple'],
['milk', 'bread', 'apple']
]
# Step 2: Convert the list of transactions into one-hot encoded DataFrame
te = TransactionEncoder()
te_data = te.fit(dataset).transform(dataset)
df = pd.DataFrame(te_data, columns=te.columns_)
print(" Transaction Data (One-Hot Encoded):")
print(df)
# Step 3: Apply Apriori to find frequent itemsets
frequent_itemsets = apriori(df, min_support=0.6, use_colnames=True)
print("\n📦 Frequent Itemsets (Support >= 0.6):")
print(frequent_itemsets)
20
# Step 4: Derive Association Rules
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)
print("\n🔗 Association Rules (Confidence >= 0.7):")
print(rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']])
unique, counts = np.unique(I, return_counts=True)
print("Cluster Distribution:", dict(zip(unique, counts)))
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
# Reduce dimensions using PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
# Scatter plot of clusters
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=I.flatten(), cmap='viridis', edgecolor='k')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.title('FAISS K-Means Clustering on Iris Dataset')
plt.colorbar(label="Cluster")
plt.show()
from sklearn.metrics import accuracy_score
true_labels = iris.target # Actual labels from dataset
print("Accuracy (approximate):", accuracy_score(true_labels, I.flatten()))
true_labels = iris.target
# Create a mapping between predicted clusters and true labels
mapping = {}
for cluster in range(3):
mask = (I.flatten() == cluster) # Find all data points in cluster
21
if np.sum(mask) > 0: # Ensure the mask is not empty
most_common_label = mode(true_labels[mask], keepdims=True).mode[0] # Fix
mapping[cluster] = most_common_label
# Map the predicted clusters to corrected labels
mapped_clusters = np.array([mapping[label] for label in I.flatten()])
# Compute accuracy
accuracy = accuracy_score(true_labels, mapped_clusters)
print("Corrected Accuracy:", accuracy)
Output:
Cluster Assignments: [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 0 0 0 2 0 0 0 0 0 0 0 0 2 0 0 0 0 2 0 0 0
0 2 2 2 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 2 2 2 2 0 2 0 2 2
0 2 0 0 2 2 2 2 0 2 0 2 0 2 2 0 0 2 2 2 2 2 0 0 2 2 2 0 2 2 2 0 2 2 2 0 2
2 0]
Cluster Distribution: {0: 56, 1: 50, 2: 44}
Accuracy (approximate): 0.22
Corrected Accuracy: 0.8133333333333334
22
Program – 9
Aim: Write R script to diagnose any disease using KNN classification and plot the
results.
Program:
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, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# Load dataset
df = pd.read_csv('diabetes.csv') # replace with your file path if needed
# Features and target
X = df.drop('Outcome', axis=1)
y = df['Outcome']
# Normalize features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# Split the data
23
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.25,
random_state=42)
# Hyperparameter tuning for KNN
k_range = range(1, 31)
cv_scores = []
for k in k_range:
knn = KNeighborsClassifier(n_neighbors=k)
scores = cross_val_score(knn, X_train, y_train, cv=5, scoring='accuracy')
cv_scores.append(scores.mean())
# Plot accuracy vs. k
plt.figure(figsize=(10, 6))
plt.plot(k_range, cv_scores, marker='o')
plt.title('KNN Hyperparameter Tuning')
plt.xlabel('Number of Neighbors K')
plt.ylabel('Cross-Validated Accuracy')
plt.grid()
plt.show()
# Best k
best_k = k_range[cv_scores.index(max(cv_scores))]
print(f"Best K value: {best_k}")
# Train with best K
knn_best = KNeighborsClassifier(n_neighbors=best_k)
knn_best.fit(X_train, y_train)
y_pred_knn = knn_best.predict(X_test)
24
# Evaluation
print("\n✅ KNN Model Performance:")
print("Accuracy:", accuracy_score(y_test, y_pred_knn))
print("Classification Report:\n", classification_report(y_test, y_pred_knn))
# Confusion matrix
cm = confusion_matrix(y_test, y_pred_knn)
plt.figure(figsize=(6,5))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['No Disease', 'Disease'],
yticklabels=['No Disease', 'Disease'])
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix - KNN')
plt.tight_layout()
plt.show()
# Optional: Compare with Random Forest and SVM
models = {
"Random Forest": RandomForestClassifier(random_state=42),
"SVM": SVC(),
"KNN": knn_best
}
for name, model in models.items():
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(f"\n🔍 {name} Accuracy: {accuracy_score(y_test, y_pred):.2f}")
print(classification_report(y_test, y_pred))
25
Output:
Best K value: 7
✅ KNN Model Performance:
Accuracy: 0.6875
Classification Report:
precision recall f1-score support
0 0.74 0.78 0.76 123
1 0.57 0.52 0.55 69
accuracy 0.69 192
macro avg 0.66 0.65 0.65 192
weighted avg 0.68 0.69 0.68 192
26
🔍 Random Forest Accuracy: 0.73
precision recall f1-score support
0 0.80 0.78 0.79 123
1 0.62 0.65 0.64 69
accuracy 0.73 192
macro avg 0.71 0.72 0.71 192
weighted avg 0.74 0.73 0.74 192
🔍 SVM Accuracy: 0.73
precision recall f1-score support
0 0.77 0.82 0.80 123
1 0.64 0.57 0.60 69
accuracy 0.73 192
macro avg 0.71 0.69 0.70 192
weighted avg 0.72 0.73 0.73 192
🔍 KNN Accuracy: 0.69
precision recall f1-score support
...
accuracy 0.69 192
macro avg 0.66 0.65 0.65 192
weighted avg 0.68 0.69 0.68 192
27
Program – 10
Aim: To perform market basket analysis using Association Rules (Apriori).
Program:
!pip install mlxtend
import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori, association_rules
# Step 1: Define the dataset (list of transactions)
dataset = [
['milk', 'bread', 'nuts', 'apple'],
['milk', 'bread', 'nuts'],
['milk', 'bread'],
['milk', 'bread', 'apple'],
['milk', 'bread', 'apple']
]
# Step 2: Convert the list of transactions into one-hot encoded DataFrame
te = TransactionEncoder()
te_data = te.fit(dataset).transform(dataset)
df = pd.DataFrame(te_data, columns=te.columns_)
print("🧾 Transaction Data (One-Hot Encoded):")
print(df)
# Step 3: Apply Apriori to find frequent itemsets
frequent_itemsets = apriori(df, min_support=0.6, use_colnames=True)
28
print("\n📦 Frequent Itemsets (Support >= 0.6):")
print(frequent_itemsets)
# Step 4: Derive Association Rules
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)
print("\n🔗 Association Rules (Confidence >= 0.7):")
print(rules[['antecedents', 'consequents', 'support', 'confidence', 'lift']])
Output:
(milk) (bread) 1.0 1.0 1.0
(apple, bread) (milk) 0.6 1.0 1.0
(apple, milk) (bread) 0.6 1.0 1.0
(apple) (bread, milk) 0.6 1.0 1.0
29
