4. Neural network development

🧠 NEURAL NETWORK ARCHITECTURE & IMPLEMENTATION

📊 Architecture Overview

The (841, 9) shape means we have 841 different 3×3 perception examples, each flattened into 9 features, and the neural network processes them one at a time through 9 input neurons! 🎯

Complete Architecture

Input Layer: 9 neurons (3×3 flattened perception)
Hidden Layer 1: 64 neurons + ReLU + Dropout(0.2)
Hidden Layer 2: 32 neurons + ReLU + Dropout(0.2)
Output Layer: 4 neurons + Softmax

Data Flow Visualization

Sample 0: [0,1,0,0,0,1,0,1,0] ← 3×3 perception grid

↓

┌─────────────────┐

│ Input Layer │ ← 9 neurons (one per grid cell)

│ N1: 0.0 │

│ N2: 1.0 │

│ N3: 0.0 │

│ N4: 0.0 │

│ N5: 0.0 │

│ N6: 1.0 │

│ N7: 0.0 │

│ N8: 1.0 │

│ N9: 0.0 │

└─────────────────┘

↓

┌─────────────────┐

│ Hidden Layer 1 │ ← 64 neurons + ReLU + Dropout

│ (64 neurons) │

└─────────────────┘

↓

┌─────────────────┐

│ Hidden Layer 2 │ ← 32 neurons + ReLU + Dropout

│ (32 neurons) │

└─────────────────┘

↓

┌─────────────────┐

│ Output Layer │ ← 4 neurons + Softmax

│ UP: 0.1 │ ← Probability of UP action

│ DOWN: 0.7 │ ← Probability of DOWN action

│ LEFT: 0.1 │ ← Probability of LEFT action

│ RIGHT: 0.1 │ ← Probability of RIGHT action

└─────────────────┘

Prediction: DOWN (highest probability)

🔬 Design Choices Explained

1. Why use only two Hidden Layers and select 64 and 32 neurons for it?

The “Funnel” Design Philosophy:

Our architecture follows a 9 → 64 → 32 → 4 pattern, which is carefully designed based on several principles:

🧠 Why 2 Hidden Layers?

• 1 Layer: Too simple, can only learn linear decision boundaries

• 2 Layers: Sweet spot - can learn complex non-linear patterns without overfitting

• 3+ Layers: Overkill for 9 inputs, high risk of overfitting with limited data

📊 Why 64 → 32 Neurons (Decreasing Pattern)?

The “Funnel” Effect:

• Input (9): Raw 3×3 perception data

• Hidden1 (64): 7× expansion for pattern extraction and feature detection

• Hidden2 (32): 3.5× compression for decision making and pattern combination

• Output (4): Final action selection

Mathematical Reasoning:

Total Parameters = (9×64) + 64 + (64×32) + 32 + (32×4) + 4 = 6,660 parameters

Training Samples = ~841 samples

Parameters/Sample Ratio = 7.9 (optimal: <10)

🔬 Biological Inspiration:

Visual Cortex → Motor Cortex Hierarchy:

• Layer 1 (64 neurons): Like visual cortex - extracts complex patterns from raw perception

• Layer 2 (32 neurons): Like association cortex - combines patterns into decisions

• Output (4 neurons): Like motor cortex - executes final action choice

⚖️ Alternative Architectures Comparison:

| Architecture | Hidden Layers | Parameters | P/S Ratio | Status |

|-------------|---------------|------------|-----------|---------|

| Too Small | 16 → 8 | 1,748 | 2.1 | ✅ Safe |

| Current | 64 → 32 | 6,660 | 7.9 | ✅ Optimal |

| Too Large | 128 → 64 | 25,476 | 30.3 | ⚠️ Risky |

| Overkill | 256 → 128 | 99,012 | 117.8 | ❌ Overfit |

🎯 Why This Design Works:

1. Pattern Extraction: 64 neurons can detect various obstacle patterns in 3×3 grids

2. Decision Making: 32 neurons combine these patterns into navigation decisions

3. Efficiency: Fast training and inference for real-time robot control

4. Generalization: Balanced complexity prevents overfitting

5. Scalability: Can easily adjust size based on data availability

1. Why ReLU Activation? (Not Sigmoid)

ReLU Advantages:

• Gradient Flow: ReLU gradient = 1 for x > 0, prevents vanishing gradients

• Biological Inspiration: Mimics spiking neurons (active/silent states)

• Computational Efficiency: Simple max(0, x) operation

• Sparse Activation: Creates sparse representations (many zeros)

Sigmoid Problems:

• Vanishing Gradients: Gradient → 0 for extreme values

• Computational Cost: Expensive exponential operations

• No Sparsity: Always positive, no biological realism

2. Why Softmax + Cross-Entropy? (Not Separate)

The Truth: You’re using BOTH! Here’s how:

 
# Forward pass produces logits
 
logits = [2.1, 4.3, 1.8, 0.9] # Raw scores
 
  
 
# Softmax converts to probabilities
 
probabilities = softmax(logits) # [0.1, 0.7, 0.1, 0.1]
 
  
 
# Cross-entropy measures prediction error
 
loss = -log(probabilities[true_action]) # Cross-entropy loss
 

Why This Combination:

• Softmax: Ensures probabilities sum to 1.0 (competition)

• Cross-entropy: Measures prediction accuracy

• Biological: Mimics neural competition and prediction error

3. Why Dropout(0.2)?

Dropout Benefits:

• Prevents Overfitting: With only 841 samples, network might memorize

• Biological Inspiration: Simulates neural noise and robustness

• Regularization: Forces network to be robust to missing information

Rate Choice (0.2):

• 0.0: No regularization (overfitting risk)

• 0.2: Light regularization (perfect for your data size)

• 0.5: Heavy regularization (might hurt learning)

4. Why 3-Way Data Split? (Not 2-Way)

Recommended Split:

Train: 80% (673 samples) ← Learning parameters

Validation: 10% (84 samples) ← Hyperparameter tuning

Test: 10% (84 samples) ← Final unbiased evaluation

Why 3-Way is Better:

• Prevents Data Leakage: Test set never used for decisions

• Hyperparameter Tuning: Use validation set for model selection

• Early Stopping: Monitor validation loss to prevent overfitting

• Unbiased Evaluation: Test set gives true performance estimate

🏗️ Code Structure

Modular Implementation

core/

├── neural_network.py ← Complete NN implementation

├── data_generation.py ← Data loading utilities

└── __init__.py

  

scripts/

├── train_nn.py ← Training pipeline

└── generate_data.py ← Data generation

  

tests/

├── test_neural_network.py ← Comprehensive test suite

└── test_data_generation.py

  

configs/

└── nn_config.yaml ← All hyperparameters

Key Features

• Biological Documentation: Every function explains neuroscience connection

• Mathematical Foundation: Clear equations and reasoning

• Modular Design: Easy to extend and modify

• Comprehensive Testing: Full test suite with biological validation

• Configuration Management: All hyperparameters in YAML

🚀 Usage Examples

Basic Training

 
from core.neural_network import RobotNavigationNN, create_data_splits
 
  
 
# Load data
 
X, y = load_training_data("data/raw/small_training_dataset.npz")
 
  
 
# Split data
 
X_train, X_val, X_test, y_train, y_val, y_test = create_data_splits(X, y)
 
  
 
# Create model
 
model = RobotNavigationNN(
 
input_size=9,
 
hidden1_size=64,
 
hidden2_size=32,
 
output_size=4,
 
dropout_rate=0.2,
 
learning_rate=0.001
 
)
 
  
 
# Train model
 
history = model.train(X_train, y_train, X_val, y_val, epochs=100)
 
  
 
# Evaluate
 
test_loss, test_accuracy = model.evaluate(X_test, y_test)
 
print(f"Test Accuracy: {test_accuracy:.4f}")
 

Hyperparameter Tuning

 
# Test different learning rates
 
for lr in [0.001, 0.01, 0.1]:
 
model = RobotNavigationNN(learning_rate=lr)
 
model.train(X_train, y_train, X_val, y_val, epochs=20)
 
val_loss, val_acc = model.evaluate(X_val, y_val)
 
print(f"LR={lr}: Val Acc={val_acc:.4f}")
 

Architecture Comparison

 
# Compare different architectures
 
architectures = [
 
{"name": "Small", "hidden1": 32, "hidden2": 16},
 
{"name": "Medium", "hidden1": 64, "hidden2": 32},
 
{"name": "Large", "hidden1": 128, "hidden2": 64}
 
]
 
  
 
for arch in architectures:
 
model = RobotNavigationNN(
 
hidden1_size=arch["hidden1"],
 
hidden2_size=arch["hidden2"]
 
)
 
# Train and evaluate...
 

🧬 Biological Connections

Neuroscience Principles

• Local Perception: 3×3 grid mimics animal peripheral vision

• Sparse Coding: ReLU creates sparse representations like brain

• Neural Competition: Softmax mimics winner-take-all competition

• Robustness: Dropout simulates neural noise and failures

• Learning: Backpropagation mimics synaptic plasticity

Mathematical Foundation

• ReLU: f(x) = max(0, x) - Simple, biologically plausible

• Softmax: p_i = exp(z_i) / Σ exp(z_j) - Probability normalization

• Cross-entropy: L = -Σ y_i log(p_i) - Classification loss

• Dropout: x’ = x * mask / (1-p) - Regularization technique

📈 Training Strategy

Optimized Hyperparameters

 
# From configs/nn_config.yaml
 
model:
 
input_size: 9
 
hidden1_size: 64
 
hidden2_size: 32
 
output_size: 4
 
dropout_rate: 0.2
 
  
 
training:
 
learning_rate: 0.001
 
batch_size: 32
 
epochs: 100
 
early_stopping:
 
patience: 15
 
monitor: "val_loss"
 
  
 
data:
 
train_ratio: 0.8
 
val_ratio: 0.1
 
test_ratio: 0.1
 

Training Pipeline

1. Load Data: Load 841 samples from generated dataset

2. Split Data: 80% train, 10% validation, 10% test

3. Initialize Model: Xavier initialization for stable gradients

4. Train: Mini-batch gradient descent with early stopping

5. Evaluate: Test on unseen data for unbiased performance

6. Save: Store trained model and training history

🎯 Expected Performance

Training Metrics

• Training Accuracy: 85-95% (should learn training patterns)

• Validation Accuracy: 80-90% (generalization ability)

• Test Accuracy: 80-90% (true performance estimate)

• Training Time: 1-5 minutes (depending on hardware)

Biological Validation

• Sparse Activation: Many neurons should be silent (ReLU zeros)

• Competition: One action should dominate (softmax competition)

• Robustness: Model should work despite dropout (neural noise)

• Learning: Performance should improve over epochs (synaptic plasticity)

🔧 Next Steps

Immediate Actions

1. Run Training: python scripts/train_nn.py

2. Analyze Results: Check training history plots

3. Test Performance: Evaluate on test set

4. Save Model: Store trained weights for deployment

Future Enhancements

• Hyperparameter Tuning: Automated grid search

• Architecture Search: Test different layer sizes

• Data Augmentation: Generate more training samples

• Visualization: Create interactive training plots

• Deployment: Integrate with robot control system

---

🎉 Your neural network is ready for training! The architecture is biologically inspired, mathematically sound, and optimized for your robot navigation task.