న్యూరల్ నెట్‌వర్క్‌ల పరిచయం — AI పొరలలో ఎలా ఆలోచిస్తుంది

మెదడు-ప్రేరిత అల్గారిథమ్ 👋

గత పాఠంలో మీరు డెసిషన్ ట్రీలు, KNN మరియు లీనియర్ రిగ్రెషన్ నేర్చుకున్నారు. అవి శక్తివంతమైనవి — కానీ ముఖ గుర్తింపు లేదా భాష అర్థం చేసుకోవడం వంటి సంక్లిష్ట పనుల్లో కష్టపడతాయి.

ఆ పనులకు మనకు న్యూరల్ నెట్‌వర్క్‌లు కావాలి — మీ మెదడు ఎలా పనిచేస్తుందో దాని నుండి ప్రేరణ పొందిన అల్గారిథమ్‌లు.

---

న్యూరాన్ల నుండి కృత్రిమ న్యూరాన్ల వరకు 🔬

మీ మెదడులో సుమారు 86 బిలియన్ న్యూరాన్లు ఉన్నాయి. ప్రతి ఒక్కటి:

1. ఇతర న్యూరాన్ల నుండి సిగ్నల్‌లు అందుకుంటుంది
2. ఆ సిగ్నల్‌లను ప్రాసెస్ చేస్తుంది (కూడుతుంది)
3. ఫైర్ అవ్వాలా వద్దా నిర్ణయిస్తుంది

కృత్రిమ న్యూరాన్ కూడా అదే చేస్తుంది, కానీ సంఖ్యలతో:

1. ఇన్‌పుట్‌గా సంఖ్యలు అందుకుంటుంది
2. ప్రతి ఇన్‌పుట్‌ను వెయిట్‌తో గుణిస్తుంది
3. అన్నీ కూడుతుంది
4. యాక్టివేషన్ ఫంక్షన్ ద్వారా నిర్ణయిస్తుంది

ఇన్‌పుట్       వెయిట్‌లు      మొత్తం      యాక్టివేషన్    ఔట్‌పుట్
──────          ──────         ──────      ──────────     ──────
x₁ = 0.5  ──→  w₁ = 0.8  ─┐
                             ├──→ 1.25 ──→ f(1.25) ──→  0.78
x₂ = 0.3  ──→  w₂ = 1.5  ─┘

మొత్తం = (0.5 × 0.8) + (0.3 × 1.5) = 0.40 + 0.85 = 1.25

---

పొరలు: న్యూరాన్లు ఎలా నిర్వహించబడతాయి 🏗️

ఒక న్యూరాన్ ఎక్కువ చేయలేదు. శక్తి పొరలుగా నిర్వహించడం నుండి వస్తుంది.

1. ఇన్‌పుట్ లేయర్ — కళ్ళు మరియు చెవులు 👀

• ముడి డేటా అందుకుంటుంది
• ప్రతి ఇన్‌పుట్ లక్షణానికి ఒక న్యూరాన్

2. హిడెన్ లేయర్(లు) — ఆలోచించే మెదడు 🧠

• ఇక్కడ నిజమైన నేర్చుకోవడం జరుగుతుంది
• ప్రతి న్యూరాన్ డేటాలో ఒక నమూనా కనుగొంటుంది
• ఎక్కువ హిడెన్ లేయర్లు = సంక్లిష్ట నమూనాలు

3. ఔట్‌పుట్ లేయర్ — సమాధానం 💡

• తుది అంచనా ఇస్తుంది
• వర్గీకరణకు: ప్రతి వర్గానికి ఒక న్యూరాన్
• రిగ్రెషన్‌కు: ఒక సంఖ్యతో ఒక న్యూరాన్

ఇన్‌పుట్ లేయర్   హిడెన్ లేయర్ 1   హిడెన్ లేయర్ 2    ఔట్‌పుట్ లేయర్
(3 లక్షణాలు)     (4 న్యూరాన్లు)    (4 న్యూరాన్లు)     (2 క్లాసులు)

  [x₁] ──────→   [h₁] ──────→    [h₅] ──────→       [పిల్లి: 0.92]
  [x₂] ──────→   [h₂] ──────→    [h₆] ──────→       [కుక్క: 0.08]
  [x₃] ──────→   [h₃] ──────→    [h₇]
                  [h₄] ──────→    [h₈]

---

యాక్టివేషన్ ఫంక్షన్లు — నిర్ణయకర్తలు 💧

న్యూరాన్ తన ఇన్‌పుట్‌లు కూడిన తర్వాత నిర్ణయిస్తుంది: నేను యాక్టివేట్ అవ్వాలా వద్దా?

నీటి ప్రవాహ ఉపమానం 🚿

వాల్వ్ ఉన్న నీటి పైపు ఊహించుకోండి:

• నీరు లోపలికి వస్తుంది (ఇన్‌పుట్ల భారిత మొత్తం)
• వాల్వ్ బయటకు ఏమి వెళ్తుందో నియంత్రిస్తుంది (యాక్టివేషన్ ఫంక్షన్)

సాధారణ యాక్టివేషన్ ఫంక్షన్లు

ReLU — సాధారణ గేట్

• పాజిటివ్ ఇన్‌పుట్ → వెళ్ళనివ్వు
• నెగటివ్ ఇన్‌పుట్ → ఆపు (ఔట్‌పుట్ సున్న)

def relu(x):
    return max(0, x)

print(relu(3.5))   # 3.5 (పాజిటివ్ → వెళ్తుంది)
print(relu(-2.0))  # 0.0 (నెగటివ్ → ఆగిపోయింది)

Sigmoid — మెత్తటి కుదింపు

• ఏ ఇన్‌పుట్‌నైనా 0 మరియు 1 మధ్య కుదిస్తుంది
• సంభావ్యతలకు సరైనది: "ఇది పిల్లి అనే 0.87 సంభావ్యత"

import math

def sigmoid(x):
    return 1 / (1 + math.exp(-x))

print(sigmoid(5.0))    # 0.993 (చాలా నమ్మకంగా "అవును")
print(sigmoid(0.0))    # 0.500 (పూర్తిగా అనిశ్చితం)
print(sigmoid(-5.0))   # 0.007 (చాలా నమ్మకంగా "కాదు")

Softmax — ఓట్ల లెక్కింపుదారు

• వర్గీకరణ కోసం ఔట్‌పుట్ లేయర్‌లో ఉపయోగిస్తారు
• అనేక విలువలను 1 కు కూడే సంభావ్యతలుగా మారుస్తుంది

ముడి ఔట్‌పుట్లు:  [2.0, 1.0, 0.5]
Softmax తర్వాత:  [0.59, 0.24, 0.17]  → పిల్లి (59%), కుక్క (24%), పక్షి (17%)

---

ఫార్వర్డ్ ప్రాపగేషన్ — డేటా ప్రవహిస్తుంది 🌊

రిలే రేస్ లాగా ఆలోచించండి:

1. ఇన్‌పుట్ లేయర్ డేటా అందుకుని మొదటి హిడెన్ లేయర్‌కు పంపుతుంది
2. ప్రతి న్యూరాన్ గుణించు, కూడు మరియు యాక్టివేట్ చేస్తుంది
3. ఫలితాలు తదుపరి లేయర్‌కు వెళ్తాయి
4. ఇది ఔట్‌పుట్ లేయర్ వరకు కొనసాగుతుంది
5. ఔట్‌పుట్ లేయర్ తుది అంచనా ఇస్తుంది

ఒక ఉదాహరణ

ఆపిల్ లేదా నారింజ వర్గీకరించడం:

ఇన్‌పుట్: బరువు = 150g, రంగు = 0.8 (నారింజ రంగు)

దశ 1 — ఇన్‌పుట్ లేయర్ విలువలు పంపుతుంది:
  x₁ = 150 (బరువు), x₂ = 0.8 (రంగు)

దశ 2 — హిడెన్ న్యూరాన్ 1:
  మొత్తం = (150 × 0.01) + (0.8 × 2.0) + bias(0.1) = 3.2
  ఔట్‌పుట్ = ReLU(3.2) = 3.2

దశ 3 — హిడెన్ న్యూరాన్ 2:
  మొత్తం = (150 × -0.005) + (0.8 × 1.5) + bias(0.3) = 0.75
  ఔట్‌పుట్ = ReLU(0.75) = 0.75

దశ 4 — ఔట్‌పుట్ లేయర్:
  ఆపిల్_స్కోర్  = (3.2 × -0.5) + (0.75 × 0.8) = -1.0
  నారింజ_స్కోర్ = (3.2 × 0.7) + (0.75 × 0.3) = 2.465

దశ 5 — Softmax:
  ఆపిల్:  18%
  నారింజ: 82%  ← అంచనా: నారింజ! 🍊

---

బ్యాక్‌ప్రాపగేషన్ — తప్పుల నుండి నేర్చుకోవడం 🔄

ఫార్వర్డ్ ప్రాపగేషన్ అంచనా ఇస్తుంది. కానీ తప్పు అయితే? అప్పుడు బ్యాక్‌ప్రాపగేషన్ వస్తుంది.

డార్ట్ విసరడం ఉపమానం 🎯

1. డార్ట్ విసరండి (ఫార్వర్డ్ ప్రాపగేషన్ — అంచనా వేయండి)
2. ఎంత దూరం తప్పారో ఎవరో చెప్తారు (ఎర్రర్ లెక్కించండి)
3. గురి సరిచేయండి (వెయిట్‌లు అప్‌డేట్ చేయండి)
4. మళ్ళీ విసరండి — ఈసారి దగ్గరగా!
5. వేల సార్లు పునరావృతం చేయండి

ఫార్వర్డ్ ప్రాపగేషన్:  డేటా → నెట్‌వర్క్ → అంచనా
                                               ↓
పోల్చడం:                అంచనా vs నిజమైన సమాధానం = ఎర్రర్
                                               ↓
బ్యాక్‌ప్రాపగేషన్:     ఎర్రర్ నెట్‌వర్క్‌లో వెనక్కి వెళ్తుంది
                                               ↓
అప్‌డేట్:               ఎర్రర్ తగ్గించడానికి వెయిట్‌లు సరిచేయండి
                                               ↓
పునరావృతం:              వేల సార్లు!

---

ఇంటరాక్టివ్: నెట్‌వర్క్ ద్వారా డేటా ట్రేస్ చేయండి 🔍

స్పామ్ ఇ-మెయిల్ వర్గీకరించే చిన్న నెట్‌వర్క్ ద్వారా డేటా ట్రేస్ చేయండి.

లక్షణాలు:

• x₁ = ఆశ్చర్యార్థక చిహ్నాల సంఖ్య (5)
• x₂ = "ఉచితం" అనే పదం ఉందా (1 = అవును)

import math

# ఇన్‌పుట్లు
x1, x2 = 5, 1

# హిడెన్ న్యూరాన్ 1
z1 = (x1 * 0.6) + (x2 * 0.9) + 0.1    # = 4.0
h1 = max(0, z1)                          # ReLU → 4.0

# హిడెన్ న్యూరాన్ 2
z2 = (x1 * 0.3) + (x2 * 0.4) + 0.2    # = 2.1
h2 = max(0, z2)                          # ReLU → 2.1

# ఔట్‌పుట్ న్యూరాన్
z_out = (h1 * 0.7) + (h2 * 0.5) - 0.5  # = 3.35
output = 1 / (1 + math.exp(-z_out))      # Sigmoid → 0.966

print(f"హిడెన్ లేయర్: h1={h1}, h2={h2}")
print(f"ముడి ఔట్‌పుట్: {z_out:.2f}")
print(f"స్పామ్ సంభావ్యత: {output:.1%}")    # 96.6% → స్పామ్! 🚫

---

పెద్ద చిత్రం 🗺️

డేటా (పాఠం 1) → అల్గారిథమ్ (పాఠం 2) → న్యూరల్ నెట్‌వర్క్ (పాఠం 3)
     📊                 🧮                       🧠

న్యూరల్ నెట్‌వర్క్‌లు వీటికి శక్తినిస్తాయి:

• 🗣️ ChatGPT — భాషను అర్థం చేసుకోవడం మరియు ఉత్పత్తి చేయడం
• 🎨 DALL-E / Midjourney — టెక్స్ట్ నుండి చిత్రాలు సృష్టించడం
• 🚗 సెల్ఫ్-డ్రైవింగ్ కారులు — రోడ్డును చూడటం మరియు అర్థం చేసుకోవడం
• 🔬 AlphaFold — ప్రోటీన్ నిర్మాణాలను అంచనా వేయడం

---

సారాంశం 🎯

1. కృత్రిమ న్యూరాన్లు ఇన్‌పుట్ అందుకుంటాయి, వెయిట్‌లతో గుణిస్తాయి, కూడుతాయి మరియు యాక్టివేషన్ వర్తింపజేస్తాయి
2. న్యూరల్ నెట్‌వర్క్‌లలో మూడు రకాల లేయర్లు ఉన్నాయి: ఇన్‌పుట్, హిడెన్ మరియు ఔట్‌పుట్
3. యాక్టివేషన్ ఫంక్షన్లు నాన్-లీనియారిటీ కలుపుతాయి — వాటి లేకుండా నెట్‌వర్క్ సరళ రేఖలు మాత్రమే నేర్చుకోగలదు
4. ఫార్వర్డ్ ప్రాపగేషన్ అంచనా కోసం డేటాను నెట్‌వర్క్ ద్వారా నెట్టుతుంది
5. బ్యాక్‌ప్రాపగేషన్ వెయిట్‌లు సరిచేయడానికి ఎర్రర్‌లను వెనక్కి పంపుతుంది
6. న్యూరల్ నెట్‌వర్క్‌లు ఆధునిక AI కి శక్తినిస్తాయి — చాట్‌బాట్‌ల నుండి సెల్ఫ్-డ్రైవింగ్ కారుల వరకు

---

తదుపరి ఏమిటి? 🚀

అభినందనలు — మీరు ఇప్పుడు AI యొక్క మూడు స్తంభాలను అర్థం చేసుకున్నారు: డేటా, అల్గారిథమ్‌లు మరియు న్యూరల్ నెట్‌వర్క్‌లు! రాబోయే పాఠాలలో AI టూల్స్ మరియు బాధ్యతాయుతమైన AI గురించి తెలుసుకుందాం 🌱