Ex.

No: 1 - Candidate-Elimination Algorithm\

import numpy as np

import pandas as pd

data = pd.read_csv('Ex1_data.csv')

concepts = [Link]([Link][:, :-1])

target = [Link]([Link][:, -1])

def candidate_elimination(concepts, target):

n_features = [Link][1]

specific_h = concepts[0].copy()

general_h = [['?' for _ in range(n_features)]]

for i, instance in enumerate(concepts):

if target[i] == "yes":

for x in range(n_features):

if instance[x] != specific_h[x]:

specific_h[x] = '?'

general_h = [g for g in general_h if all(

(feature == '?' or feature == specific_h[x])

for x, feature in enumerate(g)

)]

else:

general_h_new = []

for g in general_h:

for x in range(n_features):

if g[x] == "?":

for val in [Link](concepts[:, x]):

if instance[x] != val:
 g_new = [Link]()

g_new[x] = val

if g_new not in general_h_new:

general_h_new.append(g_new)

elif g[x] != instance[x]:

if g not in general_h_new:

general_h_new.append([Link]())

general_h = general_h_new.copy()

general_h = [g for g in general_h if g != ['?' for _ in range(n_features)]]

return specific_h, general_h

s_final, g_final = candidate_elimination(concepts, target)

print("Final Specific Hypothesis:", s_final)

print("Final General Hypotheses:", g_final)

[Link]: 2 - ID3 Decision Tree Algorithm

import math

import csv

class Node:

def __init__(self, attribute):

[Link] = attribute

[Link] = []

[Link] = ""

def load_csv(filename):
 with open(filename, "r") as file:

lines = [Link](file)

dataset = list(lines)

headers = [Link](0)

return dataset, headers

def subtables(data, col, delete):

dic = {}

coldata = [row[col] for row in data]

attr = list(set(coldata))

counts = [0] * len(attr)

for x in range(len(attr)):

for y in range(len(data)):

if data[y][col] == attr[x]:

counts[x] += 1

for x in range(len(attr)):

dic[attr[x]] = []

pos = 0

for y in range(len(data)):

if data[y][col] == attr[x]:

new_row = data[y][:col] + data[y][col+1:] if delete else data[y]

dic[attr[x]].append(new_row)

return attr, dic

def entropy(S):

if not S:

return 0
 counts = {}

for item in S:

counts[item[-1]] = [Link](item[-1], 0) + 1

entropy = 0

for key in counts:

prob = counts[key] / len(S)

entropy -= prob * [Link](prob, 2)

return entropy

def compute_gain(data, col):

attr, dic = subtables(data, col, delete=False)

total_entropy = entropy(data)

weighted_entropy = 0

total_size = len(data)

for x in range(len(attr)):

subset = dic[attr[x]]

weighted_entropy += (len(subset) / total_size) * entropy(subset)

return total_entropy - weighted_entropy

def build_tree(data, features):

last_col = [row[-1] for row in data]

if len(set(last_col)) == 1:

node = Node("")

[Link] = last_col[0]

return node

n = len(data[0]) - 1
 gains = [compute_gain(data, col) for col in range(n)]

split = [Link](max(gains))

node = Node(features[split])

fea = features[:split] + features[split+1:]

attr, dic = subtables(data, split, delete=True)

for x in range(len(attr)):

child = build_tree(dic[attr[x]], fea)

[Link]((attr[x], child))

return node

def print_tree(node, level):

if [Link] != "":

print(" " * level, [Link])

return

print(" " * level, [Link])

for value, child in [Link]:

print(" " * (level + 1), value)

print_tree(child, level + 2)

dataset, features = load_csv("Ex2_data.csv")

node = build_tree(dataset, features)

print("Decision Tree:")

print_tree(node, 0)

[Link]: 3 - Backpropagation Algorithm

import numpy as np

def sigmoid(x):
 return 1 / (1 + [Link](-x))

def sigmoid_derivative(x):

return x * (1 - x)

epoch = 7000

lr = 0.1

input_neurons = 2

hidden_neurons = 3

output_neurons = 1

wh = [Link](size=(input_neurons, hidden_neurons))

bh = [Link](size=(1, hidden_neurons))

wout = [Link](size=(hidden_neurons, output_neurons))

bout = [Link](size=(1, output_neurons))

X = [Link]([[2, 9], [1, 5], [3, 6]], dtype=float)

y = [Link]([[92], [86], [89]], dtype=float)

X = X / [Link](X, axis=0)

y = y / 100

for _ in range(epoch):

# Forward pass

hidden_input = [Link](X, wh) + bh

hidden_output = sigmoid(hidden_input)

output = sigmoid([Link](hidden_output, wout) + bout)

# Backpropagation

error = y - output
 d_output = error * sigmoid_derivative(output)

error_hidden = d_output.dot(wout.T)

d_hidden = error_hidden * sigmoid_derivative(hidden_output)

# Update weights

wout += hidden_output.[Link](d_output) * lr

wh += [Link](d_hidden) * lr

print("Predicted Output:\n", output)

[Link]: 4 - Naive Bayesian Classifier

import csv

import random

import math

from [Link] import confusion_matrix, classification_report

def load_csv(filename):

with open(filename, "r") as file:

lines = [Link](file)

dataset = [list(map(float, row)) for row in lines]

return dataset

def split_dataset(dataset, split_ratio):

train_size = int(len(dataset) * split_ratio)

[Link](dataset)

return dataset[:train_size], dataset[train_size:]

def separate_by_class(dataset):

separated = {}

for row in dataset:

if class_val not in separated:

separated[class_val] = []

separated[class_val].append(row[:-1])

return separated

def summarize(dataset):

summaries = [([Link](attr), [Link](attr)) for attr in zip(*dataset)]

return summaries

def calculate_probability(x, mean, stdev):

if stdev == 0:

return 1.0 if x == mean else 0.0

exponent = [Link](-([Link](x - mean, 2) / (2 * [Link](stdev, 2))))

return (1 / ([Link](2 * [Link]) * stdev)) * exponent

def predict(summaries, input_vector):

probabilities = {}

for class_val, class_summaries in [Link]():

probabilities[class_val] = 1

for i in range(len(class_summaries)):

mean, stdev = class_summaries[i]

x = input_vector[i]

probabilities[class_val] *= calculate_probability(x, mean, stdev)

return max(probabilities, key=[Link])

dataset = load_csv('Ex4_data.csv')

train, test = split_dataset(dataset, 0.67)

summaries = separate_by_class(train)
summaries = {k: summarize(v) for k, v in [Link]()}

predictions = [predict(summaries, row) for row in test]

accuracy = sum(1 for i in range(len(test)) if test[i][-1] == predictions[i]) / len(test)

print(f"Accuracy: {accuracy * 100}%")

[Link]: 5 - Document Classification with Naive Bayes

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.feature_extraction.text import CountVectorizer

from sklearn.naive_bayes import MultinomialNB

from sklearn import metrics

msg = pd.read_csv('Ex5_data.csv', names=['message', 'label'])

msg['labelnum'] = [Link]({'pos': 1, 'neg': 0})

X = [Link]

y = [Link]

xtrain, xtest, ytrain, ytest = train_test_split(X, y, test_size=0.2, random_state=42)

count_vect = CountVectorizer()

xtrain_dtm = count_vect.fit_transform(xtrain)

xtest_dtm = count_vect.transform(xtest)

clf = MultinomialNB().fit(xtrain_dtm, ytrain)

predicted = [Link](xtest_dtm)

print("Confusion Matrix:\n", metrics.confusion_matrix(ytest, predicted))

print("Precision:", metrics.precision_score(ytest, predicted))

print("Recall:", metrics.recall_score(ytest, predicted))

import pandas as pd

from [Link] import BayesianModel

from [Link] import MaximumLikelihoodEstimator

from [Link] import VariableElimination

data = pd.read_csv('Ex6_data.csv').replace('?', [Link])

model = BayesianModel([

('Fever', 'InfectionStatus'),

('Cough', 'InfectionStatus'),

('TravelHistory', 'InfectionStatus'),

('ContactWithConfirmed', 'InfectionStatus')

])

[Link](data, estimator=MaximumLikelihoodEstimator)

infer = VariableElimination(model)

result = [Link](variables=['InfectionStatus'], evidence={'Fever': 'Yes', 'Cough': 'Yes'})

print(result)

[Link]: 7 - EM and K-Means Clustering

import pandas as pd

from [Link] import KMeans, GaussianMixture

from [Link] import StandardScaler

import [Link] as plt

data = pd.read_csv('Ex7_data.csv')

X = [Link]('Target', axis=1)

scaler = StandardScaler().fit(X)

X_scaled = [Link](X)
kmeans = KMeans(n_clusters=3, n_init=10).fit(X)

gmm = GaussianMixture(n_components=3).fit(X_scaled)

[Link](figsize=(12, 5))

[Link](121)

[Link]([Link][:, 2], [Link][:, 3], c=kmeans.labels_)

[Link]('K-Means')

[Link](122)

[Link]([Link][:, 2], [Link][:, 3], c=[Link](X_scaled))

[Link]('GMM')

[Link]()

[Link]: 8 - k-Nearest Neighbors

from [Link] import load_iris

from sklearn.model_selection import train_test_split

from [Link] import KNeighborsClassifier

from [Link] import classification_report, confusion_matrix

iris = load_iris()

X_train, X_test, y_train, y_test = train_test_split([Link], [Link], test_size=0.3)

knn = KNeighborsClassifier(n_neighbors=5).fit(X_train, y_train)

y_pred = [Link](X_test)

print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))

print("\nClassification Report:\n", classification_report(y_test, y_pred))

import numpy as np

import [Link] as plt

def local_regression(x0, X, Y, tau):

X = np.c_[[Link](len(X)), X]

x0 = np.r_[1, x0]

weights = [Link](-[Link]((X - x0) ** 2, axis=1) / (2 * tau ** 2))

W = [Link](weights)

beta = [Link](X.T @ W @ X) @ (X.T @ W @ Y)

return x0 @ beta

X = [Link](-3, 3, 100)

Y = [Link](X) + [Link](0, 0.1, 100)

predictions = [local_regression(x, X, Y, 0.1) for x in X]

[Link](X, Y)

[Link](X, predictions, color='red')

[Link]()