Index

S.no. Title Date Sign

1 Extract the data from the database using
Python
2 Write a program to Result Prediction
3 Write a program to Heart Disease predictor
4 Write a program to Computer accuracy of
classifier.
5 Write a program to Diabetes Prediction Model
6 Build an Artificial Neural Network (ANN) by
implementing the Back propagation algorithm
and test the same using appropriate data sets.
7 Apply k-Means algorithm k-Means algorithm
to cluster a set of data stored in a .CSV file.
Use the same data set for clustering using the
k- Means algorithm. Compare the results of
these two algorithms and comment on the
quality of clustering. You can add Python ML
library classes in the program.
8 Write a program to implement Self-
Organizing Map (SOM).
9 Write a program for empirical comparison of
different supervised
10 Write a program for empirical comparison of
different unsupervised learning algorithms.
 Program – 1

Q1. Extract the data from the database using Python.

Code:

# Python code to extract data from MySQL database.

import mysql. connector as a
mycon=a.connect(host="localhost",user="root",passwd="1234",database="12a")
cursor=mycon.cursor()
cursor.execute("select * from student")
data=cursor.fetchall()
for i in data:
print(i)

Output:
 Program – 2

Q2. Write a program to Result Prediction.

Code:

# Result Prediction Model using Logistic Regression

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
data = pd.read_csv("marks.csv")
print(data.head())

data['RESULT'].fillna(0, inplace=True) # Filling NaN with 0 for simplicity

X = data.drop(columns='RESULT', axis=1)
Y = data['RESULT']
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, stratify=Y,
random_state=2)
model = LogisticRegression()
model.fit(X_train, Y_train)

X_train_prediction = model.predict(X_train)
training_data_accuracy = accuracy_score(X_train_prediction, Y_train)
print("Accuracy on Training data:", training_data_accuracy)

X_test_prediction = model.predict(X_test)
test_data_accuracy = accuracy_score(X_test_prediction, Y_test)
print("Accuracy on Test data:", test_data_accuracy)
input_data = np.array([90, 50]).reshape(1, -1)

prediction = model.predict(input_data)
print("Prediction for example input data:", prediction[0])

input_data = np.array([70, 25]).reshape(1, -1)

prediction = model.predict(input_data)
print("Prediction for additional input data:", prediction[0])
if prediction[0] == 0:
print("FAIL")
else:
print("PASS")
Output:
 Program – 3

Q3. Write a program to Heart Disease predictor.

Code:
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
data=pd.read_csv("heart_data.csv")
data.head()

print(data)
data.isnull().sum()
data['HeartDisease'].value_counts()
X=data.drop(columns='HeartDisease',axis=1)
Y=data['HeartDisease']
print(X)
print(Y)

X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.2,stratify=Y,random_state=2)
print(X.shape,X_train.shape,X_test.shape)
model=LogisticRegression()
model.fit(X_train,Y_train)

X_train_prediction=model.predict(X_train)
training_data_accuracy=accuracy_score(X_train_prediction,Y_train)
print("Accuracy on Training data",training_data_accuracy)

X_test_prediction=model.predict(X_test)
test_data_accuracy=accuracy_score(X_test_prediction,Y_test)
print("Accuracy on Test data:",test_data_accuracy)

input_data=(74,0,2,20,264,0,2,121,1,0.2,1,1,3)
input_data_as_numpy_array=np.asarray(input_data)

input_data_reshaped=input_data_as_numpy_array.reshape(1,-1)
prediction=model.predict(input_data_reshaped)
print(prediction)
if(prediction[0]==0):
print("The person does not have Heart Disease")
else:
print("The person has Heart Disease")
Output:
 Program – 4

Q4. Write a program to Computer accuracy of classifier.

Code:

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report
from sklearn.datasets import load_iris

# Load the Iris dataset

iris = load_iris()

# Create a DataFrame using Pandas

iris_df = pd.DataFrame(data=np.c_[iris['data'], iris['target']], columns=iris['feature_names'] +
['target'])

# Save the DataFrame to a CSV file

iris_df.to_csv('iris_dataset.csv', index=False)

# Load the Iris dataset from the saved file

loaded_df = pd.read_csv('iris_dataset.csv')
X_loaded = loaded_df.drop('target', axis=1).values
y_loaded = loaded_df['target'].values

# Split the loaded dataset into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X_loaded, y_loaded, test_size=0.2,
random_state=42)

# Create a Random Forest Classifier

clf = RandomForestClassifier(n_estimators=100, random_state=42)

# Train the classifier on the training set

clf.fit(X_train, y_train)

# Make predictions on the test set

y_pred = clf.predict(X_test)

# Evaluate the classifier

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")
# Print classification report
print("Classification Report:")
print(classification_report(y_test, y_pred))

Output:
 Program – 5

Q5. Write a program to Diabetes Prediction Model.

Code:

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn import svm
from sklearn.metrics import accuracy_score

data=pd.read_csv('diabetes2.csv')
print(data)

X=data.drop(columns='Report',axis=1)
Y=data['Report']

scaler=StandardScaler()
scaler.fit(X)
StandardScaler(copy=True,with_mean=True,with_std=True)
standardized_data=scaler.transform(X)
print(standardized_data)

X=standardized_data
Y=data['Report']

X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.2,stratify=Y,random_state=2)

X_test_prediction=classifier.predict(X_test)
test_data_accuracy=accuracy_score(X_test_prediction,Y_test)
print('Accuracy score of the test data:',test_data_accuracy)

input_data=(85,60,23,8,30.1,0.163,57)
input_data_as_numpy_array = np.asarray(input_data)
input_data_reshaped = input_data_as_numpy_array.reshape(1,-1)
std_data = scaler.transform(input_data_reshaped)
print(std_data)

prediction=classifier.predict(std_data)
print(prediction)
if(prediction[0]==0):
print("The person is not diabetic")
else:
print("The person is diabetic")

Output:
 Program – 6

Q6 Build an Artificial Neural Network (ANN) by implementing the Back propagation

algorithm and test the same using appropriate data sets.

Code:
import numpy as np

class NeuralNetwork:

def init (self, input_size, hidden_size, output_size, learning_rate=0.01):

self.input_size = input_size

self.hidden_size = hidden_size

self.output_size = output_size

self.learning_rate = learning_rate

# Initialize weights and biases

self.weights_input_hidden = np.random.rand(self.input_size, self.hidden_size)

self.bias_hidden = np.zeros((1, self.hidden_size))

self.weights_hidden_output = np.random.rand(self.hidden_size,

self.output_size) self.bias_output = np.zeros((1, self.output_size))

def sigmoid(self, x):

return 1 / (1 + np.exp(-x))

def sigmoid_derivative(self,

x): return x * (1 - x)

def forward(self, X):

# Forward pass through the network

self.hidden_input = np.dot(X, self.weights_input_hidden) + self.bias_hidden

self.hidden_output = self.sigmoid(self.hidden_input)
 self.output_input = np.dot(self.hidden_output, self.weights_hidden_output) +
self.bias_output

self.predicted_output = self.sigmoid(self.output_input)

return

self.predicted_output def

backward(self, X, y, output):

# Backward pass through the

network error = y - output

output_delta = error * self.sigmoid_derivative(output)

hidden_error =

output_delta.dot(self.weights_hidden_output.T)

hidden_delta = hidden_error *

self.sigmoid_derivative(self.hidden_output) # Update weights and biases

self.weights_hidden_output += self.hidden_output.T.dot(output_delta) *
self.learning_rate

self.bias_output += np.sum(output_delta, axis=0, keepdims=True) *

self.learning_rate self.weights_input_hidden += X.T.dot(hidden_delta) *

self.learning_rate self.bias_hidden += np.sum(hidden_delta, axis=0,

keepdims=True) * self.learning_rate

def train(self, X, y, epochs):

for epoch in

range(epochs): #

Forward pass

output = self.forward(X)

# Backward pass and optimization

self.backward(X, y, output)

# Print the mean squared error at each

 epoch mse = np.mean((y - output) **

2)

if epoch % 1000 == 0:

print(f"Epoch {epoch}, Mean Squared Error: {mse:.4f}")

# Sample dataset (XOR problem)

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])

y = np.array([[0], [1], [1], [0]])

# Initialize and train the neural

network input_size = 2

hidden_size = 4

output_size = 1

nn = NeuralNetwork(input_size, hidden_size, output_size)

nn.train(X, y, epochs=10000)

# Test the trained network

predictions = nn.forward(X)

print("\nPredictions:")

print(predictions)

Output:
 Program – 7

Q7. Apply k-Means algorithm k-Means algorithm to cluster a set of data stored in
a .CSV file. Use the same data set for clustering using the k- Means algorithm.
Compare the results of these two algorithms and comment on the quality of
clustering. You can add Python ML library classes in the program.

Code:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans,
AgglomerativeClustering from sklearn.preprocessing
import StandardScaler
from sklearn.metrics import adjusted_rand_score
# Load the Iris dataset (you can replace this with your CSV
file) from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y_true =
iris.target
# Standardize the data
scaler =
StandardScaler()
X_std =
scaler.fit_transform(X) #
Perform k-Means clustering
kmeans = KMeans(n_clusters=3,
random_state=42) kmeans_labels =
kmeans.fit_predict(X_std)
# Perform hierarchical clustering (Agglomerative Clustering)
hierarchical = AgglomerativeClustering(n_clusters=3)
hierarchical_labels = hierarchical.fit_predict(X_std)
# Visualize the results
 plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.scatter(X_std[:, 0], X_std[:, 1], c=kmeans_labels,
cmap='viridis') plt.title('k-Means Clustering')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], marker='X',
s=200, c='red')
plt.subplot(1, 2, 2)
plt.scatter(X_std[:, 0], X_std[:, 1], c=hierarchical_labels, cmap='viridis')
plt.title('Hierarchical Clustering')
plt.show()
# Evaluate clustering results using adjusted Rand index
ari_kmeans = adjusted_rand_score(y_true, kmeans_labels)
ari_hierarchical = adjusted_rand_score(y_true,
hierarchical_labels) print(f"Adjusted Rand Index (k-Means):
{ari_kmeans:.4f}") print(f"Adjusted Rand Index
(Hierarchical): {ari_hierarchical:.4f}")
Output
 Program – 8

Q8. Write a program to implement Self-Organizing Map (SOM).

Code:

import numpy as np

import matplotlib.pyplot as plt

class SOM:

def init (self, input_size, map_size, learning_rate=0.1):

self.input_size = input_size

self.map_size = map_size

self.learning_rate = learning_rate

# Initialize the SOM weights

self.weights = np.random.rand(map_size[0], map_size[1], input_size)

def find_winner(self, input_vector):

# Find the winning neuron (the one with the closest weight

vector) distances = np.linalg.norm(self.weights - input_vector,

axis=-1) winner = np.unravel_index(np.argmin(distances),

distances.shape) return winner

def update_weights(self, input_vector,

winner): # Update the weights of the

neurons

for i in range(self.map_size[0]):

for j in

range(self.map_size[1]):
 # Update each weight vector

distance = np.linalg.norm(np.array([i, j]) - np.array(winner))

influence = np.exp(-distance / (2 * 0.5**2)) # Influence function (e.g., Gaussian)

self.weights[i, j] += self.learning_rate * influence * (input_vector - self.weights[i, j])

def train(self, data, epochs):

for epoch in

range(epochs):

for input_vector in data:

# Find the winner and update weights for each input

vector winner = self.find_winner(input_vector)

self.update_weights(input_vector, winner)

def predict(self, data):

# Find the winning neuron for each input vector in the dataset

winners = [self.find_winner(input_vector) for input_vector in

data] return np.array(winners)

# Example usage with a 2D dataset

data = np.array([[1, 2],

[5, 6],

[8, 7],

[2, 1]])

# Normalize the data to be in the range [0, 1]

data_normalized = data / np.max(data)

# Initialize SOM

input_size = data.shape[1]

map_size = (5, 5) # Adjust the map size based on your

dataset som = SOM(input_size, map_size,

learning_rate=0.1)
 # Train the SOM

epochs = 1000

som.train(data_normalized, epochs)

# Get the predicted winning neurons for each input vector

predicted_winners = som.predict(data_normalized)

# Visualize the SOM and the input vectors

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

plt.scatter(data_normalized[:, 0], data_normalized[:, 1], label='Input Vectors')

plt.scatter(predicted_winners[:, 0] / (map_size[0] - 1), predicted_winners[:, 1] /

(map_size[1] - 1), marker='X', c='red', label='SOM Winners')

plt.legend()

plt.title('Self-Organizing Map (SOM) Results')

plt.show()

Output
 Program – 9

Q9) Write a program for empirical comparison of different supervised

Code:
import numpy as np
import pandas as pd
from sklearn.model_selection import
train_test_split from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score,
classification_report from sklearn.datasets import load_iris
# Load the Iris dataset
iris = load_iris()
X = iris.data
y=
iris.target
# 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) # Support Vector Machines (SVM)
svm_model = SVC()
svm_model.fit(X_train, y_train)
svm_predictions = svm_model.predict(X_test)
svm_accuracy = accuracy_score(y_test,
svm_predictions)
# Decision Trees
dt_model = DecisionTreeClassifier()
dt_model.fit(X_train, y_train)
dt_predictions =
dt_model.predict(X_test)
dt_accuracy = accuracy_score(y_test,
dt_predictions) # Random Forests
rf_model = RandomForestClassifier()
 rf_model.fit(X_train, y_train)
rf_predictions =
rf_model.predict(X_test)
rf_accuracy = accuracy_score(y_test, rf_predictions)
# Print the results
print("Support Vector Machines Accuracy:",
svm_accuracy) print("Decision Trees Accuracy:",
dt_accuracy) print("Random Forests Accuracy:",
rf_accuracy)
# Additional information: Classification Report
print("\nSupport Vector Machines Classification
Report:") print(classification_report(y_test,
svm_predictions)) print("\nDecision Trees
Classification Report:")
print(classification_report(y_test, dt_predictions))
print("\nRandom Forests Classification Report:")
print(classification_report(y_test, rf_predictions))
Output
 Program – 10

Q10. Write a program for empirical comparison of different

unsupervised learning algorithms.

Code:

import

numpy as np

import

pandas as pd

import matplotlib.pyplot as plt

from sklearn.cluster import KMeans, AgglomerativeClustering,

DBSCAN from sklearn.decomposition import PCA

from sklearn.datasets import load_iris

from sklearn.preprocessing import

StandardScaler from sklearn.metrics

import silhouette_score

# Load the Iris

dataset iris =

load_iris()

X=

iris.d

ata y

iris.t

arget

# Standardize the
 features scaler =

StandardScaler()

X_scaled = scaler.fit_transform(X)

# Reduce dimensionality for

visualization pca =

PCA(n_components=2)

X_pca =

pca.fit_transform(X_scaled)

# Initialize clustering

algorithms

kmeans = KMeans(n_clusters=3,

random_state=42) hierarchical =

AgglomerativeClustering(n_clusters=3)

dbscan = DBSCAN(eps=0.5,

min_samples=5)

# Perform clustering

kmeans_labels =

kmeans.fit_predict(X_scaled)

hierarchical_labels =

hierarchical.fit_predict(X_scaled)

dbscan_labels =

dbscan.fit_predict(X_scaled)

# Visualize the results

plt.figure(figsize=(15,

5))
plt.subplot(1, 3, 1)

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=kmeans_labels, cmap='viridis',

marker='o', edgecolors='k')

plt.title('K-Means

Clustering')

plt.subplot(1, 3, 2)

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=hierarchical_labels, cmap='viridis',

marker='o', edgecolors='k')

plt.title("Hierarchical Clustering")

plt.subplot(1, 3, 3)

plt.scatter(X_pca[:, 0], X_pca[:, 1], c=dbscan_labels, cmap='viridis',

marker='o', edgecolors='k')

plt.title('DBSCAN Clustering')

plt.tight_layout()

plt.show()

# Evaluate the quality of clustering using silhouette score

silhouette_kmeans = silhouette_score(X_scaled,

kmeans_labels) silhouette_hierarchical =

silhouette_score(X_scaled, hierarchical_labels)

silhouette_dbscan = silhouette_score(X_scaled,

dbscan_labels) print("Silhouette Score (K-Means):",

silhouette_kmeans) print("Silhouette Score

(Hierarchical):", silhouette_hierarchical) print("Silhouette

Score (DBSCAN):", silhouette_dbscan)

Output