प्रस्तावना: AI की जादुई दुनिया में आपका स्वागत है

आजकल हर जगह Artificial Intelligence (AI) की चर्चा है। चाहे वह ChatGPT हो, जो इंसानों की तरह बात करता है, या Tesla की कारें जो खुद चलती हैं—ऐसा लगता है जैसे हम भविष्य में जी रहे हैं। लेकिन क्या यह कोई जादू है? बिलकुल नहीं। AI पूरी तरह से डेटा (Data) और गणित (Mathematics) पर आधारित एक तकनीक है।

यह किताब किसके लिए है?

यह किताब उन सभी के लिए लिखी गई है जो AI के पीछे के विज्ञान को आसान भाषा (हिंदी) में समझना चाहते हैं। आपको पहले से किसी कोडिंग या मशीन लर्निंग की जानकारी होने की आवश्यकता नहीं है। यदि आप एक छात्र हैं, एक प्रोफेशनल हैं, या केवल एक जिज्ञासु व्यक्ति हैं जो यह जानना चाहते हैं कि "कंप्यूटर कैसे सोचते हैं", तो यह किताब आपके लिए है।

हम क्या सीखेंगे?

इस सफर में हम AI के मुख्य स्तंभों को कवर करेंगे:

• Chapter 1: AI डेटा से कैसे सीखता है (Machine Learning)
• Chapter 2: कंप्यूटर दुनिया को कैसे देखता है (Computer Vision & Deep Learning)
• Chapter 3: AI भविष्यवाणियां कैसे करता है (Predictive Modeling)
• Chapter 4: कंप्यूटर इंसानी भाषा को कैसे समझता है (NLP & ChatGPT)
• Chapter 5: एक वास्तविक प्रोजेक्ट (Spam Filter) बनाकर इन सभी चीजों को एक साथ जोड़ना।

AI डेटा से कैसे सीखता है? (Machine Learning Fundamentals)

1.1 मशीन लर्निंग के प्रकार (Types of Machine Learning)

मशीन लर्निंग में कंप्यूटर को खुद ब खुद डेटा से सीखने की क्षमता दी जाती है। इसके मुख्य तीन प्रकार हैं:

• Supervised Learning (सुपरवाइज्ड लर्निंग): हम AI को इनपुट डेटा के साथ सही आउटपुट (Labels) भी देते हैं। इसका लक्ष्य इनपुट से आउटपुट तक एक मैपिंग फंक्शन खोजना है। जैसे - घर का क्षेत्रफल (इनपुट) और घर की कीमत (आउटपुट)।
• Unsupervised Learning (अनसुपरवाइज्ड लर्निंग): इसमें AI को केवल इनपुट डेटा दिया जाता है। AI स्वयं डेटा के अंदर के पैटर्न्स और संरचनाओं (Structures) को खोजता है। जैसे - ग्राहकों को उनके खरीदारी के तरीके के आधार पर समूहों (Clusters) में बांटना।
• Reinforcement Learning (रीइन्फोर्समेंट लर्निंग): यह एक इनाम-दंड (Reward-Penalty) प्रणाली पर आधारित है। AI एक पर्यावरण (Environment) में क्रियाएं (Actions) करता है और अपनी गलतियों से सीखकर एक नीति (Policy) बनाता है। सेल्फ-ड्राइविंग कारें (Self-driving cars) इसी तकनीक का उपयोग करती हैं।

1.2 डेटा को तैयार करना (Data Preparation)

इंडस्ट्री में 80% समय डेटा को साफ (Clean) करने और तैयार करने में जाता है। मॉडल में डालने से पहले डेटा से खाली मान (Null values) हटाना, उसे एक स्केल (Normalization) पर लाना और ट्रेनिंग व टेस्टिंग सेट्स (Train/Test Split) में विभाजित करना आवश्यक है।

1.3 व्यावहारिक उदाहरण 1: सुपरवाइज्ड लर्निंग (House Price Prediction)

यहाँ हम Multiple Linear Regression का उपयोग करेंगे जो एक सुपरवाइज्ड लर्निंग अल्गोरिदम है। हम घर के 'Area' और 'Bedrooms' के आधार पर 'Price' की भविष्यवाणी करेंगे।

Python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

# 1. डेटासेट तैयार करना
data = {
    'Area_sqft': [800, 1500, 1200, 2000, 950, 1800],
    'Bedrooms': [2, 3, 2, 4, 2, 3],
    'Price_Lakhs': [45, 85, 65, 110, 55, 95]
}
df = pd.DataFrame(data)

# 2. Features (इनपुट X) और Labels (आउटपुट y)
X = df[['Area_sqft', 'Bedrooms']] 
y = df['Price_Lakhs']             

# 3. डेटा को Training (80%) और Testing (20%) में बांटना
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 4. मॉडल को ट्रेन करना (सीखना)
model = LinearRegression()
model.fit(X_train, y_train)

# 5. टेस्टिंग डेटा पर भविष्यवाणी करना
predictions = model.predict(X_test)
print(f"Actual Price: {y_test.values[0]} Lakhs")
print(f"AI Prediction: {predictions[0]:.2f} Lakhs")

1.4 व्यावहारिक उदाहरण 2: अनसुपरवाइज्ड लर्निंग (Customer Clustering)

अब एक ऐसा उदाहरण देखते हैं जहाँ हमारे पास कोई लेबल (आउटपुट) नहीं है। हम ई-कॉमर्स ग्राहकों को उनकी 'आय' और 'खर्च' के आधार पर K-Means Clustering का उपयोग करके 2 समूहों में बांटेंगे।

Python
from sklearn.cluster import KMeans

# डेटा: [वार्षिक आय (Income in K), खर्च स्कोर (Spending Score 1-100)]
customers = [
    [15, 39], [15, 81], # कम आय वाले
    [16, 6],  [16, 77], 
    [120, 90], [130, 85], # उच्च आय, उच्च खर्च वाले
    [125, 95], [110, 80]
]

# AI को बिना लेबल के 2 ग्रुप्स (Clusters) बनाने के लिए कहना
kmeans = KMeans(n_clusters=2, random_state=42, n_init=10)
kmeans.fit(customers)

# AI ने किस ग्राहक को किस ग्रुप में रखा?
labels = kmeans.labels_
print("AI द्वारा बनाए गए Customer Groups (0 और 1):")
print(labels)

(नोट: AI ने सफलतापूर्वक पहले 4 ग्राहकों को एक ग्रुप '1' में और अंतिम 4 अमीर ग्राहकों को ग्रुप '0' में डाल दिया, बिना हमारी किसी मदद के!)

पैटर्न कैसे पहचानता है? (Deep Learning & Computer Vision)

2.1 कंप्यूटर इमेजेज को कैसे समझते हैं?

कम्प्यूटर को रंग या चेहरे नहीं दिखाई देते। एक तस्वीर उनके लिए सिर्फ संख्याओं का एक 3D मैट्रिक्स (3D Matrix) है—जिसमें ऊँचाई (Height), चौड़ाई (Width), और 3 कलर चैनल्स (Red, Green, Blue) होते हैं। हर पिक्सल का मान 0 से 255 तक होता है।

2.2 CNNs (Convolutional Neural Networks)

छवियों (Images) में पैटर्न पहचानने के लिए सामान्य न्यूरल नेटवर्क के बजाय CNN का उपयोग किया जाता है। इसमें खास परतें होती हैं:

• Convolutional Layers: ये परतें छवि पर छोटे 'फिल्टर्स' (Filters) चलाती हैं जो किनारों (Edges), रेखाओं (Lines) और आकृतियों को पहचानते हैं।
• Pooling Layers: ये परतें डेटा का आकार कम (Down-sample) करती हैं ताकि गणना तेज़ हो सके और सबसे महत्वपूर्ण फीचर्स को ही आगे भेजा जाए।

2.3 व्यावहारिक उदाहरण 1: CNN के साथ MNIST Digit Recognition

आइए एक पूर्ण CNN आर्किटेक्चर बनाते हैं जो हाथों से लिखे अंकों (0-9) को 99% तक की सटीकता से पहचान सकता है।

Python
import tensorflow as tf
from tensorflow.keras import layers, models

# 1. डेटा लोड करना और रीशेप (Reshape) करना (CNN के लिए 3D आकार आवश्यक है)
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape((60000, 28, 28, 1)) / 255.0
x_test = x_test.reshape((10000, 28, 28, 1)) / 255.0

# 2. CNN आर्किटेक्चर डिज़ाइन करना
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)), # Edge Detection
    layers.MaxPooling2D((2, 2)),                                         # Pooling
    layers.Conv2D(64, (3, 3), activation='relu'),                        # Complex Features
    layers.MaxPooling2D((2, 2)),
    layers.Flatten(),                                                    # 2D से 1D में बदलना
    layers.Dense(64, activation='relu'),                                 # Fully Connected Layer
    layers.Dense(10, activation='softmax')                               # 10 Classes (0-9)
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
print("Training CNN...")
# model.fit(x_train, y_train, epochs=3) # Training command

2.4 एडवांस ट्रांसफर लर्निंग (Transfer Learning) का तकनीकी सिद्धांत

डीप लर्निंग इंडस्ट्री में हम शायद ही कभी मॉडल्स को शून्य (Scratch) से ट्रेन करते हैं। इसके बजाय, हम Transfer Learning का उपयोग करते हैं। इसका मतलब है किसी विशाल डेटासेट (जैसे ImageNet, जिसमें 1.2 मिलियन तस्वीरें हैं) पर पहले से ट्रेन किए गए मॉडल (जैसे ResNet50 या MobileNetV2) के "ज्ञान" (Weights & Biases) का उपयोग किसी नए और छोटे टास्क के लिए करना।

ट्रांसफर लर्निंग कैसे काम करता है? (How it Works)

एक CNN मॉडल के मुख्य रूप से दो हिस्से होते हैं:

1. Convolutional Base (फीचर एक्सट्रैक्टर): यह मॉडल का निचला हिस्सा होता है जो रंग, किनारे (Edges) और जटिल आकृतियों को पहचानना सीखता है।
2. Classifier Head: यह अंतिम लेयर होती है जो इन आकृतियों के आधार पर आउटपुट (जैसे - क्या यह कार है?) तय करती है।

ट्रांसफर लर्निंग में हम प्री-ट्रेन्ड मॉडल के Classifier Head को हटा देते हैं और उसकी जगह अपने नए टास्क के अनुसार एक नया (Randomly Initialized) Head लगा देते हैं। इसके बाद हम दो रणनीतियों (Strategies) का उपयोग कर सकते हैं:

• Feature Extraction (फ्रीजिंग): इसमें हम Convolutional Base के वेट्स को लॉक (Freeze: trainable = False) कर देते हैं। हम केवल नए Classifier Head को ट्रेन करते हैं। यह तब उपयोगी होता है जब हमारे पास डेटा कम हो।
• Fine-Tuning (फाइन-ट्यूनिंग): जब हमारा नया मॉडल थोड़ा स्थिर हो जाता है, तो हम Base की कुछ ऊपरी लेयर्स को अनफ्रीज़ (Unfreeze) करते हैं और बहुत कम लर्निंग रेट (Low Learning Rate) के साथ पूरे मॉडल को फिर से ट्रेन करते हैं, ताकि वह हमारे विशिष्ट डेटा के अनुकूल हो सके।

व्यावहारिक कोड उदाहरण (Feature Extraction with MobileNetV2)

नीचे दिए गए कोड में हम Google के MobileNetV2 मॉडल का उपयोग कर रहे हैं। हम इसके बेस को फ्रीज करके एक नया क्लासिफायर (Classifier) जोड़ेंगे।

Python
import tensorflow as tf
from tensorflow.keras.applications import MobileNetV2
import numpy as np

# 1. Google का प्री-ट्रेन्ड मॉडल लोड करना
# include_top=False का मतलब है कि हम पुराना Classifier Head हटा रहे हैं
base_model = MobileNetV2(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# 2. Feature Extraction: बेस मॉडल को 'Freeze' करना ताकि उसका पुराना ज्ञान नष्ट न हो
base_model.trainable = False

# 3. नया Classifier Head जोड़ना
model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(2, activation='softmax') # मान लीजिए हम केवल 2 क्लास (Cat vs Dog) क्लासिफाई कर रहे हैं
])

# 4. मॉडल को कंपाइल करना
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
print("Transfer Learning Model is ready for training on new data!")

# अब आप model.fit() का उपयोग करके अपने नए डेटा (जैसे Cat vs Dog) पर इसे ट्रेन कर सकते हैं।