ROCHIS VALLEY, MANIKBANDAR
NIZAMABD -503 003
CERTIFICATE
NAME OF THE LABORATORY________________________________
ACADEMIC YEAR:20___-20___
Certified that is the bonafide record of work done in the_______________
____________laboratory by Mr/Ms _______________________________
__________________________of____Year B.Tech, ___SEM____Branch
With HALLTICKET NO:_____________________during Academic year
20___-20___ and has performed_____no.Of Experiments out of_____no.
Of experiment under my Supervision
LECTURER INCHARGE HEAD OF THE DEPARTMENT
WITH SEAL
DATE EXTERNAL EXAMINER
VIJAY RURAL ENGINEERING COLLEGE
MACHINE LEARNING LAB INDEX
DATE OF
DATE OF LECTURER
S.NO NAME OF THE EXPERIMENT EXPERIMENT PAGE NO. REMARK
SUBMISSION SIGN
PERFORMED
Write a python program to compute Central
Tendency Measures: Mean, Median,
1
Mode Measure of Dispersion: Variance,
Standard Deviation
Study of Python Basic Libraries such as
2
Statistics, Math, Numpy and Scipy
Study of Python Libraries for ML application
3
such as Pandas and Matplotlib
Write a Python program to implement Simple
4
Linear Regression
Implementation of Multiple Linear Regression
5
for House Price Prediction using sklearn
Implementation of Decision tree using sklearn
6
and its parameter tuning
7 Implementation of KNN using sklearn
Implementation of Logistic Regression using
8
sklearn
9 Implementation of K-Means Clustering
Performance analysis of Classification
10
Algorithms on a specific dataset (Mini Project)
MEACHINE LEARNING
LAB MANUAL
III - II
1)Write a python program to compute Central Tendency Measures: Mean, Median,
Mode Measure of Dispersion: Variance, Standard Deviation
Program:
import statistics
def ctm(data):
if not data:
return("no data found")
mean = statistics.mean(data)
median = statistics.median(data)
try:
mode = statistics.mode(data)
except statistics.StatisticsError:
mode= "No unique mode found"
variance = statistics.variance(data)
sd = statistics.stdev(data)
print(f"mean: {mean}")
print(f"median: {median}")
print(f"mode: {mode}")
print(f"varience: {variance}")
print(f"standard division: {sd}")
if __name__ == "__main__":
data = [10,20,30,40,40,50,60,70,80,90]
ctm(data)
Output:
mean: 49
median: 45.0
mode: 40
varience: 676.6666666666666
standard division: 26.01281735350223
2) Study of Python Basic Libraries such as Statistics, Math, Numpy and Scipy
1. Statistics Library
The statistics module in Python provides functions for calculating mathematical statistics of
numeric data.
Key Features:
Central Tendency Measures:
o mean(data): Arithmetic mean.
o median(data): Median value.
o mode(data): Most common value.
Spread Measures:
o variance(data): Variance of the data.
o stdev(data): Standard deviation.
Additional Functions:
o median_low(data): Low median of data.
o median_high(data): High median of data.
o harmonic_mean(data): Harmonic mean of data.
Example:
import statistics as stats
data = [1, 2, 2, 3, 4]
print("Mean:", stats.mean(data))
print("Median:", stats.median(data))
print("Mode:", stats.mode(data))
2. Math Library
The math module provides access to mathematical functions defined by the C standard.
Key Features:
Basic Math Operations:
o sqrt(x): Square root.
o pow(x, y): x raised to the power y.
o factorial(x): Factorial of x.
Trigonometric Functions:
o sin(x), cos(x), tan(x): Trigonometric functions.
Logarithmic Functions:
o log(x, base): Logarithm of x to the specified base.
o log10(x): Base-10 logarithm.
Constants:
o pi: Mathematical constant π.
o e: Euler's number.
Example:
import math
print("Square root of 16:", math.sqrt(16))
print("Value of Pi:", math.pi)
print("Sine of 90 degrees:", math.sin(math.radians(90)))
3. NumPy
NumPy is a powerful library for numerical computations.
Key Features:
Arrays:
o numpy.array(): Create arrays.
o numpy.zeros(shape): Create an array of zeros.
o numpy.ones(shape): Create an array of ones.
Mathematical Operations:
o Element-wise operations on arrays (+, -, *, /).
o Linear algebra functions (dot, cross, linalg).
Statistical Functions:
o numpy.mean(): Mean of array elements.
o numpy.std(): Standard deviation.
o numpy.median(): Median value.
Indexing and Slicing:
o Access specific elements or subarrays.
Example:
import numpy as np
arr = np.array([1, 2, 3, 4])
print("Array:", arr)
print("Mean:", np.mean(arr))
print("Standard Deviation:", np.std(arr))
4. SciPy
SciPy builds on NumPy and provides additional functionality for scientific computing.
Key Features:
Optimization:
o scipy.optimize.minimize(): Minimize a scalar function.
Integration:
o scipy.integrate.quad(): Numerical integration.
Linear Algebra:
o scipy.linalg.solve(): Solve linear systems.
Statistics:
o scipy.stats: Statistical distributions and functions.
Signal Processing:
o scipy.signal: Signal processing utilities.
Example:
from scipy import stats
data = [1, 2, 2, 3, 4]
print("Mode:", stats.mode(data).mode[0])
Applications:
1. Statistics: Data analysis and summarization.
2. Math: Solving equations, trigonometry, and logarithmic calculations.
3. NumPy: High-performance array manipulation.
4. SciPy: Advanced computation in engineering, machine learning, and scientific domains.
3) Study of Python Libraries for ML application such as Pandas and Matplotlib
Python libraries like Pandas and Matplotlib are essential for Machine Learning (ML)
applications, as they help with data manipulation, analysis, and visualization. Here’s a detailed
overview:
1. Pandas
Pandas is a powerful library for data manipulation and analysis. It provides data structures like
Series and DataFrame, which are widely used in ML for preprocessing and exploration.
Key Features:
Data Structures:
o Series: One-dimensional labeled array.
o DataFrame: Two-dimensional labeled data structure (like a table).
Data Manipulation:
o read_csv(), read_excel(): Load datasets from files.
o to_csv(), to_excel(): Save datasets to files.
o Filtering and indexing using .loc[] and .iloc[].
Data Cleaning:
o Handling missing values: dropna(), fillna().
o Duplicates: drop_duplicates().
Data Analysis:
o Aggregation: groupby(), pivot_table().
o Statistical methods: .mean(), .std(), .describe().
Integration with ML Libraries:
o Easily convert DataFrames to NumPy arrays or directly use them in ML libraries
like Scikit-learn.
Example:
import pandas as pd
# Load data
data = pd.read_csv('sample.csv')
# Display first few rows
print(data.head())
# Basic statistics
print(data.describe())
# Handling missing values
data.fillna(0, inplace=True)
2. Matplotlib
Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations.
It is often used to visualize data trends and patterns in ML.
Key Features:
Basic Plotting:
o plot(): Line plots.
o scatter(): Scatter plots.
o bar(): Bar charts.
Customizations:
o Title, labels, and legends: title(), xlabel(), ylabel(), legend().
o Colors, markers, and styles.
Subplots:
o Multiple plots in one figure: subplot().
Integration:
o Works seamlessly with Pandas: Direct plotting from DataFrames.
Example:
import matplotlib.pyplot as plt
# Sample data
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]
# Line plot
plt.plot(x, y, label='Line Plot')
plt.title('Basic Plot')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.legend()
plt.show()
Combined Use of Pandas and Matplotlib in ML:
The combination of Pandas and Matplotlib is particularly useful in the exploratory data analysis
(EDA) phase of ML, where you examine your dataset to identify trends, correlations, and
anomalies.
Example: Data Analysis and Visualization
import pandas as pd
import matplotlib.pyplot as plt
# Load dataset
data = pd.read_csv('sample.csv')
# Check missing values
print(data.isnull().sum())
# Visualize a specific column
data['Age'].hist(bins=10)
plt.title('Age Distribution')
plt.xlabel('Age')
plt.ylabel('Frequency')
plt.show()
# Scatter plot
plt.scatter(data['Height'], data['Weight'], color='blue', alpha=0.5)
plt.title('Height vs. Weight')
plt.xlabel('Height')
plt.ylabel('Weight')
plt.show()
Applications in ML:
1. Pandas:
o Preprocessing: Data cleaning, normalization, and transformation.
o Feature engineering: Creating new features from existing ones.
o Handling time-series data.
2. Matplotlib:
o Visualizing data distributions, trends, and outliers.
o Understanding relationships between features.
o Plotting model performance (e.g., training and validation loss curves)
4)Write a Python program to implement Simple Linear Regression
PROGRAM
Example as pizza
import statistics
#defining sizes
data_items_collected = int(input("enter the parameter of data:"))
pizza_sizes = []
for i in range (data_items_collected):
size_of_pizza = int(input("enter the pizza sizes: "))
pizza_sizes.append(size_of_pizza)
print("list of pizza sizes collected are: ")
for size in pizza_sizes:
print(size)
#defining prizes
prizes = []
for i in range (data_items_collected):
no_of_prizes = int(input("enter the pizza prizes: "))
prizes.append(no_of_prizes)
print("list of pizza prizes collected are ")
for prize in prizes:
print(prize)
#mean of sizes(x)n
x_mean = statistics.mean(pizza_sizes)
print(f"mean of sizes:{x_mean}")
#mean of costs(y)
y_mean = statistics.mean(prizes)
print(f"mean of prizes:{y_mean}")
#diviation of sizes
diviation_sizes = []
for i in range (data_items_collected):
dev_x = pizza_sizes[i]-x_mean
diviation_sizes.append(dev_x)
print("diviation of x: ")
for dev_s in diviation_sizes:
print(dev_s)
#diviation of prizes
diviation_prizes = []
for i in range (data_items_collected):
dev_y = prizes[i]-y_mean
diviation_prizes.append(dev_y)
print("diviation of y:")
for dev_p in diviation_prizes:
print(dev_p)
#product of divitions(pod)
product_of_diviation = []
for i in range (data_items_collected):
p_o_d = diviation_sizes[i] * diviation_prizes[i]
product_of_diviation.append(p_o_d)
print("product_of_diviation")
for pod in product_of_diviation:
print(pod)
#sum of product
sum_of_product_of_diviation = sum(product_of_diviation)
print(f"sum of the product: {sum_of_product_of_diviation}")
#square_of_diviation_of_sizes
square_of_diviation_of_sizes = []
for i in range (data_items_collected):
sod = diviation_sizes[i]** 2
square_of_diviation_of_sizes.append(sod)
print("square_of_diviation_of_sizes:")
for sodos in square_of_diviation_of_sizes:
print(sodos)
#sum of square_of_diviation_of_sizes_x(sod)
sum_of_square_of_diviation_of_sizes_x = sum(square_of_diviation_of_sizes)
print(f"sum of the product: {sum_of_square_of_diviation_of_sizes_x}")
#m vlaue
slopp_m = sum_of_product_of_diviation/sum_of_square_of_diviation_of_sizes_x
print(f"m:{slopp_m}")
# Y = m * mean of x = > (mean of y)-m * (mean of x) final output is denoted as flag
flag = y_mean - slopp_m * x_mean
print(f"flag value:{flag}")
#doing a pridiction
new_size = int(input("enter the size of pizza you created: "))
prize_pridiction = slopp_m * new_size + flag
print(f"size of {new_size} pizza can be: {prize_pridiction} ")
OUTPUT
enter the parameter of data:3
enter the pizza sizes: 8
enter the pizza sizes: 10
enter the pizza sizes: 12
list of pizza sizes collected are:
10
12
enter the pizza prizes: 10
enter the pizza prizes: 13
enter the pizza prizes: 16
list of pizza prizes collected are
10
13
16
mean of sizes:10
mean of prizes:13
diviation of x:
-2
diviation of y:
-3
product_of_diviation
sum of the product: 12
square_of_diviation_of_sizes:
sum of the product: 8
m:1.5
flag value:-2.0
enter the size of pizza you created: 20
size of 20 pizza can be: 28.0
5. Implementation of Multiple Linear Regression for House Price Prediction using sklearn
Program:
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
# Sample Data
data = {
'square_feets': [1000, 1500, 2000, 2500, 3000],
'bedrooms': [1, 2, 3, 4, 5],
'bathrooms': [1, 2, 2, 2.5, 3],
'prize': [5000, 8000, 12000, 18000, 25000]
df = pd.DataFrame(data)
print(df)
# Features and Target Variable
X = df[['square_feets', 'bedrooms', 'bathrooms']]
y = df[['prize']]
# Train the Model
model = LinearRegression()
model.fit(X, y)
# User Input
sq_feet = float(input("Enter the area of the plot: "))
bdrooms = float(input("Enter the number of bedrooms: ")) # Converted to float
btrooms = float(input("Enter the number of bathrooms: ")) # Converted to float
# Predict Rent
predict_rent = model.predict(np.array([[sq_feet, bdrooms, btrooms]]))
# Print Prediction
print(f"Predicted rent for {sq_feet} square feet, {bdrooms} bedrooms, and {btrooms} bathrooms
is: ₹{predict_rent[0][0]:,.2f}")
Output:
6. Implementation of Decision tree using sklearn and its parameter tuning
Program
from sklearn.tree import DecisionTreeClassifier
b_tech = ["cse","aiml","ece","eee","mech","civil"]
bse = ["mpcs", "mecs", "ba", "ca", "bba"]
X=[
[1, 450],
[1, 800],
[0, 0],
[1, 250],
[1, 600],
]
y = [0, 1, 2, 3, 1]
clf = DecisionTreeClassifier()
clf.fit(X, y)
emcet_rank = int(input("did you get rank(yes(1)/no(0))"))
if emcet_rank == 1 or emcet_rank == 0:
score_1 = int(input("enter the score you got in emcet: "))
prediction = clf.predict([[emcet_rank, score_1]])[0]
if prediction == 0:
print("You can apply for this courses::", b_tech[len(b_tech)//2:])
elif prediction == 1:
print("You can apply for this courses:", b_tech[:len(b_tech)//2])
elif prediction == 2:
print(bse)
elif prediction == 3:
print("You are not eligible for application")
else:
print("Invalid decision")
else:
print("Invalid input")
Output:
7. Implementation of KNN using sklearn
Program:
import numpy as np
from sklearn.neighbors import KNeighborsClassifier
marks = [95, 75, 69, 51, 39, 21, 0]
grade = ["a1", "a", "b", "c", "d", "e", "f"]
testing_score = int(input("enter your score: "))
marks_array = np.array(marks).reshape(-1, 1)
k=3
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(marks_array, grade)
distances, indices = knn.kneighbors([[testing_score]])
print(f"Distances: {distances[0]}")
print(f"Indices of the nearest neighbors: {indices[0]}")
predicted_grade = [grade[i] for i in indices[0]]
print(f"The grade for {testing_score} marks is: {predicted_grade[0]}")
Output:
8. Implementation of Logistic Regression using sklearn
from sklearn.linear_model import LogisticRegression
import numpy as np
import pandas as pd
data = {
'in_study_hours' : [2,4,6,8,10,12],
'y_n':[0,0,1,1,1,1]
}
df = pd.DataFrame(data)
print(data)
x = df[['in_study_hours']]
y = df['y_n']
model = LogisticRegression()
model.fit(x,y)
study_hours = float(input("enter the no of study hours: "))
predict = model.predict(np.array([[study_hours]]))
if predict == 1:
print("pass")
else:
print("fail")
Output:
9. Implementation of K-Means Clustering
import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
data = {
'sr_no':["cr1","cr2","cr3","cr4","cr5","cr6","cr7"],
'age':[20,40,30,18,28,35,45],
'amount':[500,1000,800,300,1200,1400,1800]
}
df = pd.DataFrame(data)
print(df)
x = df[['age','amount']].values
nc = KMeans(n_clusters=3)
nc.fit(x)
test_data = np.array([[13,750]])
pridect = nc.predict(test_data)
print(f"the cloeset class are: {pridect[0]}")
Output:
10. Performance analysis of Classification Algorithms on a specific dataset (Mini Project)
Program:
# Import necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score,
confusion_matrix
# Load Iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Split the data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Standardize the features (important for some models like SVM, KNN)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Initialize classifiers
models = {
"Logistic Regression": LogisticRegression(),
"Decision Tree": DecisionTreeClassifier(),
"KNN": KNeighborsClassifier(),
"SVM": SVC(),
"Random Forest": RandomForestClassifier()
}
# Function to evaluate models
def evaluate_model(model, X_train, X_test, y_train, y_test):
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')
cm = confusion_matrix(y_test, y_pred)
return accuracy, precision, recall, f1, cm
# Create a DataFrame to store results
results = []
# Loop through each model, evaluate and store results
for model_name, model in models.items():
accuracy, precision, recall, f1, cm = evaluate_model(model, X_train, X_test, y_train, y_test)
results.append([model_name, accuracy, precision, recall, f1, cm])
# Convert the results into a DataFrame for easy display
results_df = pd.DataFrame(results, columns=["Model", "Accuracy", "Precision", "Recall", "F1-
Score", "Confusion Matrix"])
# Print the results
print(results_df)
# Plot the performance comparison
metrics = ['Accuracy', 'Precision', 'Recall', 'F1-Score']
for metric in metrics:
plt.figure(figsize=(10, 6))
sns.barplot(x="Model", y=metric, data=results_df)
plt.title(f'Comparison of {metric} across Models')
plt.show()
# Plot confusion matrix for the best model (based on accuracy)
best_model_index = results_df['Accuracy'].idxmax()
best_model_cm = results_df.iloc[best_model_index]['Confusion Matrix']
plt.figure(figsize=(6,6))
sns.heatmap(best_model_cm, annot=True, fmt="d", cmap='Blues', xticklabels=iris.target_names,
yticklabels=iris.target_names)
plt.title(f'Confusion Matrix of {results_df.iloc[best_model_index]["Model"]}')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()
Output
