AI Kaise Seekhain

Chapter 1: AI kya hai aur kya nahi?

AI ki asaan tareef

Artificial Intelligence (AI) computer ko aisa banane ka naam hai jo woh kaam kar sake jin ke liye aam tor par insani zehanat chahiye hoti hai: dekhna, sunna, samajhna, faisla karna aur seekhna. Computer ko har qadam likh kar dene ke bajaye hum usay data dete hain aur woh khud pattern seekhta hai.

AI, ML, DL: kaun kis ke andar hai?

AI ka mukhtasar safar

• 1956: "Artificial Intelligence" lafz pehli baar istemal hua.
• 1997: IBM Deep Blue ne shatranj ke champion Kasparov ko haraya.
• 2012: Deep Learning ne image pehchan mein bara inqilab layaa.
• 2017: Transformer architecture aaya, jis par aaj ke LLMs bane hain.
• 2022 ke baad: Generative AI aam logon tak pohanch gayi.

Gehrai mein: computer "seekhta" kaise hai?

Aam programming aur Machine Learning ka asal farq yeh hai ke rules kaun likhta hai.

AI ke 3 buniyadi ajza

• Data: khaam maal. Jitna saaf aur zyada, utna behtar.
• Algorithm: seekhne ka tareeqa (recipe).
• Compute: hisaab ki taqat (CPU/GPU), yaani chulha.

Khana pakane ki tarah: ghalat ajza hon to behtareen recipe bhi kharab khana banati hai. Isi liye AI mein "ganda data, ganda nateeja" mashhoor jumla hai.

AI ki qismein (salahiyat ke lihaz se)

Bohat se log aaj ke LLMs ko AGI ki taraf qadam samajhte hain aur kuch nahi. Yeh behes abhi jari hai, is liye aap ko sirf itna yaad rakhna hai ke jo AI aaj istemal hoti hai woh Narrow AI hai.

AI aaj kahan istemal hoti hai?

Interactive Q/A

Khulasa: AI bara dayra hai, ML us ka hissa, DL ML ka, aur LLMs DL par bane hain. AI data se seekhti hai, rules se nahi.

Chapter 2: AI Career Map

Har role ka aik din

Dekhein: har role mein baat karna aur samjhana bhi utna hi ahem hai jitna code likhna.

Skills ka overlap: pehlay kya seekhein?

✓ bohat zaroori, ~ thora bohat, - kam zaroorat. Natija: Python aur SQL taqreeban har rasta mein common hain, is liye sab se pehlay yehi seekhein, role baad mein bhi chun sakte hain.

Role kaise chunein? 3 sawal

1. Mujhe data se kahaniyan nikalna pasand hai, ya cheezein bana kar chalana?
2. Meri maujooda skills kya hain (Excel, coding, tajurba)?
3. Agle 6 mahine mein mujhe kya chahiye: pehli job, freelancing ya research?

Interactive Q/A

Khulasa: Har role ka rasta alag hai, lekin Python aur data ki samajh sab mein common hai.

Chapter 3: Apna Rasta Chunain

Self-assessment: 3 sawal

Har rasta ke pehle 30 din

Seekhne ke 3 marahil

1. Samajhna: concept parhna ya dekhna.
2. Banana: khud code likhna ya chhota project banana.
3. Samjhana: jo seekha usay apne alfaz mein likhna ya kisi ko batana.

Aksar log sirf pehlay marhale par rukay rehte hain. Jab tak aap doosray aur teesray marhale tak na pohnchein, concept pakka nahi hota.

Apni progress kaise napein?

• Hafte mein kitne ghantay practice ki?
• Mahine mein kitne chhote projects mukammal kiye?
• Kya main bina dekhe aik chhota program likh sakta hoon?
• Aik chhoti diary mein rozana 3 line likhein: aaj kya seekha, kahan atka.

Interactive Q/A

Khulasa: Apni haisiyat dekh kar rasta chunain, aur rozana ka waqt tay karein. Agla hissa Python se shuru hota hai.

Chapter 4: Programming (Python)

Python hi kyun?

AI ki lagbhag saari libraries (NumPy, Pandas, PyTorch, scikit-learn) Python mein hain. Is ki zubaan angrezi jaisi saaf hai, is liye beginners ke liye behtareen hai. Install ki fikar chorein: Google Colab browser mein chalta hai aur bilkul free hai.

Pehla program

naam = "Ali"
marks = [70, 85, 90]
average = sum(marks) / len(marks)
print(naam, "ka average:", average)

Yahan naam aik variable hai (text), marks aik list hai (kai values), aur sum, len Python ke apne functions hain. Natija: Ali ka average: 81.67 ke qareeb.

Faisla aur dohrana

def grade(avg):
    if avg >= 80:
        return "A"
    return "B"

for m in marks:
    print(m, "marks")
print("Grade:", grade(average))

Data types: Python data ko kaise pehchanti hai

Kisi bhi cheez ki type dekhne ke liye type(x) likhein. Python mein "5" (text) aur 5 (number) mukhtalif hain, aur bohat se errors isi farq se aate hain.

List aur dict gehrai se

marks = [70, 85, 90]
print(marks[0])      # 70 (ginti 0 se shuru hoti hai)
print(marks[-1])     # 90 (aakhri value)
marks.append(60)     # naya jorna
print(marks[1:3])    # [85, 90] (slicing: index 1 se 3 se pehlay tak)
print(len(marks))    # 4

ghar = {"area": 1200, "rooms": 3}
print(ghar["area"])  # 1200
ghar["age"] = 5      # nayi cheez jorna

Misal se samjhein: list line mein khaday log hain (aap number se bulate hain: "pehla, doosra"). dict aik diary hai jis mein aap naam se dhoondte hain ("area kitna hai?").

Faisla: if, elif, else

avg = 72
if avg >= 80:
    print("A")
elif avg >= 60:
    print("B")      # avg 72 hai, is liye yahan "B" chhape ga
else:
    print("C")

Python upar se neeche shartein check karta hai. Jo pehli shart sahi nikle, woh chalti hai aur baaqi chhor di jati hain. Is liye shartein bari se chhoti tarteeb mein likhein.

Dohrana: for aur while

for i in range(3):
    print("Din", i + 1)      # Din 1, Din 2, Din 3

count = 0
while count < 3:
    print(count)
    count += 1               # count barhana na bhoolein

for: jab pata ho kitni baar karna hai ya list ki har cheez par. while: jab tak shart sahi rahe. Agar while mein count += 1 bhool gaye to loop kabhi khatam nahi hota (infinite loop).

Code ko line by line chalayein (dry run)

Jab code samajh na aaye to kagaz par har line ke baad variables ki value likhein. Marks calculator ka dry run:

Errors se na ghabrayein

Error aaye to aakhri line sab se pehlay parhein, wahan batata hai kya masla hai aur kaun si line. Phir bhi samajh na aaye to apna code aur error dono kisi AI assistant ya search se poochein. Yeh bilkul aam tareeqa hai, is mein sharam ki koi baat nahi.

AI ke liye Python ka ghar

List aur dict se data rakha jata hai, loop se har row par kaam hota hai, function se code saaf rehta hai. Agle chapters mein NumPy aur Pandas yehi kaam hazaron guna tez karte hain, is liye yeh buniyad pakki karna zaroori hai.

Interactive Q/A

Khulasa: Python AI ki zubaan hai. Variables, list, loop aur function pakkay kar lein, baaqi sab inhi par bana hai.

Chapter 5: Math for AI (asaan zubaan mein)

Ghabrayen nahi. Practical AI ke liye 4 cheezain chahiye, aur woh bhi sirf us had tak jitni zaroorat hai.

1. Linear Algebra: data ko numbers ki list banana

Computer ko sab kuch numbers mein chahiye. Aik vector numbers ki list hai, aur matrix unki table.

import numpy as np
ghar = np.array([1200, 3, 5])
wazan = np.array([0.02, 1.5, -0.3])
print(ghar @ wazan)   # 27.0

2. Probability: yaqeen ka andaza

Probability 0 se 1 ke darmiyan hoti hai. 0.9 ka matlab "90% imkan". Model aksar jawab ke sath yeh bhi batata hai: "yeh email 95% spam hai."

3. Statistics: data ko samajhna

• Mean: average. Median: bichli value (bohat bari values se kam mutasir hoti hai).
• Standard deviation: data kitna phailaa hua hai.

4. Calculus: seekhna kaise hota hai

Model ki ghalti (loss) ko kam karna hi seekhna hai. Gradient bata'ta hai ke ghalti kis taraf kam hogi, bilkul pahaar se neeche utarne ki tarah. Is tareeqay ko Gradient Descent kehte hain.

Gradient Descent aankhon se dekhein (numbers ke sath)

Maan lein ghalti ka formula loss = (w - 3)² hai. Is ka sab se kam point w = 3 par hai, lekin model ko yeh pata nahi. Woh 0 se shuru karta hai aur slope (gradient) dekh kar qadam leta hai. Slope ka formula 2 × (w - 3) hai, aur learning rate = 0.1 (qadam ka size).

Dekhein: w har qadam par 3 ke qareeb ja raha hai, aur jaise jaise qareeb aata hai slope chhota hota jata hai, is liye qadam bhi chhotay hotay jatay hain. Yehi neural network ki training hai, bas w ki jagah lakhon weights hotay hain.

Matrix aur vector: kai gharon ka score aik sath

Pehlay hum aik ghar ka score nikal rahe thay. Matrix mein har row aik ghar hai, aur multiply karne se sab gharon ke score aik hi baar mein mil jatay hain.

import numpy as np
X = np.array([[1000, 2, 10],     # ghar 1
              [1500, 3, 2]])     # ghar 2
wazan = np.array([0.02, 1.5, -0.3])
print(X @ wazan)                 # [20.  33.9]

Ghar 2 ka hisaab: 1500×0.02 + 3×1.5 + 2×(-0.3) = 30 + 4.5 - 0.6 = 33.9. Neural network ki har layer asal mein yehi matrix multiplication hai.

Probability aur Bayes: ek asaan example

Maan lein 20% emails spam hain. "lottery" lafz 90% spam mein aata hai aur sirf 5% aam emails mein. Agar kisi email mein "lottery" ho to spam hone ka imkan kitna hai?

Standard deviation: data kitna phailaa hua hai

Do classes ke average marks 80 hain. Class A: 70, 80, 90. Class B: 79, 80, 81. Average wohi hai, lekin A mein farq zyada hai.

• Class A: average se farq -10, 0, +10. Un ke squares 100, 0, 100. Un ka average 66.7. Jad (square root) taqreeban 8.2.
• Class B: farq -1, 0, +1. Squares 1, 0, 1. Average 0.67. Jad taqreeban 0.8.

Chhota standard deviation matlab data average ke qareeb jama hai, bara matlab phailaa hua. ML mein isi se pata chalta hai ke features ka scale kitna mukhtalif hai (Chapter 10).

Math AI mein kahan lagti hai? (khulasa table)

Interactive Q/A

Khulasa: Vector data hai, probability yaqeen hai, statistics samajh hai, aur gradient seekhne ka rasta hai.

Chapter 6: Data ke Tools

Aik AI engineer ka zyada waqt data saaf karne mein jata hai, model banane mein kam. Is liye yeh tools pakke karna zaroori hai.

Pandas ka example

import pandas as pd
df = pd.read_csv("sales.csv")
print(df.head())                 # pehli 5 rows
df = df.dropna()                 # khali rows hatao
print(df.groupby("category")["amount"].sum())
df.groupby("category")["amount"].sum().plot(kind="bar")

SELECT category, SUM(amount)
FROM sales
GROUP BY category;

Yeh SQL query wohi kaam database mein karti hai.

NumPy: list se tez aur zyada samajhdar

import numpy as np
a = np.array([10, 20, 30])
print(a * 2)          # [20 40 60]  (har cheez 2 se multiply)
print([10, 20, 30] * 2)   # [10, 20, 30, 10, 20, 30]  (aam list dohrati hai!)
print(a.mean(), a.sum())  # 20.0 60
print(a.reshape(3, 1).shape)  # (3, 1)

NumPy ka bara faida vectorization hai: poore array par aik hi hukm se kaam, bina loop ke. Yeh lakhon numbers par bohat tez chalta hai. shape bata'ta hai array kitni rows aur columns ka hai, aur ML mein shape ke errors bohat aam hain, is liye usay hamesha print kar ke dekhein.

Pandas gehrai se

Maan lein sales ka data yeh hai:

groupby("category")["amount"].sum() same category ki rows jama kar deta hai: Electronics = 1200, Clothes = 500.

df["amount"]                       # aik column
df[["category", "amount"]]         # kai columns
df[df["amount"] > 400]             # sirf woh rows jahan amount 400 se zyada
df["tax"] = df["amount"] * 0.1     # naya column
df.sort_values("amount", ascending=False)
df.drop_duplicates()               # dohrayi hui rows hatana
df.describe()                      # mean, min, max wagaira

Pandas ka kaam aksar yehi hota hai: chunna (select), chhanna (filter), naya banana, group karna, aur saaf karna.

Matplotlib: sahi chart chunein

import matplotlib.pyplot as plt
data = df.groupby("category")["amount"].sum()
plt.bar(data.index, data.values)
plt.title("Category ke hisaab se sales")
plt.xlabel("Category"); plt.ylabel("Rupay")
plt.show()

Hamesha chart ka title aur axes ke naam likhein, warna dekhne wala samajh nahi paye ga.

SQL gehrai se

SELECT category, SUM(amount) AS total
FROM sales
WHERE amount > 100
GROUP BY category
ORDER BY total DESC;

Tarteeb se parhein: SELECT kya chahiye, FROM kahan se, WHERE kaun si rows, GROUP BY kis ke hisaab se group, ORDER BY tarteeb. Jab do tables milani hon to JOIN istemal hota hai, maslan orders aur customers ko customer_id se jorna.

Git aur GitHub ke buniyadi qadam

git init                       # folder ko Git project banana
git add .                      # tabdeeliyan tayyar karna
git commit -m "pehla version"  # tabdeeliyon ko save karna (record)
git push                       # GitHub par bhejna

Git ko aap code ka "save game" samjhein. Har commit aik checkpoint hai jahan aap wapas ja sakte hain. GitHub par push karne se aap ka kaam online save hota hai aur portfolio ban jata hai. Pehlay hafte mein bas yeh 4 commands pakkay kar lein.

Interactive Q/A

Khulasa: Colab mein kaam, Pandas se data, Matplotlib se chart, SQL se database, aur Git se code ka record. Yeh teen hafton mein seekhay ja sakte hain.

Chapter 7: ML ka Buniyadi Concept

Machine Learning mein hum computer ko rules nahi, misalein dete hain. Woh un se pattern seekhta hai aur naye data par andaza lagata hai.

Supervised ki do aam qismein hain: Regression (number batana, jaise qeemat) aur Classification (category batana, jaise spam ya nahi).

ML ka workflow

Features aur Label: ML ki zubaan

ML mein har table ke columns do hisson mein baante jate hain: Features (jo hum dete hain) aur Label / Target (jo model ko batana hai).

Pehli teen columns features hain (aam tor par X likhte hain), aakhri column label hai (y). Pehli do rows mein jawab maujood hai (training data), teesri row mein model ko jawab batana hai.

Training andar se kya hoti hai?

1. Model ek andaza lagata hai (shuru mein lagbhag random).
2. Andaze ko asal jawab se compare kar ke loss (ghalti) nikalta hai.
3. Gradient Descent (Chapter 5) se weights thore theek karta hai.
4. Yeh hazaron baar dohrata hai jab tak ghalti kam na ho jaye.

Asal maqsad: naye data par achha chalna

Model ko is liye nahi banate ke woh purani misalon par sahi ho, balkay is liye ke naye, unsen data par sahi chale. Ise generalization kehte hain. Misal: aik student jo sirf pichlay saal ka paper ratta laga le, naya paper aane par fail ho jata hai. Jo student concept samajhta hai, woh naye sawalat bhi hal karta hai.

Kab ML istemal NA karein?

Har masle ke liye ML zaroori nahi hota. Aik achha engineer pehlay yeh sochta hai ke kya aasan hal kaafi hai.

Interactive Q/A

Khulasa: ML misalon se seekhta hai. Qism aur workflow samajh lein to har project ka nakshah saaf ho jata hai.

Chapter 8: Core Algorithms

Har algorithm gehrai se

1. Linear Regression. Data mein aisi seedhi lakeer dhoondta hai jo points ke sab se qareeb ho: qeemat = w × area + b. Chapter mein diye gaye data (800→40, 1000→50, 1200→60, 1500→75) mein w = 0.05 (har sq ft par 0.05 lakh) aur b = 0 nikalta hai. Model ki ghalti ko MSE (Mean Squared Error) se napte hain: har jawab ki ghalti ka square le kar average. Training ka maqsad MSE kam karna hai.

2. Logistic Regression. Naam mein regression hai lekin yeh classification karta hai. Yeh aik number nikalta hai aur usay sigmoid function se 0 aur 1 ke darmiyan imkan (probability) mein badal deta hai. Agar imkan 0.5 se zyada ho to "haan", warna "nahi".

from sklearn.linear_model import LogisticRegression
X = [[1], [2], [3], [8], [9], [10]]      # parhai ke ghantay
y = [0, 0, 0, 1, 1, 1]                   # 0 = fail, 1 = pass
m = LogisticRegression().fit(X, y)
print(m.predict_proba([[5]]))            # [[fail ka imkan, pass ka imkan]]

3. Decision Tree. Sawalon ka darakht: har qadam par woh sawal poochta hai jo data ko sab se saaf do hisson mein baante. Masla: agar darakht bohat gehra ho jaye to data ratt leta hai (overfitting). Hal: gehrai hadd mein rakhein.

from sklearn.tree import DecisionTreeClassifier
tree = DecisionTreeClassifier(max_depth=3)   # max 3 sawal gehra

4. Random Forest. Aik darakht ki jagah bohat se (maslan 100) alag trees banata hai, har aik data ke thore alag hisse par, aur sab ki raye (voting) se faisla karta hai. Misal: 100 doctors ki raye aik doctor se zyada bharose ki hoti hai. Isi liye yeh aksar pehli pasand hai.

from sklearn.ensemble import RandomForestClassifier
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)
clf = RandomForestClassifier(n_estimators=100, random_state=42).fit(X_tr, y_tr)
print(clf.score(X_te, y_te))      # test par accuracy

5. KNN (K-Nearest Neighbors). Naye point ke K sab se qareebi saathiyon ko dekhta hai aur unki aksariyat ki raye leta hai. Agar K=3 aur 3 mein se 2 qareebi ghar mehnge hain, to naya ghar bhi mehnga mana jata hai. Dhyan: KNN doori napta hai, is liye features ko aik scale par laana zaroori hai (Chapter 10).

6. K-Means. Bina label ke groups banata hai:

1. K markaz (center) randomly chunta hai.
2. Har point ko sab se qareebi markaz ka member bana deta hai.
3. Har group ka naya markaz us ke members ka average bana deta hai.
4. Qadam 2 aur 3 tab tak dohrata hai jab tak groups na badlein.

7. PCA. Kai features ko kam features mein is tarah compress karta hai ke zyada tar maloomat bach jaye. Misal: aik bari tasveer ko chhota kar dena lekin shakl samajh aati rahe. Visualization aur sust models ko tez karne mein kaam aata hai.

Kaun sa algorithm kab?

Mashwara: hamesha pehlay sab se saada model chalayein, phir pechida models se muqabla karein. Agar saada model kaafi hai to pechida ki zaroorat nahi.

Pehla model

from sklearn.linear_model import LinearRegression
X = [[800], [1000], [1200], [1500]]   # area
y = [40, 50, 60, 75]                  # qeemat (lakh)
model = LinearRegression().fit(X, y)
print(model.predict([[1100]]))        # 55 ke qareeb

Sirf 3 lines: fit se model seekhta hai, predict se andaza deta hai. Baaqi algorithms ka dhancha bhi yehi hai.

Interactive Q/A

Khulasa: Pehle Linear/Logistic Regression aur Random Forest seekhein. In se aam masail hal ho jate hain.

Chapter 9: Model Evaluation

Train/Test split

Model ko jis data par seekhaya, usi par jaanchna aisa hai jaise imtihan ka paper pehlay hi bata dena. Is liye data ko do hissay karte hain: Train (seekhne ke liye, aam tor par 80%) aur Test (jaanchne ke liye, 20%).

Overfitting aur Underfitting

• Underfitting: model bohat saada, train aur test dono par kharab.
• Overfitting: model ne data ratt liya, train par bohat achha lekin test par kharab.

Classification ke metrics

Precision aur Recall: kab kaun ahem?

• Precision: model ne jinhein "haan" kaha, un mein se kitne sach mein "haan" thay? Spam filter mein yeh ahem hai: aap ki zaroori email spam mein nahi jani chahiye.
• Recall: jitne asal "haan" thay, un mein se kitne model ne pakray? Bimari ki screening mein yeh ahem hai: koi mareez chhootna nahi chahiye, chahe kuch ghalat alarm ho.

Dono mein tawazun hota hai: model ko zyada sakht karein to precision barhti hai magar recall girti hai, aur ulta. F1 dono ka balance hai. Is example mein: F1 = 2 × 0.80 × 0.889 / (0.80 + 0.889) ≈ 0.84.

Number batane wale models (regression) ke metrics

Asal qeematein 50, 60, 70 aur model ke andaze 52, 58, 75 hon to ghaltiyan 2, 2, 5 hain.

MAE samajhna asaan hai: "average andaza 3 lakh ghalat hai". Agar aik bhi bohat bari ghalti nuqsan deh ho to RMSE dekhein.

Cross-validation: sirf aik split par bharosa na karein

Aik hi train/test split ittifaq se achha ya bura ho sakta hai. 5-fold cross-validation mein data ko 5 hisson mein baantte hain. Har baar aik hissa test hota hai aur baaqi 4 train, yoon 5 nateejay milte hain, aur unka average aap ka asal andaza hota hai.

from sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X, y, cv=5)
print(scores, scores.mean())

Overfitting se bachne ke tareeqay

• Zyada data jama karna.
• Model ko saada rakhna (maslan tree ki gehrai kam karna).
• Regularization (weights ko bohat bara hone se rokna).
• Cross-validation se jaanchna.
• Zaroori na features hata dena.

Interactive Q/A

Khulasa: Hamesha test data par jaanchein, aur sirf accuracy par bharosa na karein.

Chapter 10: Feature Engineering aur Data Cleaning

Kehte hain: "Garbage in, garbage out." Ganda data hoga to behtareen algorithm bhi kharab nateeja de ga.

df["age"] = df["age"].fillna(df["age"].median())
df = pd.get_dummies(df, columns=["city"])
df["price_per_ft"] = df["price"] / df["area"]
from sklearn.preprocessing import StandardScaler
df[["area"]] = StandardScaler().fit_transform(df[["area"]])

Khali values (missing data) ka hal

Zyada outliers hon to median behtar hai (Chapter 5).

Outliers (be-tuki bari ya chhoti values) pehchanna

Data: 50, 52, 53, 55, 500. IQR tareeqa: Q1 (25%) = 52, Q3 (75%) = 55, farq IQR = 3. Upar ki had = Q3 + 1.5 × IQR = 59.5. Is se bari har value outlier hai, yahan 500.

Q1, Q3 = df["price"].quantile([0.25, 0.75])
iqr = Q3 - Q1
upar = Q3 + 1.5 * iqr
neeche = Q1 - 1.5 * iqr
print(df[(df["price"] > upar) | (df["price"] < neeche)])   # outliers dekhein

Outlier ko foran na hatayen. Pehlay dekhein ke woh typing ki ghalti hai (hatayen/theek karein) ya asal cheez (maslan bohat mehnga ghar, jo rakhna chahiye).

Scaling kyun aur kaise?

Area 1000 ke qareeb hai aur kamray 3 ke qareeb. Bina scaling ke KNN aur Gradient Descent wale models bare numbers ko zyada ahmiyat de dete hain. StandardScaler har value ko (x - average) / standard deviation mein badalta hai. Misal: marks 70, 80, 90 (average 80, SD 8.2) ban jatay hain ≈ -1.2, 0, +1.2.

• StandardScaler: average 0 aur SD 1 (aam pasand).
• MinMaxScaler: sab values 0 se 1 ke darmiyan.

Encoding ki do qismein

• One-Hot: jab category mein tarteeb na ho (shehr: Lahore, Karachi).
• Ordinal / Label: jab tarteeb ho (chhota=0, darmiyana=1, bara=2).

Naye features banana

Maujooda columns se naye maani wale columns banana aksar model ko sab se zyada faida deta hai:

• Tareekh se mahina, din, ya "weekend hai ya nahi".
• price_per_ft = price / area (qeemat per sq ft).
• Do columns ka jor ya farq (maslan kul kamray = bedrooms + bathrooms).

Data cleaning ki checklist

1. df.info() aur df.describe() se data ko samjhein.
2. Dohrayi hui rows hatayen (drop_duplicates).
3. Khali values ka faisla karein.
4. Outliers dekhein.
5. Text ko numbers mein badlein (encoding).
6. Train/test split karein.
7. Phir scaling (sirf train se seekh kar).

Interactive Q/A

Khulasa: Behtar data aksar behtar algorithm se zyada fayda deta hai.

Chapter 11: Pehla Real Project, Ghar ki Qeemat

Maqsad: area, kamray aur umar se ghar ki qeemat predict karna. Dataset Kaggle par "house prices" naam se mil jaye ga, columns area, rooms, age, price rakh lein.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error

df = pd.read_csv("house.csv").dropna()          # 1. data + safai
X = df[["area", "rooms", "age"]]               # 2. features
y = df["price"]                                # 3. target
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)
model = LinearRegression().fit(X_tr, y_tr)     # 4. training
print("Ausat ghalti:", mean_absolute_error(y_te, model.predict(X_te)))  # 5. jaanch

Aage kya karein?

• RandomForestRegressor se muqabla karein, kaun behtar hai?
• Naye features (shehr, location) shamil karein.
• Project GitHub par daalein aur README mein natija likhein.

Code ki har line ka matlab

Nateeja kaise parhein?

Agar Ausat ghalti: 4.2 aaye aur qeemat lakh mein ho, to model average 4.2 lakh ghalat hai. Yeh achha hai ya bura? Is ke liye baseline se muqabla karein: sab se saada model jo hamesha average qeemat batata hai.

from sklearn.dummy import DummyRegressor
base = DummyRegressor().fit(X_tr, y_tr)
print("Baseline ghalti:", mean_absolute_error(y_te, base.predict(X_te)))

Agar aap ka model baseline se bohat behtar hai (maslan 4.2 versus 15), to model ne kuch seekha hai. Agar farq bohat kam hai to model kaam ka nahi.

Model ne har feature ko kitna wazan diya, yeh bhi dekh sakte hain:

print(pd.Series(model.coef_, index=X.columns))

Misal ke tor par area = 0.05 ka matlab hai: baaqi cheezein barabar hon to har aik sq ft barhne par qeemat taqreeban 0.05 lakh barhti hai. Agar age ka wazan manfi (negative) ho to purana ghar sasta hota hai, jo samajh mein aata hai.

Aam masail aur unka hal

Model behtar kaise banayen

1. Outliers jaanchein aur theek karein.
2. Naye features banayen (shehr, qeemat per sq ft).
3. RandomForestRegressor se muqabla karein.
4. cross_val_score se nateeja mazboot karein (Chapter 9).

README ka dhancha

# Ghar ki qeemat ka andaza
Masla: area, kamray aur umar se qeemat predict karna.
Data: Kaggle house prices (X rows)
Tareeqa: LinearRegression, 80/20 split
Nateeja: MAE = 4.2 lakh (baseline 15 lakh)
Hadood: sirf aik shehr ka data, outliers ka asar
Chalane ka tareeqa: pip install pandas scikit-learn, notebook chalayein

Interactive Q/A

Khulasa: Data se model tak ka poora safar aap ne tay kar liya. Ab aap ML ki buniyad par kharay hain.

Chapter 12: Neural Networks

Neural Network insani dimagh se mutasir aik structure hai: bohat se chhote "neurons" jo aik doosray se jure hotay hain. Har neuron aik chhota sa hisaab karta hai, aur jab hazaron milte hain to woh pechida pattern pakar lete hain.

Aik neuron kya karta hai?

Wohi jo Chapter 5 mein dekha: inputs ko wazan (weights) se multiply karna, jama karna, aur phir aik activation function se guzarna. Activation function network ko seedhi lakeer se aagay pechida shaklein seekhne ke qabil banata hai (maslan ReLU manfi numbers ko 0 kar deta hai).

Network seekhta kaise hai?

• Forward pass: input se output tak andaza.
• Loss: andaze aur asal jawab ka farq.
• Backpropagation: ghalti ko peechay ki taraf bhej kar batana ke har weight ne kitni ghalti ki.
• Gradient Descent: weights ko thora sa theek karna. Yeh poora chakkar hazaron baar dohrata hai.

Aik neuron ka hisaab (numbers ke sath)

Maan lein aik neuron ke inputs x = [2, 3], weights w = [0.5, -1] aur bias b = 1 hain. Bias aik extra number hai jo neuron ko shift karne deta hai.

Activation functions ki qismein

Hidden layers kyun? Digit pehchanne ki misal

Aik 28×28 tasveer 784 numbers hoti hai. Network ki pehli hidden layer chhoti lakeerein aur kinare pakarti hai, agli layer unhein jor kar goley (loops) aur seedhi lakeerein banati hai, aur aakhri layer inse digit pehchanti hai ("goley aur seedhi lakeer = 9"). Yani har layer pichli layer se bara concept banati hai. Isi liye "deep" (gehra) learning kehte hain.

Network ke parameters gino

Chapter mein bane network (3 input, 4 hidden, 2 output) mein: 3×4 + 4×2 = 20 weights aur 4 + 2 = 6 biases, kul 26 parameters. Aaj ke bare LLMs mein yeh tadad arbon tak hoti hai, aur training mein sab ko theek karna parta hai.

Training ki zaroori istilahat

• Epoch: poore training data par aik mukammal guzar.
• Batch: data ka chhota hissa jis par aik baar weights theek hotay hain. 1000 samples aur batch size 100 ho to aik epoch mein 10 updates hotay hain.
• Learning rate: qadam ka size (Chapter 5).

Neural network ka overfitting

Bare networks data ratt lene mein bohat maahir hotay hain. Dropout training ke dauran kuch neurons ko randomly band kar deta hai taake network kisi aik raste par nirbhar na ho. Early stopping tab training rok deti hai jab validation ghalti barhne lage.

Interactive Q/A

Khulasa: Neural network = weights wale neurons ki layers. Seekhna = andaza, ghalti, backpropagation, weights ki durusti, aur yeh dohrana.

Chapter 13: Frameworks, PyTorch aur TensorFlow/Keras

Mashwara: beginner Keras se shuru kare, phir PyTorch bhi seekhe. Aaj ki research aur LLM duniya mein PyTorch ka istemal zyada hai.

Keras mein

from tensorflow import keras
model = keras.Sequential([
    keras.layers.Dense(16, activation="relu", input_shape=(3,)),
    keras.layers.Dense(1)])
model.compile(optimizer="adam", loss="mse")
model.fit(X_train, y_train, epochs=20)

PyTorch mein

import torch, torch.nn as nn
model = nn.Sequential(nn.Linear(3, 16), nn.ReLU(), nn.Linear(16, 1))
opt = torch.optim.Adam(model.parameters(), lr=0.01)
for epoch in range(20):
    loss = nn.functional.mse_loss(model(X), y)
    opt.zero_grad(); loss.backward(); opt.step()

Keras ki har line ka matlab

Loss aur aakhri layer ka sahi jora

Yeh jora ghalat ho to model theek se seekhta nahi aur nateeja ajeeb aata hai. Beginners ki sab se aam ghaltiyon mein se hai.

Shape: sab se aam error ki wajah

Neural network mein data hamesha ek tay shape mein jata hai: (kitni rows, kitne features). 100 gharon ke 3 features ki shape (100, 3) hai. Agar network 3 features ki umeed rakhta ho aur aap 4 de dein to shape error aata hai. Hamesha print(X.shape) karein.

PyTorch loop qadam ba qadam

X = torch.tensor(X_np, dtype=torch.float32)          # numpy se tensor
y = torch.tensor(y_np, dtype=torch.float32).view(-1, 1)   # shape (rows, 1)

for epoch in range(20):
    pred = model(X)                         # 1. andaza (forward pass)
    loss = nn.functional.mse_loss(pred, y)  # 2. ghalti
    opt.zero_grad()                         # 3. purane gradients saaf
    loss.backward()                         # 4. backpropagation
    opt.step()                              # 5. weights theek
    if epoch % 5 == 0: print(epoch, loss.item())

zero_grad() isliye zaroori hai ke PyTorch gradients ko jama karta rehta hai, aur har round se pehlay purane saaf karne parte hain.

Model save aur load karna

model.save("model.keras")                         # Keras
loaded = keras.models.load_model("model.keras")

torch.save(model.state_dict(), "model.pt")        # PyTorch (sirf weights)

Model train karne mein ghantay lag sakte hain, is liye hamesha save karein taake dobara train na karna pare, aur deployment (Chapter 23) mein yehi file istemal hoti hai.

Interactive Q/A

Khulasa: Keras se jaldi shuru karein, PyTorch se gehri samajh banayen.

Chapter 14: CNN, Computer Vision

Tasveer pixels (numbers) ki table hoti hai. CNN (Convolutional Neural Network) chhote chhote filters ko poori tasveer par sarka kar patterns dhoondta hai: pehlay kinare aur lakeerein, phir aankh aur naak, aakhir mein poora chehra.

• Convolution: filter se patterns (kinare, shakl) nikalna.
• Pooling: tasveer chhoti kar ke sirf ahem cheez rakhna.
• Flatten + Dense: aakhir mein faisla karna ke yeh kya hai.

Aam tasks

Tasveer computer ke liye kya hai?

• Grayscale tasveer: numbers ki aik table, har pixel 0 (kala) se 255 (safaid). 28×28 ki tasveer = 784 numbers.
• Rangeen tasveer: 3 tables (Red, Green, Blue), yaani shape (height, width, 3).

Convolution aik chhoti misal se

Filter aik chhoti 3×3 table hai jo tasveer ke upar sarakti hai. Har jagah woh milte hue numbers ko multiply kar ke jama karta hai. Yeh filter upar se neeche brightness ka farq (horizontal kinara) pakarta hai:

Filter:  [ 1  1  1]       Patch A (kinara):  [9 9 9]
         [ 0  0  0]                          [5 5 5]
         [-1 -1 -1]                          [1 1 1]

Patch A: (9+9+9)×1 + 0 + (1+1+1)×(-1) = 27 - 3 = 24   (bara number: kinara mila)
Patch B (sapaat, sab 5): 15 + 0 - 15 = 0              (kinara nahi)

CNN mein aise bohat se filters hotay hain aur woh khud seekhte hain ke kaun se patterns kaam ke hain. Pehle filters kinare pakarte hain, aagay wale shaklein aur cheezein.

Pooling aur stride

Max pooling (2×2): har 2×2 hissay se sab se bari value rakhta hai. [[1, 3], [2, 4]] se 4 bachta hai. Is se tasveer chhoti hoti hai magar sab se ahem cheez bachi rehti hai. Stride filter ke sarakne ka qadam hai (stride 2 matlab 2 pixel ka qadam, is se output chhota hota hai).

Seedha Dense network tasveer ke liye kyun nahi?

28×28 ki chhoti tasveer ke liye bhi Dense layer ko har pixel se har neuron ka alag weight chahiye, bohat zyada parameters. Aur agar digit thora sa kisi aur jagah ho to naya masla. CNN mein aik hi filter poori tasveer par istemal hota hai, is liye parameters kam hotay hain aur cheez kahin bhi ho pehchani jati hai.

Data augmentation: zyada tasveerein banana

Agar tasveerein kam hon to unhein ulta karke, thora ghuma kar ya zoom kar ke nayi misalein banayi jati hain. Model ko ek cheez alag alag shakl mein dekhne ka mauqa milta hai aur overfitting kam hoti hai.

Transfer learning: bana banaya model istemal karein

Chhoti dataset ho to model shuru se train karna zaroori nahi. Pehle se lakhon tasveeron par train hua model (jaise MobileNet) le kar sirf aakhri hissa apne kaam ke liye train karein.

base = keras.applications.MobileNetV2(include_top=False,
        input_shape=(224, 224, 3), weights="imagenet")
base.trainable = False        # purani seekhi hui cheezein na bigaren
model = keras.Sequential([base,
        keras.layers.GlobalAveragePooling2D(),
        keras.layers.Dense(2, activation="softmax")])   # apni 2 categories

Is tareeqay se thori tasveeron aur kam waqt mein bhi achha nateeja mil jata hai, isi liye asal projects mein yehi sab se aam hai.

Interactive Q/A

Khulasa: CNN tasveer ko filters se parhta hai: pehlay chhoti shaklein, phir bari cheezein.

Chapter 15: RNN/LSTM aur Sequence Data

Kuch data mein tarteeb ahem hoti hai: jumla, stock ki qeemat, awaaz, mausam. "Ali ne Ahmed ko maara" aur "Ahmed ne Ali ko maara" ke alfaz wohi hain magar matlab ulta.

• RNN: sequence ko aik aik cheez kar ke parhta hai. Masla: lambay jumlon mein shuru ki baat bhool jata hai.
• LSTM: RNN ka behtar rup jis mein "gates" hotay hain jo tay karte hain kya yaad rakhna hai aur kya bhoolna hai.

RNN qadam ba qadam

RNN har qadam par do cheezein leta hai: naya input aur pichli yaaddasht (hidden state). In se naya hidden state banata hai, jo agle qadam ko jata hai. Jumla "Main kal Lahore gaya" ke liye: "Main" parha, yaaddasht banayi. "kal" aaya to "Main" ki yaaddasht ke sath mila kar nayi yaaddasht, aur isi tarah aage. Aakhir tak ki yaaddasht mein poore jumle ka khulasa hota hai.

RNN ki kamzori: yaaddasht phiki par jati hai

Kisi se kisi tak sargoshi karte hue 50 logon ki qatar sochein. Pehle shakhs ki baat aakhri tak pohanchte pohanchte bigar jati hai. Isi tarah lambay sequences mein RNN shuru ki baat bhool jata hai, kyun ke training mein gradient peechay jate hue bohat chhota ho jata hai (vanishing gradient).

LSTM ke teen "gates"

LSTM ko aik notebook samjhein jis mein woh tay karta hai kya likhna aur kya mitana hai:

• Forget gate: purani yaaddasht mein se kya bhoolna hai?
• Input gate: naye input mein se kya yaad rakhna hai?
• Output gate: abhi ki yaaddasht mein se kya bahar dena hai?

Isi system se LSTM lambay sequences mein ahem baatein sambhal kar rakhta hai.

Time-series ko model ke liye tayyar karna

Sales ke data (roz ki aik value) ko "window" mein torte hain: pichle 7 din input, agla din label.

import numpy as np
def windows(data, n=7):
    X, y = [], []
    for i in range(len(data) - n):
        X.append(data[i:i+n]); y.append(data[i+n])
    return np.array(X), np.array(y)

X, y = windows(np.arange(30), 7)    # misal ke tor par 0 se 29
print(X.shape, y.shape)             # (23, 7) (23,)

model = keras.Sequential([
    keras.layers.LSTM(32, input_shape=(7, 1)),
    keras.layers.Dense(1)])
# X ko (23, 7, 1) shape mein reshape kar ke fit karein

Interactive Q/A

Khulasa: Sequence data mein tarteeb ahem hai. RNN/LSTM ne yeh sikhaya, aur Transformers ne ise agle darjay par pohancha diya.

Chapter 16: Project, Image Classifier

Dataset: MNIST (70,000 tasveerein, 28×28 pixels). Keras ke sath khud download ho jata hai, is liye Colab mein seedha chalayen.

from tensorflow import keras
(x_tr, y_tr), (x_te, y_te) = keras.datasets.mnist.load_data()
x_tr = (x_tr / 255.0).reshape(-1, 28, 28, 1)
x_te = (x_te / 255.0).reshape(-1, 28, 28, 1)

model = keras.Sequential([
    keras.layers.Conv2D(32, 3, activation="relu", input_shape=(28, 28, 1)),
    keras.layers.MaxPooling2D(),
    keras.layers.Flatten(),
    keras.layers.Dense(10, activation="softmax")])
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
model.fit(x_tr, y_tr, epochs=3, validation_split=0.1)
print(model.evaluate(x_te, y_te))

Aage badhayen

• Aik aur Conv2D layer lagayen, accuracy dekhein.
• Apni haath se likhi tasveer par prediction karwayen.
• MNIST ke baad Kaggle ka "cats vs dogs" dataset try karein.

Training ka output kaise parhein?

fit har epoch ke baad kuch is tarah ke numbers dikhata hai (yeh sirf misal hai, aap ke nateeje thore mukhtalif honge):

Epoch 1/3  accuracy: 0.92  val_accuracy: 0.97
Epoch 2/3  accuracy: 0.98  val_accuracy: 0.98
Epoch 3/3  accuracy: 0.99  val_accuracy: 0.98

• accuracy: training data par sahi jawab ka hissa.
• val_accuracy: validation data (jo model ne train nahi kiya) par accuracy. Asal tasveer yeh hai.
• Dono barhein to sab theek. Training barhe aur validation ruk jaye ya gire to overfitting.

Aik tasveer par prediction dekhna

import numpy as np, matplotlib.pyplot as plt
probs = model.predict(x_te[:1])             # 10 digits ka imkan
print("Andaza:", np.argmax(probs), "Asal:", y_te[0])
plt.imshow(x_te[0].reshape(28, 28), cmap="gray"); plt.show()

probs 10 numbers ki list hai jin ka jama 1 hota hai (softmax). argmax sab se bara imkan wala digit batata hai.

Model kahan ghalti karta hai?

from sklearn.metrics import confusion_matrix
pred = np.argmax(model.predict(x_te), axis=1)
print(confusion_matrix(y_te, pred))

Is 10×10 table mein diagonal par sahi jawab hain, baaqi ghaltiyan. Aam tor par model 4 aur 9, ya 3 aur 5 jaisay milte julte digits mein ghalti karta hai. Kahan ghalti ho rahi hai yeh jaan'na model behtar karne ka pehla qadam hai.

Model behtar banana

model = keras.Sequential([
    keras.layers.Conv2D(32, 3, activation="relu", input_shape=(28, 28, 1)),
    keras.layers.MaxPooling2D(),
    keras.layers.Conv2D(64, 3, activation="relu"),
    keras.layers.MaxPooling2D(),
    keras.layers.Flatten(),
    keras.layers.Dropout(0.3),                 # overfitting kam karne ke liye
    keras.layers.Dense(10, activation="softmax")])

Dusri Conv2D layer zyada pechida shaklein seekhti hai aur Dropout overfitting rokta hai. Phir fit kar ke val_accuracy se pehlay wale model ke sath muqabla karein.

Apni haath se likhi tasveer par try karein

1. Safaid kagaz par kala/gehra marker se aik digit likhein, tasveer khenchein.
2. Tasveer ko 28×28 grayscale mein badlein (Pillow library se).
3. MNIST mein digit safaid aur background kala hota hai, is liye apni tasveer ke rang ulte karein.
4. 255 se divide kar ke (1, 28, 28, 1) shape mein predict karein.

Aksar pehli koshish mein nateeja kharab aata hai kyun ke aap ki tasveer aur MNIST ki tasveeron mein farq hota hai. Yeh khud data ke farq ka masla samajhne ka behtareen tareeqa hai: model sirf wohi seekhta hai jo usay training mein dikhaya gaya.

Interactive Q/A

Khulasa: Aap ne ab ML aur Deep Learning dono ke project kar liye hain. Agla hissa wohi hai jis ne dunya badal di: LLMs aur Generative AI.

Chapter 17: Transformers aur Attention

LLM (Large Language Model) asal mein aik bohat bara Transformer network hai jo aik hi kaam seekhta hai: agla token (lafz ka hissa) kya hoga? Bohat sa text parh kar yeh andaza itna behtar ho jata hai ke model jawab likhna, translate karna aur code likhna seekh leta hai.

Model text ko kaise dekhta hai?

• Tokenization: text ko chhote tukron (tokens) mein torna.
• Embedding: har token ko numbers ki list (vector, Chapter 5) bana dena jo us ka matlab pakarti hai.
• Attention: har lafz dekhta hai ke jumle ke kaun se doosray lafz us ke liye ahem hain.
• Output: agle token ki probability, phir aik chun kar dohrana.

Model kaise tayyar hota hai?

Token: model ke liye text ki ikai

Model alfaz nahi, tokens dekhta hai. Aik token poora lafz, lafz ka hissa, ya sirf aik nishan ho sakta hai. Maslan "Machine learning" aam tor par 2 tokens mein toot jata hai. Angrezi ka aam lafz aksar aik token hota hai, jabke Roman Urdu aur Urdu aksar zyada tokens mein toot jate hain. Is liye wohi baat Urdu mein likhne par context window zyada istemal hoti hai aur API ka kharcha bhi zyada ho sakta hai.

Embedding: lafz ka matlab numbers mein

Har token ko numbers ki aik lambi list (vector) mil jati hai. Milte julte matlab wale lafzon ke vectors qareeb hotay hain ("ghar" aur "makan"), aur alag matlab walay door. Mashhoor misal: "badshah" − "mard" + "aurat" ≈ "malika". Matlab vectors mein rishte bhi chhupe hotay hain.

Attention gehrai se: Query, Key, Value

Kutub khane ki misal lein. Aap ka Query hai "mujhe kisi bimari ki kitab chahiye". Har kitab ke upar aik Key (label) hai, aur andar ka maazmoon Value. Aap apne query ko har label se milate hain (dot product, Chapter 5), jo zyada milta ho us ko zyada number milta hai. Phir softmax (Chapter 12) in numbers ko wazan banata hai jin ka jama 1 ho, aur aap sab kitabon ke maazmoon ko un wazan ke hisaab se mila lete hain.

Jumle "Billi ne doodh piya kyunke woh bhooki thi" mein "woh" apna query bana kar baaqi alfaz ki keys se milata hai, "Billi" ki key sab se zyada milti hai, isliye "woh" ka matlab billi se bhar jata hai. Transformer mein yeh kaam multi-head attention ke zariye kai alag nazariyon (heads) se hota hai, maslan aik head grammar dekhta hai aur doosra matlab.

Jawab kaise banta hai: ek ek token

Sawal "Pakistan ki rajdhani ___" par model har mumkin agle token ko imkan deta hai, maslan Islamabad 95%, Lahore 3%, Karachi 1%. Phir aik token chuna jata hai, jawab mein jur jata hai, aur poora jumla dobara model ko input ban kar jata hai. Yeh chakkar jawab khatam hone tak chalta hai.

Temperature chunao ko control karta hai: kam temperature par model sab se mumkin lafz chunta hai (mehfooz, mustaqil jawab), zyada temperature par kam imkan wale lafz bhi chun leta hai (zyada takhleeqi, magar ghalti ka khatra zyada).

Context window aur "bhool jana"

Model sirf utna dekh sakta hai jitna context window mein aaye. Bohat lambi guftagu mein shuru ki baatein bahar nikal sakti hain ya kam wazan paati hain. Isi liye lambi chat mein kabhi kabhi model purani baat bhool jata hai, aur zaroori baatein dobara likhna mufeed hota hai.

Hallucination kyun hoti hai?

Model ko "agla lafz kya hoga" sikhaya gaya hai, "sach kya hai" nahi. Jahan usay jawab nahi aata wahan bhi woh bahaa'o mein sahi lagne wala jawab bana deta hai. Is liye aham facts hamesha khud verify karein, ya RAG (Chapter 19) se model ko asal documents dein.

Interactive Q/A

Khulasa: LLM = Transformer jo agla token predict karta hai. Attention us ki asal taqat hai, aur hallucination us ki bari kamzori.

Chapter 18: Prompt Engineering

Prompt woh hukm hai jo aap model ko dete hain. Model aap ka zehan nahi parh sakta, is liye jitna saaf likhein ge utna behtar jawab milega.

Tum aik sabr wale teacher ho. Mere sawal ka jawab 3 hisson mein do:
1. Asaan wazahat  2. Aik misal  3. Aik practice sawal
Sawal: Overfitting kya hai?

Achhe prompt ka dhancha

Har prompt mein sab hissay zaroori nahi, lekin jitni cheezein saaf hongi, jawab utna aap ki zaroorat ke qareeb hoga.

Zero-shot, One-shot aur Few-shot

• Zero-shot: koi misal nahi, sirf hukm. "Is review ka sentiment batao."
• Few-shot: pehle 2 se 3 misalein dete hain, phir naya sawal.

Review ka sentiment batao (positive ya negative):
"Khana bohat zabardast tha" -> positive
"Service bohat sust thi" -> negative
"Delivery waqt par aayi aur packing achhi thi" ->

Misalon se model format aur andaz pakar leta hai, khaas tor par jab aap ko aik makhsoos shakal mein jawab chahiye.

Qadam ba qadam sochne ko kehna

Hisaab ya pechida masle mein kehein: "Pehlay qadam ba qadam socho, phir aakhir mein jawab likho." Is se model beech ke hisse likhta hai aur ghalti ka imkan kam hota hai. Phir bhi hisaab ka nateeja khud check karein.

Structured jawab (JSON)

Is email se naam, tareekh aur maqsad nikalo. Sirf JSON do, aur kuch nahi:
{"naam": "", "tareekh": "", "maqsad": ""}

Jab jawab ko code mein istemal karna ho to saaf format mangein, taake aap usay seedha parh sakein.

Behtar karte jana (iteration)

Pehla jawab aam tor par aakhri nahi hota. Phir kahein: "Isay aur chhota karo", "2 misalein jodo", "Is hissay ko asaan zubaan mein likho". Prompt aik baar mein perfect nahi hota, baatchit se behtar hota hai.

Aam ghaltiyan

Interactive Q/A

Khulasa: Saaf kaam, context, misal aur format. Yeh chaar cheezain prompt ko behtar karti hain.

Chapter 19: RAG, apna data AI ko dena

Model ko aap ki company ki policy ya aap ki notes nahi pata, aur us ka ilm purana ho sakta hai. RAG (Retrieval-Augmented Generation) ka hal: pehlay aap ke documents mein se mutaliqa hissa dhoondein, phir wohi hissa sawal ke sath model ko dein.

Retrieval ka chhota code

from sentence_transformers import SentenceTransformer
m = SentenceTransformer("all-MiniLM-L6-v2")
docs = ["Leave requests are submitted on the HR portal.",
        "Salary is paid on the 28th of every month."]
D = m.encode(docs, normalize_embeddings=True)
q = m.encode(["When do I get my salary?"], normalize_embeddings=True)
best = int((D @ q.T).argmax())
print(docs[best])      # salary wali line

Yeh model English text ke liye behtar hai. Roman Urdu ya Urdu documents ke liye multilingual embedding model (jaise paraphrase-multilingual-MiniLM-L12-v2) istemal karein.

Chunking: documents ko tukron mein kyun torein?

Poora 100 safhon ka document aik vector mein daalna theek nahi, kyun ke vector mein sab kuch ghul mil jata hai. Is liye documents ko chhote chunks (aam tor par 200 se 400 alfaz) mein torte hain. Chunks ke darmiyan overlap (maslan 50 alfaz) rakhte hain taake kisi jumle ke beech mein toot kar maani na bigar jaye.

• Chunk bohat chhota: maani adhoore, jawab ke liye kaafi context nahi.
• Chunk bohat bara: matlab ghul mil jata hai aur model ko faltu text milta hai.

Similarity kaise napte hain? Cosine similarity

Do vectors ka rukh (direction) kitna milta hai, yeh napne ke liye cosine similarity istemal hoti hai: 1 matlab bilkul milta hua, 0 matlab koi taluq nahi.

Top-k retrieval aur prompt banana

scores = (D @ q.T).ravel()              # har chunk ka score
top = scores.argsort()[::-1][:3]        # sab se qareebi 3
ctx = "\n---\n".join(docs[i] for i in top)
prompt = f"Sirf is context se jawab do.\n\nContext:\n{ctx}\n\nSawal: {sawal}"

Sirf aik chunk ki jagah 3 chunks dene se jawab ke chhoot jane ka imkan kam hota hai. Jawab ke sath source (kaun sa document/safha) bhi dikhayen taake user khud check kar sake.

RAG mein aam masail

RAG ko jaanchna

20 se 30 asal sawal likhein jin ke jawab aap ko documents se maloom hon. Har sawal par do cheezein dekhein: (1) kya sahi chunk top-3 mein aaya? (retrieval ka nateeja) (2) kya final jawab sahi tha? Agar retrieval hi ghalat hai to prompt badalne se faida nahi, pehle retrieval theek karein.

Interactive Q/A

Khulasa: RAG = dhoondo phir likho. Yeh sab se aam aur sasta tareeqa hai AI ko apna data dene ka.

Chapter 20: Fine-tuning, Embeddings aur Vector Databases

Vector Database

Jab documents hazaron ho jayen to har baar sab ke embeddings compare karna sust hai. Vector database (maslan FAISS, Chroma, pgvector) embeddings ko is tarah rakhta hai ke qareebi matlab wala text foran mil jaye.

Fine-tuning

Model ko apni misalon par mazeed train karna taake us ka andaz ya tareeqa-e-kaar badal jaye (maslan hamesha aik makhsoos format mein jawab, ya aap ki zubaan ka lehja).

Vector database kaise kaam karti hai?

Lakhon vectors mein har baar sab se compare karna sust hota hai. Vector databases approximate nearest neighbor (ANN) tareeqe se qareebi vectors bohat tez dhoond leti hain, jis mein sab se qareebi ka thora sa farq ho sakta hai magar raftaar bohat zyada hoti hai.

import chromadb
c = chromadb.Client()
col = c.create_collection("docs")
col.add(ids=["1", "2"],
        documents=["Leave requests are submitted on the HR portal.",
                   "Salary is paid on the 28th of every month."])
res = col.query(query_texts=["When do I get my salary?"], n_results=1)
print(res["documents"])

Chroma khud embeddings bana leta hai, is liye shuru karne mein asaan hai. Pehli baar chalane par woh embedding model download kar sakta hai.

Embeddings sirf RAG ke liye nahi

• Semantic search: alfaz na milein tab bhi matlab se dhoondna ("sasta ghar" aur "kam qeemat makan").
• Recommendations: milti julti cheezein suggest karna.
• Duplicate pehchanna: aik hi baat ke alag alfaz.
• Clustering: text ko mauzu ke hisaab se groups mein baantna.

Fine-tuning gehrai se

• Full fine-tuning: model ke saare weights badalna. Bohat mehngi aur bari GPU memory chahiye.
• LoRA jaisay parameter-efficient tareeqay: sirf chhote se extra hissay train hotay hain, kam kharcha, aur aaj zyada tar yehi istemal hota hai.

Training data aam tor par "sawal aur behtareen jawab" ke jore hotay hain:

{"sawal": "Refund kitnay din mein milta hai?", "jawab": "Refund 7 kaam ke dinon mein aap ke account mein aa jata hai."}
{"sawal": "Order cancel kaise karein?", "jawab": "My Orders mein ja kar Cancel dabayen."}

Faisla karne ka tareeqa (ek aur nazar)

1. Pehlay behtar prompt aur misalein likhein. Aksar yehi kaafi hota hai.
2. Agar model ko aap ka ya taaza data chahiye to RAG lagayen.
3. Agar makhsoos andaz, chhota model, ya bohat tez/sasta jawab chahiye aur data tayyar hai to fine-tuning sochein.
4. Zaroorat par teenon aik sath bhi chal sakte hain.

Dhyan: fine-tuning ke baad data ya zaroorat badle to dobara train karna parta hai, jabke RAG mein sirf documents update hotay hain.

Interactive Q/A

Khulasa: Prompt → RAG → Fine-tuning. Is tarteeb se chalein.

Chapter 21: AI Agents aur Automation

Agent aisa AI hai jo sirf jawab nahi deta, balkay maqsad ko hasil karne ke liye tools (search, calculator, database, email) istemal kar ke kai qadam khud uthata hai.

API se pehli call

import anthropic
client = anthropic.Anthropic()   # ANTHROPIC_API_KEY set ho
r = client.messages.create(model="claude-sonnet-5-5", max_tokens=300,
    messages=[{"role": "user", "content": "AI seekhne ke 3 tips do"}])
print(r.content[0].text)

Agent ka asal dhancha (mukammal code nahi):

while not done:
    jawab = llm(history, tools)
    if jawab.tool_call:
        natija = run_tool(jawab.tool_call)
        history.append(natija)
    else:
        done = True

Tool calling asal mein kaise hoti hai?

Model khud koi kaam nahi chalata. Aap usay tools ki list dete hain (naam, kaam ki wazahat, aur kaun se inputs chahiyen). Model jawab mein likhta hai "mujhe yeh tool is input ke sath chalana hai". Aap ka code woh tool chalata hai aur natija wapas model ko deta hai. Phir model aagay ka faisla karta hai.

tools = [{
    "name": "get_order_status",
    "description": "Order ID se order ka status batata hai",
    "input_schema": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"]}}]

r = client.messages.create(model="claude-sonnet-5-5", max_tokens=300, tools=tools,
    messages=[{"role": "user", "content": "Mere order 123 ka kya status hai?"}])
for block in r.content:
    if block.type == "tool_use":          # model tool chalane ko keh raha hai
        print(block.name, block.input)    # get_order_status {"order_id": "123"}

Is ke baad aap ka code asal function chalata hai, natija ek tool_result message mein wapas bhejta hai, aur model us se final jawab banata hai. Tool ki wazahat jitni saaf ho, model utna sahi tool chunta hai.

Workflow ya Agent? Kya chunein

Agar kaam ke qadam pehle se maloom hain (maslan: khabrein jama karo, summary banao, email bhejo), to fixed workflow behtar hai, sasta aur mehfooz. Agent tab banayen jab sach mein rasta khulaa hona zaroori ho.

Agent banate waqt ke usool

• Chhote, saaf tools: har tool aik kaam kare.
• Zyada se zyada qadam ki had rakhein (maslan 10), taake loop na phans jaye.
• Har qadam ka record (log) rakhein taake ghalti ki wajah dekhi ja sake.
• Errors sambhalein: tool fail ho to model ko batayen taake woh doosra raasta chune.
• Khatarnak kaamon par insan ki manzoori.

Agent ke aam masail

News summary agent: qadam ba qadam

1. Search tool: aaj ki khabrein dhoondta hai.
2. Fetch tool: har khabar ka matan lata hai.
3. LLM: har khabar ka khulasa banata hai aur 10 lines mein jama karta hai.
4. Email tool: summary bhejta hai (pehle sirf draft bana kar aap ko dikhaye, aap manzoori dein).

Ghalat ho sakne wali jagahein: koi website na khule (error handling), model aik hi khabar ko dohra de (jaanch), ya kisi page ka chhupa hukm email bhejne ki koshish kare (injection se bachao).

Interactive Q/A

Khulasa: Agent = LLM + tools + loop. Taqatwar hai, is liye hadood aur manzoori zaroori hain.

Chapter 22: Project, Document Q&A Chatbot

Maqsad: kisi PDF/notes ke hisson se sawal ka jawab, aur jawab na ho to saaf "maloom nahi" kehna. Chapter 19 ka retrieval (m, docs, D) aur Chapter 21 ka client yahan istemal hotay hain.

def jawab(sawal):
    q = m.encode([sawal], normalize_embeddings=True)
    ctx = docs[int((D @ q.T).argmax())]
    prompt = ("Sirf is context se jawab do. Agar jawab na ho to kaho 'maloom nahi'.\n\n"
              f"Context: {ctx}\n\nSawal: {sawal}")
    r = client.messages.create(model="claude-sonnet-5-5", max_tokens=300,
        messages=[{"role": "user", "content": prompt}])
    return r.content[0].text

print(jawab("When do I get my salary?"))

Behtar banane ke qadam

• Lambay documents ko 200 se 400 alfaz ke chunks mein torein.
• Sirf aik nahi, sab se qareebi 3 chunks bhejein.
• Streamlit se chhota web interface banayen.
• 20 sawalat likh kar jaanchein ke kitnay sahi aaye (yehi aap ka evaluation hai).

Documents load aur chunk karna

from pypdf import PdfReader

def pdf_text(path):
    return " ".join(p.extract_text() or "" for p in PdfReader(path).pages)

def chunk(text, size=300, overlap=50):
    words = text.split()
    out, i = [], 0
    while i < len(words):
        out.append(" ".join(words[i:i+size]))
        i += size - overlap
    return out

docs = chunk(pdf_text("policy.pdf"))
D = m.encode(docs, normalize_embeddings=True)

Is se aap ka PDF chhote overlapping chunks mein toot kar embeddings ban jata hai (Chapter 19). Scan ki hui tasveer wale PDF mein text nahi hota, un ke liye pehlay OCR chahiye.

Top 3 chunks aur source dikhana

def jawab(sawal):
    q = m.encode([sawal], normalize_embeddings=True)
    scores = (D @ q.T).ravel()
    top = scores.argsort()[::-1][:3]
    ctx = "\n---\n".join(docs[i] for i in top)
    prompt = ("Sirf is context se jawab do. Agar jawab na ho to kaho 'maloom nahi'.\n\n"
              f"Context:\n{ctx}\n\nSawal: {sawal}")
    r = client.messages.create(model="claude-sonnet-5-5", max_tokens=400,
        messages=[{"role": "user", "content": prompt}])
    return r.content[0].text, [int(i) for i in top]   # jawab aur chunk numbers

Chunk numbers wapas dene se user dekh sakta hai ke jawab kis hisse se aaya, aur bharosa barhta hai.

Streamlit se chhota web interface

import streamlit as st
st.title("Document Q&A")
sawal = st.text_input("Apna sawal likhein")
if sawal:
    text, srcs = jawab(sawal)
    st.write(text)
    st.caption(f"Source chunks: {srcs}")

# chalane ke liye: streamlit run app.py

Apne chatbot ko jaanchna (evaluation)

20 asal sawal likhein jin ke jawab aap ko maloom hon, aur table banayen:

Do hisaab nikalein: kitne sawalon ka jawab sahi tha, aur kitnon mein sahi chunk top-3 mein aaya. Agar chunk aaya magar jawab ghalat to prompt behtar karein. Agar chunk hi nahi aaya to chunking ya embedding model theek karein. Aur kuch sawal aise bhi shamil karein jin ka jawab documents mein nahi hai, taake dekha ja sake ke chatbot "maloom nahi" kehta hai.

Interactive Q/A

Khulasa: Aap ne apna RAG chatbot bana liya. Ab AI ko sirf istemal nahi, balkay apne data ke sath jorna bhi seekh gaye hain.

Chapter 23: MLOps Basics, Model ko live karna

Notebook mein chalta model sirf aap ke liye hai. Jab doosray log (app, website, customer) usay istemal karein to usay deploy karna parta hai. Is poore kaam ko MLOps kehte hain.

1. Model ko save karein

import joblib
joblib.dump(model, "model.pkl")      # Chapter 11 wala model

2. FastAPI se API banayen

from fastapi import FastAPI
import joblib
app = FastAPI()
model = joblib.load("model.pkl")

@app.get("/predict")
def predict(area: float, rooms: int, age: int):
    qeemat = model.predict([[area, rooms, age]])[0]
    return {"qeemat": float(qeemat)}

# chalane ke liye: uvicorn main:app --reload

Ab koi bhi app /predict?area=1200&rooms=3&age=5 ko call kar ke andaza le sakti hai.

3. Docker, har jagah aik jaisa

"Mere computer par chalta hai" ka masla Docker hal karta hai: aap code, Python aur libraries ek container mein band kar dete hain jo kisi bhi server par yaksan chalta hai.

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

4. Cloud aur nigrani

• Cloud: container kisi cloud service (AWS, Google Cloud, Azure ya chhoti hosting services) par chalta hai. Pehlay free tier se seekhein.
• Monitoring: model waqt ke sath kharab ho sakta hai kyun ke dunya badal jati hai (data drift). Ghalti aur raftaar ko dekhte rehna zaroori hai.
• Versioning: har model ka version aur us ka data record rakhein, taake kharabi par pichla version wapas laga sakein.

API ki buniyadi baatein

• Request / Response: client sawal (request) bhejta hai, server jawab (response) deta hai, aam tor par JSON format mein.
• GET: maloomat mangna. POST: data bhej kar kaam karwana (model ke inputs bhejne ke liye behtar).
• Status codes: 200 kamyab, 400 aap ke input mein ghalti, 404 cheez nahi mili, 500 server mein ghalti.

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
model = joblib.load("model.pkl")

class Ghar(BaseModel):          # input ki shakal aur type ki jaanch
    area: float
    rooms: int
    age: int

@app.post("/predict")
def predict(g: Ghar):
    qeemat = model.predict([[g.area, g.rooms, g.age]])[0]
    return {"qeemat": float(qeemat)}

BaseModel ghalat input (maslan area ki jagah text) ko khud rok deta hai. FastAPI chalane par /docs par khud ba khud aik page banta hai jahan se aap API browser mein hi test kar sakte hain.

Docker chalane ke commands

pip freeze > requirements.txt              # libraries ki list
docker build -t house-api .                # image banana
docker run -p 8000:8000 house-api          # chalana, ab localhost:8000 par API chalti hai

Secrets aur settings

API keys aur passwords kabhi code mein na likhein. Unhein environment variables mein rakhein (os.environ["API_KEY"]) aur .env file ko .gitignore mein daalein taake GitHub par na jaye.

Nigrani mein kya dekhein?

Jab accuracy ek had se neeche aaye ya data bohat badal jaye to model ko naye data par dobara train karein, aur naye version ko pehlay thore users par test kar ke phir sab ke liye lagayen.

Interactive Q/A

Khulasa: Save, API, Docker, cloud, monitoring. Yeh paanch qadam model ko notebook se asal duniya tak pohanchate hain.

Chapter 24: AI Ethics, Safety aur Limitations

AI taqatwar hai, lekin ghalat istemal ya be-ehtiyati se nuqsan bhi pohancha sakta hai. Aik achha AI engineer sirf "chalta hai ya nahi" nahi dekhta, "kis ko nuqsan ho sakta hai" bhi sochta hai.

Aap ki checklist

• Kis ka data istemal ho raha hai, aur kya us ki ijazat hai?
• Ghalti ho to kis ko nuqsan hoga, aur kitna bara?
• Kya aham faislay mein insan ki jaanch rakhi hai?
• Kya user ko pata hai ke woh AI se baat kar raha hai?

Bias kaise jaanchein? Groups ke hisaab se nateeja

Poore data par accuracy achhi nazar aa sakti hai jabke aik group ke liye model bohat kharab ho. Is liye nateeja groups mein baant kar dekhein:

df_test["sahi"] = (pred == y_te)
print(df_test.groupby("gender")["sahi"].mean())
# agar aik group ki accuracy bohat kam ho to bias ka shak

Dhyan: "munsifana" hone ki koi aik tareef nahi hoti. Alag nazariyon mein trade-off hota hai, is liye faisla karte waqt batayen ke aap ne kaun si cheez napi aur kyun.

Privacy: kam se kam data

• Sirf wohi data lein jo asal mein zaroori ho (data minimization).
• Naam, phone, CNIC/ID jaisi shinakhti maloomat hataein ya chhupayen (anonymization) jahan mumkin ho.
• Logon se data lene ki wazeh ijazat (consent) lein aur batayen kis kaam ke liye istemal hoga.
• Agar data bahar ki service ko nahi bhejna chahtay to local models par ghor karein.

Data aur AI ke qawaneen mulk aur kaam ke hisaab se alag ho sakte hain. Client ya company ke liye kaam karte waqt un ki policy aur apne mulk ke qawaneen khud check karein ya mutaliqa mahir se poochein.

Security ke khatray

• Prompt injection: ghair mutamad text mein chhupa hukm (Chapter 18, 21).
• API keys ka leak: code ya screenshot mein key (Chapter 23).
• Hassas data prompt mein: jo likha jata hai wohi service tak jata hai.

Wazahat aur shafafiyat (transparency)

Jahan AI ka faisla kisi ki zindagi par asar daalta ho (karz, naukri, sehat) wahan wajah batana zaroori hai, aur insan ko faisla badalne ka haq hona chahiye. Apne model ke baare mein aik chhota "model card" likhein: kis data par train hua, kahan achha chalta hai, kahan kamzor hai, aur kin kaamon ke liye istemal nahi karna chahiye.

Launch se pehle checklist

1. Data kahan se aaya, aur kya us ki ijazat hai?
2. Groups ke hisaab se nateeja check kiya?
3. Ghalti ho to sab se bura nuqsan kya hoga?
4. Insan ki jaanch ya "appeal" ka raasta hai?
5. User ko pata hai ke woh AI se baat kar raha hai?
6. Hadood (kamzoriyan) likhi hui hain?

Interactive Q/A

Khulasa: Bias, hallucination, privacy, copyright aur zyada bharosa, in paanch se hoshiyar rahein, aur aham faislon mein insan ko shamil rakhein.

Chapter 25: Portfolio aur Projects

Job ya client aap ki digree se zyada ye dekhta hai: "Is ne kya banaya hai?" Portfolio aap ka saboot hai.

Achhe README mein kya ho

• Masla: kis cheez ka hal hai, aur kis ke liye?
• Data: kahan se aaya, kitna bara hai?
• Tareeqa: kaun se models aur kyun?
• Nateeja: numbers aur aik do charts ya screenshots.
• Chalane ka tareeqa: dusra insan code kaise chalaye?
• Hadood: model kahan kamzor hai?

10 projects ki tafseel

Project chunne ke usool

• Chhota lekin mukammal: adhoore 5 bade projects se aik mukammal behtar hai.
• Data se nateeje tak poora safar: safai, model, jaanch, aur nateeja samjhana.
• Apna angle: aam tutorial ki copy ke bajaye apna sawal ya apna data. Maslan aik hi MNIST project mein apni haath ki likhai par test karna.

GitHub repository ka saaf dhancha

house-price/
├── README.md          # masla, tareeqa, nateeja, chalane ka tareeqa
├── requirements.txt   # zaroori libraries
├── data/              # chhota sample (bara data ka link do)
├── notebooks/         # tajarbay (EDA, modelling)
├── src/               # saaf code (train.py, predict.py)
└── app.py             # chhota demo (Streamlit ya FastAPI)

Demo dikhana

Recruiter ke paas waqt kam hota hai. Chhota sa live demo link (Streamlit/Hugging Face Spaces jaisi free hosting) ya 1 se 2 minute ki screen recording README mein lagayen. Dekh kar samajh aa jaye to bharosa foran barhta hai.

Portfolio ki aam ghaltiyan

Interactive Q/A

Khulasa: 10 projects ka plan banayen, README par mehnat karein, aur aakhri project apne shobay ka rakhein.

Chapter 26: Job aur Freelancing Guide

Job ke liye

• CV: aik page, projects pehlay, har project mein masla, tareeqa aur nateeja (numbers ke sath).
• LinkedIn: saaf headline (maslan "Aspiring AI Engineer | Python, ML, RAG"), projects ka link, aur hafte mein aik post jis mein seekhi hui cheez ho.
• GitHub: saaf README wale projects.
• Kaggle: chhote competitions aur notebooks se practice aur pehchan.
• Remote aur local dono: companies, software houses aur internship ke mauqe dhoondein.

Freelancing ke liye

Upwork aur Fiverr jaisay platforms par shuru karne ke liye pehlay chhoti, saaf service chunein, aur aik hi kaam par mahir dikhein.

• Profile par portfolio ke 3 behtareen projects dikhayen.
• Qeemat market dekh kar tay karein, shuru mein chhote kaam le kar reviews banayen.
• Client ko saaf batayen AI kya kar sakta hai aur kya nahi (Chapter 24). Jhoote wade na karein.

Interview ki tayyari

Aam tor par yeh topics poochay jatay hain: Python aur Pandas, ML ki bunyad (overfitting, metrics), aapke projects, aur LLM/RAG ke sawal.

CV ka aik achha bullet kaise likhein?

Formula: Kya kiya + kaise + nateeja. Numbers ho to behtar.

Sirf wohi numbers likhein jo aap ne asal mein napay hain. CV mein jhoot interview mein pakra jata hai.

LinkedIn: headline aur posts

• Headline: "Aspiring ML Engineer | Python, scikit-learn, RAG | Projects: house price, document Q&A".
• Post ke idea: "Aaj maine seekha...", aik project ka nateeja aur sabaq, aik ghalti jo hui aur kaise theek ki, aik chhota tutorial jo aap ne khud banaya.
• Connections: logon ke posts par soch samajh kar comment karein, aur seekhne walay logon aur hiring walon se judein.

Freelancing proposal ka chhota dhancha

Salam [Naam],
Aap ko [masla] hal karna hai. Main [aik jumle mein kya karun ga].
Mere kaam ki misal: [project link]. Isi tarah ka masla maine [kaise] hal kiya.
Aap ke liye main pehlay [chhota kaam / sample] kar ke dikha sakta hoon.
Waqt: [x din]. Mujhe aap ke data ke baare mein ye maloom karna hai: [1 se 2 sawal].

• Client ke masle se shuru karein, apne baare mein baad mein.
• Kaam ki hadd (scope) pehle likhwa lein: kya shamil hai aur kya nahi.
• Platform ki payment aur dispute system istemal karein, platform se bahar paise ya sirf zabani wade se bachein.
• Waqt par rabta rakhein aur chhoti progress batate rahein.

Interview ke marahil aur 2 hafte ki tayyari

• Hafta 1: Python/Pandas/SQL ke rozana 3 se 5 masle, ML ki bunyadi istilahat dohrana.
• Hafta 2: apne 2 projects ko zubani samjhane ki mashq (kyun, kaise, nateeja, kya behtar ho sakta tha), aur dost se mock interview.

Practice sawal: Precision aur recall mein farq? Train/test split kyun? Missing values ka kya karein? Overfitting kaise roken? Embedding kya hai? RAG kab fine-tuning se behtar hai? Aap ne project mein kya ghalti ki?

Interactive Q/A

Khulasa: Mazboot projects, saaf CV/LinkedIn, imandari aur lagataar seekhna: yehi sab se pakka rasta hai.

Chapter 27: 12 Mahine ka Roadmap

Yeh plan Rasta A (Zero Start) ke liye hai, rozana taqreeban 2 ghantay ke hisaab se. Agar aap Rasta B ya C mein hain (Chapter 3) to shuru ke mahine chhote karein ya chhor dein.

Rozana ke 2 ghantay

• 30 minute: naya concept parhna ya dekhna.
• 75 minute: khud code likhna (asal seekhna yehi hai).
• 15 minute: aaj ka nota likhna: kya seekha, kahan atka.

Hafte ka dhancha

Aaram bhi plan ka hissa hai. Roz bina rukay seekhne se thakan aur chhor dene ka khatra barhta hai.

Har mahine ka "checkpoint": aap kya kar sakein

Agar mahine ke aakhir mein checkpoint poora nahi hua to agle mahine ke naye topic par jaane se pehle aik hafta usi par lagayen.

Rasta B aur C ke liye roadmap

Peechay reh jayen to?

• Plan ko dobara mat shuru karein, jahan hain wahin se agle checkpoint ki taraf barhein.
• Agar 2 hafte ruk gaye to pehlay 20 minute rozana se dobara shuruat karein.
• Kam zaroori cheezein chhor dein (maslan RNN ki gehrai), lekin buniyad (Python, Pandas, ML ki bunyad) na chhoden.

Mahine ka review (5 sawal)

1. Is mahine mujhe kya kar lena tha, aur kya kar paya?
2. Kaun si cheez ab bhi samajh nahi aati?
3. Maine kitnay ghantay khud code likha?
4. Aik cheez jo maine kisi aur ko samjhayi ya likhi?
5. Agle mahine ke liye aik sab se ahem hadaf kya hai?

Interactive Q/A

Khulasa: Chaar marahil, rozana 2 ghantay, aur har 2 se 3 mahine mein aik project.

Chapter 28: Behtareen Resources

Resource kaise istemal karein

• Aik waqt mein aik course chunein aur usay mukammal karein.
• Har video ke baad khud code likhein, sirf copy na karein.
• Kisi cheez par atakein to pehlay khud 20 minute koshish, phir documentation, phir poochein.
• Roman Urdu ya Urdu content bhi dekhein, magar technical terms angrezi mein seekhein kyun ke documentation wohi hai.

Resource chunne se pehle 4 sawal

1. Kya yeh mere level ke liye hai (na bohat asaan, na bohat mushkil)?
2. Kya is mein khud code likhne wali practice hai?
3. Kya yeh taaza hai? (AI ke purane tutorials aksar purani libraries istemal karte hain.)
4. Kya mujhe is ke baad koi cheez banani ayegi?

Documentation kaise parhein?

1. Quickstart aur "Getting started" pehle, poora manual nahi.
2. Chhote examples ko apne laptop par chala kar dekhein.
3. Phir API reference se sirf wohi function dekhein jis ki zaroorat ho.

Research paper ya lambay article ko kaise parhein?

Pehle abstract (khulasa), phir tasveerein aur charts, phir conclusion. Agar aap ko woh kaam ka lagay tab introduction aur tafseel. Har cheez ko mukammal samajhna pehle din zaroori nahi.

Madad kaise maangein (taake jawab jaldi mile)

Masla: [aik jumle mein]
Maqsad: [main kya karna chahta hoon]
Mera code: [chhota se chhota hissa jo error deta hai]
Error: [poora error message copy kar ke]
Maine kya koshish ki: [2 se 3 baatein]
Mera setup: [Colab/Windows, library ke versions]

Is dhancha se forum par ya kisi dost se poochte waqt aap ka masla seedha samajh aata hai.

AI assistants ko seekhne mein kaise istemal karein?

• Achha tareeqa: "Yeh concept mere level par samjhao", "Mujh se 5 sawal poochho", "Mere code mein ghalti dhoondo aur wajah batao".
• Kamzor tareeqa: poora code likhwa kar bina samjhe copy kar lena. Is se aap seekhte nahi.
• AI ke jawab ko hamesha chala kar test karein aur zaroori baaton ka official documentation se check karein.

Rozana ke tools

• Google Colab ya Kaggle Notebooks: install ke baghair Python.
• VS Code: jab projects bare hon aur laptop par kaam karna ho.
• Git/GitHub: har project ka record.

Interactive Q/A

Khulasa: Kam lekin mukammal. Aik rasta, aik course, aur roz practice.

Chapter 29: Aam Ghaltiyan aur unka Hal

Jab aap atak jayen: 5 qadam

1. 20 minute ka usool: pehlay khud koshish karein, error ko dhyan se parhein.
2. Masle ko chhota karein: poora code nahi, sirf woh chhoti line jahan masla hai alag chala kar dekhein.
3. Print karein: variables aur shapes print kar ke dekhein ke asal mein kya hai (print(df.shape)).
4. Kisi aur ko samjhayen: yahan tak ke deewar ya dost ko bhi. Bol kar samjhane se aksar masla khud nazar aa jata hai.
5. Phir madad maangein: saaf dhancha ke sath (Chapter 28).

Jab dil chhota ho: aam jazbaati masail

Agar thakan ya preshani bohat barh jaye to kisi bharose ke dost ya ghar walay se baat karein. Seekhna lamba safar hai, aur apni sehat us ka hissa hai.

Seekhne ka "plateau"

Kuch hafton tak lagta hai ke aap kuch seekh nahi rahe, jabke andar andar buniyad pakki ho rahi hoti hai. Is waqt naya topic shuru karne ki bajaye pichlay project ko behtar banayen: naya feature, behtar README, aur apne code ko saaf karna. Aksar isi se agla barha qadam aata hai.

Interactive Q/A

Khulasa: Practice, sabr aur sahi cheezon par focus. Zyada tar ghaltiyan in teenon ki kami se hoti hain.

Chapter 30: Aage ka Safar, Specialization

Buniyad ke baad aap aik shobay mein gehre ja sakte hain. Is ko T-shape kehte hain: aam buniyad (T ka upar ka hissa) aur aik shobay mein gehri maharat (neechay ka hissa).

Kab specialization chunein?

Jab aap Chapter 1 se 16 tak ki buniyad par do se teen projects mukammal kar chuke hon. Is se pehle specialization ki fikar karna jaldbazi hai, kyun ke buniyad kamzor ho to gehrai mein jana mushkil hota hai.

Har specialization ke pehle 3 mahine aur project idea

Mulk ke hisaab se mauqe

Aap ke aas paas ke masail (zubaan, kheti, chhote kaarobar, e-commerce, maali khidmaat, taleem) aise mauqe hain jahan bahar ki companies ka tayyar-shuda hal kabhi kabhi poori tarah munasib nahi hota. Aap apni zubaan, apne data aur apne logon ke masail samajhte hain, aur yeh aap ki asal taqat ban sakti hai.

AI ke badalte hone par taaza kaise rahein?

• Hype se ziyada official documentation aur release notes par bharosa karein.
• 2 se 3 mutamad sources chunein, sab kuch follow karne ki koshish na karein.
• Har naye tool ke saath aik chhoti cheez khud bana kar dekhein.
• Hafte mein aik cheez parhein, aik cheez banayen, aur aik cheez kisi se share karein.

Kya aap tayyar hain? Aakhri checklist

1. Python aur Pandas mein bina dekhe chhoti problem hal kar sakta hoon.
2. Train/test split, overfitting aur metrics apne alfaz mein samjha sakta hoon.
3. Kam az kam aik ML aur aik deep learning project mukammal kiya hai.
4. Token, embedding aur attention ka matlab samajhta hoon.
5. Aik RAG ya chatbot project banaya aur jaancha hai.
6. Model ko API ke zariye chalana jaanta hoon.
7. AI ke khatraat aur hadood (bias, hallucination, privacy) samajhta hoon.
8. GitHub par saaf README wale 3 projects hain.
9. CV aur LinkedIn tayyar hain.
10. Seekhte rehne ki aik aadat bana li hai.

Agar 7 se zyada jawab "haan" hain to aap aagay barhne ke liye tayyar hain. Baaqi cheezein practice se aati rahengi.

Aakhri baat

AI ka field tezi se badalta hai, is liye sab se bari salahiyat seekhne ki aadat hai. Is kitab ne aap ko buniyad aur rasta diya hai, aagay ka safar practice, projects aur sabr se tay hoga. Har din thora sa, lekin lagataar.

Interactive Q/A

Khulasa: Buniyad mazboot rakhein, aik shobah chunein, aur seekhte rahein.

A. Glossary

B. Python Cheat Sheet

# Basics
x = 10; naam = "Ali"; marks = [70, 85, 90]; d = {"area": 1200, "rooms": 3}
for m in marks: print(m)
def jama(a, b): return a + b
if x > 5: print("bara") 
else: print("chhota")

# NumPy
import numpy as np
a = np.array([1, 2, 3]); a.mean(); a * 2

# Pandas
import pandas as pd
df = pd.read_csv("file.csv"); df.head(); df.describe()
df.dropna(); df["col"].fillna(0); df.groupby("cat")["amt"].sum()

# scikit-learn ka dhancha
from sklearn.model_selection import train_test_split
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)
model.fit(X_tr, y_tr); model.predict(X_te)

C. Final Test, 50 sawalat

Har sawal ka jawab chunein. Jawab dene ke baad sahi jawab nazar aaye ga, aur aakhir mein aap ka score.