EXPERIMENT-1
Aim: Write an application to build a perceptron.
Dataset Description: The dataset is synthetically generated with two features for each data
point. The labels are assigned based on whether the sum of the two features is greater than 0.
• Features:
o Two random values (x1, x2) generated between -1 and 1.
• Labels:
o A label of 1 is assigned if the sum of the two features (x1 + x2) is greater than
0.
o Otherwise, the label is 0.
Attributes:
1. X (Features):
o Shape: (num_examples, 2)
o Values are randomly generated between -1 and 1.
2. y (Labels):
o Shape: (num_examples,)
o Binary labels: 0 or 1 depending on whether the sum of the features is greater than 0.
Code:
import numpy as np
import matplotlib.pyplot as plt
# Generate dataset
def generate_dataset(num_examples):
np.random.seed(42)
X = np.random.rand(num_examples, 2) * 2 - 1 # Generate random points
y = (X[:, 0] + X[:, 1] > 0).astype(int) # Label: 1 if sum > 0, else 0
return X, y
# Train perceptron
def perceptron_train(X, y, learning_rate, epochs):
num_examples, num_features = X.shape
weights = np.random.rand(num_features) # Initialize weights
bias = np.random.rand() # Initialize bias
for epoch in range(epochs):
for i in range(num_examples):
prediction = np.dot(X[i], weights) + bias
error = y[i] - (prediction > 0)
if error != 0:
weights += learning_rate * error * X[i]
bias += learning_rate * error
return weights, bias
# Predict function
def perceptron_predict(X, weights, bias):
return (np.dot(X, weights) + bias) >= 0
# Plot decision boundary
def plot_decision_boundary(X, y, weights, bias, title):
plt.figure(figsize=(8, 4))
x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1
y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
Z = perceptron_predict(np.c_[xx.ravel(), yy.ravel()], weights, bias)
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.8, cmap=plt.cm.Paired)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=plt.cm.Paired)
plt.title(title)
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()
# Run experiment with specific parameters
size = 40
lr = 0.3
epoch = 10
# Generating dataset
X, y = generate_dataset(size)
# Training perceptron
weights, bias = perceptron_train(X, y, lr, epoch)
# Plotting decision boundary
title = f'Dataset Size: {size}, Learning Rate: {lr}, Epochs: {epoch}'
plot_decision_boundary(X, y, weights, bias, title)
# Printing predictions
predictions = perceptron_predict(X, weights, bias)
inputs_predictions = [(X[i], int(predictions[i])) for i in range(size)]
inputs_predictions
Output:
[(array([-0.25091976, 0.90142861]), 1),
(array([0.46398788, 0.19731697]), 1),
(array([-0.68796272, -0.68801096]), 0),
(array([-0.88383278, 0.73235229]), 0),
(array([0.20223002, 0.41614516]), 1),
(array([-0.95883101, 0.9398197 ]), 0),
(array([ 0.66488528, -0.57532178]), 0),
(array([-0.63635007, -0.63319098]), 0),
(array([-0.39151551, 0.04951286]), 0),
(array([-0.13610996, -0.41754172]), 0),
(array([ 0.22370579, -0.72101228]), 0),
(array([-0.4157107 , -0.26727631]), 0),
(array([-0.08786003, 0.57035192]), 1),
(array([-0.60065244, 0.02846888]), 0),
(array([ 0.18482914, -0.90709917]), 0),
(array([ 0.2150897 , -0.65895175]), 0),
(array([-0.86989681, 0.89777107]), 0),
(array([0.93126407, 0.6167947 ]), 1),
(array([-0.39077246, -0.80465577]), 0),
(array([ 0.36846605, -0.11969501]), 1),
(array([-0.75592353, -0.00964618]), 0),
(array([-0.93122296, 0.8186408 ]), 0),
(array([-0.48244004, 0.32504457]), 0),
(array([-0.37657785, 0.04013604]), 0),
(array([ 0.09342056, -0.63029109]), 0),
(array([0.93916926, 0.55026565]), 1),
(array([0.87899788, 0.7896547 ]), 1),
(array([0.19579996, 0.84374847]), 1),
(array([-0.823015 , -0.60803428]), 0),
(array([-0.90954542, -0.34933934]), 0),
(array([-0.22264542, -0.45730194]), 0),
(array([ 0.65747502, -0.28649335]), 1),
(array([-0.43813098, 0.08539217]), 0),
(array([-0.71815155, 0.60439396]), 0),
(array([-0.85089871, 0.97377387]), 1),
(array([ 0.54448954, -0.60256864]), 0),
(array([-0.98895577, 0.63092286]), 0),
(array([0.41371469, 0.45801434]), 1),
(array([ 0.54254069, -0.8519107 ]), 0),
(array([-0.28306854,-0.76826188]),0)]
EXPERIMENT-2
Aim: Write an application to build AND, OR gates using perceptron.
Dataset Description: The inputs for the gates are binary combinations of two inputs:
• [0, 0], [0, 1], [1, 0], [1, 1].
These represent the possible input combinations for logic gates. The expected outputs depend
on the behavior of the logic gate (AND or OR).
Attributes:
1. Inputs:
o Binary combinations of two inputs (0 or 1).
o Shape: (4, 2).
2. Weights and Bias:
o For the AND gate:
▪ Weights: [1, 1].
▪ Bias: -1.5.
o For the OR gate:
▪ Weights: [1, 1].
▪ Bias: -0.5.
3. Outputs:
o AND Gate:
▪ Produces 1 only when both inputs are 1.
o OR Gate:
▪ Produces 1 if at least one of the inputs is 1.
Code:
import numpy as np
import matplotlib.pyplot as plt
# Perceptron for AND gate
class PerceptronAND:
weights = np.array([1, 1]) # Weights for AND gate
bias = -1.5 # Bias for AND gate
@classmethod
def predict(cls, inputs):
return 1 if np.dot(inputs, cls.weights) + cls.bias > 0 else 0
# Perceptron for OR gate
class PerceptronOR:
weights = np.array([1, 1]) # Weights for OR gate
bias = -0.5 # Bias for OR gate
@classmethod
def predict(cls, inputs):
return 1 if np.dot(inputs, cls.weights) + cls.bias > 0 else 0
# Test cases and printing results
def test_gates():
# Test cases for AND gate
print("AND Gate:")
test_inputs_and = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
for inputs_and in test_inputs_and:
prediction_and = PerceptronAND.predict(inputs_and)
print(f"{inputs_and} -> {prediction_and}")
# Test cases for OR gate
print("\nOR Gate:")
test_inputs_or = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
for inputs_or in test_inputs_or:
prediction_or = PerceptronOR.predict(inputs_or)
print(f"{inputs_or} -> {prediction_or}")
# Visualization function for decision boundaries
def plot_gate(gate, gate_name):
plt.figure(figsize=(6, 6))
plt.title(f"{gate_name} Gate")
# Plotting the points
plt.scatter([0, 1, 0, 1], [0, 0, 1, 1], color='blue', label='Output: 0') # Points for 0 (blue)
if gate_name == "AND":
plt.scatter(1, 1, color='red', label='Output: 1') # Point for 1 (red)
else:
plt.scatter([0, 1, 1], [1, 0, 1], color='red', label='Output: 1') # Points for 1 (red)
# Creating the decision boundary
x_vals = np.linspace(-1, 2, 100)
y_vals = (-gate.weights[0] * x_vals - gate.bias) / gate.weights[1]
plt.plot(x_vals, y_vals, 'g--', label='Decision Boundary')
plt.xlim(-0.5, 1.5)
plt.ylim(-0.5, 1.5)
plt.xlabel('Input 1')
plt.ylabel('Input 2')
plt.legend()
plt.grid()
plt.show()
# Running tests and plotting
test_gates()
plot_gate(PerceptronAND, "AND")
plot_gate(PerceptronOR, "OR")
Output:
AND Gate:
[0 0] -> 0
[0 1] -> 0
[1 0] -> 0
[1 1] -> 1
OR Gate:
[0 0] -> 0
[0 1] -> 1
[1 0] -> 1
[1 1] -> 1
EXPERIMENT-3
Aim: Write an application to implement a simple neural network.
Dataset Description:
The dataset is designed to solve the XOR problem, which is a non-linear classification
problem.
• Inputs: Two binary inputs (0 or 1).
• Outputs: A single binary output where the result is 1 if the inputs are different and 0
if they are the same.
Attributes:
1. Input Features:
o Two binary values representing the inputs to the XOR gate.
2. Target Output:
o A single binary value representing the XOR output.
3. Neural Network Architecture:
o Input Layer: 2 neurons (corresponding to the two inputs).
o Hidden Layer: 4 neurons (configurable).
o Output Layer: 1 neuron (for the binary XOR output).
Code:
import numpy as np
import matplotlib.pyplot as plt
# Sigmoid activation function and its derivative
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1 - x)
# Neural network training function
def train_neural_network(X, Y, hidden_neurons=4, epochs=10000, learning_rate=0.1):
input_neurons = X.shape[1]
output_neurons = Y.shape[1]
# Initialize weights and biases using Xavier/Glorot initialization
hidden_weights = np.random.randn(input_neurons, hidden_neurons) * np.sqrt(2 /
(input_neurons + hidden_neurons))
hidden_bias = np.zeros((1, hidden_neurons))
output_weights = np.random.randn(hidden_neurons, output_neurons) * np.sqrt(2 /
(hidden_neurons + output_neurons))
output_bias = np.zeros((1, output_neurons))
losses = [] # To track the loss during training
for epoch in range(epochs):
# Forward propagation
hidden_layer_activation = np.dot(X, hidden_weights) + hidden_bias
hidden_layer_output = sigmoid(hidden_layer_activation)
output_layer_activation = np.dot(hidden_layer_output, output_weights) + output_bias
predicted_output = sigmoid(output_layer_activation)
# Calculate loss and append to losses list for visualization
loss = np.mean(np.square(Y - predicted_output))
losses.append(loss)
# Backpropagation
error = Y - predicted_output
d_predicted_output = error * sigmoid_derivative(predicted_output)
error_hidden_layer = d_predicted_output.dot(output_weights.T)
d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)
# Updating weights and biases
output_weights += hidden_layer_output.T.dot(d_predicted_output) * learning_rate
output_bias += np.sum(d_predicted_output, axis=0, keepdims=True) * learning_rate
hidden_weights += X.T.dot(d_hidden_layer) * learning_rate
hidden_bias += np.sum(d_hidden_layer, axis=0, keepdims=True) * learning_rate
return hidden_weights, hidden_bias, output_weights, output_bias, losses
# XOR input and output
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
Y = np.array([[0], [1], [1], [0]])
# Training the model
hidden_weights, hidden_bias, output_weights, output_bias, losses = train_neural_network(X,
Y)
# Predictions
hidden_layer_activation = np.dot(X, hidden_weights) + hidden_bias
hidden_layer_output = sigmoid(hidden_layer_activation)
output_layer_activation = np.dot(hidden_layer_output, output_weights) + output_bias
predicted_output = sigmoid(output_layer_activation)
print("Predictions:")
for i in range(len(X)):
print(f"Input: {X[i]}, Predicted Output: {predicted_output[i][0]:.4f}, Actual Output:
{Y[i][0]}")
# Plotting the decision boundary
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=Y.flatten(), cmap='coolwarm', s=100, label='XOR Data')
plt.title('XOR Data and Decision Boundary')
plt.xlabel('Input 1')
plt.ylabel('Input 2')
x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1
y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
grid_inputs = np.c_[xx.ravel(), yy.ravel()]
# Forward propagation to get predictions for the grid
grid_hidden = sigmoid(np.dot(grid_inputs, hidden_weights) + hidden_bias)
grid_output = sigmoid(np.dot(grid_hidden, output_weights) + output_bias)
predictions_grid = grid_output.reshape(xx.shape)
# Plot decision boundary
plt.contourf(xx, yy, predictions_grid, cmap='coolwarm', alpha=0.3)
plt.legend()
plt.colorbar(label='Output')
plt.show()
# Plotting training loss
plt.figure(figsize=(8, 6))
plt.plot(losses)
plt.title('Training Loss over Epochs')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.show()
Output:
Predictions:
Input: [0 0], Predicted Output: 0.0402, Actual Output: 0
Input: [0 1], Predicted Output: 0.9420, Actual Output: 1
Input: [1 0], Predicted Output: 0.9420, Actual Output: 1
Input: [1 1], Predicted Output: 0.0678, Actual Output: 0
EXPERIMENT-4
Aim: Write an application to implement a Multi-layer neural network.
Dataset Description: The dataset consists of all possible 3-bit binary combinations as
inputs and their corresponding outputs based on the behavior of an AND gate.
• Input Data:
All possible combinations of three binary digits (0 or 1).
• Output Data:
The AND gate outputs 1 if and only if all three input bits are 1. Otherwise, it outputs 0.
Attributes:
• Input 1: The first binary input (0 or 1).
• Input 2: The second binary input (0 or 1).
• Input 3: The third binary input (0 or 1).
• Output: The AND gate output (0 or 1).
Code:
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
# Sigmoid activation function and its derivative
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1 - x)
# Input data (3-bit combinations)
inputs = np.array([
[0, 0, 0],
[0, 0, 1],
[0, 1, 0],
[0, 1, 1],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0],
[1, 1, 1]
])
# Corresponding AND gate outputs
outputs = np.array([[0], [0], [0], [0], [0], [0], [0], [1]])
# Initialize weights randomly
np.random.seed(42)
weights_input_hidden = np.random.rand(3, 4) # Weights for input to hidden layer
weights_hidden_output = np.random.rand(4, 1) # Weights for hidden to output layer
# Training the neural network
epochs = 1000
learning_rate = 0.1
for epoch in range(epochs):
# Forward propagation
hidden_layer_input = np.dot(inputs, weights_input_hidden)
hidden_layer_output = sigmoid(hidden_layer_input)
output_layer_input = np.dot(hidden_layer_output, weights_hidden_output)
predicted_output = sigmoid(output_layer_input)
# Backpropagation
error = outputs - 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)
# Updating weights using gradients
weights_hidden_output += hidden_layer_output.T.dot(d_predicted_output) * learning_rate
weights_input_hidden += inputs.T.dot(d_hidden_layer) * learning_rate
# Testing the trained model
test_data = np.array([
[0, 0, 0],
[0, 0, 1],
[0, 1, 0],
[0, 1, 1],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0],
[1, 1, 1]
])
hidden_layer_output = sigmoid(np.dot(test_data, weights_input_hidden))
predicted_output = sigmoid(np.dot(hidden_layer_output, weights_hidden_output))
print("3-Bit AND Gate Representation:")
for i in range(len(test_data)):
print(f"Input: {test_data[i]} Output: {round(predicted_output[i][0])}")
# Plotting the 3-bit AND gate
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for i in range(len(test_data)):
x, y, z = test_data[i]
color = 'b' # Default color for 0 output
if (x, y, z) == (1, 1, 1): # Highlighting the true output
color = 'r'
ax.scatter(x, y, z, c=color)
ax.set_xlabel('Input 1')
ax.set_ylabel('Input 2')
ax.set_zlabel('Input 3')
ax.set_title('Output of 3-Bit AND Gate')
plt.show()
Output:
3-Bit AND Gate Representation:
Input: [0 0 0] Output: 0
Input: [0 0 1] Output: 0
Input: [0 1 0] Output: 0
Input: [0 1 1] Output: 0
Input: [1 0 0] Output: 0
Input: [1 0 1] Output: 0
Input: [1 1 0] Output: 0
Input: [1 1 1] Output: 0
EXPERIMENT-5
Aim: To write an application to solve real world problem.
Dataset Description: The dataset is synthetically generated and consists of 1000 samples
with the following attributes:
1. Temperature: Represents the temperature in degrees Celsius, ranging between 10
and 35.
2. Humidity: Represents the humidity percentage, ranging between 30% and 80%.
3. Wind Speed: Represents the wind speed in m/s, ranging between 0 and 15.
4. Emission Levels: The target variable that represents the emission levels, calculated
using a linear equation with some added noise.
Attributes:
• Temperature: Independent variable that affects emission levels.
• Humidity: Independent variable that influences emission levels.
• Wind Speed: Independent variable contributing to emission levels.
• Emission Levels: Dependent variable that is predicted using the regression model.
Code:
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt
# Setting seed for reproducibility
np.random.seed(42)
# Generating random data
num_samples = 1000
temperature = np.random.uniform(10, 35, num_samples) # Temperature in degrees Celsius
humidity = np.random.uniform(30, 80, num_samples) # Humidity in percentage
wind_speed = np.random.uniform(0, 15, num_samples) # Wind speed in m/s
# Generating target variable (Emission Levels) with added noise
emission_levels = 10 + 2*temperature + 1.5*humidity + 0.5*wind_speed +
np.random.normal(0, 5, num_samples)
# Creating a DataFrame
data = pd.DataFrame({
'Temperature': temperature,
'Humidity': humidity,
'Wind_Speed': wind_speed,
'Emission_Levels': emission_levels
})
# Splitting data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(
data[['Temperature', 'Humidity', 'Wind_Speed']],
data['Emission_Levels'],
test_size=0.2,
random_state=42
# Fitting a Linear Regression model
model = LinearRegression()
model.fit(X_train, y_train)
# Predicting on test data
y_pred = model.predict(X_test)
# Evaluating the model
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')
# Plotting results
plt.scatter(y_test, y_pred, label='Actual vs. Predicted')
plt.plot(y_test, y_test, color='red', label='Ideal Line') # Ideal line where Predicted = Actual
plt.xlabel('Actual Emission Levels')
plt.ylabel('Predicted Emission Levels')
plt.title('Actual vs. Predicted Emission Levels')
plt.legend()
plt.show()
Output:
