FIND – S ALGORITHM
import csv
def more_general(h1, h2):
return all(h1[i] == '?' or h2[i] == '?' or h1[i] == h2[i] for i in range(len(h1)))
def find_s(data):
most_specific = data[0][1:]
for instance in data[1:]:
current = ['?' if instance[1:][i] != most_specific[i] else most_specific[i] for i in
range(len(most_specific))]
if more_general(current, most_specific):
most_specific = current
return most_specific
with open('training_data.csv', 'r') as file:
reader = csv.reader(file)
next(reader) # Skip header
data = list(reader)
print("Most Specific Hypothesis:", find_s(data))
CANDIDATE – ELIMINATION ALGO
import csv
def more_general(h1, h2):
return all(h1[i] == '?' or h2[i] == '?' or h1[i] == h2[i] for i in range(len(h1)))
def find_s(data):
most_specific = data[0][1:]
for instance in data[1:]:
current = ['?' if instance[1:][i] != most_specific[i] else most_specific[i] for i in
range(len(most_specific))]
if more_general(current, most_specific):
most_specific = current
return most_specific
def find_g(data):
most_general = ['?'] * len(data[0][1:])
for instance in data:
current = [instance[1:][i] if instance[1:][i] != most_general[i] else '?' for i in
range(len(most_general))]
if not more_general(most_general, current):
most_general = current
return most_general
with open('training_data.csv', 'r') as file:
reader = csv.reader(file)
next(reader) # Skip header
data = list(reader)
s, g = find_s(data), find_g(data)
print("Set of all hypotheses consistent with the training examples:")
for i, (s_val, g_val) in enumerate(zip(s, g), start=1):
print(f"Attribute {i}: {s_val if g_val == '?' else g_val}")
DECISION TREE – ID3
import math
def entropy(data, target_attr):
val_freq = {}
for record in data:
val_freq[record[target_attr]] = val_freq.get(record[target_attr], 0) + 1
return sum(-freq/len(data) * math.log2(freq/len(data)) for freq in val_freq.values())
def info_gain(data, attr, target_attr):
base_entropy = entropy(data, target_attr)
attr_vals = set(record[attr] for record in data)
exp_entropy = sum((len([rec for rec in data if rec[attr] == val])/len(data)) * entropy([rec for
rec in data if rec[attr] == val], target_attr) for val in attr_vals)
return base_entropy - exp_entropy
def id3(data, attrs, target_attr):
base_entropy = entropy(data, target_attr)
if base_entropy == 0:
return next(iter(set(record[target_attr] for record in data)))
elif len(attrs) == 0:
return max(set(record[target_attr] for record in data), key=[record[target_attr] for
record in data].count)
else:
attr_gains = [info_gain(data, attr, target_attr) for attr in attrs]
selected_attr = attrs[attr_gains.index(max(attr_gains))]
node = {selected_attr: {}}
attr_values = set(record[selected_attr] for record in data)
for value in attr_values:
new_data = [record for record in data if record[selected_attr] == value]
new_attrs = attrs.copy()
new_attrs.remove(selected_attr)
child_node = id3(new_data, new_attrs, target_attr)
node[selected_attr][value] = child_node
return node
def classify(tree, sample):
for attr, values in tree.items():
value = sample[attributes.index(attr)]
if value in values:
child = values[value]
if isinstance(child, dict):
return classify(child, sample)
else:
return child
data = [['Sunny', 'Hot', 'High', 'False'], ['Sunny', 'Hot', 'High', 'True'], ['Overcast', 'Hot', 'High',
'False'], ['Rain', 'Mild', 'High', 'False'], ['Rain', 'Cool', 'Normal', 'False'], ['Rain', 'Cool', 'Normal',
'True'], ['Overcast', 'Cool', 'Normal', 'True'], ['Sunny', 'Mild', 'High', 'False'], ['Sunny', 'Cool',
'Normal', 'False'], ['Rain', 'Mild', 'Normal', 'False'], ['Sunny', 'Mild', 'Normal', 'True'],
['Overcast', 'Mild', 'High', 'True'], ['Overcast', 'Hot', 'Normal', 'False'], ['Rain', 'Mild', 'High',
'True']]
attributes = ['Outlook', 'Temperature', 'Humidity', 'Play Tennis']
tree = id3(data, [i for i in range(len(data[0])-1)], len(data[0])-1)
print("Decision Tree:", tree)
sample = ['Rain', 'Mild', 'High']
prediction = classify(tree, sample)
print("Prediction for sample", sample, ":", prediction)
Backpropagation algorithm --
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, StandardScaler
iris = datasets.load_iris()
X, y = iris.data, iris.target
y = OneHotEncoder().fit_transform(y.reshape(-1, 1)).toarray()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train = StandardScaler().fit_transform(X_train)
X_test = StandardScaler().transform(X_test)
input_size, hidden_size, output_size = 4, 8, 3
W1, b1, W2, b2 = np.random.randn(input_size, hidden_size), np.zeros((1, hidden_size)),
np.random.randn(hidden_size, output_size), np.zeros((1, output_size))
sigmoid = lambda x: 1 / (1 + np.exp(-x))
sigmoid_derivative = lambda x: x * (1 - x)
def backpropagation(X, y, learning_rate=0.1, epochs=10000):
for _ in range(epochs):
layer1 = sigmoid(np.dot(X, W1) + b1)
layer2 = sigmoid(np.dot(layer1, W2) + b2)
error = y - layer2
delta2 = error * sigmoid_derivative(layer2)
W2_grad, b2_grad = np.dot(layer1.T, delta2), np.sum(delta2, axis=0, keepdims=True)
delta1 = np.dot(delta2, W2.T) * sigmoid_derivative(layer1)
W1_grad, b1_grad = np.dot(X.T, delta1), np.sum(delta1, axis=0, keepdims=True)
W2 += learning_rate * W2_grad
b2 += learning_rate * b2_grad
W1 += learning_rate * W1_grad
b1 += learning_rate * b1_grad
return W1, b1, W2, b2
W1, b1, W2, b2 = backpropagation(X_train, y_train)
def predict(X, W1, b1, W2, b2):
layer1 = sigmoid(np.dot(X, W1) + b1)
layer2 = sigmoid(np.dot(layer1, W2) + b2)
return np.argmax(layer2, axis=1)
y_pred = predict(X_test, W1, b1, W2, b2)
accuracy = np.mean(y_pred == np.argmax(y_test, axis=1))
print(f"Test accuracy: {accuracy * 100:.2f}%")
naïve Bayesian classifier—
import csv
import math
def load_data(filename):
return [row for row in csv.reader(open(filename))]
def split_data(data):
features = [row[:-1] for row in data]
labels = [row[-1] for row in data]
return features, labels
def get_stats(feature):
values = [float(x) for x in feature if x.isdigit()]
mean = sum(values) / len(values)
stdev = (sum((x - mean) ** 2 for x in values) / len(values)) ** 0.5
return mean, stdev
def pdf(x, mean, stdev):
return math.exp(-((x - mean) ** 2) / (2 * stdev ** 2)) / (stdev * math.sqrt(2 * math.pi))
def prob_cat(value, values):
return values.count(value) / len(values)
def train(features, labels):
label_counts = {label: labels.count(label) for label in set(labels)}
feature_stats = [{label: [float(feat) if feat.isdigit() else feat for feat in feats] for label, feats
in zip([label] * len(features), zip(*features))} for label in set(labels)]
for i, feature in enumerate(feature_stats):
for label, values in feature.items():
if all(isinstance(val, float) for val in values):
mean, stdev = get_stats(values)
feature[label] = (mean, stdev)
return label_counts, feature_stats
def classify(feature_vector, label_counts, feature_stats):
label_probs = {label: math.log(count / sum(label_counts.values())) for label, count in
label_counts.items()}
for i, feature_value in enumerate(feature_vector):
for label, stats in feature_stats[i].items():
if isinstance(stats, tuple):
mean, stdev = stats
label_probs[label] += math.log(pdf(float(feature_value), mean, stdev))
else:
label_probs[label] += math.log(prob_cat(feature_value, stats))
return max(label_probs.items(), key=lambda x: x[1])[0]
def compute_accuracy(test_features, test_labels, label_counts, feature_stats):
correct = sum(classify(feature_vector, label_counts, feature_stats) == label for
feature_vector, label in zip(test_features, test_labels))
return correct / len(test_labels)
training_data = load_data('training_data.csv')
features, labels = split_data(training_data)
label_counts, feature_stats = train(features, labels)
test_data = load_data('test_data.csv')
test_features, test_labels = split_data(test_data)
accuracy = compute_accuracy(test_features, test_labels, label_counts, feature_stats)
print(f"Accuracy: {accuracy * 100:.2f}%")
Bayesian network—
from pgmpy.models import BayesianModel
from pgmpy.estimators import MaximumLikelihoodEstimator
# Construct the Bayesian network
model = BayesianModel([('age', 'num'), ('sex', 'num'), ('cp', 'num'), ('trestbps', 'num'), ('chol',
'num'), ('fbs', 'num'), ('restecg', 'num'), ('thalach', 'num'), ('exang', 'num'), ('oldpeak', 'num'),
('slope', 'num'), ('ca', 'num'), ('thal', 'num')])
# Estimate the parameters of the Bayesian network
estimator = MaximumLikelihoodEstimator(model, heart_data)
estimator.estimate()
# Perform inference
inference = model.fit(heart_data)
# Example: Predict the probability of heart disease for a new patient
patient_data = {'age': 50, 'sex': 1, 'cp': 3, 'trestbps': 130, 'chol': 250, 'fbs': 0, 'restecg': 0,
'thalach': 180, 'exang': 0, 'oldpeak': 0.8, 'slope': 2, 'ca': 0, 'thal': 3}
# Convert categorical variables to integer values for the new patient
patient_data = pd.DataFrame([patient_data]).replace({'cp': {0: 'cp_0', 1: 'cp_1', 2: 'cp_2', 3:
'cp_3'}, 'restecg': {0: 'restecg_0', 1: 'restecg_1', 2: 'restecg_2'}, 'slope': {0: 'slope_0', 1:
'slope_1', 2: 'slope_2'}, 'thal': {0: 'thal_0', 1: 'thal_1', 2: 'thal_2', 3: 'thal_3'}})
# Perform inference for the new patient
query = inference.map_query('num', patient_data)
# Print the probability of heart disease
print(f"Probability of heart disease: {query.values[-1]:.2f}")
EM algorithm—
import pandas as pd
from sklearn.mixture import GaussianMixture
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
# Load the dataset from a CSV file
data = pd.read_csv('dataset.csv')
X = data.iloc[:, :-1].values # Features
y = data.iloc[:, -1].values # Labels (for evaluation purposes)
# EM Clustering
print("EM Clustering:")
em = GaussianMixture(n_components=3, covariance_type='full', max_iter=100,
random_state=42)
em_labels = em.fit_predict(X)
em_score = silhouette_score(X, em_labels)
print(f"Silhouette Score: {em_score:.2f}")
# k-Means Clustering
print("\nk-Means Clustering:")
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans_labels = kmeans.fit_predict(X)
kmeans_score = silhouette_score(X, kmeans_labels)
print(f"Silhouette Score: {kmeans_score:.2f}")
# Compare the results
print("\nComparison:")
if em_score > kmeans_score:
print("EM algorithm performs better than k-Means for this dataset.")
else:
print("k-Means algorithm performs better than EM for this dataset.")
k-Nearest Neighbour algorithm—
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# Load the iris dataset
iris = load_iris()
X, y = iris.data, iris.target
# Split the dataset into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Create a kNN classifier object
knn = KNeighborsClassifier(n_neighbors=3)
# Train the classifier
knn.fit(X_train, y_train)
# Make predictions on the test set
y_pred = knn.predict(X_test)
# Calculate the accuracy
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")
# Print correct and wrong predictions
print("\nCorrect Predictions:")
correct_indices = [i for i, (pred, true) in enumerate(zip(y_pred, y_test)) if pred == true]
for i in correct_indices:
print(f"Instance {i+1}: Predicted: {iris.target_names[y_pred[i]]} (Correct:
{iris.target_names[y_test[i]]})")
print("\nWrong Predictions:")
wrong_indices = [i for i, (pred, true) in enumerate(zip(y_pred, y_test)) if pred != true]
for i in wrong_indices:
print(f"Instance {i+1}: Predicted: {iris.target_names[y_pred[i]]} (Correct:
{iris.target_names[y_test[i]]})")
non-parametric Locally Weighted Regression algorithm—
import numpy as np
import matplotlib.pyplot as plt
# Sample dataset
X = np.linspace(-3, 3, 50)
y = np.sin(X) + np.random.normal(0, 0.2, len(X))
# Function to calculate the weight for a given x and x_i
def weight(x, x_i, tau):
return np.exp(-(x - x_i)**2 / (2 * tau**2))
# LWR function
def lwr(x, X, y, tau):
weights = np.array([weight(x, x_i, tau) for x_i in X])
W = np.diag(weights)
X_mat = np.vstack([np.ones(len(X)), X]).T
theta = np.linalg.pinv(X_mat.T @ W @ X_mat) @ (X_mat.T @ W @ y)
return theta[1]
# LWR predictions
tau = 1.0
y_pred = [lwr(x_val, X, y, tau) for x_val in X]
# Plot the data and LWR fit
plt.figure(figsize=(10, 6))
plt.scatter(X, y, label='Data Points', color='b', marker='o')
plt.plot(X, y_pred, label='LWR Fit', color='r')
plt.xlabel('X')
plt.ylabel('y')
plt.title('Locally Weighted Regression')
plt.legend()
plt.show()
