Dynamic Neural Learning

Engine: A Practical Approach to

Understanding AI Adaptability
ChatGPT-4¹, Ninaad Das²

¹LLM AI Research & Computational Learning

²BSc Filmmaking, Direction

Abstract and adaptive neural adjustments, we

demonstrate how AI models
Neural engines form the computational progressively refine their learning.
backbone of modern artificial intelligence
(AI), allowing models to dynamically This study employs a neural network-
learn and adapt to evolving datasets. This based classifier that categorizes input
study introduces a real-time neural data points into distinct classes. The
learning engine (NLE) capable of paper provides an in-depth discussion of
continuous learning by adjusting decision the mechanics of neural networks, a
boundaries as new data is introduced. By stepwise analysis of the NLE's learning
integrating an interactive system process, and insights into its
featuring live-updating visualizations, effectiveness as an educational and
user-controlled dataset randomness, research tool.

1. Introduction 3. Output Layer – Produces

classifications or predictions.
A Neural Learning Engine (NLE) is a
Mathematically, the operation of a single
computational framework designed to
artificial neuron is expressed as:
process data in a manner akin to
biological neural systems—through
multi-layered information processing and 𝑦 = 𝑓(𝑊𝑋 + 𝐵)
pattern recognition. The structure of an
NLE is typically defined as follows: where:

1. Input Layer – Receives and • X represents the input features

preprocesses raw data. (e.g., spatial coordinates of data
points).
2. Hidden Layers – Extracts and
refines patterns through weighted • W denotes the weight vector,
processing. assigning relative importance to
each feature.
 • B is the bias term, serving as an The NLE employs a feedforward
adjustment factor. network trained through
backpropagation and gradient descent,
• f signifies the activation function both of which iteratively minimize
(e.g., ReLU, Softmax). classification errors.
• Y corresponds to the computed
output (predicted classification).

crucial because it allows the network to

1.1. Function Breakdown learn complex patterns beyond simple
linear relationships.

Input (X) - Receiving Information

The neuron receives input signals from

other neurons or from external data.
fig 01: procedural flow of the Neural Function y = f(WX + B)
These inputs can be numerical values
representing features, such as pixel
intensity in an image, words in a sentence, Common activation functions:
or sensor readings.
Sigmoid: Outputs values between 0 and 1
2. Linear Transformation - (useful for probabilities).
Weighted Sum ReLU (Rectified Linear Unit): Outputs 0
Each input is multiplied by a weight for negative values and keeps positive
(W), which determines its importance. values unchanged (helps avoid vanishing
gradients).
A bias term (B) is added to shift the
result, helping the neuron learn patterns 4. Output (y) - Passing the Signal
even when inputs are zero.
The transformed value y becomes the
This operation models how biological output of the neuron.
neurons sum up signals they receive
This output can either be:
before deciding whether to fire.
Sent to another neuron in a hidden layer
3. Activation Function - Decision (if part of a deep network).
Making
Used as a final prediction, such as
The weighted sum is passed through an classifying an image or detecting a spam
activation function f, which introduces email.
non-linearity. This non-linearity is
5. Understanding a Neuron in a Neural
Network

The entire process mimics how a It sends a signal forward if activated

biological neuron works: (axon → output y).

It receives signals (dendrites → input X). By stacking many of these artificial

neurons together, we form deep neural
It processes the signal by weighing its networks capable of recognizing images,
importance (synapse → (WX+B)). translating languages, and making
It decides whether to fire (neuron body complex decisions.
→ activation function(f), i.e. overcoming
action potential).

1.2 Learning Process Fundamentals

The learning dynamics of neural networks are governed by the continuous update of
weights, wherein a loss function quantitatively assesses prediction errors, thereby guiding
weight adjustments. The primary objectives of our study are to:

• Examine real-time weight updates during neural network learning.

• Visualize model convergence using interactive tools.

• Facilitate user experimentation through direct control of dataset variability.

2. Methodology
This study implements a real-time adaptive neural network that dynamically learns from
an interactive dataset. The core features of our experimental setup are outlined in Table 1.

2.1 Key Components of the NLE System

Feature Function

Live Decision Boundary Graph Provides a real-time visualization of the NLE's classification boundary.

Loss vs. Epochs Graph Illustrates model learning performance over time.

Hidden Layer Weights Graph Displays how neurons adjust their processing of input features.

Reset Functionality Allows dataset randomization while maintaining the learning process.
Feature Function

Drasticity Control Empowers users to modulate the degree of dataset randomness.

2.2 Neural Network 𝐿𝑜𝑠𝑠 = − ∑(𝑦 log(𝑦 ^ ) + (1 − 𝑦) log (1 − 𝑦 ^ ))

Training Phases where:

The following procedural steps outline • y represents the true class label (0
the training process for the ‘point binding’ or 1).
NLE model. The objective of the model is
to bind the given arbitrary points • y^ represents the predicted
within a bounded region. probability of class 1.

Step 1: Initial State This function penalizes incorrect

predictions, compelling the model to
The model initializes with randomly refine its weight assignments.
assigned weights and biases.
Step 4: Backpropagation & Weight
Initial classification accuracy is low, Updates
with an undefined decision boundary.
• The gradient of the loss function
Step 2: Forward Propagation is computed for each parameter.

Each input data point (x1, x2) is • Weights are updated via gradient
multiplied by the corresponding descent, optimizing for minimal
weight matrix in the hidden layers. classification error.

The intermediate values are passed Step 5: Adjustment of the Decision

through an activation function (e.g., Boundary
ReLU) to introduce non-linearity.
The decision boundary gradually shifts
Step 3: Loss Computation and refines as training progresses,
dynamically adapting to changes in
The model's prediction accuracy is
dataset structure (Figure 02).
evaluated using the Cross-Entropy Loss
Function:
3. Results & Discussion
The NLE’s learning dynamics were analysed using real-time graphs and interactive
visualization techniques. Several issues emerged during development but they were
resolved collaboratively with the cowriter.

3.1 Observed Issues and Solutions

Issue Identified Problem Implemented Solution

Matplotlib UI Resetting the dataset caused system Used FuncAnimation for

Freezing unresponsiveness. smooth updates.

Sudden Decision
Training appeared instantaneous Adjusted graph updates to show
Boundary
instead of gradual. learning steps.
Changes

Loss graph displayed linear decrease Fixed loss function computation

Incorrect Loss
instead of fluctuating training for accurate performance
Reduction Pattern
dynamics. tracking.

Highlighting the importance of real-time debugging and visualization in neural

network training above.
5. Conclusion
This study introduced an interactive neural learning engine (NLE) designed to
dynamically adapt to real-time dataset changes. Experimental results demonstrate the
progressive refinement of AI decision-making through continuous learning. Future work
will explore multi-class classification and unsupervised learning extensions.

References

• Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press.

• LeCun, Y., Bottou, L., Bengio, Y., & Haffner, P. (1998). Gradient-Based Learning
Applied to Document Recognition.

Glossary of Terms

• Activation Function¹: A function that determines whether a neuron should activate

based on an input signal. Example: ReLU, which outputs zero for negative values and
the input itself for positive values.

• Derivative²: In calculus, the derivative of a function represents its rate of change. In

neural networks, it is used to measure how changes in input weights affect the
output, guiding weight updates during training.

• Backpropagation³: A supervised learning algorithm used to update neural network

weights by propagating errors backward through the layers.

• Gradient Descent⁴: An optimization algorithm that adjusts weights to minimize the

loss function, iteratively reducing prediction errors.

• Loss Function⁵: A mathematical function that quantifies how well a neural

network’s predictions match actual values. Example: Cross-Entropy Loss.

• Epoch⁶: A full cycle where the neural network has seen the entire training dataset
once. Multiple epochs help refine predictions.

•
fig 03: The final debugged python code excerpt used in this study.