{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a7cc64ba",
   "metadata": {},
   "source": [
    "# 🧠 Train Data vs Test Data — \n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "## 🔵 Train Data (Training Data)\n",
    "\n",
    "**परिभाषा:**\n",
    "> Model लाई **pattern र rules सिकाउन** प्रयोग गरिने dataset हो। यो data बाट model ले आफ्नो weight adjust गर्छ।\n",
    "\n",
    "**विशेषताहरू:**\n",
    "- Model यही data हेरेर **parameters (weights)** update गर्छ\n",
    "- एकै data धेरैपटक **(epochs)** हेरिन्छ\n",
    "- Total dataset को **70–80%** भाग train को लागि राखिन्छ\n",
    "- जति quality भएको data, उति **राम्रो model** बन्छ\n",
    "\n",
    "📖 **उदाहरण:** विद्यार्थीले परीक्षाको तयारीका लागि पढ्ने **किताब** जस्तै\n",
    "\n",
    "---\n",
    "\n",
    "## 🟠 Test Data (Testing Data)\n",
    "\n",
    "**परिभाषा:**\n",
    "> Training सकिसकेपछि model को **real-world performance** मापन गर्न प्रयोग गरिने **नयाँ र unseen** dataset हो।\n",
    "\n",
    "**विशेषताहरू:**\n",
    "- Model ले यो data training मा **कहिल्यै देखेको हुँदैन**\n",
    "- यसमा **weight update हुँदैन** — evaluation मात्र हुन्छ\n",
    "- Total dataset को **20–30%** भाग test को लागि राखिन्छ\n",
    "- Model कति राम्ररी **generalize** गर्न सक्छ भनेर जाँच्छ\n",
    "\n",
    "📝 **उदाहरण:** किताब पढिसकेपछि दिइने **परीक्षाको प्रश्नपत्र** जस्तै\n",
    "\n",
    "---\n",
    "\n",
    "## 📊 Dataset विभाजन\n",
    "\n",
    "```\n",
    "पूरा Dataset (100%)\n",
    "│\n",
    "├── 🔵 Train Data      ──────────────────── 70–80%\n",
    "│        └── Model यहाँबाट सिक्छ\n",
    "│\n",
    "├── 🟢 Validation Data ──────────────────── 10–15%  (optional)\n",
    "│        └── Training को बीचमा tune गर्न\n",
    "│\n",
    "└── 🟠 Test Data       ──────────────────── 10–20%\n",
    "         └── Final evaluation को लागि\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## ⚙️ Training Process — कसरी काम गर्छ\n",
    "\n",
    "```\n",
    "Input Data → Model → Prediction → Error Calculate → Weight Update\n",
    "     ↑                                                      │\n",
    "     └──────────────── बारम्बार दोहोर्याउँछ ───────────────┘\n",
    "```\n",
    "\n",
    "यो process लाई **Backpropagation** भनिन्छ।  \n",
    "Model गल्ती गरेपछि weight सच्याउँदै जान्छ जबसम्म performance राम्रो नहुन्छ।\n",
    "\n",
    "---\n",
    "\n",
    "## ⚖️ Train vs Test — तुलना तालिका\n",
    "\n",
    "| विशेषता | Train Data | Test Data |\n",
    "|:---|:---:|:---:|\n",
    "| **उद्देश्य** | Model सिकाउन | Performance जाँच्न |\n",
    "| **Model ले देख्छ?** | ✅ हो — बारम्बार | ❌ पहिलो पटक मात्र |\n",
    "| **Weight Update** | ✅ हुन्छ | ❌ हुँदैन |\n",
    "| **Dataset %** | ७०–८०% | २०–३०% |\n",
    "| **समय** | Training phase | Evaluation phase |\n",
    "| **उदाहरण** | किताब पढ्नु | परीक्षा दिनु |\n",
    "\n",
    "---\n",
    "\n",
    "## ⚠️ महत्वपूर्ण अवधारणाहरू — सावधान!\n",
    "\n",
    "### 📈 Overfitting\n",
    "> Train data मा धेरै राम्रो गर्छ तर Test data मा **खराब** गर्छ।  \n",
    "> Model ले pattern सिकेन — data **रट्यो** मात्र।\n",
    "\n",
    "### 📉 Underfitting\n",
    "> Train data मा नै राम्रो **नगर्नु** — model धेरै simple छ भन्ने संकेत।\n",
    "\n",
    "### 🚨 Data Leakage\n",
    "> Test data को जानकारी Training मा परेमा model को evaluation **गलत** हुन्छ।  \n",
    "> यो एक **गम्भीर गल्ती** हो — सधैँ avoid गर्नुपर्छ।\n",
    "\n",
    "---\n",
    "\n",
    "## 🎯 सार (Summary)\n",
    "\n",
    "| | |\n",
    "|:---|:---|\n",
    "| **Train Data** | Model सिक्ने माध्यम |\n",
    "| **Validation Data** | Training बीचमा tune गर्न |\n",
    "| **Test Data** | सिकाइको अन्तिम परीक्षा |\n",
    "\n",
    "> 💡 **याद राख्नुस्:** राम्रो ML model को लागि — **धेरै र quality भएको Train Data** + **unseen Test Data** दुवै जरुरी छ।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f45a1c14",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas import read_csv\n",
    "data1 = read_csv(\"/Users/shridharmankar/age1.csv\")\n",
    "data1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6c28a72",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = data1['Age']\n",
    "Y = data1['Income']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33bb3651",
   "metadata": {},
   "source": [
    "sklearn library को model_selection भन्ने module बाट train_test_split function लाई import (ल्याउनु) गर्नु पर्छ।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da18851b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size = 0.2, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68b4111e",
   "metadata": {},
   "source": [
    "# 🎲 `random_state` र Backpropagation \n",
    "\n",
    "---\n",
    "\n",
    "## 🔷 `random_state` किन राख्ने?\n",
    "\n",
    "### समस्या — random_state नराखेको खण्डमा\n",
    "\n",
    "```python\n",
    "# हरपटक run गर्दा फरक-फरक data split हुन्छ\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)\n",
    "\n",
    "# Run 1: [row 5, row 2, row 8 ...] → Train मा जान्छ\n",
    "# Run 2: [row 1, row 9, row 3 ...] → Train मा जान्छ  ← फरक!\n",
    "# Run 3: [row 7, row 4, row 6 ...] → Train मा जान्छ  ← फेरि फरक!\n",
    "```\n",
    "\n",
    "> ⚠️ हरपटक **फरक accuracy** आउँछ — model reliable छैन भन्न मिल्दैन!\n",
    "\n",
    "---\n",
    "\n",
    "### समाधान — random_state राखेको खण्डमा\n",
    "\n",
    "```python\n",
    "# हरपटक उही split हुन्छ\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Run 1: [row 5, row 2, row 8 ...] → Train मा जान्छ\n",
    "# Run 2: [row 5, row 2, row 8 ...] → उही!  ✅\n",
    "# Run 3: [row 5, row 2, row 8 ...] → उही!  ✅\n",
    "```\n",
    "\n",
    "> ✅ हरपटक **उही accuracy** आउँछ — result reproducible हुन्छ!\n",
    "\n",
    "---\n",
    "\n",
    "### `random_state` को number कति राख्ने?\n",
    "\n",
    "| Number | चल्छ? | कहाँ प्रचलित छ? |\n",
    "|:---:|:---:|:---|\n",
    "| `0` | ✅ | सामान्य use |\n",
    "| `1` | ✅ | सामान्य use |\n",
    "| `42` | ✅ | सबैभन्दा popular (convention) |\n",
    "| `100` | ✅ | सामान्य use |\n",
    "| `999` | ✅ | जुनसुकै number चल्छ |\n",
    "\n",
    "> 💡 **नियम:** जुनसुकै positive integer राख्न मिल्छ।  \n",
    "> **42** सबैभन्दा popular छ किनभने यो **\"The Hitchhiker's Guide to the Galaxy\"** बाट आएको culture हो।  \n",
    "> मुख्य कुरा — **project भरि एउटै number** सधैँ राख्नु!\n",
    "\n",
    "---\n",
    "\n",
    "### `random_state` को 3 वटा मुख्य फाइदा\n",
    "\n",
    "```\n",
    "1. Reproducibility  →  उही code = उही result (कुनै पनि computer मा)\n",
    "2. Debugging        →  गल्ती खोज्न सजिलो (data same भएकाले)\n",
    "3. Fair Comparison  →  दुई model को result compare गर्न सकिन्छ\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "---\n",
    "\n",
    "## 🔁 Backpropagation र Randomness\n",
    "\n",
    "### Backpropagation भनेको के हो?\n",
    "\n",
    "```\n",
    "Forward Pass:\n",
    "  Input → Hidden Layers → Output → Prediction\n",
    "\n",
    "Error Calculate:\n",
    "  Prediction vs Actual Answer → Loss/Error निकाल्छ\n",
    "\n",
    "Backward Pass (Backpropagation):\n",
    "  Error लाई पछाडि फर्काउँछ → हरेक weight कति गल्ती भयो हिसाब गर्छ → Weight Update\n",
    "```\n",
    "\n",
    "> Backpropagation ले model लाई **गल्तीबाट सिक्न** मद्दत गर्छ।\n",
    "\n",
    "---\n",
    "\n",
    "### Backpropagation मा कहाँ-कहाँ Randomness आउँछ?\n",
    "\n",
    "Backpropagation मा **random_state एउटा मात्र होइन** — धेरै ठाउँमा randomness हुन्छ:\n",
    "\n",
    "---\n",
    "\n",
    "#### 1️⃣ Weight Initialization (सुरुको weights)\n",
    "\n",
    "```python\n",
    "# Model सुरु हुँदा weights randomly set हुन्छन्\n",
    "# random_state नराखेको खण्डमा — हरपटक फरक weights\n",
    "model = MLPClassifier(hidden_layer_sizes=(100,))  # ❌ random weights\n",
    "\n",
    "# random_state राखेको खण्डमा — उही weights बाट सुरु\n",
    "model = MLPClassifier(hidden_layer_sizes=(100,), random_state=42)  # ✅\n",
    "```\n",
    "\n",
    "> सुरुको weights फरक भए → training को बाटो फरक → **final result फरक**\n",
    "\n",
    "---\n",
    "\n",
    "#### 2️⃣ Data Split को Randomness (`train_test_split`)\n",
    "\n",
    "```python\n",
    "# यहाँ पनि random_state राख्नुपर्छ\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, Y, \n",
    "    test_size=0.2, \n",
    "    random_state=42  # ← यो\n",
    ")\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "#### 3️⃣ Mini-Batch को Randomness (SGD)\n",
    "\n",
    "```python\n",
    "# Stochastic Gradient Descent मा data randomly shuffle हुन्छ\n",
    "# प्रत्येक epoch मा फरक order मा data आउँछ\n",
    "model = SGDClassifier(random_state=42)  # ← यहाँ पनि राख्नुपर्छ\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "#### 4️⃣ Dropout को Randomness (Neural Network मा)\n",
    "\n",
    "```python\n",
    "# Training मा randomly केही neurons बन्द हुन्छन्\n",
    "# random_state नराखेको खण्डमा हरपटक फरक neurons बन्द हुन्छन्\n",
    "model = MLPClassifier(random_state=42)  # ← control हुन्छ\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "### के Backpropagation को लागि random_state change गर्दै जानुपर्छ?\n",
    "\n",
    "```\n",
    "❌ गलत सोच:  random_state = 1, 2, 3 ... बदल्दै जानुपर्छ\n",
    "✅ सही सोच:   एउटै random_state सधैँ राख्नुपर्छ\n",
    "```\n",
    "\n",
    "**किन?**\n",
    "\n",
    "```python\n",
    "# ❌ गलत तरिका — random_state बदल्दै जाने\n",
    "for i in range(10):\n",
    "    model = MLPClassifier(random_state=i)  # हरपटक फरक\n",
    "    model.fit(X_train, y_train)\n",
    "    # यसले model compare गर्न गाह्रो बनाउँछ\n",
    "\n",
    "# ✅ सही तरिका — एउटै राख्ने\n",
    "model = MLPClassifier(random_state=42)   # fix गर्ने\n",
    "model.fit(X_train, y_train)              # Backpropagation आफैँ handle गर्छ\n",
    "```\n",
    "\n",
    "> Backpropagation ले आफ्नै algorithm अनुसार weights update गर्छ —  \n",
    "> **random_state बदल्नु पर्दैन, बरु fix गर्नु पर्छ!**\n",
    "\n",
    "---\n",
    "\n",
    "### Backpropagation आफैँ के-के adjust गर्छ?\n",
    "\n",
    "```\n",
    "random_state fix गरेपछि Backpropagation ले automatically:\n",
    "\n",
    "├── Learning Rate  →  कति ठूलो step लिने हिसाब गर्छ\n",
    "├── Gradient       →  कुन direction मा जाने निर्धारण गर्छ  \n",
    "├── Weights        →  हरेक epoch मा update गर्छ\n",
    "└── Bias           →  model लाई flexible बनाउन adjust गर्छ\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## 📋 सम्पूर्ण Randomness Summary\n",
    "\n",
    "| कहाँ | के गर्छ | कसरी fix गर्ने |\n",
    "|:---|:---|:---|\n",
    "| `train_test_split` | Data split | `random_state=42` |\n",
    "| `MLPClassifier` | Weight initialization | `random_state=42` |\n",
    "| `SGDClassifier` | Data shuffle (mini-batch) | `random_state=42` |\n",
    "| `RandomForest` | Tree building | `random_state=42` |\n",
    "| `KMeans` | Cluster center initialization | `random_state=42` |\n",
    "\n",
    "> 💡 **Golden Rule:** जहाँ-जहाँ `random_state` parameter छ — **उही number** राख्नुस्!\n",
    "\n",
    "---\n",
    "\n",
    "## 🎯 Final सार\n",
    "\n",
    "```\n",
    "random_state राख्नुको कारण:\n",
    "  → Result reproducible हुन्छ\n",
    "  → Debugging सजिलो हुन्छ\n",
    "  → Fair comparison हुन्छ\n",
    "\n",
    "random_state को number:\n",
    "  → जुनसुकै integer चल्छ\n",
    "  → 42 सबैभन्दा popular\n",
    "  → Project भरि एउटै राख्नुस्\n",
    "\n",
    "Backpropagation को लागि:\n",
    "  → random_state बदल्नु पर्दैन\n",
    "  → एकपटक fix गरेपछि Backpropagation आफैँ सिक्छ\n",
    "  → Weight, Gradient, Learning Rate सबै automatic\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c09197a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X_train,'\\n')\n",
    "print(X_test,'\\n')\n",
    "print(y_train,'\\n')\n",
    "print(y_test,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5fd7da5",
   "metadata": {},
   "outputs": [],
   "source": [
    ", random_state=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48d6d7a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "shuffle=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dff77f4a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa397161",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "data = pd.read_csv(\"\")\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcb3d0ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = data[['sepal_length','sepal_width','petal_length','petal_width']]\n",
    "y = data['species']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3db567e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.2, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c6a0542",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(X_train,'\\n')\n",
    "print(X_test,'\\n')\n",
    "print(y_train,'\\n')\n",
    "print(y_test,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4123eb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "data.describe()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}