Program – 1
▪ Write a program using 2d binary classification data generated by
make_circles() have a spherical decision boundary.
# Import necessary libraries
from sklearn.datasets import make_circles
import matplotlib.pyplot as plt
# Generate 2d classification dataset
X, y = make_circles(n_samples=200, shuffle=True,
noise=0.1, random_state=42)
# Plot the generated datasets
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()
Page | 1
Output :
Page | 2
Program – 2
▪ Write a program for Two interlocking half circles represent the 2d binary
classification data produced by the make_moons() function.
#import the necessary libraries
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt
# generate 2d classification dataset
X, y = make_moons(n_samples=500, shuffle=True,
noise=0.15, random_state=42)
# Plot the generated datasets
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()
Page | 3
Output :
Page | 4
Program – 3
▪ Write a program to generate the data by using the function make_blobs()
are blobs that can be utilized for clustering.
#import the necessary libraries
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
# Generate 2d classification dataset
X, y = make_blobs(n_samples=500, centers=3, n_features=2, random_state=23)
# Plot the generated datasets
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()
Page | 5
Output :
Page | 6
Program – 4
▪ Write a program to generate data by the function make_classification()
need to balance between n_informative, n_redundant and n_classes
attributes X[:, :n_informative + n_redundant + n_repeated]
#import the necessary libraries
from sklearn.datasets import make_classification
import matplotlib.pyplot as plt
# generate 2d classification dataset
X, y = make_classification(n_samples = 100,
n_features=2,
n_redundant=0,
n_informative=2,
n_repeated=0,
n_classes =3,
n_clusters_per_class=1)
# Plot the generated datasets
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()
Page | 7
Output :
Page | 8
Program – 5
▪ Write a Program for the implementation of Q-Learning (Reinforcement
Learning)
import numpy as np
import pylab as pl
import networkx as nx
edges = [(0, 1), (1, 5), (5, 6), (5, 4), (1, 2),
(1, 3), (9, 10), (2, 4), (0, 6), (6, 7),
(8, 9), (7, 8), (1, 7), (3, 9)]
goal = 10
G = nx.Graph()
G.add_edges_from(edges)
pos = nx.spring_layout(G)
nx.draw_networkx_nodes(G, pos)
nx.draw_networkx_edges(G, pos)
nx.draw_networkx_labels(G, pos)
pl.show()
Page | 9
Output :
Page | 10
Program – 6
▪ 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 to classify a new sample.
# Import necessary libraries
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
# Load a dataset (for example, using the iris dataset)
iris = datasets.load_iris()
X = iris.data
y = iris.target
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Create the decision tree classifier using ID3 algorithm (information gain)
clf = DecisionTreeClassifier(criterion="entropy")
# Train the classifier using the training data
clf.fit(X_train, y_train)
# Make predictions on the testing data
y_pred = clf.predict(X_test)
# Evaluate the performance of the classifier
print("Accuracy:", accuracy_score(y_test, y_pred))
print("\nConfusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("\nClassification Report:\n", classification_report(y_test, y_pred))
Page | 11
# Now, let's classify a new sample
new_sample = [[5.1, 3.5, 1.4, 0.2]] # example values for the new sample
predicted_class = clf.predict(new_sample)
print("\nPredicted class for new sample:", predicted_class)
Page | 12
output :
Page | 13
Program – 7
▪ Build an Artificial Neural Network by implementing the Backpropagation
algorithm and test the same using appropriate data sets.
import numpy as np
class NeuralNetwork:
def __init__(self, input_size, hidden_size, output_size):
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
self.learning_rate = 0.1
self.weights_input_hidden=np.random.rand(self.input_size
, self.hidden_size)
self.weights_hidden_output=np.random.rand(self.hidden_s
ize, self.output_size)
def sigmoid(self, x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(self, x):
return x * (1 - x)
def forward_propagation(self, input_data):
self.hidden_input = np.dot(input_data, self.weights_input_hidden)
self.hidden_output = self.sigmoid(self.hidden_input)
self.output = np.dot(self.hidden_output,
self.weights_hidden_output)
return self.output
def backward_propagation(self, input_data, target):
error = target - self.output
d_output = error * self.sigmoid_derivative(self.output)
error_hidden = d_output.dot(self.weights_hidden_output.T)
d_hidden = error_hidden *
self.sigmoid_derivative(self.hidden_output)
Page | 14
self.weights_hidden_output += self.hidden_output.T.dot(d_output) *
self.learning_rate
self.weights_input_hidden += input_data.T.dot(d_hidden) *
self.learning_rate
def train(self, input_data, target, epochs):
for _ in range(epochs):
output = self.forward_propagation(input_data)
self.backward_propagation(input_data, target)
def predict(self, input_data):
return self.forward_propagation(input_data)
# Example usage
input_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
target = np.array([[0], [1], [1], [0]])
# Create a neural network with 2 input nodes, 2 hidden nodes, and 1 output
node
nn = NeuralNetwork(2, 2, 1)
# Train the neural network
nn.train(input_data, target, epochs=10000)
# Test the neural network
print("Predictions:")
for i in range(len(input_data)):
print(f"Input: {input_data[i]},
Predicted Output: {nn.predict(input_data[i])}")
Page | 15
Output :
Page | 16
Program – 8
▪ Implement the non-parametric Locally Weighted Regression
algorithm in order to fit datapoints. Select appropriate data set for
your experiment and draw graphs.
import numpy as np
import matplotlib.pyplot as plt
# Generate a sample dataset
np.random.seed(0)
X = np.linspace(0, 10, 100)
y = 2 * X + 1 + np.random.normal(scale=2, size=100)
# Locally Weighted Regression function
def lowess(x, y, tau=0.1):
n = len(x)
y_hat = np.zeros(n)
for i in range(n):
weights = np.exp(-0.5 * ((x - x[i]) / tau) ** 2)
b = np.array([np.sum(weights * y), np.sum(weights * y * x)])
A = np.array([[np.sum(weights), np.sum(weights * x)],
[np.sum(weights * x), np.sum(weights * x * x)]])
theta = np.linalg.solve(A, b)
y_hat[i] = theta[0] + theta[1] * x[i]
return y_hat
# Fit the data using Locally Weighted Regression
tau = 0.3 # Bandwidth parameter
y_lowess = lowess(X, y, tau)
# Plot the original data and the fitted curve
plt.scatter(X, y, label='Original data', color='b')
plt.plot(X, y_lowess, label=f’LOWESS (tau={tau})', color='r')
plt.legend()
plt.show()
Page | 17
Output :
Page | 18
