प्रस्तावना: 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) पर इसे ट्रेन कर सकते हैं।

प्रेडिक्शन कैसे की जाती है? (Advanced Predictive Modeling)

3.1 ओवरफिटिंग और अंडरफिटिंग (Overfitting vs Underfitting)

• Underfitting: जब मॉडल डेटा से कुछ भी नहीं सीख पाता और बहुत खराब प्रदर्शन करता है। (जैसे बिना पढ़े परीक्षा देना)।
• Overfitting: जब मॉडल ट्रेनिंग डेटा को 'रट' लेता है लेकिन नए डेटा पर फेल हो जाता है। (जैसे केवल पुराने प्रश्न पत्र रटना लेकिन कांसेप्ट न समझना)।

इन समस्याओं से बचने के लिए हम Ensemble Models (कई मॉडल्स का समूह) का उपयोग करते हैं, जैसे रैंडम फॉरेस्ट।

3.2 रैंडम फॉरेस्ट (Random Forest) कैसे काम करता है?

रैंडम फॉरेस्ट एक क्लासिफिकेशन एल्गोरिदम है जो एक नहीं, बल्कि सैकड़ों Decision Trees (निर्णय वृक्षों) का निर्माण करता है। अंत में, यह सभी पेड़ों के उत्तरों का "बहुमत" (Majority Vote) लेकर अंतिम भविष्यवाणी करता है। इससे सटीकता (Accuracy) बहुत बढ़ जाती है।

3.3 व्यावहारिक उदाहरण: Bank Loan Approval System

आइए एक रैंडम फॉरेस्ट मॉडल बनाएं जो यह तय करेगा कि किसी ग्राहक का लोन अप्रूव होना चाहिए या रिजेक्ट।

Python
from sklearn.ensemble import RandomForestClassifier
import pandas as pd

# 1. डेटासेट: [Credit Score, Income (रु), Loan Amount (रु)]
# Labels: 1 = Approved, 0 = Rejected
data = [
    [750, 50000, 10000],  # Good score, decent income -> Approved
    [600, 30000, 20000],  # Low score, high loan -> Rejected
    [800, 80000, 15000],  # Excellent score -> Approved
    [550, 25000, 30000],  # Poor score -> Rejected
    [710, 40000, 10000]   # Fair score -> Approved
]
labels = [1, 0, 1, 0, 1]

# 2. Random Forest मॉडल (जिसमें 10 Decision Trees हैं)
rf_model = RandomForestClassifier(n_estimators=10, random_state=42)
rf_model.fit(data, labels)

# 3. नए ग्राहक का डेटा
# नया ग्राहक: Credit Score=680, Income=45000, Loan Requested=12000
new_applicant = [[680, 45000, 12000]]

# 4. बैंक के लिए भविष्यवाणी
prediction = rf_model.predict(new_applicant)
if prediction[0] == 1:
    print("Result: Loan Approved ✅")
else:
    print("Result: Loan Rejected ❌")

3.4 टेक दिग्गज और प्रेडिक्टिव AI की प्रगति (How Tech Giants are Progressing)

प्रेडिक्टिव मॉडलिंग के क्षेत्र में दुनिया की शीर्ष तकनीकी कंपनियाँ (Tech Giants) लगातार नवाचार (Innovation) कर रही हैं। उनका मुख्य लक्ष्य प्रेडिक्शन को अधिक सटीक, तेज़ और हर रोज़ के उपयोग के अनुकूल बनाना है।

• Google (DeepMind): Google ने AlphaFold जैसे प्रोजेक्ट्स के जरिए बायोलॉजी में क्रांति ला दी है, जो प्रोटीन की संरचना की भविष्यवाणी (Prediction) करता है। इसके अलावा, Google Maps का ट्रैफ़िक प्रेडिक्शन और YouTube का रिकमेंडेशन सिस्टम दुनिया के सबसे एडवांस प्रेडिक्टिव मॉडल्स पर चलते हैं।
• Amazon (AWS): ई-कॉमर्स में Amazon का प्रेडिक्टिव सिस्टम इतना एडवांस है कि वे अक्सर आपके ऑर्डर करने से पहले ही आपके नजदीकी वेयरहाउस में सामान भेज देते हैं (Anticipatory Shipping)। वे AWS SageMaker के जरिए अन्य कंपनियों को भी प्रेडिक्टिव AI टूल्स दे रहे हैं।
• Microsoft & OpenAI: Microsoft अपने Azure क्लाउड और OpenAI के साथ मिलकर बिजनेस एनालिटिक्स में प्रेडिक्शन को जोड़ रहा है। Copilot जैसे टूल्स अब सिर्फ कोड या टेक्स्ट ही नहीं लिखते, बल्कि सेल्स डेटा और मार्केट ट्रेंड्स की भी सटीक भविष्यवाणी कर सकते हैं।
• Tesla: टेस्ला का सेल्फ-ड्राइविंग (Autopilot) सिस्टम पूरी तरह से रियल-टाइम प्रेडिक्शन पर निर्भर है। कार का AI लगातार भविष्यवाणी करता है कि अगले सेकंड में पैदल चलने वाला इंसान या दूसरी गाड़ी क्या करेगी।

इंसानों की भाषा को कैसे समझ पाता है? (Natural Language Processing - NLP)

4.1 Transformers और Attention Mechanism

GPT (Generative Pre-trained Transformer) जैसे आधुनिक मॉडल Attention Mechanism का उपयोग करते हैं। इसका मतलब है कि AI किसी वाक्य को पढ़ते समय यह समझ सकता है कि वाक्य के किस शब्द का संबंध किस दूसरे शब्द से सबसे अधिक है। इसी वजह से AI लंबे वाक्यों का सटीक संदर्भ (Context) समझ पाता है।

4.2 व्यावहारिक उदाहरण 1: उन्नत Sentiment Analysis Pipeline

यहाँ हम एक पूरी पाइपलाइन बनाते हैं जो कच्चे टेक्स्ट को साफ करेगी, उसे नंबरों में बदलेगी, और फिर मशीन लर्निंग के जरिए उसकी भावना (Sentiment) का अनुमान लगाएगी।

Python
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline

# डेटा (Reviews) और लेबल्स (1 = Positive, 0 = Negative)
reviews = [
    "The product quality is absolutely stunning and I love it.",
    "Worst experience ever, totally a waste of my hard-earned money.",
    "Highly recommended, customer support works perfectly fine!",
    "Very bad delivery and broken item arrived."
]
labels = [1, 0, 1, 0]

# Pipeline: TF-IDF (Vectorization) -> Logistic Regression (Classification)
model_pipeline = make_pipeline(TfidfVectorizer(), LogisticRegression())
model_pipeline.fit(reviews, labels)

# टेस्ट करने के लिए नया वाक्य
test_review = ["I am somewhat disappointed with the battery life."]
pred = model_pipeline.predict(test_review)
print("Sentiment:", "Positive" if pred[0] == 1 else "Negative")

4.3 व्यावहारिक उदाहरण 2: मॉडर्न AI टेक्स्ट जनरेशन (Hugging Face)

आजकल हम AI को शुरुआत से नहीं बनाते। हम Hugging Face जैसी ओपन-सोर्स लाइब्रेरी का उपयोग करते हैं। नीचे दिया गया कोड GPT-2 मॉडल का उपयोग करके स्वयं एक कहानी या लेख लिखता है।

Python
from transformers import pipeline

# 1. टेक्स्ट जनरेशन (Text Generation) पाइपलाइन इनिशियलाइज़ करना
# यह इंटरनेट से GPT-2 मॉडल डाउनलोड करेगा (पहली बार चलाने पर)
generator = pipeline("text-generation", model="gpt2")

# 2. AI को एक शुरुआती विचार (Prompt) देना
prompt = "Artificial Intelligence will change the future of education because"

# 3. AI से आगे की कहानी लिखवाना (अधिकतम 40 शब्द)
response = generator(prompt, max_length=40, num_return_sequences=1, truncation=True)

print("--- AI Generated Text ---")
print(response[0]['generated_text'])

मास्टर प्रोजेक्ट: स्पैम फ़िल्टर (End-to-End AI Postman)

5.1 प्रोजेक्ट का उद्देश्य (The Goal)

हम एक ऐसा AI बनाना चाहते हैं जो किसी भी नए ईमेल को पढ़कर यह बता सके कि वह 'Spam' (कचरा/धोखा) है या 'Ham' (ज़रूरी ईमेल)। इसमें हम उन सभी 4 स्टेप्स का उपयोग करेंगे जो हमने पिछले चैप्टर्स में सीखे हैं।

5.2 सभी 4 स्टेप्स एक साथ (The 4-Step Process)

स्टेप 1: डेटा कलेक्शन (Chapter 1)

सबसे पहले हमें AI को सिखाने के लिए पुराना डेटा चाहिए। हम हज़ारों पुराने ईमेल लेंगे जिन्हें इंसानों ने पहले ही 'Spam' या 'Ham' लेबल किया हुआ है।

स्टेप 2: भाषा को समझना / NLP (Chapter 4)

AI सीधे अंग्रेज़ी या हिंदी नहीं पढ़ सकता। इसलिए हम NLP (जैसे TF-IDF) का उपयोग करके ईमेल के शब्दों को नंबरों (Vectors) में बदलेंगे। (उदा: 'Lottery', 'Free', 'Click' जैसे शब्दों को अधिक अहमियत मिलेगी)।

स्टेप 3: पैटर्न खोजना (Chapter 2)

अब हमारा अल्गोरिदम (जैसे Random Forest) उन नंबरों में पैटर्न खोजेगा। वह सीखेगा कि जब भी किसी ईमेल में 'Free' और 'Money' शब्द एक साथ आते हैं, तो 99% चांस है कि वह स्पैम है।

स्टेप 4: नई प्रेडिक्शन करना (Chapter 3)

जब ट्रेनिंग पूरी हो जाएगी, तो हम AI को एक बिल्कुल नया ईमेल देंगे जो उसने पहले कभी नहीं देखा। वह सीखे गए पैटर्न्स के आधार पर तुरंत अपनी भविष्यवाणी (Prediction) देगा।

5.3 पूरा कोड एक साथ (The Complete Python Code)

Python
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import make_pipeline

# --- स्टेप 1: डेटा ---
# 1 = Spam, 0 = Ham (Normal)
emails = [
    "Congratulations! You won a $1000 Walmart gift card. Click here to claim.",
    "Hey John, are we still meeting for lunch tomorrow at 1 PM?",
    "URGENT: Your bank account has been locked. Verify your password immediately!",
    "Please find the attached project report for this week.",
    "Get 50% off on all shoes today only! Free shipping."
]
labels = [1, 0, 1, 0, 1]

# हम डेटा को ट्रेन और टेस्ट में बांटते हैं
X_train, X_test, y_train, y_test = train_test_split(emails, labels, test_size=0.2, random_state=42)

# --- स्टेप 2 और 3: NLP + पैटर्न रिकग्निशन (पाइपलाइन) ---
# TfidfVectorizer शब्दों को नंबरों में बदलेगा (NLP)
# RandomForest पैटर्न पहचानेगा (ML)
ai_postman = make_pipeline(TfidfVectorizer(), RandomForestClassifier(random_state=42))

# AI को सिखाना (Training)
ai_postman.fit(X_train, y_train)

# --- स्टेप 4: नई प्रेडिक्शन (Deployment) ---
print("--- AI Postman Live Testing ---")

new_inbox = [
    "Hi Mom, I will be late for dinner today.",
    "YOU ARE THE LUCKY WINNER! Reply with your bank details to get 1 Million Dollars."
]

predictions = ai_postman.predict(new_inbox)

for email, pred in zip(new_inbox, predictions):
    result = "🚨 SPAM" if pred == 1 else "✅ NORMAL"
    print(f"\nEmail: '{email}'")
    print(f"AI Prediction: {result}")