Experiment -1 DL-#3.

1 AI & ML (AITK)

1. Introduction of Keras
History of Keras:

Keras was originally developed by François Chollet in March 2015 as a user-friendly API for building and training neural
networks. It aimed to simplify the development of deep learning models by providing a high-level interface that could run on top
of various backends such as TensorFlow, Theano, and Microsoft Cognitive Toolkit (CNTK). In 2017, Keras was integrated into
TensorFlow as tf.keras, making it the default high-level API for TensorFlow.

Why Keras?

• Keras was designed with several key goals in mind:

• Ease of Use: Keras provides a simple and intuitive API, making it accessible for both beginners and experienced
practitioners.
• Modularity: It allows for easy creation and experimentation with different neural network architectures.
• Extensibility: Users can customize and extend the framework for more complex scenarios.
• Interoperability: By supporting multiple backends, it allows users to choose the most suitable computational engine for
their needs.

How Keras Works:

• Keras abstracts many of the complexities involved in building and training neural networks. It provides:
• Layers and Models: Tools to create and stack layers to build models, such as Sequential or Functional API.
• Optimizers and Loss Functions: Predefined functions to compile models, making it easy to switch between different
optimization strategies and loss metrics.
• Training and Evaluation: Functions to fit models on data, evaluate performance, and make predictions.
• Pretrained Models: Access to various pretrained models for transfer learning and fine-tuning.

Sequential API: The Sequential API is a straightforward way to build models layer by layer. It is ideal for simple, linear stacks
of layers.

Example :

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

model = Sequential([

Dense(64, activation='relu', input_shape=(input_dim,)),

Dense(10, activation='softmax')

])
Functional API: The Functional API is more flexible and allows for complex architectures such as multi-input, multi-output
models, and shared layers.

Example:

from tensorflow.keras.layers import Input, Dense

from tensorflow.keras.models import Model

inputs = Input(shape=(input_dim,))

x = Dense(64, activation='relu')(inputs)

outputs = Dense(10, activation='softmax')(x)

model = Model(inputs, outputs)

Model Subclassing: This approach allows for the most flexibility, enabling users to define custom models by sub classing the
tf.keras.Model class.

Example:

from tensorflow.keras.models import Model

from tensorflow.keras.layers import Dense, Input

class MyModel(Model):

def __init__(self):

super(MyModel, self).__init__()

self.dense1 = Dense(64, activation='relu')

self.dense2 = Dense(10, activation='softmax')

def call(self, inputs):

x = self.dense1(inputs)

return self.dense2(x)

What Keras Provides:

• Pre-built Layers and Models: Keras includes a wide range of layers (Dense, Conv2D, LSTM, etc.) and pre-trained
models (like VGG, ResNet, etc.) for easy experimentation and fine-tuning.
• Optimizers: Various optimizers like SGD, Adam, and RMSprop are available to optimize model training.
• Loss Functions: Common loss functions (e.g., mean squared error, categorical cross-entropy) are included to measure
model performance.
• Metrics: Metrics for evaluating model performance, such as accuracy and precision, are readily available.
 • Callbacks: Tools for model monitoring and training control, including checkpoints, early stopping, and learning rate
adjustments.

Where Keras is Used:

• Research: Keras is widely used in research due to its ease of use, allowing researchers to quickly prototype and
experiment with neural network models.
• Industry: Many industry applications use Keras for tasks like image classification, natural language processing, and
recommendation systems due to its simplicity and integration with TensorFlow.
• Education: Keras is popular in educational settings for teaching deep learning concepts due to its intuitive API and
simplicity.

Getting Started with Keras:

• To use Keras, you typically need to install TensorFlow, as Keras is included as part of TensorFlow.
• On cmd: pip install tensorflow

Example of building and training a neural network using Keras:

import numpy as np

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

# Generate some example data

X_train = np.random.rand(1000, 20)

y_train = np.random.randint(2, size=1000)

# Build the model

model = Sequential([

Dense(64, activation='relu', input_shape=(20,)),

Dense(64, activation='relu'),

Dense(1, activation='sigmoid')

])

# Compile the model

model.compile(optimizer='adam',

loss='binary_crossentropy',
metrics=['accuracy'])

# Train the model

model.fit(X_train, y_train, epochs=10, batch_size=32)

# Evaluate the model

loss, accuracy = model.evaluate(X_train, y_train)

print(f'Loss: {loss}, Accuracy: {accuracy}')

When Keras?

• Keras is suitable for various stages of the machine learning workflow:

• Model Development: When you need to quickly prototype and experiment with different neural network architectures.
• Production: When you want a streamlined interface for model training and deployment, especially when using
TensorFlow.
• Education: For teaching and learning purposes, due to its straightforward API and ease of understanding.
Step by step installation of packages.

1. Install Visual Studio Code (VS Code)

1. Download Visual Studio Code:

o Go to the Visual Studio Code website.
o Download the installer for your operating system (Windows, macOS, or
Linux).
2. Install Visual Studio Code:
o Run the installer and follow the on-screen instructions to complete the
installation.
3. Go to Visual Studio Extensions, install Python, Keras Snippets and Tensorflow
Snippets.

2. Install Python and Set Up the Environment

1. Download Python:
o Go to the Python website.
o Download and install the latest version of Python. Ensure that the "Add
Python to PATH" option is checked during installation.
2. Verify Python Installation:
o Open a terminal (Command Prompt, PowerShell, or Terminal on macOS).
o Type python --version to verify the installation.
3. Install Pip:
o Pip is the package installer for Python, and it should be included with Python.
Verify it by typing pip --version in the terminal.
4. Create folder on the desktop and name it DL_Lab_your roll number last 4 digits.

3. Set Up Visual Studio Code for Python

1. Open VS Code:
o Launch Visual Studio Code.
o Open the folder that you have created on the desktop via VStudio.
Open terminal via visual studio code, then follow the below instructions.

4. Configure a Virtual Environment

(Creating a virtual environment makes sure that your package versions won’t
overlap with the new or old versions, thereby giving you the stability over the
package versions and gives you the ability to have total control over your package
versions.)

4.1. Create a Virtual Environment:

o In the terminal, navigate to the folder containing your Python script and run:
 python -m venv myenv

o Activate the virtual environment:

▪ Windows: myenv\Scripts\activate

4.2.Install Dependencies in the Virtual Environment:

With the virtual environment activated, install the necessary packages:

pip install numpy keras

pip install tensorflow
pip install matplotlib

o Right click on the folder where your python files are present, copy the relative path.
o Go to terminal type: cd ‘relative path of python files folder’. Click enter.

(python files folder means: The place where you save your python code.)

o Execute python file : python filename.py

If the terminal doesn’t allow you to create the environment or activate the environment that you have
created then use the below:

The following will allow all local scripts to execute on the VM, irrespective of whether they're
signed or not:

Open terminal or command prompt,(Run as Administrator) then paste the below command.

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope LocalMachine

 Experiment -2 DL-#3.1 AI & ML (AITK)

2. Installing Keras and Packages in Keras

Brief introduction of packages:

Package -1 - Tensorflow
What is TensorFlow?

TensorFlow is an open-source machine learning framework developed by Google that facilitates building, training, and
deploying machine learning and deep learning models.

Why Use TensorFlow?

It offers flexible and comprehensive tools for deep learning research and production, allowing for easy scalability and
deployment on various platforms and devices.

Where is TensorFlow Used?

TensorFlow is used in diverse applications including natural language processing, computer vision, speech recognition, and
robotics across industries such as healthcare, finance, and technology.

How Does TensorFlow Work?

TensorFlow uses computational graphs to represent and optimize mathematical operations, enabling efficient training and
inference of models on CPUs, GPUs, and TPUs.

When Was TensorFlow Developed?

TensorFlow was developed by the Google Brain team and was first released in November 2015.

Who Developed TensorFlow?

TensorFlow was created by Google Brain, a research team within Google that focuses on machine learning and artificial
intelligence.

TensorFlow Sub-Packages:

• TensorFlow Core: The foundational library providing low-level APIs for building and training machine learning models.

• TensorFlow Keras: A high-level API for building and training deep learning models, integrated into TensorFlow as tf.keras.

• TensorFlow Hub: A library for reusable machine learning modules, facilitating easy sharing and usage of pre-trained
models.

• TensorFlow Extended (TFX): A production-ready platform for managing and deploying machine learning pipelines in
production environments.

• TensorFlow Lite: A lightweight solution for deploying machine learning models on mobile and edge devices.

• TensorFlow.js: A library for running machine learning models directly in the browser or on Node.js.
• TensorFlow Probability: A library for probabilistic reasoning and statistical analysis, extending TensorFlow with
probabilistic models and methods.

• TensorFlow Federated: A framework for federated learning, allowing for decentralized machine learning model training
across multiple devices.

• TensorFlow Graphics: Provides tools for incorporating computer graphics and geometric transformations into TensorFlow
models.

Package -2 - NumPy
Why?

NumPy (Numerical Python) is essential for efficient numerical computation in Python. It provides support for large, multi-
dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays.

Where?

NumPy is used in scientific computing, data analysis, machine learning, and any domain requiring fast numerical computations.
It's a foundational library for libraries like Pandas, SciPy, and scikit-learn.

How?

NumPy provides powerful array objects (ndarray), and functions for mathematical operations, linear algebra, random number
generation, and more. It integrates seamlessly with other scientific libraries in Python.

When?

Use NumPy when you need to perform high-performance numerical operations, manipulate large datasets, or require support
for mathematical functions and algorithms.

Who?

NumPy was created by Travis Olliphant and is now maintained by a large community of contributors and the NumPy
developers' team.

Sub-packages

1. numpy.core: Contains the core functionalities of NumPy including the ndarray object, array operations, and broadcasting.

2. numpy.lib: Provides utility functions and tools, such as mathematical functions, array manipulation routines, and
input/output support.

3. numpy.fft: Implements fast Fourier transform algorithms and tools for signal processing in the frequency domain.

4. numpy.linalg: Offers linear algebra routines including matrix decomposition, eigenvalue computations, and matrix
operations.

5. numpy.random: Supplies functions for generating random numbers, including distributions and random sampling.

6. numpy.polynomial: Contains functions for polynomial operations, including polynomial fitting, roots, and evaluations.
7. numpy.ma: Provides a masked array class for handling arrays with missing or invalid entries.

8. numpy.testing: Includes tools for writing and running tests to verify the correctness of NumPy functions and user code.

9. numpy.distutils: A collection of utilities for building and distributing NumPy extensions and related software.

Package -3 - Matplotlib
What:

Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. It provides a variety
of plotting functions for generating charts, graphs, and figures.

Why:

Matplotlib is widely used for data visualization because it allows users to create high-quality plots and graphs that can be
customized in detail. It is particularly useful for visualizing data distributions, trends, and patterns, which is essential for data
analysis, scientific research, and reporting.

How:

To use Matplotlib, you typically start by importing the library and then create plots using functions from the pyplot module,
which provides a MATLAB-like interface for plotting. You can generate a wide range of plots such as line graphs, bar charts,
scatter plots, histograms, and more. Customization options are extensive, allowing you to modify plot styles, colors, labels, and
other graphical elements.

Where:

Matplotlib is available through the Python Package Index (PyPI) and can be installed using package managers like pip.

It is commonly used in data science, machine learning, and scientific computing projects to create visualizations for analysis and
presentation. Matplotlib integrates well with other libraries like NumPy and pandas, and can generate plots for use in Jupyter
notebooks, web applications, and standalone graphical interfaces.
 Experiment -3 DL-#3.1 AI & ML (AITK)

3. Train the model to add two numbers and report the result.

Aim:

To create and train a simple neural network using Keras to predict the sum of two input numbers. Here
the neural network is designed to learn this relationship by being trained on randomly generated data.

Description:
Defining and training a simple neural network using Keras to approximate the sum of two random input
numbers. We begin by generating random training and test data, where each sample consists of two random numbers
and their sum as the target. The neural network model is built with a sequential structure, featuring an input layer that
accepts two features, a hidden layer with 10 neurons using the ReLU(Rectified Linear Unit) activation function, and an
output layer with a single neuron that predicts the sum. The model is compiled with the Adam optimizer and a mean
squared error loss function. It is then trained on the generated data for 100 epochs with a batch size of 10. After
training, the model's performance is evaluated on test data, and the test loss is printed. Finally, the model predicts the
sum for five new random samples, comparing the predicted sums with the actual sums, and printing the results.

Algorithm:

Algorithm Steps

1. Import Required Libraries:

o Import numpy for numerical operations.
o Import relevant classes from keras to build the neural network model.
2. Generate Training and Testing Data:
o Define a function generate_data(num_samples) that generates num_samples pairs of
random numbers between 0 and 1.
o Calculate the sum of each pair, which serves as the target value.
o Generate training data with 1000 samples and testing data with 100 samples.
3. Build the Neural Network Model:
o Initialize a Sequential model.
o Add an input layer that accepts two features (the two random numbers).
o Add a dense hidden layer with 10 neurons and ReLU activation function.
o Add a dense output layer with 1 neuron, which will predict the sum.
4. Compile the Model:
o Compile the model using the Adam optimizer and mean squared error as the
loss function.
5. Train the Model:
o Train the model on the generated training data for 100 epochs with a batch
size of 10.
6. Evaluate the Model:
o Evaluate the model's performance on the testing data, and print the test loss.
7. Make Predictions:
o Generate new data for predictions.
o Use the trained model to predict the sum of the new input pairs.
o Print the input pairs, predicted sums, and actual sums for comparison.
Program:

import numpy as np

from keras.models import Sequential

from keras.layers import Input, Dense

# Generate some training data

def generate_data(num_samples):

X = np.random.rand(num_samples, 2)

y = np.sum(X, axis=1)

return X, y

# Prepare data

num_samples = 1000

X_train, y_train = generate_data(num_samples)

X_test, y_test = generate_data(100)

# Build the model

model = Sequential()

model.add(Input(shape=(2,))) # Define the input shape explicitly

model.add(Dense(10, activation='relu'))

model.add(Dense(1))

# Compile the model

model.compile(optimizer='adam', loss='mean_squared_error')

# Train the model

model.fit(X_train, y_train, epochs=100, batch_size=10)

 # Evaluate the model

loss = model.evaluate(X_test, y_test)

print(f'Test loss: {loss}')

# Make predictions

X_new, y_new = generate_data(5)

y_pred = model.predict(X_new)

for i in range(len(X_new)):

print(f'Input: {X_new[i]}, Predicted Sum: {y_pred[i]}, Actual Sum: {y_new[i]}')

Output: (Write only the highlighted output in your observation)

Epoch 1/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 1s 1ms/step - loss: 0.8843
Epoch 2/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 977us/step - loss: 0.1159
Epoch 3/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0410
Epoch 4/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0283
Epoch 5/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0210
Epoch 6/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0139
Epoch 7/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0099
Epoch 8/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0072
Epoch 9/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0044
Epoch 10/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0028
Epoch 11/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0019
Epoch 12/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.0013
Epoch 13/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 8.0418e-04
Epoch 14/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.9264e-04
Epoch 15/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.5900e-04
Epoch 16/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.3260e-04
Epoch 17/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.0423e-04
Epoch 18/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.9129e-04
Epoch 19/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.7924e-04
Epoch 20/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.6521e-04
Epoch 21/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.5278e-04
Epoch 22/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.4266e-04
Epoch 23/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.3129e-04
Epoch 24/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.2104e-04
Epoch 25/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.1697e-04
Epoch 26/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.1000e-04
Epoch 27/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.0567e-04
Epoch 28/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 9.5071e-05
Epoch 29/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 9.6115e-05
Epoch 30/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 971us/step - loss: 9.6170e-05
Epoch 31/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 9.0636e-05
Epoch 32/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 7.5612e-05
Epoch 33/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 8.7476e-05
Epoch 34/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 6.9642e-05
Epoch 35/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 7.9479e-05
Epoch 36/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 945us/step - loss: 7.2127e-05
Epoch 37/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 7.2826e-05
Epoch 38/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 962us/step - loss: 6.1595e-05
Epoch 39/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.9255e-05
Epoch 40/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 5.1165e-05
Epoch 41/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.7385e-05
Epoch 42/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.9696e-05
Epoch 43/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 992us/step - loss: 4.1046e-05
Epoch 44/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.0283e-05
Epoch 45/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.2368e-05
Epoch 46/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.8291e-05
Epoch 47/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.2874e-05
Epoch 48/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.8344e-05
Epoch 49/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 991us/step - loss: 2.2106e-05
Epoch 50/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.3974e-05
Epoch 51/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.4708e-05
Epoch 52/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.2457e-05
Epoch 53/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.5983e-05
Epoch 54/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.6423e-05
Epoch 55/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.5198e-05
Epoch 56/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.3365e-05
Epoch 57/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.2296e-05
Epoch 58/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.0973e-05
Epoch 59/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.0367e-05
Epoch 60/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 8.9368e-06
Epoch 61/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 9.7416e-06
Epoch 62/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 8.0464e-06
Epoch 63/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 982us/step - loss: 7.0115e-06
Epoch 64/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 6.9316e-06
Epoch 65/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 7.5704e-06
Epoch 66/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 5.4279e-06
Epoch 67/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 5.7383e-06
Epoch 68/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.4438e-06
Epoch 69/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 960us/step - loss: 3.1996e-06
Epoch 70/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.4006e-06
Epoch 71/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.9607e-06
Epoch 72/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.8781e-06
Epoch 73/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 2.0032e-06
Epoch 74/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.4425e-06
Epoch 75/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 972us/step - loss: 1.6147e-06
Epoch 76/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.7277e-06
Epoch 77/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.6596e-06
Epoch 78/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.4454e-06
Epoch 79/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.0257e-06
Epoch 80/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.1475e-06
Epoch 81/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 9.0030e-07
Epoch 82/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 997us/step - loss: 6.2815e-07
Epoch 83/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 5.4013e-07
Epoch 84/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.7233e-07
Epoch 85/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.7572e-07
Epoch 86/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 6.4095e-07
Epoch 87/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.1832e-07
Epoch 88/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.1261e-07
Epoch 89/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 970us/step - loss: 4.2651e-07
Epoch 90/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.7920e-07
Epoch 91/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.7882e-07
Epoch 92/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.3310e-07
Epoch 93/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.8664e-07
Epoch 94/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 3.3547e-07
Epoch 95/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.5919e-07
Epoch 96/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 7.2388e-08
Epoch 97/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.3954e-07
Epoch 98/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.1865e-07
Epoch 99/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 1.0115e-07
Epoch 100/100
100/100 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 4.8476e-08
4/4 ━━━━━━━━━━━━━━━━━━━━ 0s 5ms/step - loss: 2.6410e-07
Test loss: 3.141294371289405e-07
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step
Input: [0.46379759 0.55639574], Predicted Sum: [1.0203897], Actual Sum: 1.0201933303955435
Input: [0.96101123 0.28522363], Predicted Sum: [1.2465782], Actual Sum: 1.24623485691041
Input: [0.22075686 0.01841456], Predicted Sum: [0.23940752], Actual Sum: 0.23917141907781858
Input: [0.57684523 0.14231923], Predicted Sum: [0.71945286], Actual Sum: 0.7191644614584992
Input: [0.97511424 0.15069722], Predicted Sum: [1.12618], Actual Sum: 1.1258114643949049
Result:
A simple neural network was successfully designed and trained using Keras to predict the
sum of two input numbers. Trained on randomly generated data, the model accurately predicted sums for unseen
input pairs, demonstrating its ability to learn and generalize the relationship between input numbers and their sum.
 Experiment -4 DL-#3.1 AI & ML (AITK)

4. Train the model to multiply two matrices and report the result using keras.

Aim:

To develop and train a neural network using Keras to predict the product of two 3x3 matrices. The model will
be trained on a dataset of randomly generated matrices and their corresponding products, with the goal of learning
the matrix multiplication operation.

Description:

In this experiment, a neural network will be trained to approximate matrix multiplication results using Keras.
We begin by generating a dataset of 100,000 samples, each consisting of two 3x3 matrices and their product. These
matrices will be normalized, and the data will be reshaped to fit the model’s input requirements. The model will be
constructed using a Sequential architecture with three Dense layers, including ReLU activations and a final linear
layer to predict the matrix product. After training the model for 100 epochs, it will be evaluated for loss and mean
absolute error. To test the model, new matrices will be provided, and the predicted product will be compared to the
actual product obtained via traditional matrix multiplication, demonstrating the model's capability to generalize and
predict matrix products.

Algorithm:

Generate Training Data:

• Create Random Matrices: Generate two sets of random matrices, X1 and X2, each with
dimensions (num_samples, matrix_size, matrix_size).
• Compute Matrix Products: For each pair of matrices, compute their matrix product to form the
target output y. The result y has dimensions (num_samples, matrix_size, matrix_size).

Normalize Data:

• Normalize Input Matrices: Scale the elements of matrices X1 and X2 by dividing by 10.0 to
bring values into the range [0, 1].
• Normalize Output: Scale the matrix product y by dividing by 100.0, assuming the maximum
possible value is 100.

Prepare Data for Model:

• Reshape Input Matrices: Flatten each matrix in X1 and X2 from shape (matrix_size, matrix_size) to
shape (matrix_size*matrix_size,).
• Concatenate Inputs: Combine the flattened matrices from X1 and X2 into a single array X with
shape (num_samples, matrix_size*matrix_size*2).
• Reshape Output: Flatten each matrix in y to shape (matrix_size*matrix_size,).

Build the Neural Network Model:

Define Model Architecture: Create a Sequential model with the following layers:
 • Input Layer: Accepts input with shape (matrix_size*matrix_size*2,).
• Hidden Layers: Two dense layers with 128 units each and ReLU activation functions.
• Output Layer: A dense layer with matrix_size*matrix_size units and a linear activation function to
output the flattened matrix product.

Compile the Model:

• Choose Optimizer and Loss Function: Use the Adam optimizer and mean squared error
(MSE) as the loss function. Include mean absolute error (MAE) as an additional metric.

Train the Model:

• Fit the Model: Train the model using the concatenated input data X and the flattened output y,
for 100 epochs with a batch size of 32. Use 20% of the data for validation.

Evaluate the Model:

• Assess Performance: Evaluate the model on the training data to get the loss and MAE metrics.

Predict Matrix Product:

• Normalize Input Matrices: Scale the input matrices A and B by dividing by 10.0.
• Concatenate and Flatten: Flatten the normalized matrices and concatenate them.
• Predict and De-normalize: Use the trained model to predict the matrix product, and then scale
the output by multiplying by 100.0 to revert to the original range.

Output Results:

• Print Matrices and Results: Display the input matrices A and B, the predicted matrix product,
and the actual matrix product computed using NumPy's dot function.

Program:

import numpy as np

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense, Input

# Step 1: Generate Training Data

def generate_matrix_data(num_samples, matrix_size):

X1 = np.random.randint(0, 10, size=(num_samples, matrix_size, matrix_size))

X2 = np.random.randint(0, 10, size=(num_samples, matrix_size, matrix_size))

 y = np.array([np.dot(X1[i], X2[i]) for i in range(num_samples)])

return X1, X2, y

num_samples = 100000

matrix_size = 3 # Using 3x3 matrices for simplicity

X1, X2, y = generate_matrix_data(num_samples, matrix_size)

# Normalize the data

X1 = X1 / 10.0

X2 = X2 / 10.0

y = y / 100.0 # Normalizing the result assuming max value could be 100

# Reshape the input data to fit the model

X1 = X1.reshape(num_samples, matrix_size*matrix_size)

X2 = X2.reshape(num_samples, matrix_size*matrix_size)

X = np.concatenate((X1, X2), axis=1)

y = y.reshape(num_samples, matrix_size*matrix_size)

# Step 2: Build the Model

model = Sequential([

Input(shape=(matrix_size*matrix_size*2,)), # Define the input shape

Dense(128, activation='relu'),

Dense(128, activation='relu'),
 Dense(matrix_size*matrix_size, activation='linear')

])

# Compile the model

model.compile(optimizer='adam', loss='mse', metrics=['mae'])

# Step 3: Train the Model

model.fit(X, y, epochs=100, batch_size=32, validation_split=0.2)

# Step 4: Evaluate the Model

loss, mae = model.evaluate(X, y)

print(f"Loss: {loss}, MAE: {mae}")

# Step 5: Predict

def multiply_matrices(model, A, B):

A_norm = A / 10.0

B_norm = B / 10.0

input_data = np.concatenate((A_norm.flatten(), B_norm.flatten())).reshape(1, -1)

prediction = model.predict(input_data)

prediction = prediction.reshape(matrix_size, matrix_size) * 100.0 # De-normalize the output

return prediction

A = np.random.randint(0, 10, size=(matrix_size, matrix_size))

 B = np.random.randint(0, 10, size=(matrix_size, matrix_size))

predicted_product = multiply_matrices(model, A, B)

print(f"Matrix A:\n{A}")

print(f"Matrix B:\n{B}")

print(f"Predicted Product:\n{predicted_product}")

print(f"Actual Product:\n{np.dot(A, B)}")

Output: (Write the highlighted output in the observation)

Epoch 1/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 1ms/step - loss: 0.0251 - mae: 0.1049 - val_loss: 0.0025 - val_mae: 0.0396
Epoch 2/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 0.0023 - mae: 0.0374 - val_loss: 0.0018 - val_mae: 0.0330
Epoch 3/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 0.0016 - mae: 0.0318 - val_loss: 0.0015 - val_mae: 0.0302
Epoch 4/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 0.0013 - mae: 0.0288 - val_loss: 0.0012 - val_mae: 0.0273
Epoch 5/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 0.0012 - mae: 0.0268 - val_loss: 0.0011 - val_mae: 0.0259
Epoch 6/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 0.0010 - mae: 0.0255 - val_loss: 8.6211e-04 - val_mae:
0.0232
Epoch 7/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 9.2023e-04 - mae: 0.0240 - val_loss: 9.1212e-04 -
val_mae: 0.0239
Epoch 8/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 8.4285e-04 - mae: 0.0230 - val_loss: 8.0924e-04 -
val_mae: 0.0225
Epoch 9/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 7.9744e-04 - mae: 0.0223 - val_loss: 7.1454e-04 -
val_mae: 0.0212
Epoch 10/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 7.5380e-04 - mae: 0.0217 - val_loss: 6.9452e-04 -
val_mae: 0.0209
Epoch 11/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 7.1389e-04 - mae: 0.0212 - val_loss: 6.4523e-04 -
val_mae: 0.0201
Epoch 12/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 6.6335e-04 - mae: 0.0204 - val_loss: 6.0905e-04 -
val_mae: 0.0196
Epoch 13/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 6.1863e-04 - mae: 0.0197 - val_loss: 6.3751e-04 -
val_mae: 0.0201
Epoch 14/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 5.7706e-04 - mae: 0.0190 - val_loss: 6.2270e-04 -
val_mae: 0.0197
Epoch 15/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 5.5016e-04 - mae: 0.0186 - val_loss: 4.8145e-04 -
val_mae: 0.0174
Epoch 16/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 5.1575e-04 - mae: 0.0180 - val_loss: 5.6106e-04 -
val_mae: 0.0187
Epoch 17/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 4.9219e-04 - mae: 0.0176 - val_loss: 5.4850e-04 -
val_mae: 0.0186
Epoch 18/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 4.7346e-04 - mae: 0.0172 - val_loss: 4.1337e-04 -
val_mae: 0.0161
Epoch 19/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 4.3211e-04 - mae: 0.0164 - val_loss: 3.8348e-04 -
val_mae: 0.0155
Epoch 20/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 4.1981e-04 - mae: 0.0162 - val_loss: 4.3307e-04 -
val_mae: 0.0164
Epoch 21/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 3.8418e-04 - mae: 0.0155 - val_loss: 4.4417e-04 -
val_mae: 0.0167
Epoch 22/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 3.6867e-04 - mae: 0.0152 - val_loss: 4.5252e-04 -
val_mae: 0.0169
Epoch 23/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 3.5513e-04 - mae: 0.0149 - val_loss: 3.7051e-04 -
val_mae: 0.0152
Epoch 24/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 3.4074e-04 - mae: 0.0146 - val_loss: 4.3809e-04 -
val_mae: 0.0167
Epoch 25/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 3.3083e-04 - mae: 0.0144 - val_loss: 2.9078e-04 -
val_mae: 0.0135
Epoch 26/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 3.1417e-04 - mae: 0.0140 - val_loss: 2.7623e-04 -
val_mae: 0.0131
Epoch 27/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - loss: 3.0339e-04 - mae: 0.0138 - val_loss: 3.5174e-04 -
val_mae: 0.0149
Epoch 28/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.9711e-04 - mae: 0.0137 - val_loss: 2.9268e-04 -
val_mae: 0.0135
Epoch 29/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.8529e-04 - mae: 0.0134 - val_loss: 3.0458e-04 -
val_mae: 0.0137
Epoch 30/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.7575e-04 - mae: 0.0131 - val_loss: 2.5399e-04 -
val_mae: 0.0126
Epoch 31/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 2.7262e-04 - mae: 0.0131 - val_loss: 2.7603e-04 -
val_mae: 0.0132
Epoch 32/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.6678e-04 - mae: 0.0129 - val_loss: 2.3653e-04 -
val_mae: 0.0122
Epoch 33/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 2.6010e-04 - mae: 0.0128 - val_loss: 2.5367e-04 -
val_mae: 0.0127
Epoch 34/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.5026e-04 - mae: 0.0125 - val_loss: 2.6374e-04 -
val_mae: 0.0129
Epoch 35/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.4475e-04 - mae: 0.0124 - val_loss: 2.1519e-04 -
val_mae: 0.0116
Epoch 36/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.3918e-04 - mae: 0.0122 - val_loss: 2.6778e-04 -
val_mae: 0.0130
Epoch 37/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.3897e-04 - mae: 0.0122 - val_loss: 2.1435e-04 -
val_mae: 0.0116
Epoch 38/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.2917e-04 - mae: 0.0120 - val_loss: 2.0181e-04 -
val_mae: 0.0112
Epoch 39/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.2675e-04 - mae: 0.0119 - val_loss: 2.0671e-04 -
val_mae: 0.0113
Epoch 40/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.2673e-04 - mae: 0.0119 - val_loss: 2.1174e-04 -
val_mae: 0.0115
Epoch 41/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.2273e-04 - mae: 0.0118 - val_loss: 2.1399e-04 -
val_mae: 0.0115
Epoch 42/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 2.2049e-04 - mae: 0.0118 - val_loss: 2.4355e-04 -
val_mae: 0.0123
Epoch 43/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 2.1323e-04 - mae: 0.0116 - val_loss: 1.9336e-04 -
val_mae: 0.0110
Epoch 44/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.0913e-04 - mae: 0.0115 - val_loss: 2.1335e-04 -
val_mae: 0.0115
Epoch 45/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 2.0799e-04 - mae: 0.0114 - val_loss: 2.0002e-04 -
val_mae: 0.0112
Epoch 46/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.0884e-04 - mae: 0.0114 - val_loss: 2.4978e-04 -
val_mae: 0.0125
Epoch 47/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 2.0552e-04 - mae: 0.0114 - val_loss: 1.9655e-04 -
val_mae: 0.0111
Epoch 48/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.9955e-04 - mae: 0.0112 - val_loss: 2.0663e-04 -
val_mae: 0.0114
Epoch 49/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.9744e-04 - mae: 0.0111 - val_loss: 1.9205e-04 -
val_mae: 0.0110
Epoch 50/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.9571e-04 - mae: 0.0111 - val_loss: 1.7301e-04 -
val_mae: 0.0104
Epoch 51/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.9006e-04 - mae: 0.0109 - val_loss: 2.0252e-04 -
val_mae: 0.0113
Epoch 52/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 1ms/step - loss: 1.9107e-04 - mae: 0.0110 - val_loss: 1.9002e-04 -
val_mae: 0.0109
Epoch 53/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - loss: 1.8669e-04 - mae: 0.0108 - val_loss: 1.9169e-04 -
val_mae: 0.0110
Epoch 54/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.9115e-04 - mae: 0.0109 - val_loss: 1.9303e-04 -
val_mae: 0.0111
Epoch 55/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.8883e-04 - mae: 0.0109 - val_loss: 1.6163e-04 -
val_mae: 0.0101
Epoch 56/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.8663e-04 - mae: 0.0108 - val_loss: 1.9245e-04 -
val_mae: 0.0110
Epoch 57/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.8558e-04 - mae: 0.0108 - val_loss: 1.7094e-04 -
val_mae: 0.0104
Epoch 58/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.8391e-04 - mae: 0.0107 - val_loss: 1.8369e-04 -
val_mae: 0.0108
Epoch 59/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.7936e-04 - mae: 0.0106 - val_loss: 1.8456e-04 -
val_mae: 0.0108
Epoch 60/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.7928e-04 - mae: 0.0106 - val_loss: 1.8028e-04 -
val_mae: 0.0107
Epoch 61/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.7962e-04 - mae: 0.0106 - val_loss: 1.6864e-04 -
val_mae: 0.0103
Epoch 62/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.7734e-04 - mae: 0.0105 - val_loss: 1.8030e-04 -
val_mae: 0.0107
Epoch 63/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - loss: 1.7518e-04 - mae: 0.0105 - val_loss: 1.7211e-04 -
val_mae: 0.0104
Epoch 64/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.7343e-04 - mae: 0.0104 - val_loss: 1.5311e-04 -
val_mae: 0.0097
Epoch 65/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.7466e-04 - mae: 0.0105 - val_loss: 1.6916e-04 -
val_mae: 0.0103
Epoch 66/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.7298e-04 - mae: 0.0104 - val_loss: 2.0025e-04 -
val_mae: 0.0111
Epoch 67/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 2ms/step - loss: 1.7343e-04 - mae: 0.0104 - val_loss: 2.1201e-04 -
val_mae: 0.0117
Epoch 68/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - loss: 1.7015e-04 - mae: 0.0103 - val_loss: 1.4918e-04 -
val_mae: 0.0097
Epoch 69/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - loss: 1.6793e-04 - mae: 0.0103 - val_loss: 2.0422e-04 -
val_mae: 0.0112
Epoch 70/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 5s 2ms/step - loss: 1.7165e-04 - mae: 0.0104 - val_loss: 2.0216e-04 -
val_mae: 0.0114
Epoch 71/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.6343e-04 - mae: 0.0101 - val_loss: 1.8343e-04 -
val_mae: 0.0107
Epoch 72/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.6679e-04 - mae: 0.0102 - val_loss: 1.9032e-04 -
val_mae: 0.0110
Epoch 73/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.6612e-04 - mae: 0.0102 - val_loss: 1.6629e-04 -
val_mae: 0.0102
Epoch 74/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.6290e-04 - mae: 0.0101 - val_loss: 1.4802e-04 -
val_mae: 0.0096
Epoch 75/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.6273e-04 - mae: 0.0101 - val_loss: 1.8409e-04 -
val_mae: 0.0108
Epoch 76/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.6091e-04 - mae: 0.0100 - val_loss: 1.5090e-04 -
val_mae: 0.0097
Epoch 77/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5906e-04 - mae: 0.0100 - val_loss: 1.5037e-04 -
val_mae: 0.0097
Epoch 78/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5713e-04 - mae: 0.0099 - val_loss: 1.8115e-04 -
val_mae: 0.0106
Epoch 79/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5628e-04 - mae: 0.0099 - val_loss: 1.7596e-04 -
val_mae: 0.0105
Epoch 80/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5848e-04 - mae: 0.0100 - val_loss: 1.6351e-04 -
val_mae: 0.0102
Epoch 81/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5581e-04 - mae: 0.0099 - val_loss: 1.4489e-04 -
val_mae: 0.0095
Epoch 82/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5439e-04 - mae: 0.0098 - val_loss: 1.6609e-04 -
val_mae: 0.0103
Epoch 83/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5197e-04 - mae: 0.0098 - val_loss: 1.3721e-04 -
val_mae: 0.0093
Epoch 84/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.5125e-04 - mae: 0.0097 - val_loss: 1.4847e-04 -
val_mae: 0.0096
Epoch 85/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4681e-04 - mae: 0.0096 - val_loss: 1.3965e-04 -
val_mae: 0.0094
Epoch 86/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4717e-04 - mae: 0.0096 - val_loss: 1.5583e-04 -
val_mae: 0.0100
Epoch 87/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4547e-04 - mae: 0.0096 - val_loss: 1.4675e-04 -
val_mae: 0.0096
Epoch 88/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 4s 1ms/step - loss: 1.4740e-04 - mae: 0.0096 - val_loss: 1.4760e-04 -
val_mae: 0.0096
Epoch 89/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4560e-04 - mae: 0.0096 - val_loss: 1.4183e-04 -
val_mae: 0.0094
Epoch 90/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4378e-04 - mae: 0.0095 - val_loss: 1.6845e-04 -
val_mae: 0.0103
Epoch 91/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4574e-04 - mae: 0.0096 - val_loss: 1.3505e-04 -
val_mae: 0.0092
Epoch 92/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4329e-04 - mae: 0.0095 - val_loss: 1.3570e-04 -
val_mae: 0.0092
Epoch 93/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4198e-04 - mae: 0.0094 - val_loss: 2.2572e-04 -
val_mae: 0.0117
Epoch 94/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4396e-04 - mae: 0.0095 - val_loss: 1.3641e-04 -
val_mae: 0.0093
Epoch 95/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4095e-04 - mae: 0.0094 - val_loss: 1.4182e-04 -
val_mae: 0.0094
Epoch 96/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4325e-04 - mae: 0.0095 - val_loss: 1.9787e-04 -
val_mae: 0.0112
Epoch 97/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.3893e-04 - mae: 0.0093 - val_loss: 1.1618e-04 -
val_mae: 0.0085
Epoch 98/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.3981e-04 - mae: 0.0094 - val_loss: 1.3691e-04 -
val_mae: 0.0092
Epoch 99/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.3711e-04 - mae: 0.0093 - val_loss: 1.6509e-04 -
val_mae: 0.0102
Epoch 100/100
2500/2500 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - loss: 1.4034e-04 - mae: 0.0094 - val_loss: 1.4238e-04 -
val_mae: 0.0095
3125/3125 ━━━━━━━━━━━━━━━━━━━━ 3s 836us/step - loss: 1.3937e-04 - mae: 0.0094
Loss: 0.00013981072697788477, MAE: 0.009384003467857838
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step
Matrix A:
[[1 9 9]
[9 4 6]
[3 0 5]]
Matrix B:
[[5 5 8]
[2 5 8]
[1 3 7]]
Predicted Product:
[[ 32.04232 77.669975 143.1983 ]
[ 57.566856 82.91475 146.27672 ]
[ 20.682734 28.558468 57.679264]]
Actual Product:
[[ 32 77 143]
[ 59 83 146]
[ 20 30 59]]

Result:
The neural network successfully learned to predict the product of two 3x3 matrices. The model's performance was
evaluated using Mean Squared Error (MSE) and Mean Absolute Error (MAE), providing a measure of prediction accuracy.
The trained model demonstrated its capability to approximate the matrix multiplication operation effectively, with predictions
closely matching actual matrix products.
 Experiment -5 DL-#3.1 AI & ML (AITK)

5. Train the model to print the prime numbers using keras.

Aim:
To build and train a neural network model that can classify numbers as prime or non-prime based on their
binary representations. The model to be designed with multiple dense layers, PReLU activation, and dropout for
regularization, and it is trained using binary cross-entropy loss to optimize its accuracy. The objective is to evaluate the
model's ability to correctly identify prime numbers, with a focus on precision, recall, and F-score metrics, and to analyse
the model's performance through the training history and predictions.

Description:
A neural network is designed and trained to predict whether a number is prime based on its binary
representation. The model utilizes a feedforward architecture with several Dense layers, PReLU activation functions,
and Dropout layers to prevent overfitting. The dataset was generated by encoding numbers from 2 up to 16384 into
binary and labelling them as prime or not. After training the model for 100 epochs, its performance is evaluated on
numbers from 2 to 100. The results shows the model's accuracy in classifying prime numbers, with metrics including
precision, recall, and F1 score calculated to assess its effectiveness. The training history is visualized to track the model’s
loss over epochs.

Algorithm:

1. Initialization:

• Set a random seed for reproducibility using np.random.seed(7).

2. Define Parameters:

• Set num_digits to 14, which defines the binary encoding length.

• Calculate max_number as 2^14, representing the maximum number to be considered for
prime checks.

3. Generate List of Prime Numbers:

• Define a function prime_list() to generate a list of prime numbers up to max_number.

1. Initialize the list with the first two primes: 2 and 3.
2. Iterate over odd numbers starting from 5 to max_number.
3. For each number, check if it is divisible by any of the primes already in the
list.
4. If not divisible by any primes, add the number to the list as a prime.
• Store the generated prime numbers in the list primes.

4. Encode Numbers:

• Define a function prime_encode(i) that checks if a number i is in the list of primes:

1. Return 1 if the number is prime.
2. Return 0 if the number is not prime.
• Define a function bin_encode(i) that converts a number i into its binary representation of
length num_digits.
5. Create the Dataset:

• Define a function create_dataset() to generate the training dataset:

1. Iterate over numbers from 2 to max_number.
2. For each number, generate its binary representation using bin_encode(i) and
whether it is prime using prime_encode(i).
3. Store these in the feature matrix x and label vector y.
• Convert x and y to NumPy arrays and return them as x_train and y_train.

6. Build the Neural Network Model:

• Initialize a Sequential model using Keras.

• Add a dense layer with 100 units and input dimension num_digits.
• Add a PReLU activation layer and a dropout layer with a 0.2 dropout rate.
• Add another dense layer with 50 units, followed by PReLU and dropout layers.
• Add another dense layer with 25 units, followed by PReLU and dropout layers.
• Add a final dense layer with 1 unit and a sigmoid activation function.

7. Compile the Model:

• Compile the model with RMSprop optimizer, binary_crossentropy loss function, and
accuracy as the evaluation metric.

8. Train the Model:

• Train the model using model.fit() on x_train and y_train.

• Set the number of epochs to 100, batch size to 128, and use 10% of the data for
validation.
• Store the training history in the history object.

9. Evaluate the Model:

• Initialize counters for errors, correct predictions, true positives (tp), false negatives
(fn), and false positives (fp).
• Iterate over numbers from 2 to 100:
1. Convert the number to its binary form using bin_encode(i).
2. Use the trained model to predict whether the number is prime.
3. Compare the prediction with the actual prime status using prime_encode(i).
4. Update counters based on the prediction outcome (correct, tp, fn, fp).
• Calculate precision, recall, and F-score using the updated counters.
• Print the number of errors, correct predictions, and the F-score.

10. Plot the Training History:

• Define a function plot_history(history) to plot the training and validation loss over
epochs.
• Use matplotlib to generate and display the plot, showing the model's loss during
training.

11. Execution and Output:

• Execute the code to build, train, and evaluate the model, and visualize the loss curve
during training.
Program:

import numpy as np

from tensorflow.keras.layers import Dense, Dropout, Activation, PReLU

from tensorflow.keras.models import Sequential

from matplotlib import pyplot as plt

# Seed for reproducibility

seed = 7

np.random.seed(seed)

# Parameters

num_digits = 14 # Binary encoding length

max_number = 2 ** num_digits

# Generate list of prime numbers

def prime_list():

primes = [2, 3]

for n in range(5, max_number, 2):

is_prime = True

for p in primes:

if p * p > n:

break

if n % p == 0:

is_prime = False

break
 if is_prime:

primes.append(n)

return primes

primes = prime_list()

# Encode whether a number is prime or not

def prime_encode(i):

return 1 if i in primes else 0

# Binary encode a number

def bin_encode(i):

return [(i >> d) & 1 for d in range(num_digits)]

# Create dataset

def create_dataset():

x, y = [], []

for i in range(2, max_number): # Adjusted to start from 2

x.append(bin_encode(i))

y.append(prime_encode(i))

return np.array(x), np.array(y)

x_train, y_train = create_dataset()

# Build the model

model = Sequential()
model.add(Dense(units=100, input_dim=num_digits))

model.add(PReLU())

model.add(Dropout(rate=0.2))

model.add(Dense(units=50))

model.add(PReLU())

model.add(Dropout(rate=0.2))

model.add(Dense(units=25))

model.add(PReLU())

model.add(Dropout(rate=0.2))

model.add(Dense(units=1))

model.add(Activation("sigmoid"))

model.compile(optimizer='RMSprop',

loss='binary_crossentropy',

metrics=['accuracy'])

# Train the model

history = model.fit(x_train, y_train, epochs=100, batch_size=128,

validation_split=0.1, verbose=1)

# Predict and evaluate

errors, correct = 0, 0

tp, fn, fp = 0, 0, 0

for i in range(2, 101):

x = np.array(bin_encode(i)).reshape(-1, num_digits)
 y_pred = model.predict(x)[0][0]

pred = 1 if y_pred >= 0.5 else 0

obs = prime_encode(i)

print(i, obs, pred, y_pred)

if pred == obs:

correct += 1

else:

errors += 1

if obs == 1 and pred == 1:

tp += 1

if obs == 1 and pred == 0:

fn += 1

if obs == 0 and pred == 1:

fp += 1

precision = tp / (tp + fp) if (tp + fp) > 0 else 0

recall = tp / (tp + fn) if (tp + fn) > 0 else 0

f_score = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0

print("Errors:", errors, "Correct:", correct)

# Plot training history

def plot_history(history):

plt.plot(history.history['loss'])

plt.plot(history.history['val_loss'])

plt.title('Model Loss')
 plt.xlabel('Epoch')

plt.ylabel('Loss')

plt.legend(['Loss', 'Val Loss'], loc='upper right')

plt.savefig('model_loss.png')

plt.show()

plot_history(history)

Output: (Write only the highlighted output in the observation and draw the graph)

Epoch 1/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 1s 5ms/step - accuracy: 0.8539 - loss: 0.4054 - val_a
ccuracy: 0.8938 - val_loss: 0.2933
Epoch 2/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8823 - loss: 0.2988 - val_a
ccuracy: 0.8938 - val_loss: 0.2596
Epoch 3/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8818 - loss: 0.2816 - val_a
ccuracy: 0.8938 - val_loss: 0.2595
Epoch 4/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8828 - loss: 0.2784 - val_a
ccuracy: 0.8938 - val_loss: 0.2591
Epoch 5/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8783 - loss: 0.2810 - val_a
ccuracy: 0.8938 - val_loss: 0.2593
Epoch 6/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8853 - loss: 0.2723 - val_a
ccuracy: 0.8938 - val_loss: 0.2600
Epoch 7/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8849 - loss: 0.2712 - val_a
ccuracy: 0.8938 - val_loss: 0.2587
Epoch 8/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8838 - loss: 0.2716 - val_a
ccuracy: 0.8938 - val_loss: 0.2589
Epoch 9/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8809 - loss: 0.2782 - val_a
ccuracy: 0.8938 - val_loss: 0.2585
Epoch 10/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8801 - loss: 0.2772 - val_a
ccuracy: 0.8938 - val_loss: 0.2594
Epoch 11/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8837 - loss: 0.2737 - val_a
ccuracy: 0.8938 - val_loss: 0.2591
Epoch 12/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8811 - loss: 0.2739 - val_a
ccuracy: 0.8938 - val_loss: 0.2595
Epoch 13/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8836 - loss: 0.2741 - val_a
ccuracy: 0.8938 - val_loss: 0.2607
Epoch 14/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8847 - loss: 0.2719 - val_a
ccuracy: 0.8938 - val_loss: 0.2603
Epoch 15/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8784 - loss: 0.2818 - val_a
ccuracy: 0.8938 - val_loss: 0.2606
Epoch 16/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - accuracy: 0.8860 - loss: 0.2682 - val_a
ccuracy: 0.8938 - val_loss: 0.2591
Epoch 17/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8847 - loss: 0.2705 - val_a
ccuracy: 0.8938 - val_loss: 0.2596
Epoch 18/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8847 - loss: 0.2718 - val_a
ccuracy: 0.8938 - val_loss: 0.2589
Epoch 19/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8834 - loss: 0.2714 - val_a
ccuracy: 0.8938 - val_loss: 0.2589
Epoch 20/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8818 - loss: 0.2730 - val_a
ccuracy: 0.8938 - val_loss: 0.2603
Epoch 21/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8817 - loss: 0.2728 - val_a
ccuracy: 0.8938 - val_loss: 0.2589
Epoch 22/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8839 - loss: 0.2712 - val_a
ccuracy: 0.8938 - val_loss: 0.2596
Epoch 23/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8851 - loss: 0.2689 - val_a
ccuracy: 0.8938 - val_loss: 0.2618
Epoch 24/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8863 - loss: 0.2671 - val_a
ccuracy: 0.8938 - val_loss: 0.2594
Epoch 25/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8849 - loss: 0.2712 - val_a
ccuracy: 0.8938 - val_loss: 0.2597
Epoch 26/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8818 - loss: 0.2743 - val_a
ccuracy: 0.8938 - val_loss: 0.2588
Epoch 27/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8833 - loss: 0.2721 - val_a
ccuracy: 0.8938 - val_loss: 0.2589
Epoch 28/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8841 - loss: 0.2699 - val_a
ccuracy: 0.8938 - val_loss: 0.2742
Epoch 29/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8848 - loss: 0.2700 - val_a
ccuracy: 0.8938 - val_loss: 0.2604
Epoch 30/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8828 - loss: 0.2740 - val_a
ccuracy: 0.8938 - val_loss: 0.2635
Epoch 31/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8810 - loss: 0.2746 - val_a
ccuracy: 0.8938 - val_loss: 0.2591
Epoch 32/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8857 - loss: 0.2680 - val_a
ccuracy: 0.8938 - val_loss: 0.2606
Epoch 33/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8836 - loss: 0.2737 - val_a
ccuracy: 0.8938 - val_loss: 0.2609
Epoch 34/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8785 - loss: 0.2768 - val_a
ccuracy: 0.8938 - val_loss: 0.2591
Epoch 35/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8812 - loss: 0.2754 - val_a
ccuracy: 0.8938 - val_loss: 0.2624
Epoch 36/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8854 - loss: 0.2698 - val_a
ccuracy: 0.8938 - val_loss: 0.2608
Epoch 37/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8791 - loss: 0.2772 - val_a
ccuracy: 0.8938 - val_loss: 0.2627
Epoch 38/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.8856 - loss: 0.2670 - val_a
ccuracy: 0.8938 - val_loss: 0.2587
Epoch 39/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8858 - loss: 0.2660 - val_a
ccuracy: 0.8938 - val_loss: 0.2624
Epoch 40/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8799 - loss: 0.2761 - val_a
ccuracy: 0.8938 - val_loss: 0.2599
Epoch 41/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8835 - loss: 0.2698 - val_a
ccuracy: 0.8938 - val_loss: 0.2704
Epoch 42/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8866 - loss: 0.2657 - val_a
ccuracy: 0.8938 - val_loss: 0.2599
Epoch 43/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8864 - loss: 0.2649 - val_a
ccuracy: 0.8938 - val_loss: 0.2598
Epoch 44/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8824 - loss: 0.2713 - val_a
ccuracy: 0.8938 - val_loss: 0.2597
Epoch 45/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8852 - loss: 0.2680 - val_a
ccuracy: 0.8938 - val_loss: 0.2613
Epoch 46/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8789 - loss: 0.2797 - val_a
ccuracy: 0.8938 - val_loss: 0.2714
Epoch 47/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8861 - loss: 0.2683 - val_a
ccuracy: 0.8938 - val_loss: 0.2616
Epoch 48/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8826 - loss: 0.2729 - val_a
ccuracy: 0.8938 - val_loss: 0.2615
Epoch 49/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8833 - loss: 0.2717 - val_a
ccuracy: 0.8938 - val_loss: 0.2603
Epoch 50/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8819 - loss: 0.2713 - val_a
ccuracy: 0.8938 - val_loss: 0.2603
Epoch 51/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8832 - loss: 0.2702 - val_a
ccuracy: 0.8938 - val_loss: 0.2629
Epoch 52/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8848 - loss: 0.2675 - val_a
ccuracy: 0.8938 - val_loss: 0.2603
Epoch 53/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8891 - loss: 0.2617 - val_a
ccuracy: 0.8938 - val_loss: 0.2600
Epoch 54/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.8836 - loss: 0.2695 - val_a
ccuracy: 0.8938 - val_loss: 0.2596
Epoch 55/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8788 - loss: 0.2747 - val_a
ccuracy: 0.8938 - val_loss: 0.2606
Epoch 56/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8842 - loss: 0.2691 - val_a
ccuracy: 0.8938 - val_loss: 0.3085
Epoch 57/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8811 - loss: 0.2725 - val_a
ccuracy: 0.8938 - val_loss: 0.2633
Epoch 58/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8841 - loss: 0.2683 - val_a
ccuracy: 0.8938 - val_loss: 0.2607
Epoch 59/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8826 - loss: 0.2710 - val_a
ccuracy: 0.8938 - val_loss: 0.2663
Epoch 60/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8830 - loss: 0.2700 - val_a
ccuracy: 0.8938 - val_loss: 0.2594
Epoch 61/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8811 - loss: 0.2739 - val_a
ccuracy: 0.8938 - val_loss: 0.2636
Epoch 62/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8822 - loss: 0.2718 - val_a
ccuracy: 0.8938 - val_loss: 0.2606
Epoch 63/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8843 - loss: 0.2667 - val_a
ccuracy: 0.8938 - val_loss: 0.2636
Epoch 64/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8798 - loss: 0.2740 - val_a
ccuracy: 0.8938 - val_loss: 0.2598
Epoch 65/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8810 - loss: 0.2721 - val_a
ccuracy: 0.8938 - val_loss: 0.2591
Epoch 66/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8848 - loss: 0.2676 - val_a
ccuracy: 0.8938 - val_loss: 0.2611
Epoch 67/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8832 - loss: 0.2708 - val_a
ccuracy: 0.8938 - val_loss: 0.2606
Epoch 68/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8777 - loss: 0.2771 - val_a
ccuracy: 0.8938 - val_loss: 0.2841
Epoch 69/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8895 - loss: 0.2631 - val_a
ccuracy: 0.8938 - val_loss: 0.2620
Epoch 70/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8832 - loss: 0.2681 - val_a
ccuracy: 0.8938 - val_loss: 0.2648
Epoch 71/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8880 - loss: 0.2650 - val_a
ccuracy: 0.8938 - val_loss: 0.2656
Epoch 72/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8818 - loss: 0.2705 - val_a
ccuracy: 0.8938 - val_loss: 0.2633
Epoch 73/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8848 - loss: 0.2637 - val_a
ccuracy: 0.8938 - val_loss: 0.2615
Epoch 74/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8823 - loss: 0.2695 - val_a
ccuracy: 0.8938 - val_loss: 0.2624
Epoch 75/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8793 - loss: 0.2755 - val_a
ccuracy: 0.8938 - val_loss: 0.2612
Epoch 76/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - accuracy: 0.8832 - loss: 0.2704 - val_a
ccuracy: 0.8938 - val_loss: 0.2615
Epoch 77/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8864 - loss: 0.2644 - val_a
ccuracy: 0.8938 - val_loss: 0.2759
Epoch 78/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - accuracy: 0.8835 - loss: 0.2730 - val_a
ccuracy: 0.8938 - val_loss: 0.2674
Epoch 79/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8859 - loss: 0.2648 - val_a
ccuracy: 0.8938 - val_loss: 0.2638
Epoch 80/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8801 - loss: 0.2738 - val_a
ccuracy: 0.8938 - val_loss: 0.2617
Epoch 81/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8798 - loss: 0.2731 - val_a
ccuracy: 0.8938 - val_loss: 0.2614
Epoch 82/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8823 - loss: 0.2705 - val_a
ccuracy: 0.8938 - val_loss: 0.2629
Epoch 83/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8811 - loss: 0.2705 - val_a
ccuracy: 0.8938 - val_loss: 0.2611
Epoch 84/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8864 - loss: 0.2651 - val_a
ccuracy: 0.8938 - val_loss: 0.2614
Epoch 85/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8781 - loss: 0.2755 - val_a
ccuracy: 0.8938 - val_loss: 0.2650
Epoch 86/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8777 - loss: 0.2747 - val_a
ccuracy: 0.8938 - val_loss: 0.2618
Epoch 87/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8826 - loss: 0.2673 - val_a
ccuracy: 0.8938 - val_loss: 0.2628
Epoch 88/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8808 - loss: 0.2729 - val_a
ccuracy: 0.8938 - val_loss: 0.2734
Epoch 89/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8815 - loss: 0.2697 - val_a
ccuracy: 0.8938 - val_loss: 0.3050
Epoch 90/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8853 - loss: 0.2674 - val_a
ccuracy: 0.8938 - val_loss: 0.2994
Epoch 91/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8872 - loss: 0.2640 - val_a
ccuracy: 0.8938 - val_loss: 0.2688
Epoch 92/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - accuracy: 0.8863 - loss: 0.2645 - val_a
ccuracy: 0.8938 - val_loss: 0.2820
Epoch 93/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 4ms/step - accuracy: 0.8849 - loss: 0.2703 - val_a
ccuracy: 0.8938 - val_loss: 0.2639
Epoch 94/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8859 - loss: 0.2644 - val_a
ccuracy: 0.8938 - val_loss: 0.2621
Epoch 95/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8844 - loss: 0.2678 - val_a
ccuracy: 0.8938 - val_loss: 0.2636
Epoch 96/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8767 - loss: 0.2772 - val_a
ccuracy: 0.8938 - val_loss: 0.2747
Epoch 97/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.8861 - loss: 0.2667 - val_a
ccuracy: 0.8938 - val_loss: 0.2637
Epoch 98/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8828 - loss: 0.2701 - val_a
ccuracy: 0.8938 - val_loss: 0.2659
Epoch 99/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8829 - loss: 0.2682 - val_a
ccuracy: 0.8938 - val_loss: 0.2672
Epoch 100/100
116/116 ━━━━━━━━━━━━━━━━━━━━ 0s 3ms/step - accuracy: 0.8803 - loss: 0.2706 - val_a
ccuracy: 0.8938 - val_loss: 0.2629
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 73ms/step
2 1 0 0.383954
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 57ms/step
3 1 0 0.38080835
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 27ms/step
4 0 0 0.026962234
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
5 1 0 0.37707672
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
6 0 0 0.011072025
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
7 1 0 0.3830549
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 22ms/step
8 0 0 0.0120331
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
9 0 0 0.3547673
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 65ms/step
10 0 0 0.0058986926
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step
11 1 0 0.37851676
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
12 0 0 0.0007476649
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
13 1 0 0.3722207
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 20ms/step
14 0 0 0.0001849889
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
15 0 0 0.37702525
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
16 0 0 0.053087883
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 33ms/step
17 1 0 0.3585548
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
18 0 0 0.011597598
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
19 1 0 0.36810765
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 72ms/step
20 0 0 0.0060820696
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
21 0 0 0.3612024
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
22 0 0 0.0009023409
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 66ms/step
23 1 0 0.36651924
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
24 0 0 0.00094541954
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 15ms/step
25 0 0 0.3545844
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
26 0 0 0.00022615517
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step
27 0 0 0.36603397
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
28 0 0 7.8036515e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
29 1 0 0.36277783
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 69ms/step
30 0 0 1.0681912e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 23ms/step
31 1 0 0.36980352
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 25ms/step
32 0 0 0.02106894
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
33 0 0 0.3540372
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 40ms/step
34 0 0 0.02433002
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 25ms/step
35 0 0 0.3681119
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
36 0 0 0.0008112356
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 56ms/step
37 1 0 0.36699072
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
38 0 0 0.0009043261
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 22ms/step
39 0 0 0.37308374
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
40 0 0 0.00042471796
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 18ms/step
41 1 0 0.35018626
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
42 0 0 0.00026290998
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
43 1 0 0.3605038
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 44ms/step
44 0 0 3.3106484e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
45 0 0 0.35945165
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
46 0 0 1.0414666e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
47 1 0 0.36650753
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 22ms/step
48 0 0 0.004686651
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
49 0 0 0.3368874
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
50 0 0 0.0030867003
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step
51 0 0 0.3509847
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
52 0 0 0.0010047829
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 25ms/step
53 1 0 0.35520494
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 81ms/step
54 0 0 0.0003207096
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
55 0 0 0.36132163
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
56 0 0 0.0001574932
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 21ms/step
57 0 0 0.33596253
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 25ms/step
58 0 0 3.6496283e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
59 1 0 0.35572907
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
60 0 0 2.1125838e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 56ms/step
61 1 0 0.3538455
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
62 0 0 3.7109357e-06
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
63 0 0 0.35979313
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 73ms/step
64 0 0 0.015715573
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
65 0 0 0.354191
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
66 0 0 0.0075669964
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 93ms/step
67 1 0 0.35365075
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 20ms/step
68 0 0 0.001518746
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
69 0 0 0.35232738
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
70 0 0 0.0003496702
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
71 1 0 0.36261925
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
72 0 0 0.000907353
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 29ms/step
73 1 0 0.35280442
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 88ms/step
74 0 0 0.00045616785
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 32ms/step
75 0 0 0.3603841
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
76 0 0 0.0001191719
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
77 0 0 0.36085296
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
78 0 0 1.5682637e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 20ms/step
79 1 0 0.36770338
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
80 0 0 0.005096048
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 65ms/step
81 0 0 0.32275093
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
82 0 0 0.0010224471
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
83 1 0 0.34251547
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 80ms/step
84 0 0 0.00068605406
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
85 0 0 0.3481401
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 14ms/step
86 0 0 8.467569e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
87 0 0 0.35359338
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 48ms/step
88 0 0 0.0001489397
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 24ms/step
89 1 0 0.33779338
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 25ms/step
90 0 0 2.1645501e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 25ms/step
91 0 0 0.34851038
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 25ms/step
92 0 0 3.6603742e-05
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 27ms/step
93 0 0 0.34789127
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
94 0 0 2.835524e-06
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 50ms/step
95 0 0 0.3567752
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
96 0 0 0.00074291835
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step
97 1 0 0.31832483
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 82ms/step
98 0 0 0.0008699383
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 26ms/step
99 0 0 0.34367406
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 17ms/step
100 0 0 8.1156795e-05
Errors: 25 Correct: 74
Result:
The neural network was successfully trained to classify prime numbers with high accuracy. The model achieved a notable
F1 score, indicating effective performance in distinguishing prime numbers from non-primes. The training and evaluation metrics
confirm the model's reliability in predicting prime numbers.