1.....................................................................................................

......................................................................................................
#Implement and demonstrate the FIND-Salgorithm
import pandas as pd

def load_data(filename):
"""Load dataset from a CSV file."""
return pd.read_csv(filename)

def find_s_algorithm(data):
"""Implements the Find-S algorithm for learning the most specific hypothesis."""
# Extract attributes and target column
attributes = data.iloc[:, :-1].values # All columns except last
target = data.iloc[:, -1].values # Last column (Yes/No)

# Initialize the most specific hypothesis (ϕ, ϕ, ϕ, ...)

hypothesis = ["ϕ"] * len(attributes[0])

# Find first positive example to initialize hypothesis

for i in range(len(target)):
if target[i].lower() == "yes":
hypothesis = attributes[i].copy()
break

# Iterate over all examples to refine hypothesis

for i in range(len(target)):
if target[i].lower() == "yes":
for j in range(len(hypothesis)):
if hypothesis[j] != attributes[i][j]:
hypothesis[j] = "?"

return hypothesis

if __name__ == "__main__":
# Load dataset
filename = r"C:\Users\rahul\OneDrive\Desktop\mldata\training_data.csv" # Change
filename as needed
data = load_data(filename)

# Run Find-S algorithm

specific_hypothesis = find_s_algorithm(data)

# Print the result

print("Most Specific Hypothesis:", specific_hypothesis)

2...................................................................................
....................................................................................
import pandas as pd
import numpy as np

def load_data(filename):
"""Load training data from a CSV file."""
data = pd.read_csv(r'C:\Users\rahul\OneDrive\Desktop\mldata\training_data.csv')
return data

def candidate_elimination(data):
"""Implements the Candidate-Elimination Algorithm."""
 attributes = data.columns[:-1] # Exclude target column
target = data.columns[-1] # Target column

# Initialize G to the most general hypothesis

G = [['?' for _ in range(len(attributes))]] # General boundary
# Initialize S to the most specific hypothesis
S = ['ϕ' for _ in range(len(attributes))] # Specific boundary

for i, row in data.iterrows():

instance = row[:-1].values # Feature values
label = row.iloc[-1] # Correct way to access the last column
# Class label

if label == 'Yes': # Positive example

# Remove inconsistent hypotheses from G
G = [g for g in G if is_consistent(instance, g)]

# Generalize S if necessary
for j in range(len(S)):
if S[j] == 'ϕ': # Initialize S with first positive example
S = instance.copy()
elif S[j] != instance[j]:
S[j] = '?' # Generalize S

elif label == 'No': # Negative example

# Remove inconsistent hypotheses from S
S = [S] if is_consistent(instance, S) else []

# Specialize G where necessary

new_G = []
for g in G:
if is_consistent(instance, g):
for j in range(len(g)):
if g[j] == '?':
for val in np.unique(data.iloc[:, j]):
if val != instance[j]:
new_hypothesis = g.copy()
new_hypothesis[j] = val
new_G.append(new_hypothesis)
else:
new_G.append(g)
G = new_G

return S, G

def is_consistent(instance, hypothesis):

"""Checks if an instance is consistent with a hypothesis."""
for i in range(len(instance)):
if hypothesis[i] != '?' and hypothesis[i] != instance[i]:
return False
return True

if __name__ == "__main__":
filename = "training_data.csv" # Replace with actual CSV filename
data = load_data(filename)
S_final, G_final = candidate_elimination(data)
 print("Final Specific Hypothesis:", S_final)
print("Final General Hypotheses:", G_final)

3..................................................................................
....................................................................................

#Write a program to demonstrate the working of the decision tree based ID3 algorithm. Use
an appropriate data set for building the decision tree and apply this knowledge toclassify a
new sample

import numpy as np
import pandas as pd
from collections import Counter

# Function to calculate entropy

def entropy(data):
labels = data.iloc[:, -1]
label_counts = Counter(labels)
total = len(labels)
return -sum((count / total) * np.log2(count / total) for count in label_counts.values())

# Function to calculate information gain

def info_gain(data, split_attribute):
total_entropy = entropy(data)
values, counts = np.unique(data[split_attribute], return_counts=True)
weighted_entropy = sum((counts[i] / sum(counts)) * entropy(data[data[split_attribute] ==
values[i]]) for i in range(len(values)))
return total_entropy - weighted_entropy

# Function to build the ID3 decision tree

def id3(data, attributes):
labels = data.iloc[:, -1]
if len(set(labels)) == 1:
return labels.iloc[0]
if len(attributes) == 0:
return labels.mode()[0]

best_attr = max(attributes, key=lambda attr: info_gain(data, attr))

tree = {best_attr: {}}

for value in np.unique(data[best_attr]):

subset = data[data[best_attr] == value].drop(columns=[best_attr])
tree[best_attr][value] = id3(subset, [attr for attr in attributes if attr != best_attr])

return tree

# Function to classify a new sample

def classify(tree, sample):
if not isinstance(tree, dict):
return tree
attribute = next(iter(tree))
if sample[attribute] in tree[attribute]:
return classify(tree[attribute][sample[attribute]], sample)
else:
return "Unknown"

# Sample dataset (PlayTennis)

data = pd.DataFrame({
'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rain', 'Rain', 'Rain', 'Overcast', 'Sunny', 'Sunny', 'Rain',
'Sunny', 'Overcast', 'Overcast', 'Rain'],
'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Cool', 'Mild', 'Cool', 'Mild', 'Mild', 'Mild',
'Hot', 'Mild'],
'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'Normal',
'Normal', 'High', 'Normal', 'High'],
'Wind': ['Weak', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Weak', 'Weak',
'Strong', 'Strong', 'Weak', 'Strong'],
'PlayTennis': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No']
})

# Build the decision tree

tree = id3(data, ['Outlook', 'Temperature', 'Humidity', 'Wind'])
print("Decision Tree:")
print(tree)

# Classify a new sample

new_sample = {'Outlook': 'Sunny', 'Temperature': 'Cool', 'Humidity': 'High', 'Wind': 'Strong'}
result = classify(tree, new_sample)
print("Classification Result:", result)

4........................................................................................................
.........................................................................................................
import numpy as np

# Activation function (Sigmoid) and its derivative

def sigmoid(x):
return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
return x * (1 - x)

# Training data (XOR problem)

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

# Initialize weights and biases

input_layer_neurons = 2
hidden_layer_neurons = 2
output_layer_neurons = 1

np.random.seed(42)
weights_input_hidden = np.random.uniform(size=(input_layer_neurons, hidden_layer_neurons))
weights_hidden_output = np.random.uniform(size=(hidden_layer_neurons,
output_layer_neurons))
bias_hidden = np.random.uniform(size=(1, hidden_layer_neurons))
bias_output = np.random.uniform(size=(1, output_layer_neurons))

# Training the neural network

learning_rate = 0.5
epochs = 10000

for epoch in range(epochs):

# Forward pass
hidden_layer_activation = np.dot(X, weights_input_hidden) + bias_hidden
hidden_layer_output = sigmoid(hidden_layer_activation)
 output_layer_activation = np.dot(hidden_layer_output, weights_hidden_output) +
bias_output
predicted_output = sigmoid(output_layer_activation)

# Backpropagation
error = y - predicted_output
d_predicted_output = error * sigmoid_derivative(predicted_output)

error_hidden_layer = d_predicted_output.dot(weights_hidden_output.T)
d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)

# Update weights and biases

weights_hidden_output += hidden_layer_output.T.dot(d_predicted_output) * learning_rate
bias_output += np.sum(d_predicted_output, axis=0, keepdims=True) * learning_rate
weights_input_hidden += X.T.dot(d_hidden_layer) * learning_rate
bias_hidden += np.sum(d_hidden_layer, axis=0, keepdims=True) * learning_rate

# Testing the trained ANN

def predict(sample):
hidden_layer_activation = np.dot(sample, weights_input_hidden) + bias_hidden
hidden_layer_output = sigmoid(hidden_layer_activation)
output_layer_activation = np.dot(hidden_layer_output, weights_hidden_output) +
bias_output
return sigmoid(output_layer_activation)

# Test samples
test_samples = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
predictions = predict(test_samples)
print("Predictions:")
print(predictions)

5.....................................................................................................
........................................................................................................

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import accuracy_score

# Load dataset from CSV file

def load_data(filename):
return pd.read_csv(filename)

# Train Naïve Bayes classifier

def train_naive_bayes(data):
X = data.iloc[:, :-1] # Features
y = data.iloc[:, -1] # Labels
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = GaussianNB()
model.fit(X_train, y_train)
return model, X_train, X_test, y_train, y_test

# Compute accuracy of the classifier

def compute_accuracy(model, X_test, y_test):
y_pred = model.predict(X_test)
return accuracy_score(y_test, y_pred)
# Main function
def main():
filename = 'dataset.csv' # Change this to your actual dataset file
data = load_data(filename)
model, X_train, X_test, y_train, y_test = train_naive_bayes(data)
accuracy = compute_accuracy(model, X_test, y_test)
print(f'Naïve Bayes Classifier Accuracy: {accuracy * 100:.2f}%')

# Test with a few test data sets

sample_tests = X_test[:5]
predictions = model.predict(sample_tests)
print("Sample Test Predictions:")
for i, pred in enumerate(predictions):
print(f'Test {i+1}: Predicted - {pred}, Actual - {y_test.iloc[i]}')

if __name__ == "__main__":
main()

6...............................................................................
.................................................................................

import java.io.*;
import java.util.*;
import weka.classifiers.bayes.NaiveBayes;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;
import weka.classifiers.Evaluation;

public class NaiveBayesTextClassifier {

public static void main(String[] args) {
try {
// Load dataset from ARFF file (convert CSV to ARFF if needed)
DataSource source = new DataSource("dataset.arff");
Instances dataset = source.getDataSet();

// Set class attribute (last column as label)

dataset.setClassIndex(dataset.numAttributes() - 1);

// Split dataset into training and testing sets (80% train, 20% test)
int trainSize = (int) Math.round(dataset.numInstances() * 0.8);
int testSize = dataset.numInstances() - trainSize;
Instances trainSet = new Instances(dataset, 0, trainSize);
Instances testSet = new Instances(dataset, trainSize, testSize);

// Train Naïve Bayes model

NaiveBayes model = new NaiveBayes();
model.buildClassifier(trainSet);

// Evaluate the model

Evaluation eval = new Evaluation(trainSet);
eval.evaluateModel(model, testSet);

// Print evaluation metrics

System.out.println("Accuracy: " + (1 - eval.errorRate()) * 100 + "%");
System.out.println("Precision: " + eval.precision(1));
 System.out.println("Recall: " + eval.recall(1));
System.out.println("F1 Score: " + eval.fMeasure(1));
} catch (Exception e) {
e.printStackTrace();
}
}
}

7.....................................................................................
......................................................................................

import pandas as pd
from pgmpy.models import BayesianModel
from pgmpy.estimators import MaximumLikelihoodEstimator
from pgmpy.inference import VariableElimination

# Load Heart Disease dataset

data = pd.read_csv("heart_disease.csv")

# Define the Bayesian Network structure

model = BayesianModel([
('Age', 'HeartDisease'), ('Sex', 'HeartDisease'),
('ChestPain', 'HeartDisease'), ('Cholesterol', 'HeartDisease'),
('BloodPressure', 'HeartDisease')
])

# Learn CPDs (Conditional Probability Distributions) using Maximum Likelihood Estimation

model.fit(data, estimator=MaximumLikelihoodEstimator)

# Perform inference
inference = VariableElimination(model)

# Example query: Probability of Heart Disease given some conditions

query_result = inference.query(variables=['HeartDisease'], evidence={'Age': 55, 'Cholesterol':
230})
print(query_result)

8...........................................................................................
............................................................................................
import pandas as pd
import numpy as np
from sklearn.mixture import GaussianMixture
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
from sklearn.preprocessing import StandardScaler

# Load dataset from CSV file

def load_data(filename):
data = pd.read_csv(filename)
return data

# Apply EM algorithm (Gaussian Mixture Model) for clustering

def em_clustering(data, n_clusters):
gmm = GaussianMixture(n_components=n_clusters, random_state=42)
labels = gmm.fit_predict(data)
return labels
# Apply k-Means clustering
def kmeans_clustering(data, n_clusters):
kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
labels = kmeans.fit_predict(data)
return labels

# Main function
def main():
filename = 'dataset.csv' # Change this to your dataset file
data = load_data(filename)

# Preprocess data (Standardization)

scaler = StandardScaler()
data_scaled = scaler.fit_transform(data)

n_clusters = 3 # Change the number of clusters as needed

# Apply EM clustering
em_labels = em_clustering(data_scaled, n_clusters)

# Apply k-Means clustering

kmeans_labels = kmeans_clustering(data_scaled, n_clusters)

# Evaluate clustering quality using Silhouette Score

em_silhouette = silhouette_score(data_scaled, em_labels)
kmeans_silhouette = silhouette_score(data_scaled, kmeans_labels)

print(f'EM Clustering Silhouette Score: {em_silhouette:.4f}')

print(f'K-Means Clustering Silhouette Score: {kmeans_silhouette:.4f}')

if em_silhouette > kmeans_silhouette:

print("EM algorithm provides better clustering quality.")
else:
print("K-Means provides better clustering quality.")

if __name__ == "__main__":
main()
9...................................................................
....................................................................

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Load the Iris dataset

df = pd.read_csv("iris.csv") # Ensure the file is in the correct directory

# Split dataset into features and target variable

X = df.iloc[:, :-1]
y = df.iloc[:, -1]

# Split 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)
# Normalize the data
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Train k-NN classifier

k = 3 # Choose k value
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train, y_train)

# Make predictions
y_pred = knn.predict(X_test)

# Evaluate accuracy
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy: {accuracy * 100:.2f}%')

# Print correct and incorrect predictions

correct = []
incorrect = []
for i in range(len(y_test)):
if y_pred[i] == y_test.iloc[i]:
correct.append((X_test[i], y_pred[i]))
else:
incorrect.append((X_test[i], y_pred[i], y_test.iloc[i]))

print("\nCorrect Predictions:")
for item in correct:
print(f'Predicted: {item[1]}')

print("\nIncorrect Predictions:")
for item in incorrect:
print(f'Predicted: {item[1]}, Actual: {item[2]}')

10..............................................................................................
................................................................................................

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

def kernel(x, x_point, tau):

return np.exp(-np.sum((x - x_point) ** 2, axis=1) / (2 * tau ** 2))

def locally_weighted_regression(X_train, y_train, x_query, tau):

W = np.diag(kernel(X_train, x_query, tau))
theta = np.linalg.pinv(X_train.T @ W @ X_train) @ X_train.T @ W @ y_train
return x_query @ theta

# Generate synthetic dataset

np.random.seed(42)
X = np.linspace(-5, 5, 100).reshape(-1, 1)
y = np.sin(X).ravel() + np.random.normal(0, 0.2, X.shape[0])

# Add bias term

X_bias = np.c_[np.ones(X.shape[0]), X]
# Split dataset
X_train, X_test, y_train, y_test = train_test_split(X_bias, y, test_size=0.2, random_state=42)

# Fit Locally Weighted Regression

tau = 0.5 # Bandwidth parameter
y_pred = np.array([locally_weighted_regression(X_train, y_train, x, tau) for x in X_test])

# Plot results
plt.scatter(X[:, 1], y, label='Data', color='blue', alpha=0.5)
plt.scatter(X_test[:, 1], y_pred, label='Predictions', color='red', marker='x')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.title('Locally Weighted Regression')
plt.show()