Backpropagation and Training ,Forward Pass and Loss Calculation

(рдмреИрдХрдкреНрд░реЛрдкреЗрдЧреЗрд╢рди рдФрд░ рдкреНрд░рд╢рд┐рдХреНрд╖рдг рдкреНрд░рдХреНрд░рд┐рдпрд╛)


ЁЯФ╖ 1. Introduction (рдкрд░рд┐рдЪрдп)

Backpropagation = тАЬBackwards propagation of errorsтАЭ
рдпрд╣ рдПрдХ algorithm рд╣реИ рдЬреЛ Neural Network рдХреЗ weights рдХреЛ loss function рдХреЗ рдЖрдзрд╛рд░ рдкрд░ update рдХрд░рддрд╛ рд╣реИред


ЁЯФБ 2. Training рдХрд╛ рдкреВрд░рд╛ Flow

  1. Forward Pass:
    Input тЖТ Hidden тЖТ Output
    (Prediction generate рд╣реЛрддрд╛ рд╣реИ)
  2. Loss Calculation:
    Prediction рдФрд░ Ground Truth рдХреЗ рдмреАрдЪ Loss рдорд╛рдкрд╛ рдЬрд╛рддрд╛ рд╣реИ
  3. Backward Pass (Backpropagation):
    Loss рдХрд╛ Gradient calculate рд╣реЛрддрд╛ рд╣реИ рд╣рд░ weight рдХреЗ рд▓рд┐рдП
  4. Weight Update (Optimizer):
    Gradient Descent рджреНрд╡рд╛рд░рд╛ Weights рдХреЛ update рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ
  5. Repeat for Epochs:
    рдЬрдм рддрдХ model рд╕рдЯреАрдХ prediction рди рдХрд░рдиреЗ рд▓рдЧреЗ

ЁЯФз 3. Backpropagation: рдХреИрд╕реЗ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ?

Backpropagation рдПрдХ mathematical tool рд╣реИ рдЬреЛ Chain Rule of Calculus рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░рддрд╛ рд╣реИ:

рдЬрд╣рд╛рдБ:

  • L: Loss
  • y: Prediction
  • z: Neuron input
  • w: Weight

ЁЯза Visual Diagram (Flowchart):

Input тЖТ Hidden тЖТ Output тЖТ Loss
тЖС
Backpropagate Gradient
тЖУ
Update Weights (via Optimizer)

ЁЯТ╗ PyTorch рдореЗрдВ Training Code (Simple)

import torch
import torch.nn as nn
import torch.optim as optim

# Simple Model
model = nn.Linear(1, 1)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# Training Data
x = torch.tensor([[1.0], [2.0]])
y = torch.tensor([[2.0], [4.0]])

# Training Loop
for epoch in range(10):
outputs = model(x) # Forward
loss = criterion(outputs, y) # Compute Loss

optimizer.zero_grad() # Clear gradients
loss.backward() # Backpropagation
optimizer.step() # Update weights

print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

ЁЯФН Important Terms Recap

TermExplanation
Forward PassPrediction рдмрдирд╛рдирд╛
LossрдЧрд▓рддреА рдорд╛рдкрдирд╛
Backward PassGradient рдирд┐рдХрд╛рд▓рдирд╛
OptimizerWeight update рдХрд░рдирд╛
EpochDataset рдкрд░ рдПрдХ complete pass

ЁЯОп Learning Objectives Summary

  • Backpropagation рд╕реАрдЦрдиреЗ рдХрд╛ рдЖрдзрд╛рд░ рд╣реИ
  • рдпрд╣ Loss function рдХреЗ gradient рдХреЗ рдЖрдзрд╛рд░ рдкрд░ weights рдХреЛ рд╕реБрдзрд╛рд░рддрд╛ рд╣реИ
  • Optimizer gradient рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ model рдХреЛ рдмреЗрд╣рддрд░ рдмрдирд╛рддрд╛ рд╣реИ
  • рдкреВрд░рд╛ training loop PyTorch рдореЗрдВ automate рд╣реЛрддрд╛ рд╣реИ

ЁЯУЭ рдЕрднреНрдпрд╛рд╕ рдкреНрд░рд╢реНрди (Practice Questions)

  1. Backpropagation рдХрд┐рд╕ rule рдкрд░ рдЖрдзрд╛рд░рд┐рдд рд╣реИ?
  2. Forward Pass рдФрд░ Backward Pass рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  3. Loss.backward() рдХреНрдпрд╛ рдХрд░рддрд╛ рд╣реИ?
  4. Optimizer.zero_grad() рдХреНрдпреЛрдВ рдЬрд╝рд░реВрд░реА рд╣реИ?
  5. рдПрдХ training loop рдХреЗ рдЪрд╛рд░ рдореБрдЦреНрдп steps рдХреНрдпрд╛ рд╣реЛрддреЗ рд╣реИрдВ?

Forward Pass and Loss Calculation

(рдлрд╝реЙрд░рд╡рд░реНрдб рдкрд╛рд╕ рдФрд░ рд▓реЙрд╕ рдХреА рдЧрдгрдирд╛)

ЁЯФ╢ 1. Forward Pass (рдЗрдирдкреБрдЯ рд╕реЗ рдЖрдЙрдкрдЯ рддрдХ рдХреА рдпрд╛рддреНрд░рд╛)

Forward Pass рд╡рд╣ рдЪрд░рдг рд╣реИ рдЬрд┐рд╕рдореЗрдВ neural network рдХрд┐рд╕реА рдЗрдирдкреБрдЯ рдХреЛ рд▓реЗрдХрд░ рдЙрд╕реЗ рд╡рд┐рднрд┐рдиреНрди layers рдХреЗ рдорд╛рдзреНрдпрдо рд╕реЗ рдкреНрд░рд╡рд╛рд╣рд┐рдд рдХрд░рддрд╛ рд╣реИ рддрд╛рдХрд┐ рдЕрдВрддрд┐рдо output (prediction) рдЙрддреНрдкрдиреНрди рд╣реЛред

ЁЯФБ Step-by-Step Process:

  1. Input Vector (x) network рдореЗрдВ рднреЗрдЬрд╛ рдЬрд╛рддрд╛ рд╣реИ
  2. Each Layer:
    • Performs a linear transformation

Applies an activation function

  1. Final output layer рджреЗрддрд╛ рд╣реИ prediction y^

ЁЯза Neural Network Flow:

scssCopyEditInput тЖТ Hidden Layer 1 тЖТ Hidden Layer 2 тЖТ ... тЖТ Output Layer тЖТ Prediction
  • Linear + Activation sequence рд╣рд░ layer рдкрд░ рд▓рд╛рдЧреВ рд╣реЛрддрд╛ рд╣реИ
  • Output layer рдХреА activation function task рдкрд░ рдирд┐рд░реНрднрд░ рдХрд░рддреА рд╣реИ (рдЬреИрд╕реЗ classification рдХреЗ рд▓рд┐рдП softmax рдпрд╛ sigmoid)

ЁЯУМ Forward Pass рдХрд╛ рдЙрджреНрджреЗрд╢реНрдп:

  • Input features рдХреЛ progressively abstract рдХрд░рдирд╛
  • Neural network рдХреЗ current weights рд╕реЗ output generate рдХрд░рдирд╛
  • рдЗрд╕ output рдХреЛ рдЕрд╕рд▓реА label рд╕реЗ compare рдХрд░ рдкрд╛рдиреЗ рд▓рд╛рдпрдХ рдмрдирд╛рдирд╛

ЁЯФ╖ 2. Loss Calculation (Prediction рдХреА рдЧрд╝рд▓рддреА рдорд╛рдкрдирд╛)

Once prediction (y^тАЛ) is ready, it is compared to the true label (y) using a Loss Function.
Loss function рд╣рдореЗрдВ рдмрддрд╛рддрд╛ рд╣реИ prediction рдХрд┐рддрдирд╛ рд╕рд╣реА рдпрд╛ рдЧрд▓рдд рд╣реИред


ЁЯФв Common Loss Functions:


ЁЯФБ Loss Calculation рдХрд╛ Flow:

  1. Prediction (y^тАЛ) compute рдХрд░реЛ
  2. Ground truth label yрд╕реЗ compare рдХрд░реЛ
  3. Error calculate рдХрд░реЛ using loss function
  4. рдпрд╣реА error backpropagation рдореЗрдВ propagate рдХрд┐рдпрд╛ рдЬрд╛рдПрдЧрд╛

ЁЯТ╗ PyTorch Example: Loss and Prediction

import torch
import torch.nn as nn

# Input and True label
x = torch.tensor([[1.0, 2.0]])
y_true = torch.tensor([[0.0]])

# Define simple model
model = nn.Sequential(
nn.Linear(2, 3),
nn.ReLU(),
nn.Linear(3, 1),
nn.Sigmoid()
)

# Loss function
criterion = nn.BCELoss()

# Forward Pass
y_pred = model(x)

# Loss Calculation
loss = criterion(y_pred, y_true)

print("Prediction:", y_pred.item())
print("Loss:", loss.item())

ЁЯФБ Complete Diagram Flow:

Input тЖТ Hidden тЖТ Output тЖТ Loss
тЖС
Backpropagate Gradient
тЖУ
Update Weights (via Optimizer)

тЬЕ рдпрд╣ рджрд░реНрд╢рд╛рддрд╛ рд╣реИ рдХрд┐ forward pass prediction рдХрд░рддрд╛ рд╣реИ, рдФрд░ loss function рдЙрд╕ prediction рдХреА рдЧреБрдгрд╡рддреНрддрд╛ рдХреЛ рдорд╛рдкрддрд╛ рд╣реИред


ЁЯУМ Summary Table

StepDescription
Forward PassInput рдХреЛ through layers рднреЗрдЬрдирд╛
OutputPrediction generate рдХрд░рдирд╛
Loss CalculationPrediction рдФрд░ label рдХреЗ рдмреАрдЪ рдХрд╛ рдЕрдВрддрд░ рдорд╛рдкрдирд╛
Next StepLoss рдХреЛ use рдХрд░рдХреЗ gradient calculate рдХрд░рдирд╛

ЁЯОп Objectives Recap:

  • Forward Pass transforms input тЖТ prediction
  • Loss function tells how wrong the prediction is
  • Loss is key for guiding weight updates

ЁЯУЭ Practice Questions:

  1. Forward Pass рдореЗрдВ рдХреМрди-рдХреМрди рд╕реА operations рд╣реЛрддреА рд╣реИрдВ?
  2. z=Wx+b рдХрд╛ рдХреНрдпрд╛ рдЕрд░реНрде рд╣реИ?
  3. Binary Classification рдХреЗ рд▓рд┐рдП рдХреМрди-рд╕рд╛ loss function рдЙрдкрдпреЛрдЧ рд╣реЛрддрд╛ рд╣реИ?
  4. Loss function рдФрд░ optimizer рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  5. PyTorch рдореЗрдВ loss calculate рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдХреМрди-рдХреМрди рд╕реА steps рд╣реЛрддреА рд╣реИрдВ?

Loss Functions and Optimization

(рд╣рд╛рдирд┐ рдлрд▓рди рдФрд░ рдЕрдиреБрдХреВрд▓рди рд╡рд┐рдзрд┐рдпрд╛рдБ)


ЁЯФ╖ 1. Loss Function (рд╣рд╛рдирд┐ рдлрд▓рди) рдХреНрдпрд╛ рд╣реИ?

Loss function рдпрд╣ рдорд╛рдкрддрд╛ рд╣реИ рдХрд┐ рдЖрдкрдХреЗ рдореЙрдбрд▓ рдХреА prediction рдЕрд╕рд▓реА output рд╕реЗ рдХрд┐рддрдиреА рджреВрд░ рд╣реИред

ЁЯФБ Role in Training:

  • Prediction тЖТ Loss Function тЖТ Error тЖТ Backpropagation тЖТ Weight Update

ЁЯУМ рдХрд╛рд░реНрдп:

StepрдХрд╛рд░реНрдп
PredictionOutput generate рдХрд░рдирд╛
LossрдЧрд▓рддреА рдорд╛рдкрдирд╛
BackpropagationGradient рдирд┐рдХрд╛рд▓рдирд╛
OptimizerWeights update рдХрд░рдирд╛

ЁЯФ╣ 2. Loss Function рдХреЗ рдкреНрд░рдХрд╛рд░

ЁЯФ╕ A. Regression Problems рдХреЗ рд▓рд┐рдП:

тЬЕ Mean Squared Error (MSE):

  • Continuous values рдХреЗ рд▓рд┐рдП
  • Output рдХреЛ penalize рдХрд░рддрд╛ рд╣реИ рдЕрдЧрд░ prediction рдФрд░ label рдХрд╛ рдЕрдВрддрд░ рдмрдбрд╝рд╛ рд╣реЛ

тЬЕ Mean Absolute Error (MAE):

  • Outliers рд╕реЗ рдХрдо рдкреНрд░рднрд╛рд╡рд┐рдд

ЁЯФ╕ B. Classification Problems рдХреЗ рд▓рд┐рдП:

тЬЕ Binary Cross Entropy:

L=тИТ[ylogтБб(p)+(1тИТy)logтБб(1тИТp)]

  • Binary classification рдХреЗ рд▓рд┐рдП
  • Sigmoid + BCELoss

тЬЕ Categorical Cross Entropy:

  • Multi-class classification
  • Softmax + CrossEntropyLoss

ЁЯТ╗ PyTorch Examples:

import torch
import torch.nn as nn

# MSE Loss
mse_loss = nn.MSELoss()
pred = torch.tensor([2.5])
target = torch.tensor([3.0])
print("MSE:", mse_loss(pred, target).item())

# Binary Cross Entropy
bce_loss = nn.BCELoss()
pred = torch.tensor([0.9])
target = torch.tensor([1.0])
print("BCE:", bce_loss(pred, target).item())

ЁЯФз 3. Optimization (рдЕрдиреБрдХреВрд▓рди)

Optimizer рд╡рд╣ algorithm рд╣реИ рдЬреЛ model рдХреЗ weights рдХреЛ loss minimize рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП update рдХрд░рддрд╛ рд╣реИред


ЁЯФ╕ 4. Common Optimization Algorithms

OptimizerDescription
SGDSimple gradient descent
MomentumAdds momentum to SGD updates
RMSPropAdaptive learning rate, good for RNN
AdamAdaptive + Momentum = Most widely used

ЁЯФБ Gradient Descent Update Rule:

рдЬрд╣рд╛рдБ:

  • ╬╖: Learning rate
  • тИВL/тИВw: Gradient of loss w.r.t. weights

тЪая╕П Learning Rate рдХреА рднреВрдорд┐рдХрд╛:

Learning Rateрдкрд░рд┐рдгрд╛рдо
рдмрд╣реБрдд рдЫреЛрдЯрд╛Slow training
рдмрд╣реБрдд рдмрдбрд╝рд╛Overshooting, unstable
рд╕рд╣реАFast & stable convergence

ЁЯТ╗ PyTorch рдореЗрдВ Optimizer:

import torch.optim as optim

model = torch.nn.Linear(1, 1)
optimizer = optim.Adam(model.parameters(), lr=0.01)

# Example training step:
loss = torch.tensor(0.5, requires_grad=True)
loss.backward()
optimizer.step()
optimizer.zero_grad()

ЁЯОп Objectives Summary

  • Loss function prediction error рдХреЛ рдорд╛рдкрддрд╛ рд╣реИ
  • Optimizers gradients рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд░ weights рдХреЛ update рдХрд░рддреЗ рд╣реИрдВ
  • PyTorch рдореЗрдВ loss + optimizer combo рд╕рдмрд╕реЗ рдЬрд░реВрд░реА рд╕реЗрдЯрдЕрдк рд╣реИ

ЁЯУЭ рдЕрднреНрдпрд╛рд╕ рдкреНрд░рд╢реНрди (Practice Questions)

  1. Loss Function рдФрд░ Optimizer рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  2. MSE рдФрд░ MAE рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  3. Binary Cross-Entropy рдХрд╛ рдлреЙрд░реНрдореВрд▓рд╛ рд▓рд┐рдЦрд┐рдП
  4. Adam Optimizer рдХреИрд╕реЗ рдХрд╛рдо рдХрд░рддрд╛ рд╣реИ?
  5. рдиреАрдЪреЗ рджрд┐рдП рдЧрдП рдХреЛрдб рдХрд╛ output рдХреНрдпрд╛ рд╣реЛрдЧрд╛?

loss = torch.tensor(1.0, requires_grad=True) loss.backward() print(loss.grad)

Activation Functions

(рд╕рдХреНрд░рд┐рдпрдг рдлрд▓рди: Sigmoid, Tanh, ReLU)


ЁЯФ╖ 1. рдкрд░рд┐рдЪрдп (Introduction)

Neural Network рдореЗрдВ Activation Function рдпрд╣ рддрдп рдХрд░рддрд╛ рд╣реИ рдХрд┐ рдХреЛрдИ neuron тАЬactiveтАЭ рд╣реЛрдЧрд╛ рдпрд╛ рдирд╣реАрдВред
рдпрд╣ non-linearity рд▓рд╛рддрд╛ рд╣реИ, рддрд╛рдХрд┐ рдореЙрдбрд▓ complex patterns рдХреЛ рд╕реАрдЦ рд╕рдХреЗред


ЁЯФ╣ 2. рдЖрд╡рд╢реНрдпрдХрддрд╛ рдХреНрдпреЛрдВ? (Why Needed?)

рдмрд┐рдирд╛ Activation Function рдХреЗ neural network рдПрдХ simple linear model рдмрди рдЬрд╛рдПрдЧрд╛ред

ЁЯУМ With Activation Function тЖТ Deep, non-linear models
ЁЯУМ Without Activation тЖТ рд╕рд┐рд░реНрдл linear transformation


ЁЯФ╢ 3. рдореБрдЦреНрдп Activation Functions


ЁЯФ╕ A. Sigmoid Function

ЁЯУМ Output Range: (0, 1)
ЁЯУМ рдЙрдкрдпреЛрдЧ: Binary classification, Logistic regression

тЬЕ рд▓рд╛рдн:

  • Probability рдХреА рддрд░рд╣ рдЖрдЙрдЯрдкреБрдЯ рджреЗрддрд╛ рд╣реИ
  • Smooth gradient

тЭМ рдХрдореА:

  • Gradient vanishing problem
  • Output range рдЫреЛрдЯрд╛ рд╣реИ

ЁЯУИ рдЧреНрд░рд╛рдл: S-shaped (S-curve)


ЁЯФ╕ B. Tanh (Hyperbolic Tangent)

ЁЯУМ Output Range: (-1, 1)
ЁЯУМ рдЙрдкрдпреЛрдЧ: рдЬрдм input data zero-centered рд╣реЛ

тЬЕ рд▓рд╛рдн:

  • Stronger gradients than sigmoid
  • Centered at 0 тЖТ better learning

тЭМ рдХрдореА:

  • Still suffers from vanishing gradient (large input рдкрд░ gradient тЖТ 0)

ЁЯУИ рдЧреНрд░рд╛рдл: S-shaped but centered at 0


ЁЯФ╕ C. ReLU (Rectified Linear Unit)

ЁЯУМ Output Range: [0, тИЮ)
ЁЯУМ рдЙрдкрдпреЛрдЧ: Deep Networks рдореЗрдВ рд╕рдмрд╕реЗ рдЖрдо activation

тЬЕ рд▓рд╛рдн:

  • Fast computation
  • Sparse activation (only positive values pass)
  • No vanishing gradient for positive inputs

тЭМ рдХрдореА:

  • Dying ReLU Problem: negative input тЖТ always zero gradient

ЁЯУИ рдЧреНрд░рд╛рдл: 0 for x < 0, linear for x > 0


ЁЯФБ рддреБрд▓рдирд╛ рддрд╛рд▓рд┐рдХрд╛ (Comparison Table)

FeatureSigmoidTanhReLU
Output Range(0, 1)(-1, 1)[0, тИЮ)
Non-linearityтЬЕтЬЕтЬЕ
Vanishing GradientYesYesNo (partial)
SpeedSlowSlowFast
UsageBinary outputsHidden layers (earlier)Deep models (most common)

ЁЯТ╗ PyTorch Code: Activation Functions

import torch
import torch.nn.functional as F

x = torch.tensor([-2.0, 0.0, 2.0])

print("Sigmoid:", torch.sigmoid(x))
print("Tanh:", torch.tanh(x))
print("ReLU:", F.relu(x))

ЁЯОп Learning Summary (рд╕рд╛рд░рд╛рдВрд╢)

  • Sigmoid рдФрд░ Tanh smooth functions рд╣реИрдВ рд▓реЗрдХрд┐рди saturation (vanishing gradient) рд╕реЗ рдЧреНрд░рд╕реНрдд рд╣реЛ рд╕рдХрддреЗ рд╣реИрдВ
  • ReLU simple, fast, рдФрд░ deep networks рдореЗрдВ рд╕рдмрд╕реЗ рдЕрдзрд┐рдХ рдЙрдкрдпреЛрдЧреА рд╣реИ
  • Hidden layers рдореЗрдВ ReLU рд╕рдмрд╕реЗ рд▓реЛрдХрдкреНрд░рд┐рдп choice рд╣реИ

ЁЯУЭ рдЕрднреНрдпрд╛рд╕ рдкреНрд░рд╢реНрди (Practice Questions)

  1. Sigmoid рдФрд░ Tanh рдореЗрдВ рдХреНрдпрд╛ рдЕрдВрддрд░ рд╣реИ?
  2. ReLU рдХрд╛ рдЧрдгрд┐рддреАрдп рдлреЙрд░реНрдореВрд▓рд╛ рдХреНрдпрд╛ рд╣реИ?
  3. Dying ReLU problem рдХреНрдпрд╛ рд╣реИ?
  4. рдпрджрд┐ input -3 рд╣реЛ рддреЛ ReLU рдХрд╛ output рдХреНрдпрд╛ рд╣реЛрдЧрд╛?
  5. рдиреАрдЪреЗ рджрд┐рдП рдЧрдП PyTorch рдХреЛрдб рдХрд╛ рдЖрдЙрдЯрдкреБрдЯ рдмрддрд╛рдЗрдП:

x = torch.tensor([-1.0, 0.0, 1.0]) print(torch.tanh(x))

Perceptron and Multi-layer Perceptron (MLP)

(рдкрд░рд╕реЗрдкреНрдЯреНрд░реЙрди рдФрд░ рдорд▓реНрдЯреА-рд▓реЗрдпрд░ рдкрд░рд╕реЗрдкреНрдЯреНрд░реЙрди)


ЁЯФ╖ 1. Perceptron: Single-layer Neural Unit

тЮд рдкрд░рд┐рднрд╛рд╖рд╛:

Perceptron рдПрдХ single-layer feedforward neural network рд╣реИ рдЬреЛ binary classification рдХрд░рдиреЗ рдореЗрдВ рд╕рдХреНрд╖рдо рд╣реЛрддрд╛ рд╣реИред

ЁЯзо рдЧрдгрд┐рддреАрдп рд░реВрдк:


ЁЯУМ рд╡рд┐рд╢реЗрд╖рддрд╛рдПрдБ:

рдЧреБрдгрд╡рд┐рд╡рд░рдг
StructureрдПрдХ рд╣реА layer (input рд╕реЗ output)
UseLinear binary classification
LimitationNon-linear problems (рдЬреИрд╕реЗ XOR) solve рдирд╣реАрдВ рдХрд░ рд╕рдХрддрд╛

ЁЯФБ Simple Diagram:


ЁЯФ╢ 2. MLP: Multi-layer Perceptron

тЮд рдкрд░рд┐рднрд╛рд╖рд╛:

MLP рдПрдХ feedforward artificial neural network рд╣реИ рдЬрд┐рд╕рдореЗрдВ рдПрдХ рдпрд╛ рдЕрдзрд┐рдХ hidden layers рд╣реЛрддреЗ рд╣реИрдВред

ЁЯПЧя╕П рд╕рдВрд░рдЪрдирд╛:

Input тЖТ Hidden Layer(s) тЖТ Output
(рд╣рд░ layer рдореЗрдВ neurons рд╣реЛрддреЗ рд╣реИрдВ, рдФрд░ рд╣рд░ neuron activation function apply рдХрд░рддрд╛ рд╣реИ)


ЁЯУМ рд╡рд┐рд╢реЗрд╖рддрд╛рдПрдБ:

рдЧреБрдгрд╡рд┐рд╡рд░рдг
Structure2+ layers (input, hidden, output)
UseComplex, non-linear problems
TrainingBackpropagation + Gradient Descent
ActivationReLU, sigmoid, tanh, softmax

ЁЯФБ MLP Diagram (Structure):


ЁЯТ╗ PyTorch рдореЗрдВ рдПрдХ рд╕рд░рд▓ MLP рдХреЛрдб:

import torch.nn as nn

class MLP(nn.Module):
def __init__(self):
super(MLP, self).__init__()
self.net = nn.Sequential(
nn.Linear(3, 5), # Input layer тЖТ Hidden
nn.ReLU(),
nn.Linear(5, 1), # Hidden тЖТ Output
nn.Sigmoid()
)

def forward(self, x):
return self.net(x)

ЁЯФД рддреБрд▓рдирд╛ рддрд╛рд▓рд┐рдХрд╛: Perceptron vs MLP

рд╡рд┐рд╢реЗрд╖рддрд╛PerceptronMLP
LayersSingleMultiple (hidden included)
ActivationStep/SigmoidReLU, Sigmoid, Tanh, Softmax
Data HandlingрдХреЗрд╡рд▓ linearly separableComplex, non-linear data
LearningSimple weight updateBackpropagation algorithm

ЁЯОп Learning Summary:

  • Perceptron рдПрдХ рд╕рдмрд╕реЗ рд╕рд░рд▓ Neural Network рд╣реИред
  • MLP рдореЗрдВ Hidden layers рд╣реЛрдиреЗ рд╕реЗ рдпрд╣ complex pattern рд╕реАрдЦ рд╕рдХрддрд╛ рд╣реИред
  • Deep Learning рдореЗрдВ MLP рд╕рдмрд╕реЗ рдмреБрдирд┐рдпрд╛рджреА рдФрд░ рдЖрдзрд╛рд░рднреВрдд рд╕рдВрд░рдЪрдирд╛ рд╣реИред

ЁЯУЭ рдЕрднреНрдпрд╛рд╕ рдкреНрд░рд╢реНрди (Practice Questions):

  1. Perceptron рдХрд╛ рдЧрдгрд┐рддреАрдп рдлрд╝реЙрд░реНрдореВрд▓рд╛ рдХреНрдпрд╛ рд╣реИ?
  2. Perceptron рдФрд░ MLP рдореЗрдВ рдореБрдЦреНрдп рдЕрдВрддрд░ рдХреНрдпрд╛ рд╣реИ?
  3. MLP рдореЗрдВ activation functions рдХреНрдпреЛрдВ рдЬрд╝рд░реВрд░реА рд╣реЛрддреЗ рд╣реИрдВ?
  4. Perceptron XOR problem рдХреНрдпреЛрдВ solve рдирд╣реАрдВ рдХрд░ рд╕рдХрддрд╛?
  5. рдПрдХ рд╕рд░рд▓ MLP рдореЗрдВ рдХрд┐рддрдиреА layers рд╣реЛрддреА рд╣реИрдВ?

Biological Neuron vs Artificial Neuron

(рдЬреИрд╡рд┐рдХ рдиреНрдпреВрд░реЙрди рдмрдирд╛рдо рдХреГрддреНрд░рд┐рдо рдиреНрдпреВрд░реЙрди)


ЁЯФ╣ 1. Biological Neuron (рдЬреИрд╡рд┐рдХ рдиреНрдпреВрд░реЙрди) рдХреНрдпрд╛ рд╣реЛрддрд╛ рд╣реИ?

рдпрд╣ рдорд╛рдирд╡ рдорд╕реНрддрд┐рд╖реНрдХ рдХреА рдореВрд▓ рдЗрдХрд╛рдИ рд╣реИ рдЬреЛ рд╕рдВрдХреЗрддреЛрдВ (signals) рдХреЛ рд▓реЗрддреА рд╣реИ, рдкреНрд░рдХреНрд░рд┐рдпрд╛ рдХрд░рддреА рд╣реИ рдФрд░ рдЕрдиреНрдп рдиреНрдпреВрд░реЙрдиреЛрдВ рдХреЛ рднреЗрдЬрддреА рд╣реИред

ЁЯФм рд╕рдВрд░рдЪрдирд╛ (Structure):

рднрд╛рдЧрдХрд╛рд░реНрдп
DendritesInput signal рд▓реЗрддреЗ рд╣реИрдВ
Cell Body (Soma)Input рдХреЛ process рдХрд░рддрд╛ рд╣реИ
AxonOutput signal рдХреЛ рднреЗрдЬрддрд╛ рд╣реИ
SynapseрджреЛ neurons рдХреЗ рдмреАрдЪ signal рдкрд╛рд╕ рдХрд░рддрд╛ рд╣реИ

ЁЯза рдХрд╛рд░реНрдпрдкреНрд░рдгрд╛рд▓реА:

  • рдЬрдм рдХреБрд▓ Input signal рдПрдХ Threshold рд╕реЗ рдКрдкрд░ рдЬрд╛рддрд╛ рд╣реИ, рддрдм neuron тАЬFireтАЭ рдХрд░рддрд╛ рд╣реИ (Signal рднреЗрдЬрддрд╛ рд╣реИ)ред

ЁЯФ╣ 2. Artificial Neuron (рдХреГрддреНрд░рд┐рдо рдиреНрдпреВрд░реЙрди)

Deep Learning рдореЗрдВ Artificial Neuron рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ, рдЬреЛ Biological neuron рд╕реЗ рдкреНрд░реЗрд░рд┐рдд рд╣реИ рд▓реЗрдХрд┐рди рдЧрдгрд┐рддреАрдп рд╣реЛрддрд╛ рд╣реИред

ЁЯФв рдХрд╛рд░реНрдпрдкреНрд░рдгрд╛рд▓реА:

  • xiтАЛ: Inputs
  • wi: Weights
  • b: Bias
  • f: Activation function
  • y: Output

ЁЯФБ рддреБрд▓рдирд╛рддреНрдордХ рддрд╛рд▓рд┐рдХрд╛ (Comparison Table)

рд╡рд┐рд╢реЗрд╖рддрд╛рдЬреИрд╡рд┐рдХ рдиреНрдпреВрд░реЙрдирдХреГрддреНрд░рд┐рдо рдиреНрдпреВрд░реЙрди
рд╕рдВрд░рдЪрдирд╛Dendrites, Axon, SynapseInputs, Weights, Activation
рд╕рдВрдХреЗрдд (Signal)ElectrochemicalNumerical (рд╡рд╛рд╕реНрддрд╡рд┐рдХ рд╕рдВрдЦреНрдпрд╛)
рдкреНрд░рд╕рдВрд╕реНрдХрд░рдгThreshold based firingWeighted sum + Activation
рд╕реАрдЦрдирд╛Synapse рдХреЗ рдмрджрд▓рд╛рд╡ рд╕реЗWeights update (Gradient Descent)
рдиреЗрдЯрд╡рд░реНрдХBiological Neural NetworkArtificial Neural Network (ANN)

ЁЯза рд╡рд┐рдЬрд╝реБрдЕрд▓ рддреБрд▓рдирд╛ (Diagram)

Biological Neuron:                        Artificial Neuron:

Input (Dendrites) x1, x2, x3 тЖТ
тЖУ тЖУ
Cell Body (Summation) w1x1 + w2x2 + w3x3 + b
тЖУ тЖУ
Axon тЖТ Output Activation Function тЖТ Output

ЁЯФН рдирд┐рд╖реНрдХрд░реНрд╖ (Conclusion):

  • Artificial Neurons inspired рд╣реИрдВ Biological Neurons рд╕реЗ, рдкрд░рдВрддреБ рд╡реЗ рд╕рд░рд▓ рдЧрдгрд┐рддреАрдп рдореЙрдбрд▓ рд╣реИрдВред
  • рдПрдХ Artificial Neuron рд╕рд┐рд░реНрдл рдПрдХ рдЫреЛрдЯрд╛ рд╕рд╛ рднрд╛рдЧ рд╣реИ Deep Learning рдиреЗрдЯрд╡рд░реНрдХ рдХрд╛, рд▓реЗрдХрд┐рди рдЙрд╕рдХрд╛ inspiration рдорд╛рдирд╡ рдорд╕реНрддрд┐рд╖реНрдХ рд╕реЗ рдЖрдпрд╛ рд╣реИред
  • рдЬреИрд╕рд╛ рдорд╛рдирд╡ рдорд╕реНрддрд┐рд╖реНрдХ рд╕рд┐рдЦрддрд╛ рд╣реИ рдЕрдиреБрднрд╡ рд╕реЗ, рд╡реИрд╕реЗ рд╣реА ANN рд╕рд┐рдЦрддрд╛ рд╣реИ рдбреЗрдЯрд╛ рд╕реЗред

ЁЯОп рдЙрджреНрджреЗрд╢реНрдп (Objective Summary)

  • рдЬреИрд╡рд┐рдХ рдиреНрдпреВрд░реЙрди рдХреА рд╕рдВрд░рдЪрдирд╛ рдФрд░ рдХрд╛рд░реНрдпрдкреНрд░рдгрд╛рд▓реА рд╕рдордЭрдирд╛
  • рдХреГрддреНрд░рд┐рдо рдиреНрдпреВрд░реЙрди рдХрд╛ рдЧрдгрд┐рддреАрдп рд╕реНрд╡рд░реВрдк рдЬрд╛рдирдирд╛
  • рджреЛрдиреЛрдВ рдХреЗ рдмреАрдЪ рдХреА рд╕рдорд╛рдирддрд╛ рдФрд░ рднрд┐рдиреНрдирддрд╛ рдкрд╣рдЪрд╛рдирдирд╛
  • Deep Learning рдореЗрдВ рдЗрд╕ рд╕рдВрдмрдВрдз рдХрд╛ рдорд╣рддреНрд╡ рд╕рдордЭрдирд╛

ЁЯУЭ рдЕрднреНрдпрд╛рд╕ рдкреНрд░рд╢реНрди (Practice Questions)

  1. Dendrites рдФрд░ Axon рдХрд╛ рдХрд╛рд░реНрдп рдХреНрдпрд╛ рд╣реЛрддрд╛ рд╣реИ?
  2. Artificial Neuron рдХрд┐рд╕ рдкреНрд░рдХрд╛рд░ рдХрд╛ Input рд▓реЗрддрд╛ рд╣реИ?
  3. рджреЛрдиреЛрдВ рдкреНрд░рдХрд╛рд░ рдХреЗ рдиреНрдпреВрд░реЙрди рдореЗрдВ signal рдХреИрд╕рд╛ рд╣реЛрддрд╛ рд╣реИ?
  4. рдПрдХ Artificial Neuron рдХрд╛ рдЧрдгрд┐рддреАрдп formula рд▓рд┐рдЦрд┐рдПред
  5. рдХреГрддреНрд░рд┐рдо рдиреНрдпреВрд░реЙрди рдЬреИрд╡рд┐рдХ рдиреНрдпреВрд░реЙрди рд╕реЗ рдХреИрд╕реЗ рдкреНрд░реЗрд░рд┐рдд рд╣реИ?