Implementation of CNN

# import the necessary libraries

import numpy as np

import tensorflow as tf

import matplotlib.pyplot as plt

from itertools import product

# set the param

plt.rc('figure', autolayout=True)

plt.rc('image', cmap='magma')

# define the kernel

kernel = tf.constant([[-1, -1, -1],

[-1, 8, -1],

[-1, -1, -1],

])

# load the image

image = tf.io.read_file('Ganesh.jpg')

image = tf.io.decode_jpeg(image, channels=1)

image = tf.image.resize(image, size=[300, 300])

# plot the image

img = tf.squeeze(image).numpy()

plt.figure(figsize=(5, 5))

plt.imshow(img, cmap='gray')

plt.axis('off')
plt.title('Original Gray Scale image')

plt.show();

# Reformat

image = tf.image.convert_image_dtype(image, dtype=tf.float32)

image = tf.expand_dims(image, axis=0)

kernel = tf.reshape(kernel, [*kernel.shape, 1, 1])

kernel = tf.cast(kernel, dtype=tf.float32)

# convolution layer

conv_fn = tf.nn.conv2d

image_filter = conv_fn(

input=image,

filters=kernel,

strides=1, # or (1, 1)

padding='SAME',

plt.figure(figsize=(15, 5))

# Plot the convolved image

plt.subplot(1, 3, 1)

plt.imshow(

tf.squeeze(image_filter)
)

plt.axis('off')

plt.title('Convolution')

# activation layer

relu_fn = tf.nn.relu

# Image detection

image_detect = relu_fn(image_filter)

plt.subplot(1, 3, 2)

plt.imshow(

# Reformat for plotting

tf.squeeze(image_detect)

plt.axis('off')

plt.title('Activation')

# Pooling layer

pool = tf.nn.pool

image_condense = pool(input=image_detect,

window_shape=(2, 2),

pooling_type='MAX',

strides=(2, 2),

padding='SAME',

)
plt.subplot(1, 3, 3)

plt.imshow(tf.squeeze(image_condense))

plt.axis('off')

plt.title('Pooling')

plt.show()

Implementing a Text Generator Using Recurrent Neural

Networks (RNNs)
In this section, we create a character-based text generator using
Recurrent Neural Network (RNN) in TensorFlow and Keras. We’ll
implement an RNN that learns patterns from a text sequence to
generate new text character-by-character.
Step 1: Import Necessary Libraries
We start by importing essential libraries for data handling and
building the neural network.
Python

import numpy as np
2

import tensorflow as tf
3

from tensorflow.keras.models import Sequential

4

from tensorflow.keras.layers import SimpleRNN, Dense

Step 2: Define the Input Text and Prepare Character Set

We define the input text and identify unique characters in the text,
which we’ll encode for our model.
Python

text = "This is GeeksforGeeks a software training institute"

2

chars = sorted(list(set(text)))
3
char_to_index = {char: i for i, char in enumerate(chars)}
4

index_to_char = {i: char for i, char in enumerate(chars)}

Step 3: Create Sequences and Labels
To train the RNN, we need sequences of fixed length ( seq_length) and
the character following each sequence as the label.
Python

seq_length = 3
2

sequences = []
3

labels = []
4

for i in range(len(text) - seq_length):

6

seq = text[i:i + seq_length]

7

label = text[i + seq_length]

8

sequences.append([char_to_index[char] for char in seq])

9

labels.append(char_to_index[label])
10

11

X = np.array(sequences)
12

y = np.array(labels)
Step 4: Convert Sequences and Labels to One-Hot Encoding
For training, we convert X and y into one-hot encoded tensors.
Python

1
X_one_hot = tf.one_hot(X, len(chars))
2

y_one_hot = tf.one_hot(y, len(chars))

Step 5: Build the RNN Model

We create a simple RNN model with a hidden layer of 50 units and a

Dense output layer with softmax activation.
Python

model = Sequential()
2

model.add(SimpleRNN(50, input_shape=(seq_length, len(chars)),

activation='relu'))
3

model.add(Dense(len(chars), activation='softmax'))
Step 6: Compile and Train the Model
We compile the model using the categorical_crossentropy loss and
train it for 100 epochs.
Python

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

model.fit(X_one_hot, y_one_hot, epochs=100)

Output:
Epoch 1/100
2/2 ━━━━━━━━━━━━━━━━━━━━ 4s 23ms/step - accuracy: 0.0243 -
loss: 2.9043
Epoch 2/100
2/2 ━━━━━━━━━━━━━━━━━━━━ 0s 14ms/step - accuracy: 0.0139 -
loss: 2.8720
Epoch 3/100
2/2 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 0.0243 -
loss: 2.8454
.
.
.
Epoch 99/100
2/2 ━━━━━━━━━━━━━━━━━━━━ 0s 9ms/step - accuracy: 0.8889 - loss:
0.5060
Epoch 100/100
2/2 ━━━━━━━━━━━━━━━━━━━━ 0s 9ms/step - accuracy: 0.9236 - loss:
0.4934
Step 7: Generate New Text Using the Trained Model
After training, we use a starting sequence to generate new text
character-by-character.
Python

start_seq = "This is G"

2

generated_text = start_seq
3

for i in range(50):
5

x = np.array([[char_to_index[char] for char in generated_text[-

seq_length:]]])
6

x_one_hot = tf.one_hot(x, len(chars))

7

prediction = model.predict(x_one_hot)
8

next_index = np.argmax(prediction)
9

next_char = index_to_char[next_index]
10

generated_text += next_char
11

12

print("Generated Text:")
13

print(generated_text)
Output:
Generated Text: This is Geeks a software training instituteais
is is is is
Complete Code
# Step 1: Import necessary libraries

import numpy as np

import tensorflow as tf

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import SimpleRNN, Dense

# Step 2: Define text and character set

text = "This is GeeksforGeeks a software training institute"

chars = sorted(list(set(text)))

char_to_index = {char: i for i, char in enumerate(chars)}

index_to_char = {i: char for i, char in enumerate(chars)}

# Step 3: Create sequences and labels

seq_length = 3

sequences = []

labels = []

for i in range(len(text) - seq_length):

seq = text[i:i + seq_length]

label = text[i + seq_length]

sequences.append([char_to_index[char] for char in seq])

labels.append(char_to_index[label])

X = np.array(sequences)
y = np.array(labels)

# Step 4: One-hot encode sequences and labels

X_one_hot = tf.one_hot(X, len(chars))

y_one_hot = tf.one_hot(y, len(chars))

# Step 5: Build the model

model = Sequential()

model.add(SimpleRNN(50, input_shape=(seq_length, len(chars)),

activation='relu'))

model.add(Dense(len(chars), activation='softmax'))

# Step 6: Compile and train the model

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

model.fit(X_one_hot, y_one_hot, epochs=100)

# Step 7: Generate text

start_seq = "This is G"

generated_text = start_seq

for i in range(50):

x = np.array([[char_to_index[char] for char in generated_text[-

seq_length:]]])

x_one_hot = tf.one_hot(x, len(chars))

prediction = model.predict(x_one_hot)

next_index = np.argmax(prediction)

next_char = index_to_char[next_index]
 generated_text += next_char

print("Generated Text:")

print(generated_text)