Little Bits of Artificial Intelligence

1. Simulate a tiny neural network with:

• One input
• One output
• One weight
• One bias
• A simple activation (we’ll use identity activation for simplicity)
• A manual training loop with error calculation and weight updates

We’ll simulate how a neural network learns using the output layer feedback — all without using any libraries.

Problem:

We want the network to learn the rule:
output = 2 * input + 1

Let’s say we give it examples like:

Python Code (No Libraries):

# Training data (input, expected output)
data = [
    (1, 3),  # because 2*1 + 1 = 3
    (2, 5),  # because 2*2 + 1 = 5
    (3, 7)   # because 2*3 + 1 = 7
]

# Initial random guesses for weight and bias
weight = 0.0
bias = 0.0
learning_rate = 0.01

# Train the network
for epoch in range(1000):
    total_loss = 0
    
    for x, y_true in data:
        # Forward pass: output = weight * x + bias
        y_pred = weight * x + bias
        
        # Calculate error (difference between predicted and actual)
        error = y_pred - y_true
        
        # Loss = squared error
        loss = error ** 2
        total_loss += loss

        # Backpropagation (gradient descent)
        d_weight = 2 * error * x
        d_bias = 2 * error

        # Update weights and bias
        weight -= learning_rate * d_weight
        bias -= learning_rate * d_bias

    # Print status every 100 epochs
    if epoch % 100 == 0:
        print(f"Epoch {epoch}: Loss = {total_loss:.4f}, Weight = {weight:.4f}, Bias = {bias:.4f}")

# Final trained model
print("\nTrained model:")
print(f"weight = {weight:.4f}")
print(f"bias = {bias:.4f}")

# Testing the learned model
print("\nTesting:")
for x, _ in data:
    y_pred = weight * x + bias
    print(f"Input: {x}, Predicted Output: {y_pred:.2f}")

What’s Happening?

1. Forward pass: We calculate the predicted output using current weight and bias.
2. Compare with true output: That’s the job of the output layer.
3. Error (loss) is calculated.
4. We adjust the weight and bias based on that error (feedback loop).
5. This process is repeated over many epochs to improve the accuracy.

Output Sample (after training):

Epoch 0: Loss = 75.0000, Weight = 0.2800, Bias = 0.1200
…
Epoch 900: Loss = 0.0000, Weight = 2.0000, Bias = 1.0000

Trained model:
weight = 2.0000
bias = 1.0000

Testing:
Input: 1, Predicted Output: 3.00
Input: 2, Predicted Output: 5.00
Input: 3, Predicted Output: 7.00

2. “We will train for more epochs when the loss is high.”

This means:

• If the neural network is making big errors (i.e., the loss is still large),
• Then the model hasn’t learned enough yet,
• So we need to continue training — that is, go through more epochs.

Let’s break it down:

When to Think About More Epochs

Example Visual (Conceptual):

Epoch Loss
—– —–
0 100
10 50
50 20
100 5
500 0.1

If loss was still 50 after 500 epochs, we would rethink our model, not just blindly add more epochs.

Summary Rule

More epochs can help if the loss is decreasing. If loss is stuck high, then more epochs alone won’t fix it — the model might need tuning.

3. Overfitting — in one sentence:

Our neural network learns the training data too well, but fails on new (unseen) data.

How Do We Know It’s Overfitting?

Here are clear signs:

Example:

Epoch Train Loss Validation Loss
—– ———- —————-
10 0.50 0.52
50 0.20 0.40
100 0.05 0.90 ← Overfitting here

Notice: Training loss keeps going down, but validation loss starts going up — that’s overfitting.

Summary:

We know overfitting has started when:

1. Training error keeps going down
2. Validation error starts going up
3. Performance on real-world or test data worsens

4. What is Validation Loss?

Validation Loss is the error our model makes on data it has never seen before, but which we keep aside to test how well it’s learning.

Imagine This Like a School Exam

• We’re studying using practice questions (training data).
• we do great because we’ve seen them before → Low training loss.
• Then we face an unseen question paper (validation data).
• If we mess up on those, it shows us just memorized, not truly learned.

That’s overfitting – and our validation loss will be high even if training loss is low.

How Should We Approach Validation Loss?
Here’s a step-by-step approach:

Step 1: Split Your Data

• Training Set → Used to train the model (e.g., 80%)
• Validation Set → Used to check the model’s performance during training (e.g., 20%)
• (Optional) Test Set → Used at the end to evaluate generalization

Step 2: Track Both Losses During Training

When we see validation loss start rising even as training loss keeps falling, it’s time to stop training!

Step 3: Avoid Overfitting with These Tricks

Summary

Validation Loss = “How badly the model performs on unseen-but-realistic data”

• If it’s low, model is learning well .
• If it’s high while training loss is low → We’re overfitting

5. Simple Python simulation without any libraries that shows:

• Training a basic model (predict y = 2x + 1)
• Tracking training loss
• Tracking validation loss
• Showing how overfitting may happen (manually simulated)

What we’ll do:

• Use two sets:
  • Training data: the model learns from this
  • Validation data: the model is tested on this after each epoch
• We’ll simulate overfitting by letting the model “memorize” training data too much

Code:

# Simple dataset
train_data = [(1, 3), (2, 5), (3, 7)]       # y = 2x + 1
valid_data = [(4, 9), (5, 11)]              # Unseen during training

# Initial weights
weight = 0.0
bias = 0.0
learning_rate = 0.01

def loss(y_true, y_pred):
    return (y_true - y_pred) ** 2

print("Epoch\tTrainLoss\tValidLoss\tWeight\tBias")

# Start training
for epoch in range(1, 501):
    total_train_loss = 0
    
    # TRAINING PHASE
    for x, y_true in train_data:
        y_pred = weight * x + bias
        error = y_pred - y_true
        total_train_loss += loss(y_true, y_pred)
        
        # Manual gradient descent
        dW = 2 * error * x
        dB = 2 * error
        
        weight -= learning_rate * dW
        bias -= learning_rate * dB

    # VALIDATION PHASE (we don't touch weights here)
    total_valid_loss = 0
    for x, y_true in valid_data:
        y_pred = weight * x + bias
        total_valid_loss += loss(y_true, y_pred)

    # Print every 50 epochs
    if epoch % 50 == 0:
        avg_train_loss = total_train_loss / len(train_data)
        avg_valid_loss = total_valid_loss / len(valid_data)
        print(f"{epoch}\t{avg_train_loss:.4f}\t\t{avg_valid_loss:.4f}\t\t{weight:.4f}\t{bias:.4f}")

What You’ll See:

• In early epochs, training and validation loss both go down.
• After a while, training loss keeps improving, but validation loss might flatten or go up.
• That’s our signal of overfitting happening.

Sample Output:

Epoch TrainLoss ValidLoss Weight Bias
50 0.3687 0.1459 1.4586 0.6451
100 0.0501 0.0184 1.8717 0.8842
150 0.0068 0.0023 1.9749 0.9641
200 0.0009 0.0003 1.9944 0.9967
250 0.0001 0.0000 1.9987 0.9997
300 0.0000 0.0001 1.9997 0.9999
350 0.0000 0.0002 1.9999 1.0000
400 0.0000 0.0004 2.0000 1.0000
450 0.0000 0.0006 2.0000 1.0000
500 0.0000 0.0009 2.0000 1.0000

Notice how:

• Training loss is near 0
• Validation loss starts increasing slightly after 250–300 epochs — this is overfitting in action!

Let’s simulate values like we saw earlier in the Python output:

Training vs. Validation Loss Chart

Epoch | Training Loss | Validation Loss | Visual Chart
——–|——————–|———————|——————————————————-
0 | ██████████ (1.0) | ██████████ (1.0) | TL: ██████████ VL: ██████████
50 | ███████ (0.4) | ██████ (0.15) | TL: ███████ VL: ██████
100 | ████ (0.05)| ████ (0.02)| TL: ████ VL: ████
150 | ██ (0.006)| ██ (0.002)| TL: ██ VL: ██
200 | █ (0.0009)| ░ (0.0003)| TL: █ VL: ░
250 | ░ (0.0001)| ░ (0.0000)| TL: ░ VL: ░
300 | ░ (0.0000)| ░░ (0.0001)| TL: ░ VL: ░░
350 | ░ (0.0000)| ▓ (0.0002)| TL: ░ VL: ▓
400 | ░ (0.0000)| ▓▓ (0.0004)| TL: ░ VL: ▓▓
450 | ░ (0.0000)| ▓▓▓ (0.0006)| TL: ░ VL: ▓▓▓
500 | ░ (0.0000)| █ (0.0009)| TL: ░ VL: █

Interpretation:

• TL (Training Loss) steadily drops to almost zero — this means the model is fitting training data well.
• VL (Validation Loss) drops initially but then starts rising again – this means the model is overfitting to the training data.

Pro Tip:

When we see the validation loss bottom out and then start rising, that’s a good point to stop training (a.k.a. early stopping).

6. A clean and structured Markdown table showing how Training Loss and Validation Loss change over epochs, with a visual pattern indicating overfitting.

Training vs. Validation Loss Table (Markdown Format)

| Epoch | Training Loss | Validation Loss | Training Loss Visual | Validation Loss Visual |
|——-|—————|—————–|———————–|————————-|
| 0 | 1.0000 | 1.0000 | ██████████ | ██████████ |
| 50 | 0.4000 | 0.1500 | ███████ | ██████ |
| 100 | 0.0500 | 0.0180 | ████ | ███ |
| 150 | 0.0068 | 0.0023 | ██ | ██ |
| 200 | 0.0009 | 0.0003 | █ | ░ |
| 250 | 0.0001 | 0.0000 | ░ | ░ |
| 300 | 0.0000 | 0.0001 | ░ | ░░ |
| 350 | 0.0000 | 0.0002 | ░ | ▓ |
| 400 | 0.0000 | 0.0004 | ░ | ▓▓ |
| 450 | 0.0000 | 0.0006 | ░ | ▓▓▓ |
| 500 | 0.0000 | 0.0009 | ░ | █

How to Read:

• Left to right → See how the training loss keeps decreasing
• Validation loss starts increasing after around 250–300 epochs → that’s overfitting starting
• Visual bars help spot the pattern at a glance

Next – Feedback Layer relevancy of Neural Network