import numpy as np

import pandas as pd

# Load the data

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

concepts = np.array(data.iloc[:, :-1]) # All columns except the last

target = np.array(data.iloc[:, -1]) # Last column as target

def learn(concepts, target):

# Initialize specific and general hypotheses

specific_h = concepts[0].copy()

print("Initialization of specific_h and general_h:")

print(f"Specific_h: {specific_h}")

# Initialize general_h with '?' placeholders

general_h = [["?" for _ in range(len(specific_h))] for _ in range(len(specific_h))]

print(f"General_h: {general_h}")

for i, h in enumerate(concepts):

if target[i] == "yes":

# Positive example: update specific_h and general_h

for x in range(len(specific_h)):

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

specific_h[x] = '?'

general_h[x][x] = '?'

elif target[i] == "no":

# Negative example: update general_h

 for x in range(len(specific_h)):

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

general_h[x][x] = specific_h[x]

else:

general_h[x][x] = 'x'

print(f"Step {i + 1}")

print(f"Specific_h: {specific_h}")

print(f"General_h: {general_h}")

# Remove any general hypotheses that are completely '?'

indices = [i for i, val in enumerate(general_h) if val == ['?' for _ in range(len(specific_h))]]

for i in indices:

general_h.remove(['?' for _ in range(len(specific_h))])

return specific_h, general_h

# Run the learning algorithm

specific_h, general_h_final = learn(concepts, target)

# Print final results

print("\nFinal Specific_h:")

print(specific_h)

print("\nFinal General_h:")

print(general_h_final)
2)

import pandas as pd

import numpy as np

# Load dataset

dataset = pd.read_csv('playtennis.csv', names=['outlook', 'temperature', 'humidity', 'wind', 'class'])

# Entropy function

def entropy(target_col):

elements, counts = np.unique(target_col, return_counts=True)

entropy_value = np.sum([-(counts[i] / np.sum(counts)) * np.log2(counts[i] / np.sum(counts)) for i

in range(len(elements))])

return entropy_value

# Information Gain function

def InfoGain(data, split_attribute_name, target_name="class"):

total_entropy = entropy(data[target_name])

vals, counts = np.unique(data[split_attribute_name], return_counts=True)

Weighted_Entropy = np.sum([(counts[i] / np.sum(counts)) *

entropy(data.where(data[split_attribute_name] == vals[i]).dropna()[target_name]) for i in
range(len(vals))])

Information_Gain = total_entropy - Weighted_Entropy

return Information_Gain

# ID3 Algorithm

def ID3(data, Originaldata, features, target_attribute_name="class", parent_node_class=None):

if len(np.unique(data[target_attribute_name])) <= 1:

return np.unique(data[target_attribute_name])[0]
 elif len(data) == 0:

return np.unique(Originaldata[target_attribute_name])
[np.argmax(np.unique(Originaldata[target_attribute_name], return_counts=True)[1])]

elif len(features) == 0:

return parent_node_class

else:

parent_node_class = np.unique(data[target_attribute_name])
[np.argmax(np.unique(data[target_attribute_name], return_counts=True)[1])]

item_values = [InfoGain(data, feature, target_attribute_name) for feature in features]

best_feature_index = np.argmax(item_values)

best_feature = features[best_feature_index]

tree = {best_feature: {}}

features = [i for i in features if i != best_feature]

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

sub_data = data.where(data[best_feature] == value).dropna()

subtree = ID3(sub_data, Originaldata, features, target_attribute_name, parent_node_class)

tree[best_feature][value] = subtree

return tree

# Run ID3

tree = ID3(dataset, dataset, dataset.columns[:-1].tolist())

print("\nDecision Tree:\n", tree)

3)
import numpy as np

# Input and Output Data

X = np.array(([2, 9], [1, 5], [3, 6]), dtype=float)

y = np.array(([92], [86], [89]), dtype=float)

# Normalize Input and Output Data

X = X / np.amax(X, axis=0) # Feature scaling

y = y / 100 # Normalizing output values

# Sigmoid Activation Function

def sigmoid(x):

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

# Derivative of Sigmoid Function

def derivative_sigmoid(x):

return x * (1 - x)

# Initialize Neural Network Parameters

epochs = 7000 # Number of training iterations

lr = 0.1 # Learning rate

input_neurons = 2 # Input layer neurons

hidden_neurons = 3 # Hidden layer neurons

output_neurons = 1 # Output layer neurons

# Initialize Weights and Biases

wh = np.random.uniform(size=(input_neurons, hidden_neurons)) # Weights from Input to Hidden

layer
bh = np.random.uniform(size=(1, hidden_neurons)) # Bias for Hidden layer

wout = np.random.uniform(size=(hidden_neurons, output_neurons)) # Weights from Hidden to

Output layer

bout = np.random.uniform(size=(1, output_neurons)) # Bias for Output layer

# Training the Neural Network

for i in range(epochs):

# Forward Propagation

hinp = np.dot(X, wh) + bh # Hidden layer weighted sum

hlayer_act = sigmoid(hinp) # Activation function at hidden layer

outinp = np.dot(hlayer_act, wout) + bout # Output layer weighted sum

output = sigmoid(outinp) # Activation function at output layer

# Backpropagation

EO = y - output # Error at output layer

outgrad = derivative_sigmoid(output) # Output layer gradient

d_output = EO * outgrad # Delta output

EH = d_output.dot(wout.T) # Error at hidden layer

hiddengrad = derivative_sigmoid(hlayer_act) # Hidden layer gradient

d_hiddenlayer = EH * hiddengrad # Delta hidden layer

# Updating Weights and Biases

wout += hlayer_act.T.dot(d_output) * lr

bout += np.sum(d_output, axis=0, keepdims=True) * lr

wh += X.T.dot(d_hiddenlayer) * lr

bh += np.sum(d_hiddenlayer, axis=0, keepdims=True) * lr

# Print Final Results

print("Input:\n", X)

print("Actual Output:\n", y)

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

4)

import numpy as np

# Input and Output Data

X = np.array(([2, 9], [1, 5], [3, 6]), dtype=float)

y = np.array(([92], [86], [89]), dtype=float)

# Normalize Input and Output Data

X = X / np.amax(X, axis=0) # Feature scaling

y = y / 100 # Normalizing output values

# Sigmoid Activation Function

def sigmoid(x):

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

# Derivative of Sigmoid Function

def derivative_sigmoid(x):

return x * (1 - x)
# Initialize Neural Network Parameters

epochs = 7000 # Number of training iterations

lr = 0.1 # Learning rate

input_neurons = 2 # Input layer neurons

hidden_neurons = 3 # Hidden layer neurons

output_neurons = 1 # Output layer neurons

# Initialize Weights and Biases

wh = np.random.uniform(size=(input_neurons, hidden_neurons)) # Weights from Input to Hidden

layer

bh = np.random.uniform(size=(1, hidden_neurons)) # Bias for Hidden layer

wout = np.random.uniform(size=(hidden_neurons, output_neurons)) # Weights from Hidden to

Output layer

bout = np.random.uniform(size=(1, output_neurons)) # Bias for Output layer

# Training the Neural Network

for i in range(epochs):

# Forward Propagation

hinp = np.dot(X, wh) + bh # Hidden layer weighted sum

hlayer_act = sigmoid(hinp) # Activation function at hidden layer

outinp = np.dot(hlayer_act, wout) + bout # Output layer weighted sum

output = sigmoid(outinp) # Activation function at output layer

# Backpropagation

EO = y - output # Error at output layer

outgrad = derivative_sigmoid(output) # Output layer gradient

d_output = EO * outgrad # Delta output

 EH = d_output.dot(wout.T) # Error at hidden layer

hiddengrad = derivative_sigmoid(hlayer_act) # Hidden layer gradient

d_hiddenlayer = EH * hiddengrad # Delta hidden layer

# Updating Weights and Biases

wout += hlayer_act.T.dot(d_output) * lr

bout += np.sum(d_output, axis=0, keepdims=True) * lr

wh += X.T.dot(d_hiddenlayer) * lr

bh += np.sum(d_hiddenlayer, axis=0, keepdims=True) * lr

# Print Final Results

print("Input:\n", X)

print("Actual Output:\n", y)

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

5)

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

# Load dataset

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

# Print dataset dimensions

print('The dimensions of the dataset:', msg.shape)

# Map labels to numerical values

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

# Split into input (X) and output (y)

X = msg.message

y = msg.labelnum

# Train-test split (with fixed random state for reproducibility)

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

# Print shapes of splits

print("xtest.shape:", xtest.shape)

print("xtrain.shape:", xtrain.shape)

print("ytest.shape:", ytest.shape)

print("ytrain.shape:", ytrain.shape)

# Convert text to numerical features using CountVectorizer

count_vect = CountVectorizer()

xtrain_dtm = count_vect.fit_transform(xtrain)

xtest_dtm = count_vect.transform(xtest)

# Train Naïve Bayes model

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

# Predictions on test data

predicted_test = clf.predict(xtest_dtm)

# Accuracy metrics

print("Accuracy of the classifier:", metrics.accuracy_score(ytest, predicted_test))

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

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

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

6)

import csv

import random

import math

def loadCsv(filename):

lines=csv.reader(open(filename,"r"));

dataset=list(lines)

for i in range(len(dataset)):

dataset[i]=[float(x) for x in dataset[i]]

return dataset

def splitDataset(dataset,splitRatio):

trainSize=int(len(dataset)*splitRatio);

trainSet=[]

copy=list(dataset)
while len (trainSet)<trainsize:

index=random.randrange(len(copy));

trainSet,append(copy.pop(index))

return[trainSet,copy]

def separateByClass(dataset):

seperated={}

belonging to each class

for i in range(len(dataset));

vector=dataset[i]

if(vector[-1]not i9n separated):

separated[vector[-1]]=[]

separated[vector[-1]].append(vector)

return separated

def mean(numbers):

return sum(numbers)/float(len(numbers))

def stdev(numbers):

avg=mean(numbers)

variance=sum([pow(x-avg,2)for x in numbers])/float(len(numbers)-1)

return math.sqrt(variance)

def summarize(dataset):

smmaries=[(mean(attribute),stdev(attribute)) for attribute in zip(*dataset)];

del summaries[-1]

return summaries

def summarizeByClass(dataset):

separated=saparatedByClass(dataset);

summaries={}

for classValue,instance in separated.items():

summaries[classValue]=summarize(instance)

return summaries

def calculateProbability(x,mean,stdev):

exponent=math.exp(-(math.pow(*x-mean,2)/2*math.pow(stdev,2)))

return(1/(math.sqrt(2*math.pi)*stdev))*exponent

def calculateClassProbability(summari3es,inputVector):

probability={}

for class value,classsummariesw in summaries.items():

probabilities[classValue]=1

for i in range(len(classSummaries)):

mean,stdev=classSummaries[i]

x=inputVector[i]

probability[class value]* calculateProbability(x,mean,stdev);

normal dist

return probabilities

def predict(summaries,inputVector):

probabilities=calculateClassprpbabilities(summaries,inputVector)

bestLabel,bestprob=none,-1

for classValue,probability in probabilities.items()_:

highest prob

if best Label is NOne or probability>bestprob:

bestprpb=probability

bestlavel=classValue

return bestLabel

def getpredictions(summaries,testset)

predictions=[]

for i in range(len(testSet)):
 result=predict(summaries,testset[i])

predictions.append(result)

return predictions

def getAccuracy(testSet,predictions):

correct=0

for i in range(len(testSet)):

if testSet[i][-1]==predictions[i]:

corect+=1

return(correct/float(len(testset)))*100.0

def main():

filename='5data.csv'splitRatio=0.67

dataset=loadCsv(filename);

training set,testset=splitDataset(dataset,splitRatio)

print('split{0} rows into train={1} and test=2

rows'format(len(dataset),

len(training set),len(testSet)))

summaries=summarizeByclass(trainingset)

accuracy=getAccuracy(testSetr,predictions)

print('Accuarcy of the classifier is:

{0}%'.format(accuracy))

main()

7)
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

# Load dataset

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

print('The dimensions of the dataset:', msg.shape)

# Convert labels to numerical values

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

X = msg.message

y = msg.labelnum

# Split into training and testing sets

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

# Convert text data to numerical features using CountVectorizer

count_vect = CountVectorizer()

xtrain_dtm = count_vect.fit_transform(xtrain)

xtest_dtm = count_vect.transform(xtest)

# Train Naive Bayes model

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

# Predict on test data

predicted = clf.predict(xtest_dtm)

# Accuracy metrics

print('Accuracy of the classifier is:', metrics.accuracy_score(ytest, predicted))

print('Confusion matrix:')

print(metrics.confusion_matrix(ytest, predicted))

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

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

8)

import numpy as np

import pandas as pd

from pgmpy.models import BayesianNetwork

from pgmpy.estimators import MaximumLikelihoodEstimator

from pgmpy.inference import VariableElimination

# Read Cleveland Heart Disease data

heartDisease = pd.read_csv('heart.csv')

heartDisease = heartDisease.replace('?', np.nan)

# Display the data

print('Few examples from the dataset are given below:')

print(heartDisease.head())

# Define Bayesian Network Model

model = BayesianNetwork([

('age', 'trestbps'),

('age', 'fbs'),

('sex', 'trestbps'),

('exang', 'trestbps'),

('trestbps', 'heartdisease'),

('fbs', 'heartdisease'),

('heartdisease', 'restecg'),

('heartdisease', 'thalach'),

('heartdisease', 'chol')

])

print('\nLearning CPD using Maximum Likelihood Estimators...')

model.fit(heartDisease, estimator=MaximumLikelihoodEstimator)

print('\nInference with Bayesian Network:')

HeartDisease_infer = VariableElimination(model)

# Query 1: Probability of Heart Disease given Age=30

print('\n1. Probability of HeartDisease given Age=30')

q1 = HeartDisease_infer.query(variables=['heartdisease'], evidence={'age': 30})

print(q1)
# Query 2: Probability of Heart Disease given Cholesterol=100

print('\n2. Probability of HeartDisease given Cholesterol=100')

q2 = HeartDisease_infer.query(variables=['heartdisease'], evidence={'chol': 100})

print(q2)

9)

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.cluster import KMeans

from sklearn.mixture import GaussianMixture

# Load Data

X = pd.read_csv("kmeansdata.csv")

# Extract features

x1 = X['Distance_Feature'].values

x2 = X['Speeding_Feature'].values

X = np.column_stack((x1, x2))

# Plot dataset

plt.figure()

plt.xlim([0, 100])
plt.ylim([1, 50])

plt.title('Dataset')

plt.scatter(x1, x2)

plt.show()

# Gaussian Mixture Model (GMM)

gmm = GaussianMixture(n_components=3)

gmm.fit(X)

em_predictions = gmm.predict(X)

print("EM Predictions:\n", em_predictions)

print("Means:\n", gmm.means_)

print("\nCovariances:\n", gmm.covariances_)

# Plot GMM Clusters

plt.title('Expectation Maximization')

plt.scatter(X[:, 0], X[:, 1], c=em_predictions, s=50)

plt.show()

# K-Means Clustering

kmeans = KMeans(n_clusters=3, n_init=10)

kmeans.fit(X)

print("Cluster Centers:\n", kmeans.cluster_centers_)

print("Cluster Labels:\n", kmeans.labels_)

# Plot K-Means Clusters

plt.title('K-Means Clustering')

plt.scatter(X[:, 0], X[:, 1], c=kmeans.labels_, s=50)

plt.show()

10)

import numpy as np

import pandas as pd

from sklearn.neighbors import KNeighborsClassifier

from sklearn.model_selection import train_test_split

from sklearn import metrics

from sklearn.datasets import load_iris

# Load dataset

iris = load_iris()

df = pd.DataFrame(iris['data'], columns=iris['feature_names'])

X = df

y = iris['target']

# Split 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)

# Initialize and train KNN classifier

classifier = KNeighborsClassifier(n_neighbors=3)

classifier.fit(X_train, y_train)
# Make predictions

y_pred = classifier.predict(X_test)

# Print first few predictions alongside actual values

print("\n-----------------------------------")

print(f"{'Actual Label':<25}{'Predicted Label':<25}{'Result':<25}")

print("-----------------------------------")

for i in range(len(y_test)):

result = "Correct" if y_test[i] == y_pred[i] else "Wrong"

print(f"{y_test[i]:<25}{y_pred[i]:<25}{result:<25}")

print("--------------------------------------")

# Confusion Matrix

print("\nConfusion Matrix:\n", metrics.confusion_matrix(y_test, y_pred))

print("---------------------------------------")

# Classification Report

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

print("---------------------------------------")

# Accuracy of the classifier

accuracy = metrics.accuracy_score(y_test, y_pred)

print(f'Accuracy of the Classifier is {accuracy:.2f}%')

print("------------------------------")

11) import matplotlib.pyplot as plt

import pandas as pd

import as np

def kernel(point,xmat,k):

m,n=np.mat(np1.eye((m)))

for j in range(m):

diff=point-x[j]

weights[j,j]=np.exp(diff.T/(-2*k***2))

return weights

def localWeight(point,xmat,ymat,k):

wei=kernel(point,xmat,k)

W=(X.T*(wi*X)).I*(wei*ymat.T))

return W

def localWeightRegression(xmat,ymat,k):

m,n=np.shape(xmat)

ypred=np.zeros(m)

for i in range(m)

for i in range(m):

ypred[i]=xmat[i]*localWeight(xmat,ymat,k)

return ypred

data=pd.read_csv('10-dataset.csv')

bill=np.array(data.total_bill)

tip=np.array(data.tip)

mbill=np.mat(bill)

data=pd.read_csv("/Users/HP/Downloads/10-dataset.csv")

bill=np.array(data.total_bill)

tip=np.array(data.tip)

mbill=np.mat(tip)
 m=np.shape(mbill)[1]

one=np.mat(np.ones(m))

x=np.hstack((one.Tmbill.T))

ypred=localWeightRegression(X,mtip,0.5)

SortIndex=X[:,1].argsort(0)

xsort=X[SortIndex][:,0]

fig=plt.figure()

ax=fig.add_subplot(1,1,1)

ax.scatter(bill,tip,color='green')

ax.plot(xsort[:,1],ypred[SortIndex],color='red',linewidth=5)

plt.xlabel('Total bill')

plt.ylabel('tip')

plt.show()

12)

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

# Function to calculate kernel weights

def kernel(point, xmat, k):

m, n = np.shape(xmat)

weights = np.mat(np.eye(m)) # Identity matrix

for j in range(m):

diff = point - xmat[j]

 weights[j, j] = np.exp(diff * diff.T / (-2 * k**2))

return weights

# Function to compute locally weighted regression coefficients

def localWeight(point, xmat, ymat, k):

wei = kernel(point, xmat, k)

W = (xmat.T * (wei * xmat)).I * (xmat.T * (wei * ymat.T))

return W

# Function to perform local weighted regression

def localWeightRegression(xmat, ymat, k):

m, n = np.shape(xmat)

ypred = np.zeros(m)

for i in range(m):

ypred[i] = xmat[i] * localWeight(xmat[i], xmat, ymat, k)

return ypred

# Load dataset

data = pd.read_csv("10-dataset.csv") # Ensure this file exists in the working directory

bill = np.array(data.total_bill)

tip = np.array(data.tip)

# Convert to matrices

mbill = np.mat(bill).T

mtip = np.mat(tip).T

# Construct X matrix with an additional ones column

m = np.shape(mbill)[0]

one = np.mat(np.ones(m)).T

X = np.hstack((one, mbill))

# Apply locally weighted regression

ypred = localWeightRegression(X, mtip, 0.5)

# Sorting for visualization

SortIndex = X[:, 1].argsort(0)

xsort = X[SortIndex][:, 0]

# Plot the data points and regression line

fig = plt.figure()

ax = fig.add_subplot(1, 1, 1)

ax.scatter(bill, tip, color='green', label="Data Points")

ax.plot(xsort[:, 1], ypred[SortIndex], color='red', linewidth=2, label="LOWESS Fit")

plt.xlabel('Total Bill')

plt.ylabel('Tip')

plt.legend()

plt.show()