Artificial Neural Networks: Models, Learning, and Applications

Core Concepts: Biological vs. Artificial Neurons

1. Biological Neurons → Artificial Neurons

Artificial neural networks (ANNs) mimic the structure and function of biological neurons. Here’s how their components map:

Labelled parts: dendrites, soma, axon, synapse. (Image: Geetika saini, CC BY-SA 4.0, via Wikimedia Commons)

---

2. Mathematical Model of an Artificial Neuron

The output $y$ of a single artificial neuron is computed as: $$y=f\left(\sum _{i=1}^n{w}_i{x}_i+b\right)$$ where:

• $x_i$: Input values,
• $w_i$: Weights (learned during training),
• $b$: Bias term,
• $f$: Activation function (e.g., sigmoid $f(z)=\frac{1}{1+e^{-z}}$).

Worked Example: Perceptron for AND Gate

Train a perceptron to implement the AND logic gate (output = 1 only if both inputs are 1). Inputs: $x_1,x_2$ (0 or 1) Desired outputs: $y=x_1\wedge x_2$

1. Initialize weights and bias randomly: $w_1=0.5,w_2=0.5,b=-0.7$ (guess).
2. Compute output for all inputs:
   • For $x_1=0,x_2=0$: $y=f(0.5\ast 0+0.5\ast 0-0.7)=f(-0.7)=0$ ✅ (correct).
   • For $x_1=0,x_2=1$: $y=f(0.5\ast 0+0.5\ast 1-0.7)=f(-0.2)=0$ ✅ (correct).
   • For $x_1=1,x_2=0$: $y=f(0.5\ast 1+0.5\ast 0-0.7)=f(-0.2)=0$ ✅ (correct).
   • For $x_1=1,x_2=1$: $y=f(0.5\ast 1+0.5\ast 1-0.7)=f(0.3)=1$ ✅ (correct).

Result: The perceptron already works! But in practice, we’d use the Perceptron Learning Algorithm to adjust weights if errors occur.

---

Learning in Neural Networks

1. Supervised vs. Unsupervised Learning

---

2. Hebbian Learning: The "Neurons that Fire Together, Wire Together" Rule

Rule: If two neurons are active simultaneously, strengthen their connection. Mathematical Update: $$\Delta w_{ij}=\eta x_i{y}_j$$ where:

• $\eta$: Learning rate (e.g., 0.1),
• $x_i$: Input neuron’s activity,
• $y_j$: Output neuron’s activity.

Worked Example: Hebbian Learning for XOR

Problem: XOR cannot be solved by a single perceptron (non-linearly separable). Use Hebbian learning to adjust weights for inputs $x_1,x_2$ and output $y$.

1. Initialize weights: $w_1=0.1,w_2=0.1,b=0$.
2. Train on XOR truth table:
   • Input (0,0), Output 0: $\Delta w_1=0.1\ast 0\ast 0=0$, $\Delta w_2=0.1\ast 0\ast 0=0$.
   • Input (0,1), Output 1: $\Delta w_1=0.1\ast 0\ast 1=0$, $\Delta w_2=0.1\ast 1\ast 1=0.1$ → $w_2=0.2$.
   • Input (1,0), Output 1: $\Delta w_1=0.1\ast 1\ast 1=0.1$ → $w_1=0.2$, $\Delta w_2=0.1\ast 0\ast 1=0$.
   • Input (1,1), Output 0: $\Delta w_1=0.1\ast 1\ast 0=0$, $\Delta w_2=0.1\ast 1\ast 0=0$.

Result: Weights converge to $w_1=0.2,w_2=0.2$, but XOR still isn’t solved! Limitation: Hebbian learning works only for linearly separable problems. For XOR, we need multi-layer networks (covered later).

---

3. Perceptron Learning Algorithm (PLA)

Goal: Adjust weights to minimize classification errors for linearly separable data. Steps:

1. Initialize weights $w_i$ and bias $b$ randomly.
2. For each training example $(x,y)$:
   • Compute output: $\hat{y}=f(\sum w_i{x}_i+b)$.
   • If $\hat{y}\ne y$ (error), update weights: $$w_i\leftarrow w_i+\eta (y-\hat{y})x_i$$ $$b\leftarrow b+\eta (y-\hat{y})$$
3. Repeat until all examples are classified correctly.

Worked Example: PLA for OR Gate

Inputs: $x_1,x_2$ (0 or 1) Desired outputs: $y=x_1\vee x_2$

1. Initialize: $w_1=0.3,w_2=0.3,b=-0.5,\eta =0.1$.
2. Epoch 1:
   • (0,0) → $\hat{y}=f(-0.5)=0$ ✅ (correct).
   • (0,1) → $\hat{y}=f(0.3\ast 0+0.3\ast 1-0.5)=f(-0.2)=0$ ❌ (error). Update: $w_2=0.3+0.1\ast (1-0)\ast 1=0.4$, $b=-0.5+0.1\ast (1-0)=-0.4$.
   • (1,0) → $\hat{y}=f(0.3\ast 1-0.4)=f(-0.1)=0$ ❌ (error). Update: $w_1=0.3+0.1\ast (1-0)\ast 1=0.4$, $b=-0.4+0.1\ast (1-0)=-0.3$.
   • (1,1) → $\hat{y}=f(0.4\ast 1+0.4\ast 1-0.3)=f(0.5)=1$ ✅ (correct).
3. Epoch 2: Repeat until all outputs match.

Result: Converges to $w_1=1,w_2=1,b=-1.5$ (OR gate implemented).

---

Multi-Layer Neural Networks

1. Architecture: Input → Hidden → Output Layers

Why hidden layers?

• Single-layer perceptrons can only solve linearly separable problems (e.g., AND, OR).
• Multi-layer networks can model non-linear relationships (e.g., XOR, MNIST digit recognition).

Example Architecture for XOR:

```figure
{"type":"network","nodes":["Input Layer","Hidden Layer (2 neurons)","Output Layer (1 neuron)"],"edges":[["Input Layer","Hidden Layer (2 neurons)",{"label":"x₁","weight":"w₁₁"}],["Input Layer","Hidden Layer (2 neurons)",{"label":"x₂","weight":"w₂₁"}],["Hidden Layer (2 neurons)","Output Layer (1 neuron)",{"label":"h₁","weight":"w₁₂"}],["Hidden Layer (2 neurons)","Output Layer (1 neuron)",{"label":"h₂","weight":"w₂₂"}]],"directed":true,"caption":"XOR architecture: 2 inputs → 2 hidden neurons (non-linear) → 1 output. Weights adjust during learning."}

Notation:

• (x_1, x_2): Inputs,
• (h_1, h_2): Hidden neurons (with weights (w_{h1}, w_{h2})),
• (y): Output neuron (with weights (w_{o1}, w_{o2})).

---

2. Backpropagation: The Workhorse of Deep Learning

Goal: Train multi-layer networks by propagating errors backward and adjusting weights. Steps:

1. Forward Pass: Compute outputs layer-by-layer.
2. Compute Loss: Compare output to true label (e.g., Mean Squared Error for regression, Cross-Entropy for classification).
3. Backward Pass: Adjust weights using the chain rule of calculus to minimize loss.

Worked Example: Backpropagation for XOR (1 Hidden Layer)

Network:

• Inputs: (x_1, x_2),
• Hidden layer: 2 neurons with sigmoid activation,
• Output: 1 neuron with sigmoid activation.

Training Data:

Step 1: Initialize weights randomly:

• Input → Hidden: (w_{11} = 0.5, w_{12} = 0.5, w_{21} = 0.5, w_{22} = 0.5),
• Hidden → Output: (w_{o1} = 0.5, w_{o2} = 0.5),
• Biases: (b_h = 0, b_o = 0).

Step 2: Forward Pass for (1,0):

• Hidden neuron 1: (h_1 = \sigma(0.51 + 0.50 + 0) = \sigma(0.5) = 0.622),
• Hidden neuron 2: (h_2 = \sigma(0.51 + 0.50 + 0) = 0.622),
• Output: (y = \sigma(0.50.622 + 0.50.622 + 0) = \sigma(0.622) = 0.655).

Desired output: 1. Error: (0.655 - 1 = -0.345).

Step 3: Backward Pass (Simplified):

1. Compute output error derivative: [ \frac{\partial L}{\partial y} = y - y_{\text{true}} = 0.655 - 1 = -0.345 ]
2. Compute hidden layer errors: [ \delta_o = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial z_o} = -0.345 \cdot y(1-y) = -0.345 * 0.655 * 0.345 = -0.079 ] [ \delta_{h1} = \delta_o \cdot w_{o1} \cdot h_1(1-h_1) = -0.079 * 0.5 * 0.622 * 0.378 = -0.007 ]
3. Update weights: [ w_{o1} \leftarrow w_{o1} - \eta \cdot \delta_o \cdot h_1 = 0.5 - 0.1 * (-0.079) * 0.622 = 0.505 ] (Repeat for all weights.)

Result: After many epochs, the network learns XOR!

---

Activation Functions: The "Non-Linearity" Key

Activation functions introduce non-linearity, enabling networks to learn complex patterns. Common Functions:

Why ReLU?

• Avoids vanishing gradients (sigmoid/tanh saturate and kill learning).
• Computationally efficient ((f(z) = z) if (z > 0)).

---

In the Real World

1. Khalti’s Fraud Detection (Supervised Learning)

• Problem: Detect fake transactions (e.g., stolen cards, duplicate payments).
• ANN Used: Feedforward neural network trained on:
  • Inputs: Transaction amount, time, location, device ID, user history.
  • Output: "Fraud" (1) or "Legit" (0).
• How It Works:
  • The ANN is trained on labelled data (past fraud cases).
  • During prediction, it computes a probability score. If (P(\text{Fraud}) > 0.95), the transaction is blocked.
• Real Example:
  • A user in Kathmandu tries to pay ₹50,000 via Khalti at 3 AM (unusual time).
  • Inputs: [amount=50000, time=3:00, location=KTM, device=unknown].
  • ANN outputs (P(\text{Fraud}) = 0.98) → Blocked.

2. Daraz’s Recommendation System (Collaborative Filtering + ANN)

• Problem: Suggest products to users based on their past behavior.
• ANN Used: Two-tower model (user tower + item tower) with embeddings and dot-product similarity.
• How It Works:
  1. Embeddings: Convert user IDs and product IDs into dense vectors (e.g., user (u) → vector (v_u), product (p) → vector (v_p)).
  2. Similarity: Compute ( \text{score}(u,p) = v_u \cdot v_p ) (dot product).
  3. Ranking: ANN ranks products by score and recommends top 10.
• Real Example:
  • A user buys a DSLR camera and tripod.
  • Daraz’s ANN embeddings learn that these items are often bought together.
  • Next time, it recommends a memory card (high co-purchase probability).

3. Ncell’s Dynamic Pricing (Reinforcement Learning)

• Problem: Adjust call/data prices in real-time to maximize revenue.
• ANN Used: Deep Q-Network (DQN) to learn optimal pricing strategies.
• How It Works:
  • State: Time of day, network congestion, user location, historical demand.
  • Action: Increase/decrease price by 5%.
  • Reward: Revenue generated minus user churn risk.
  • Learning: The DQN explores (random actions) and exploits (best-known actions) to maximize long-term reward.
• Real Example:
  • At 6 PM (peak usage), Ncell’s DQN detects high congestion in Lalitpur.
  • Action: Increase data price by 10%.
  • Result: Revenue ↑ 15%, but some users switch to NTC → net reward = +8%.

---

Types of Artificial Neural Networks

---

Exam Tip: How to Score Full Marks

1. For definitions:

   • Always include the mathematical formula (e.g., perceptron output equation).
   • Example: "An artificial neuron’s output is (y = f(\sum w_i x_i + b)), where (f) is the activation function."

2. For algorithms (PLA, backpropagation):

   • Write pseudo-code or step-by-step updates.
   • Example for PLA:

     while error_exists:
         for (x, y_true) in dataset:
             y_pred = f(sum(w_i * x_i) + b)
             if y_pred != y_true:
                 for i in range(n):
                     w_i += η * (y_true - y_pred) * x_i
                 b += η * (y_true - y_pred)
     

3. For comparisons (supervised vs. unsupervised):

   • Use a table with Nepalese examples.
   • Example:

     Aspect	Supervised	Unsupervised
     Data	Labelled (e.g., Khalti’s fraud data).	Unlabelled (e.g., Daraz’s user logs).
     Goal	Predict output (classification/regression).	Find hidden patterns (clustering).
     ANN Model	Feedforward NN, CNN.	SOM, K-means (not pure ANN).

4. For worked examples:

   • Show all steps (even if trivial).
   • Link to real-world (e.g., "This is how Khalti detects fraud").
   • Example for XOR:

     "A single perceptron cannot solve XOR because its decision boundary is a straight line, but XOR requires a non-linear boundary (e.g., a circle). Thus, we need a hidden layer to create non-linear combinations of inputs."

5. For diagrams:

   • Draw the network architecture (input → hidden → output layers).
   • Label weights, biases, and activation functions.
   • Example:

```figure
{"type":"network","nodes":["Input: x₁, x₂","Hidden: h₁ (sigmoid)","Output: y (sigmoid)"],"edges":[["Input: x₁, x₂","Hidden: h₁ (sigmoid)",{"label":"w₁","weight":"w₁"}],["Input: x₁, x₂","Hidden: h₁ (sigmoid)",{"label":"w₂","weight":"w₂"}],["Hidden: h₁ (sigmoid)","Output: y (sigmoid)",{"label":"w₃","weight":"w₃"}]],"directed":true,"caption":"Fully labelled perceptron: weights (w₁, w₂, w₃), biases (b₁, b₂), and activation functions."}

6. Common pitfalls to avoid:
   • Confusing Hebbian learning with backpropagation: Hebbian is unsupervised; backpropagation is supervised.
   • Forgetting biases: Always include $b$ in weight updates.
   • Assuming all problems are linearly separable: Explicitly state when a multi-layer network is needed (e.g., XOR).

---

Practice Questions (Exam-Style)

1. Define the mathematical model of an artificial neuron. How does the sigmoid activation function differ from ReLU? Draw their graphs.
2. Explain the Perceptron Learning Algorithm with a trace for the XNOR gate (output = 1 only if inputs are same).
3. Compare supervised and unsupervised learning using Khalti’s fraud detection and Daraz’s recommendation system as examples.
4. Describe how backpropagation works in a 2-layer ANN. Why is the chain rule necessary?
5. Give a real-world example of reinforcement learning in Nepal. How would you design the state, action, and reward for this system?

---