PROGRAM – 1

Implementation of Feed Forward Neural Network

a) Import necessary packages

b) Load the training and testing data
c) Define the network architecture using keras
d) Train the model using SGD
e) Evaluate the network
f) Plot the training loss and accuracy

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import random
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train / 255.0
x_test = x_test / 255.0
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation="relu"),
keras.layers.Dense(10, activation="softmax")
])
model.compile(optimizer="sgd", loss="sparse_categorical_crossentropy",
metrics=["accuracy"])
history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=5)

#evaluate the network

test_loss,test_acc=model.evaluate(x_test,y_test)
print("Loss=%.3f"%test_loss)
print("Accuracy=%.3f"%test_acc)
n=random.randint(0,9999)
plt.imshow(x_test[n])
plt.show()
predicted_value=model.predict(x_test)
plt.imshow(x_test[n])
plt.show()
print("Predicted Value:", predicted_value[n])

#plotting the training accuracy

plt.plot(history.history["accuracy"])
plt.plot(history.history["val_accuracy"])
plt.title("model accuracy")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(["Train","Validation"],loc="upper left")
plt.show()

#plotting the training loss

plt.plot(history.history["loss"])
plt.plot(history.history["val_loss"])
plt.title("model loss")
plt.ylabel("loss")
plt.xlabel("epoch")
plt.legend(["Train","Validation"],loc="upper right")
plt.show()

Output
 PROGRAM – 2

Build the image classification model by dividing the model into 4 stages:

Loading and preprocessing the image data

Defining the models architecture

Training the model

Estimating the models performance

import numpy as np

import matplotlib.pyplot as plt

x=np.array([[0,1],[1,0],[1,1],[0,0]])

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

num_input=2

num_hidden=1

num_output=1

wxh=np.random.randn(num_input,num_hidden)

bh=np.zeros((1,num_hidden))

why=np.random.randn(num_hidden,num_output)

def sigmoid(z):

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

def sigmoid_derivative(z):
 return sigmoid(z)*(1-sigmoid(z))

def forward_prop(x,wxh,why):

z1 = np.dot(x,wxh)+bh

a1 = sigmoid(z1)

z2 = np.dot(a1,why)

return z1,a1,z2

def cost_function(y,y_hat):

return 0.5*np.sum((y-y_hat)**2)

def backward_prop(x,y,z1,a1,z2,why):

m=y.shape[0]

dl_dz2=z2-y

dl_da1=np.dot(dl_dz2,why.T)

dl_dz1=dl_da1 * sigmoid_derivative(z1)

dj_dwhy=np.dot(a1.T,dl_dz2)/m

dj_dwxh=np.dot(x.T,dl_dz1)/m

dj_dbh=np.sum(dl_dz1,axis=0,keepdims=True)/m

return dj_dwxh,dj_dwhy,dj_dbh

n=0.01

num_iterations = 5000

costs=[]

for i in range(num_iterations):

z1,a1,z2=forward_prop(x,wxh,why)

y_hat=z2

cost=cost_function(y,y_hat)

costs.append(cost)
 dj_dwxh,dj_dwhy,dj_dbh=backward_prop(x,y,z1,a1,z2,why)

wxh -=n*dj_dwxh

why -=n*dj_dwhy

bh -=n*dj_dbh

plt.grid()

plt.plot(range(num_iterations),costs)

plt.title('cost funtion')

plt.xlabel('Training Iterations')

plt.ylabel('cost')

plt.show()

z1,hidden_layer_activation,output=forward_prop(x,wxh,why)

print("output of the network:\n",output)

output of the network:

[[0.51499412]

[0.55763691]

[0.61069325]

[0.35298938]]
 PROGRAM 3

Build the image classification model by dividing the model into four stages

a. Loading and preprocessing the image data

b. Defining the models architecture
c. Training the model
d. Estimating the model performance

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import random

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

x_train = x_train / 255.0

x_test = x_test / 255.0

model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation="relu"),
keras.layers.Dense(10, activation="softmax")
])

model.summary()

model.compile(optimizer="sgd",
loss="sparse_categorical_crossentropy",
metrics=['accuracy'])

history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=3)

# Evaluate the model on the test data
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=2)
print(f"Test Accuracy: {test_accuracy * 100:.2f}%")
print(f"Test Loss: {test_loss:.4f}")

# Plotting the training and validation accuracy

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()

# Plotting the training and validation loss

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Training and Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

# Making predictions on random test images

num_images = 5
random_indices = random.sample(range(x_test.shape[0]), num_images)

for idx in random_indices:

plt.imshow(x_test[idx], cmap=plt.cm.binary)
plt.title(f"Predicted Label: {model.predict(x_test[idx:idx+1]).argmax()}\nTrue Label:
{y_test[idx]}")
plt.axis('off')
plt.show()

# You can also use the model to predict on new data using the `model.predict()` method.
OUTPUT

val_accuracy: 0.9259 - val_loss: 0.2610

313/313 - 0s - 941us/step - accuracy: 0.9259 - loss: 0.2610
Test Accuracy: 92.59%
Test Loss: 0.2610
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 255ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 31ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
 PROGRAM 4
Write a program to implement simple CNN

import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt

# Define the input image tensor

image = torch.tensor([
[0., 0., 0., 0., 0.],
[0., 1., 1., 1., 0.],
[0., 1., 1., 1., 0.],
[0., 1., 1., 1., 0.],
[0., 0., 0., 0., 0.]
])

# Reshape the image to match (N, C, H, W)

image = image.unsqueeze(0).unsqueeze(0) # shape: (1, 1, 5, 5)

# Define the kernel (e.g., Laplacian filter)

kernel = torch.tensor([
[[
[0., 1., 0.],
[1., -4., 1.],
[0., 1., 0.]
]]
])

# Apply convolution
conv = F.conv2d(image, kernel, stride=1, padding=0)

# Apply max pooling

pooled = F.max_pool2d(conv, kernel_size=2, stride=2)

# Plotting
fig, ax = plt.subplots(1, 3, figsize=(15, 5))

# Original Image
ax[0].imshow(image.squeeze().numpy(), cmap='gray')
ax[0].set_title('Input Image')
ax[0].axis('off')
# After Convolution
ax[1].imshow(conv.squeeze().detach().numpy(), cmap='gray')
ax[1].set_title('After Convolution')
ax[1].axis('off')
# After Max Pooling
pooled_image = pooled.squeeze(0).squeeze(0)
ax[2].imshow(pooled_image.detach().numpy(), cmap='gray')
ax[2].set_title('After Max Pooling')
ax[2].axis('off')
plt.show()

Output:
 PROGRAM 5
Write a program to perform Sentiment Analysis Using RNN

Write a program to perform Sentiment Analysis using RNN

import tensorflow as tf
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense

vocab_size = 5000
maxlen = 500
batch_size = 64
epochs = 3

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)

x_train = pad_sequences(x_train, maxlen=maxlen)
x_test = pad_sequences(x_test, maxlen=maxlen)

model = Sequential([
Embedding(vocab_size, 32, input_length=maxlen),
LSTM(100),
Dense(1, activation='sigmoid')
])

model.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy']
)

print(model.summary())

model.fit(
x_train, y_train,
validation_split=0.1,
batch_size=batch_size,
epochs=epochs
)
loss,acc=model.evaluate(x_test,y_test)
print(f"loss: {loss}\naccuracy: {acc}")

Output:
 PROGRAM 6
Write a program to implement an LSTM based Auto encoding in Tensorflow/Keras

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from tensorflow import keras

df = pd.read_csv('spx.csv', parse_dates=['date'], index_col='date')

print("Original columns:", df.columns.tolist())

# 2. Normalize column names

df.columns = [col.strip().lower() for col in df.columns]
print("Normalized columns:", df.columns.tolist())

# 3. Ensure 'close' is numeric, drop any bad rows

df['close'] = pd.to_numeric(df['close'], errors='coerce')
n_bad = df['close'].isna().sum()
if n_bad > 0:
print(f"Dropping {n_bad} rows where 'close' was not numeric")
df = df.dropna(subset=['close'])

# 4. Train/Test split
TRAIN_RATIO = 0.9
train_size = int(len(df) * TRAIN_RATIO)
train_df = df.iloc[:train_size].copy()
test_df = df.iloc[train_size:].copy()

# 5. Scale the 'close' prices

scaler = StandardScaler()
train_df['close'] = scaler.fit_transform(train_df[['close']])
test_df['close'] = scaler.transform(test_df[['close']])

# 6. Create sliding-window datasets

def create_dataset(series: pd.Series, time_steps: int = 30):
X, y = [], []
for i in range(len(series) - time_steps):
window = series.iloc[i : i + time_steps].values.reshape(-1, 1)
 X.append(window)
y.append(series.iloc[i + time_steps])
return np.array(X), np.array(y)

TIME_STEPS = 30
X_train, y_train = create_dataset(train_df['close'], TIME_STEPS)
X_test, y_test = create_dataset(test_df['close'], TIME_STEPS)

print("X_train shape:", X_train.shape) # e.g. (n_samples, 30, 1)

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

# 7. Build LSTM autoencoder

model = keras.Sequential([
keras.layers.LSTM(64, input_shape=(TIME_STEPS, 1)),
keras.layers.RepeatVector(TIME_STEPS),
keras.layers.LSTM(64, return_sequences=True),
keras.layers.Dropout(0.2),
keras.layers.TimeDistributed(keras.layers.Dense(1))
])
model.compile(optimizer='adam', loss='mse')
model.summary()

# 8. Train (using X_train as both input and target for autoencoder)

history = model.fit(
X_train, X_train,
epochs=20,
batch_size=32,
validation_split=0.1,
shuffle=False
)

# 9. Plot losses
plt.figure(figsize=(8,4))
plt.plot(history.history['loss'], label='train loss')
plt.plot(history.history['val_loss'],label='validation loss')
plt.title('LSTM Autoencoder Loss')
plt.xlabel('Epoch')
plt.ylabel('MSE')
plt.legend()
plt.show()
X_test_pred = model.predict(X_test, verbose=0)
test_mse = np.mean((X_test_pred - X_test)**2, axis=(1,2))
print("Average test MSE:", test_mse.mean())
 PROGRAM 7
Write a Program to implement image generation using GAN

import os
import numpy as np
from keras.datasets import mnist
from keras.models import Sequential, Model
from keras.layers import Input, InputLayer, Dense, Reshape, Flatten, LeakyReLU,
BatchNormalization, Dropout
from keras.optimizers import Adam
import matplotlib.pyplot as plt

def build_generator(z_dim=100, img_shape=(28,28,1)):

model = Sequential([
InputLayer(input_shape=(z_dim,)),
Dense(128), LeakyReLU(0.2), BatchNormalization(momentum=0.8),
Dense(256), LeakyReLU(0.2), BatchNormalization(momentum=0.8),
Dense(512), LeakyReLU(0.2), BatchNormalization(momentum=0.8),
Dense(np.prod(img_shape), activation='tanh'),
Reshape(img_shape)
])
noise = Input(shape=(z_dim,))
return Model(noise, model(noise))

def build_discriminator(img_shape=(28,28,1)):
seq = Sequential([
InputLayer(input_shape=img_shape),
Flatten(),
Dense(512), LeakyReLU(0.2), Dropout(0.3),
Dense(256), LeakyReLU(0.2), Dropout(0.3),
Dense(1, activation='sigmoid')
])
img = Input(shape=img_shape)
D = Model(img, seq(img))
D.compile(optimizer=Adam(2e-4, 0.5), loss='binary_crossentropy',
metrics=['accuracy'])
return D

def sample_images(G, step, z_dim, n=25):

 os.makedirs('imgs', exist_ok=True)
noise = np.random.normal(size=(n, z_dim))
gen = G.predict(noise, verbose=0)
gen = 0.5 * gen + 0.5
fig, axs = plt.subplots(5,5, figsize=(5,5))
for i, ax in enumerate(axs.flat):
ax.imshow(gen[i,:,:,0], cmap='gray')
ax.axis('off')
plt.tight_layout()
path = f"imgs/{step}.png"
fig.savefig(path)
plt.show()
plt.close()

def train(steps=2000, batch_size=64, z_dim=100):

# Load data
(X, _), _ = mnist.load_data()
X = (X.astype('float32') - 127.5) / 127.5
X = np.expand_dims(X, -1)
G = build_generator(z_dim)
D = build_discriminator()
D.trainable = False
z = Input(shape=(z_dim,))
combined = Model(z, D(G(z)))
combined.compile(optimizer=Adam(1e-4, 0.5), loss='binary_crossentropy')
D.trainable = True
real = np.ones((batch_size,1)) * 0.9
fake = np.zeros((batch_size,1))
last_d_loss = last_d_acc = last_g_loss = None
for step in range(1, steps+1):
idx = np.random.randint(0, X.shape[0], batch_size)
real_imgs = X[idx]
noise = np.random.normal(size=(batch_size, z_dim))
fake_imgs = G.predict(noise, verbose=0)
d_loss_real, d_acc_real = D.train_on_batch(real_imgs, real)
d_loss_fake, d_acc_fake = D.train_on_batch(fake_imgs, fake)
last_d_loss = 0.5 * (d_loss_real + d_loss_fake)
last_d_acc = 0.5 * (d_acc_real + d_acc_fake)
last_g_loss = combined.train_on_batch(
 np.random.normal(size=(batch_size, z_dim)), real
)
if step % 1000 == 0:
print(f"Step {step}/{steps} — D_loss: {last_d_loss:.4f}, D_acc:
{last_d_acc*100:.2f}%, G_loss: {last_g_loss:.4f}")
sample_images(G, step, z_dim)
print("Training completed!")
print(f"Final D_loss: {last_d_loss:.4f}")
print(f"Final D_acc: {last_d_acc*100:.2f}%")
print(f"Final G_loss: {last_g_loss:.4f}")
return G, D
if __name__ == '__main__':
train()

OUTPUT