مین مواد پر جائیں

Chapter 31: Text Generation aur Fine-tuning using OpenAI API

MODULE 8 | WEEK 31​

Chapter 31: Text Generation aur Fine-tuning using OpenAI API​

Pichle chapter me LLM ka andar ka nizam dekha. Ab hum LLM ko apni Python application se istemal karna seekhte hain: OpenAI API se text generate karna, prompts ko behtar banana, structured (JSON) jawab lena, kharcha ginana, errors aur retries sambhalna, aur aakhir me fine-tuning : yani model ko apne data se ek khaas andaz sikhana. Jahan code API key maangta hai wo Colab me chalega ( OUTPUT (namoona) ); baqi sab (kharcha, validation, dataset, LoRA ka hisaab) bina key ke asli outputs ke saath chalta hai.

31.1 OpenAI API ka taruf aur setup​

ChatGPT (website/app) aur OpenAI API do alag cheezein hain. ChatGPT insaan ke istemal ke liye hai; API programmers ke liye hai taake apni application se model ko call kar sakein. API ka hisaab alag hota hai aur tokens ke hisaab se paisay lagte hain. Setup ke qadam:

  1. OpenAI ke platform par account banao, billing (kuch credit) set karo.

  2. Dashboard se ek API key banao. Ye ek lambi secret string hai.

  3. pip install openai chalao.

  4. Key ko environment variable OPENAI_API_KEY me rakho. Library khud wahan se parh leti hai.

SUNEHRA USOOL​
  • API key kabhi code me mat likho aur GitHub par mat daalo. Key chori hui to doosra tumhare paiso se istemal karega.

  • Colab me: left side par Secrets (chaabi ka icon) me OPENAI_API_KEY add karo.

  • Apne computer par: key ko .env file me rakho, aur .env ko .gitignore me likho.

  • Dashboard me monthly spending limit lagao taake galti se bara bill na aaye.

# Colab: Secrets me OPENAI_API_KEY add karo, phir:
import os
from google.colab import userdata
os.environ["OPENAI_API_KEY"] = userdata.get("OPENAI_API_KEY")
# apne computer par: terminal me export OPENAI_API_KEY="sk-..." (Windows: setx)
VERSION NOTE​

Models ke naam, qeematein aur features bohat tezi se badalte hain. Is chapter me model ka naam ek variable MODEL me rakha hai (misaal ke taur par "gpt-5.4-mini", ek chhota aur sasta model). Chalane se pehle OpenAI

ke Models page me dekho ke aaj kaun se naam maujood hain, ya client.models.list() chalao. Agar naam purana ho gaya ho to sirf us ek line ko badalna hai.

31.2 Pehli call: Responses API​

OpenAI ka naya aur tajweez kiya hua tareeqa Responses API hai. Sab se chhoti call:

# pip install openai
from openai import OpenAI
client = OpenAI() # OPENAI_API_KEY khud environment se parh leta hai
MODEL = "gpt-5.4-mini" # docs me aaj ka naam dekho
response = client.responses.create(
model=MODEL,
instructions="Tum ek madadgar tutor ho jo Roman Urdu me mukhtasar jawab deta hai.",
input="Overfitting kya hoti hai? 2 jumlon me batao.",
)
print(response.output_text)

OUTPUT (namoona)

Overfitting tab hoti hai jab model training data ko zaroorat se zyada ratta laga leta hai,
yahan tak ke uske shor (noise) ko bhi seekh leta hai. Is ka nateeja ye hota hai ke wo nayi
(unseen) data par kharab kaam karta hai.

instructions model ka kirdar aur qawaid (system-level hidayat) hain, aur input user ka sawal . Jawab ka asal text response.output_text me hai. Poora object bhi kaam ka hai:

CheezMatlab
response.output_textModel ka final text jawab
response.usageKitne tokens lage: input_tokens, output_tokens, total_tokens (kharche ka hisaab
yahin se)
response.idIs jawab ki pehchan; agli call me previous_response_id ke taur par de sakte ho
response.outputAsal items ki list (text, tool calls waghera). Chapter 32 me kaam aayegi

Naye parameters jo tum responses.create me de sakti ho: model, input, instructions, max_output_tokens (jawab ki had), tools (Chapter 32), stream (turant tukron me jawab) aur text (jawab ka format). Purani Chat Completions API (client.chat.completions.create(messages=[...]), jawab completion.choices[0].message.content me) bhi chalti hai aur purane code me aam hai, is liye dono ko pehchano:

Responses API (naya)Chat Completions (purana)
Callclient.responses.create(...)client.chat.completions.create(...)
Sawalinput="..." ya messages ki listmessages=[{"role": ..., "content": ...}]
Hidayatinstructions="..."Pehla message {"role": "system", ...}
Text jawabresponse.output_textcompletion.choices[0].message.content

31.3 Roles aur Multi-turn Conversation​

Model ko pichli baatein khud yaad nahi rehti: har call naye sire se hoti hai. Guftagu ka silsila banane ke liye tum poori history khud bhejti ho . History messages ki list hoti hai, aur har message ka ek role hota hai:

RoleKaun?Kaam
developer / systemTum (programmer)Model ke qawaid: kirdar, andaz, hadood
RoleKaun?Kaam
userInsaanSawal ya hidayat
assistantModelModel ke pichle jawab
history = []
def chat(user_text):
history.append({"role": "user", "content": user_text})
response = client.responses.create( model=MODEL, instructions="Tum Roman Urdu me madad karne wala tutor ho.", input=history, # poori history har baar )
answer = response.output_text history.append({"role": "assistant", "content": answer})
return answer
print(chat("Mera naam Sara hai. Main Python seekh rahi hoon."))
print(chat("Mera naam kya tha aur main kya seekh rahi hoon?"))

OUTPUT (namoona)

Khushi hui Sara! Python ek behtareen intikhab hai. Kahan se shuru karna chahengi?
Aap ka naam Sara hai aur aap Python seekh rahi hain.

Ek aur tareeqa previous_response_id=response.id dena hai, jahan OpenAI server history yaad rakhta hai. Magar history ki lambai ka masla dono me hai: jitni lambi guftagu, utne zyada tokens (aur kharcha), aur ek waqt par context window poori ho jati hai. Is liye history ko chhota rakhna parta hai:

def trim_history(history, max_chars=120):
"""Naye messages rakho, purane hatao jab tak total lambai had me na aa jaye."""
kept, total = [], 0
for msg in reversed(history):
# naye se purane ki taraf total += len(msg["content"])
if total > max_chars:
break kept.append(msg)
return list(reversed(kept))
history = [ {"role": "user", "content": "Mera naam Sara hai."}, {"role": "assistant", "content": "Khushi hui Sara!"}, {"role": "user", "content": "Mujhe NumPy samjhao."}, {"role": "assistant", "content": "NumPy arrays ki tez library hai."}, {"role": "user", "content": "Aur Pandas?"}, ]
for m in trim_history(history):
print(m["role"], "->", m["content"])

OUTPUT user -> Mera naam Sara hai. assistant -> Khushi hui Sara! user -> Mujhe NumPy samjhao. assistant -> NumPy arrays ki tez library hai. user -> Aur Pandas?

31.4 Generation Controls, Streaming aur Kharcha​

  • max_output_tokens: jawab ki zyada se zyada lambai. Kharcha aur raftar dono kabu me rehte hain (jawab beech me kat bhi sakta hai).

  • temperature / top_p: randomness ka control (Chapter 30.3). Yaad rakho: kuch naye reasoning models ye parameters nahi lete ; docs dekho.

• stream=True: jawab tukron me turant milta hai, jaise ChatGPT me lafz ek ek karke aate hain. Lambe jawab me user ko intezar kam lagta hai.

stream = client.responses.create( model=MODEL, input="Transformer ko 3 jumlon me samjhao.", stream=True, )
for event in stream:
if event.type == "response.output_text.delta":
# text ka naya tukra
print(event.delta, end="", flush=True)
print()

OUTPUT (namoona)

Transformer ek neural network hai jo poore jumle ko ek sath dekhta hai. Wo attention
se tay karta hai ke kaun sa lafz kis lafz ke liye ahem hai. Isi wajah se wo translation
aur chat jaise kaam bohat acha karta hai.

Tokens aur Kharcha​

API ki qeemat tokens par hoti hai: input tokens (tumhara prompt + history) aur output tokens (model ka jawab), aur output aam taur par mehnga hota hai. Qeemat aksar "per 1 million tokens" me likhi hoti hai. Khud ka kharcha calculator banao, taake bill se pehle andaza ho. Neeche ki qeematein sirf misaal ke liye farzi hain; asli qeemat OpenAI ke Pricing page se dekho:

PRICE_IN, PRICE_OUT = 1.00, 4.00 # FARZI:
$ per 1M tokens (asli qeemat docs se)
def cost(in_tokens, out_tokens):
return in_tokens / 1_000_000 * PRICE_IN + out_tokens / 1_000_000 * PRICE_OUT
one_call = cost(in_tokens=800, out_tokens=300)
print(f"Ek call : ${one_call:.5f}")
print(f"1,000 calls : ${one_call * 1_000:.2f}")
print(f"Roz 5,000 calls (30 din): ${one_call * 5_000 * 30:.2f}") # prompt me RAG ke chunks jod do to input barh jata hai
print(f"RAG ke saath (3,000 in): ${cost(3000, 300):.5f} per call")

OUTPUT Ek call : $0.00200 1,000 calls : $2.00 Roz 5,000 calls (30 din): $300.00 RAG ke saath (3,000 in): $0.00420 per call

Tokens ginne ke liye OpenAI ki tiktoken library hai (pip install tiktoken). Is se pehle se maloom ho jata hai ke prompt kitna bara hai:

import tiktoken
enc = tiktoken.get_encoding("o200k_base") # naye models ka tokenizer
print(len(enc.encode("Hello world")))

OUTPUT (namoona) 2

31.5 Prompt Engineering aur Structured Output​

Prompt engineering yani model ko saaf aur mukammal hidayat dena. Chhoti si tabdeeli jawab ki quality badal deti hai:

TarkeebKya karna haiMisaal
Saaf hidayatKya chahiye, kis liye, kitna lamba"3 bullet points me, har ek 10 lafz se kam"
Kirdar (role)Model ko kirdar do"Tum ek strict python teacher ho"
Few-shot2-3 misalein (input -> output) dikhao"Review: acha -> POSITIVE, bekaar -> NEGATIVE, ..."
Step by stepMushkil sawal me soch ke qadam likhwao"Pehle hisaab ke qadam likho, phir jawab"
DelimitersHidayat aur data ko alag karoData ko """ ya ### ke andar rakho
Output formatJawab ka saancha batao"Sirf JSON do: {"label": ..., "reason": ...}"
HadoodKya na kare"Agar maloom na ho to kaho: pata nahi"

Structured Output: jawab JSON me​

Apni application ko aksar model ka jawab parse karna hota hai (maslan database me daalna). Is liye free text nahi, structured data chahiye. OpenAI Structured Outputs me tum Pydantic class dete ho aur model us saanche ke mutabiq jawab dene ka paband hota hai:

from pydantic import BaseModel
class Review(BaseModel):
label:
str # "POSITIVE" ya "NEGATIVE"
reason:
str
response = client.responses.parse( model=MODEL, input=prompt, # upar wala prompt text_format=Review, )
review = response.output_parsed # Review object
print(review.label, "|", review.reason)

OUTPUT (namoona)

NEGATIVE | Zoom ke sust chalne ki shikayat hai, jo tareef se zyada nuqsan dikhati hai.

Agar tumhara model/library structured outputs na deti ho to JSON mangwa kar khud validate karo. Model ke jawab par kabhi andha bharosa nahi:

import json
def parse_review(raw):
try:
data = json.loads(raw)
except json.JSONDecodeError:
return None, "JSON nahi hai"
if set(data) != {"label", "reason"}:
return None, "keys ghalat hain"
if data["label"] not in ("POSITIVE", "NEGATIVE"):
return None, "label ghalat hai"
return data, "theek"
replies = [ '{"label": "POSITIVE", "reason": "acha course"}', 'Mera khayal hai ye POSITIVE hai', # JSON nahi '{"label": "ACHA", "reason": "pasand aya"}', # ghalat label ]
for r in replies:
print(parse_review(r)[1], "<-", r[:40])

OUTPUT theek <- {"label": "POSITIVE", "reason": "acha co JSON nahi hai <- Mera khayal hai ye POSITIVE hai label ghalat hai <- {"label": "ACHA", "reason": "pasand aya"

31.6 Errors, Retries aur Production ke Usool​

Network ki call kabhi bhi fail ho sakti hai. Aam masail:

MaslaWajahKya karein
401 / AuthenticationAPI key ghalat ya expiredKey check karo, naya banao
429 / Rate limitBohat tezi se calls ya credit khatamThora ruk kar dobara koshish (retry), speed kam
karo
5xx / Server errorOpenAI ki taraf maslaRetry
TimeoutJawab ne bohat der lagayiTimeout set karo, retry karo
Bad request (400)Ghalat parameter ya prompt bohat lambaRequest theek karo (retry se faida nahi)

OpenAI ki Python library khud kuch retries karti hai, aur tum control bhi de sakti ho: OpenAI(max_retries=3, timeout=30). Apna retry bhi seekho: Exponential backoff with jitter : har nakami ke baad pehle se dugna intezar , thora random pan ke saath (taake sab clients ek sath na tooten).

import random
def retry_with_backoff(fn, max_tries=5, base_delay=1.0, sleep=lambda s: None):
for attempt in range(1, max_tries + 1):
try:
return fn()
except ConnectionError as e:
if attempt == max_tries:
raise
delay = base_delay * 2 ** (attempt - 1) + random.uniform(0, 0.5)
print(f"koshish {attempt} fail ({e}); {delay:.1f}s ruk kar dobara")
sleep(delay) # asli code me time.sleep random.seed(1)
state = {"calls": 0}
def flaky_api():
# pehli 3 calls fail, chauthi theek state["calls"] += 1
if state["calls"] < 4:
raise ConnectionError("server busy")
return "jawab mil gaya"
print(retry_with_backoff(flaky_api))

OUTPUT koshish 1 fail (server busy); 1.1s ruk kar dobara koshish 2 fail (server busy); 2.4s ruk kar dobara koshish 3 fail (server busy); 4.4s ruk kar dobara jawab mil gaya

Is me sirf aise errors par retry hota hai jo wakt ke saath theek ho sakte hain. Ghalat request par retry bekaar hai. Ab ek aur sasta tareeqa: caching : ek hi sawal dobara aaye to API dobara call na karo:

from functools import lru_cache
calls = {"api": 0} @lru_cache(maxsize=256)
def cached_answer(question):
calls["api"] += 1 # asli code me yahan API call hoti
return f"jawab: {question.upper()}"
for q in ["overfitting?", "numpy?", "overfitting?", "overfitting?"]:
cached_answer(q)
print("Sawal: 4 | asli API calls:", calls["api"])

OUTPUT Sawal: 4 | asli API calls: 2

SUNEHRA USOOL​
  • Hassas maloomat (password, card number, nijee data) prompt me mat bhejo , jab tak zaroori na ho.

  • User ke input ko mehdood karo (lambai, tadaad) taake koi tumhara bill na barhaye.

  • Logging: har call ka model, tokens aur waqt record karo, lekin secret data log me mat likho.

  • Moderation aur hadood: Zehni ya khatarnaak kaam ke liye model ko ijazat na do, aur jawab ko dikhane se pehle check karo.

  • Fallback rakho: API chal na rahi ho to app ko saleeqe se band hona chahiye ("thori der baad koshish karein").

31.7 Fine-tuning kya hai aur kab karein?​

Fine-tuning me tum ek tayyar (pre-trained) model ko apne chhote dataset par mazeed train karti ho taake wo tumhare khaas kaam, andaz ya format me behtar ho jaye. Chapter 27 ke transfer learning ka wohi idea, ab LLM ke liye.

VERSION NOTE​

Zaroori haqeeqat: OpenAI ke docs ke mutabiq unka fine-tuning platform ab wind-down (rafta rafta band) ho raha hai. Naye users ke liye ye khula nahi hai, aur purane users ke liye bhi cheezein badal rahi hain. Is liye docs ka "fine-tuning" aur "deprecations" page zaroor dekhna.

Is ke bawajood fine-tuning ka workflow (data tayyar karna, training, evaluation) har provider aur open-source models par ek jaisa hai, aur interview aur asli kaam me ye samajh kaam aati hai. Is liye hum 31.8 aur 31.9 me workflow seekhenge (OpenAI ke format me), aur 31.10 me open-source (LoRA) raasta dekhenge jo har kisi ke liye khula hai.

31.8 Fine-tuning ka data tayyar karna​

Fine-tuning me data ki quality, quantity se zyada ahem hai. Kuch sau achhi, saaf, mutanawwa misalein hazaron kharab misalon se behtar hain. Chat models ka format JSONL (har line ek JSON) hota hai, jahan har line ek mukammal guftagu ki misaal hai:

{"messages": [
{"role": "system", "content": "Tum SMIT ke student support assistant ho."},
{"role": "user", "content": "Class ka time kya hai?"},
{"role": "assistant", "content": "Assalam o Alaikum! Class ka time ..."}
]}

Dataset code se banao , validate karo , aur train / validation me baanto. Ye pura kaam bina API key ke hota hai:

import json, random
random.seed(7)
SYSTEM = "Tum dostana student support assistant ho. Roman Urdu me 2 jumlon me jawab do."
qa = [
("Class ka time kya hai?",
"Time schedule me likha hai. Din bata do to main time bata dungi."),
("Assignment kab jama karni hai?",
"Last date har week ke end par hoti hai. Der se bachne ke liye pehle jama kar do."),
("Mujhe Python samajh nahi aa rahi.",
"Fikr mat karo, shuru me sab ko mushkil lagti hai. Roz 30 minute practice karo."),
("Colab me code nahi chal raha.",
"Runtime restart karo aur cells dobara chalao. Error aaye to mujhe bhej do."),
("Project idea chahiye.",
"Cricket ya mausam ka data lo. Us par chhota prediction model acha project hai."),
("Test ki tayyari kaise karun?",
"Apni galtiyon ki list banao aur unhi par practice karo. Ek mock test zaroor do."),
("Mera internet kamzor hai.",
"Lecture download kar lo. Colab ka kaam wahan karo jahan internet behtar ho."),
("GPU kaise on karun?",
"Colab me Runtime, Change runtime type, phir GPU chuno. Training se pehle ye karo."),
("Mentor se kab milun?",
"Class ke baad waqt hota hai. Apne sawal pehle likh kar le jao."),
("Marks kam aye hain.",
"Dil chhota mat karo. Kamzor topics ki list banao, hum ek ek karke theek karenge."),
("Certificate kab milega?",
"Course aur final project mukammal hone par milta hai. Tarikh dekhte raho."),
("Kya main job ke liye tayyar hoon?",
"3-4 projects aur saaf GitHub code madad karta hai. Phir interview practice karo."),
]
def to_example(q, a):
return {"messages": [{"role": "system", "content": SYSTEM},
{"role": "user", "content": q},
{"role": "assistant", "content": a}]}
examples = [to_example(q, a) for q, a in qa]
random.shuffle(examples)
train, val = examples[:10], examples[10:] # 10 train, 2 validation
with open("train.jsonl", "w", encoding="utf-8") as f:
for ex in train:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
with open("val.jsonl", "w", encoding="utf-8") as f:
for ex in val:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
print("train:", len(train), "| validation:", len(val))
print(open("train.jsonl", encoding="utf-8").readline()[:85], "...")

OUTPUT train: 10 | validation: 2 {"messages": [{"role": "system", "content": "Tum dostana student support assistant ho ...

Fine-tuning se pehle har line ko check karo, kyun ke ek kharab line poora job rok sakti hai ya model ko kharab kar sakti hai:

def validate_line(line, max_chars=4000):
ex = json.loads(line)
msgs = ex.get("messages")
if not msgs:
return "messages nahi hain"
if msgs[-1]["role"] != "assistant":
return "aakhri message assistant ka hona chahiye"
for m in msgs:
if m["role"] not in ("system", "user", "assistant"):
return f"ghalat role: {m['role']}"
if not m["content"].strip():
return "khali content"
if sum(len(m["content"]) for m in msgs) > max_chars:
return "bohat lamba"
return "OK"
lines = open("train.jsonl", encoding="utf-8").read().splitlines()
results = [validate_line(l) for l in lines]
print("Theek lines:", results.count("OK"), "/", len(lines))
bad = '{"messages": [{"role": "user", "content": "hello"}]}' # assistant jawab nahi
print("Jaan boojh kar kharab line:", validate_line(bad))
total_chars = sum(len(m["content"]) for l in lines for m in json.loads(l)["messages"])
print("Taqreeban tokens (chars/3 ka andaza):", total_chars // 3)

OUTPUT Theek lines: 10 / 10 Jaan boojh kar kharab line: aakhri message assistant ka hona chahiye Taqreeban tokens (chars/3 ka andaza): 586

Aam data ki ghaltiNuqsanIlaaj
Bohat kam ya ek jaisi misaleinModel ratta laga leta hai, general nahi
hota
Mutanawwa sawal, alag alag andaz
Ghalat ya mutazaad jawabModel wahi ghalti seekhta haiInsan se review karwao
Test data train me shamilNateeja jhoota achha nazar aata haiPehle split karo, phir train
Nijee maloomatModel un ko yaad kar ke dohra sakta haiNaam, number, email hatao (anonymize)
Format ka farqJob fail ya model confuseUpar wale validator se check

31.9 Fine-tuning job ka flow aur Evaluation​

OpenAI ke fine-tuning ka flow chaar qadam ka hai (jin users ke account par ye abhi dastiyab hai):

  1. Files upload karo (purpose="fine-tune").

  2. Job banao : base model, training file, validation file, hyperparameters (maslan epochs ).

  3. Nigrani karo : status, events aur training/validation loss .

  4. Naya model (ft:... naam wala) istemal karo aur parkho .

# pip install openai
from openai import OpenAI
client = OpenAI()
train_file = client.files.create(file=open("train.jsonl", "rb"), purpose="fine-tune")
val_file = client.files.create(file=open("val.jsonl", "rb"), purpose="fine-tune")
job = client.fine_tuning.jobs.create( model="gpt-4.1-mini-2025-04-14", # docs me supported base models dekho training_file=train_file.id, validation_file=val_file.id, method={"type": "supervised", "supervised": {"hyperparameters": {"n_epochs": 3}}}, )
print(job.id, job.status)

OUTPUT (namoona) ftjob-abc123 validating_files

import time
while True:
job = client.fine_tuning.jobs.retrieve(job.id)
print(job.status)
if job.status in ("succeeded", "failed", "cancelled"):
break time.sleep(30)
print("Naya model:", job.fine_tuned_model)
response = client.responses.create( model=job.fine_tuned_model, # "ft:gpt-4.1-mini-...:org::abc123" input="Class ka time kya hai?", )
print(response.output_text)

OUTPUT (namoona)

validating_files running running succeeded Naya model:
ft:gpt-4.1-mini-2025-04-14:my-org::AbC123 Class ka time schedule me likha hota hai. Jis din ki
class chahiye uska naam batao ...

Status ki mumkin qeematein: validating_files, queued, running, succeeded, failed, cancelled. Epoch ka matlab hai poore training data par ek chakkar. Bohat zyada epochs se overfitting (training ka ratta) hoti hai, jis ko validation loss pakarta hai (Chapter 21 se yaad karo).

Evaluation: kya model sach me behtar hua?​

"Mujhe to achha laga" kaafi nahi. Held-out validation set par base model aur fine-tuned model ka muqabla karo, aur maapne wale paimane pehle tay karo (maslan format ki durusti, exact match, insani rating). Neeche ek chhota evaluation harness hai, yahan model ke jawab farzi hain taake dhancha samajh aaye:

def evaluate(predictions, expected, required_keys=("label",)):
exact, valid_format = 0, 0
for pred, exp in zip(predictions, expected):
try:
data = json.loads(pred)
if all(k in data for k in required_keys):
valid_format += 1
if data.get("label") == exp:
exact += 1
except json.JSONDecodeError:
pass
n = len(expected)
return {"exact_match": exact / n, "valid_json": valid_format / n}
expected = ["POSITIVE", "NEGATIVE", "NEGATIVE", "POSITIVE", "POSITIVE"]
base_preds = ['{"label": "POSITIVE"}', "Ye NEGATIVE lagta hai", '{"label": "NEGATIVE"}', "positive", '{"label": "POSITIVE"}'] # farzi: format kharab
tuned_preds = ['{"label": "POSITIVE"}', '{"label": "NEGATIVE"}', '{"label": "NEGATIVE"}', '{"label": "POSITIVE"}', '{"label": "NEGATIVE"}']
print("Base :", evaluate(base_preds, expected))
print("Tuned :", evaluate(tuned_preds, expected))

OUTPUT Base : {'exact_match': 0.6, 'valid_json': 0.6} Tuned : {'exact_match': 0.8, 'valid_json': 1.0}

Dekho: tuned model ka format 100% durust hai magar ek jawab ghalat bhi hai. Isi liye dono paimane (format aur durusti) alag dekhte hain. Aakhir me ek bara test set aur asli user ke sawalon par bhi parkho.

31.10 LoRA: Open-source raasta​

Full fine-tuning me model ke tamam weights (arbon!) update hote hain, jis ke liye bohat bari GPU memory chahiye. LoRA (Low-Rank Adaptation) ka bohat zeheen idea: asli weight matrix W ko jam (freeze) kar do aur sirf us me ek chhoti si tabdeeli ΔW seekho jo do patle matrices ke product se banti hai:

W_naya = W + (alpha / r)
x (B @ A)
W:
(d, d) jama hua | A:
(r, d) | B:
(d, r) | r bohat chhota (maslan 8)

ANALOGY / MISAAL

Ek mota kitabi nisaab (W) hai jise tum badalna nahi chahti. Har kitab me sticky notes (B @ A) laga do jin par tumhari khaas baatein hain. Nisaab wohi rehta hai, magar sticky notes ne tumhare maqsad ke liye usay badal diya. Sticky notes ka wazan kitab ke muqable me na ke barabar hota hai.

import numpy as np
d, r = 4096, 8 # ek bari layer:
4096 x 4096
full = d * d # full fine-tuning: ye sab seekho
lora = d * r + r * d # LoRA:
A (r x d) aur B (d x r)
print(f"Full fine-tune parameters (ek layer): {full:,}")
print(f"LoRA parameters (ek layer, r={r}) : {lora:,}")
print(f"LoRA kitne % hai: {100 * lora / full:.2f}%") # chhota sa asli demo:
B @ A ki rank r se zyada nahi ho sakti np.random.seed(0)
d_small = 64
A = np.random.randn(r, d_small)
B = np.random.randn(d_small, r)
delta = B @ A # (64 x 64) ki tabdeeli
print("Tabdeeli ki shape:", delta.shape, "| uski rank:", np.linalg.matrix_rank(delta))

OUTPUT Full fine-tune parameters (ek layer): 16,777,216 LoRA parameters (ek layer, r=8) : 65,536 LoRA kitne % hai: 0.39% Tabdeeli ki shape: (64, 64) | uski rank: 8 Matlab 64 x 64 ki matrix ki tabdeeli sirf rank 8 hai: kam jagah me zaroori badlav seekh liye. Isi liye LoRA bohat sasti aur tez hai, aur training ke baad chhote adapter file (kuch MB) alag se bachti hai jo kisi bhi copy par laga sakti ho. QLoRA isi ko aur sasta karta hai: asli model ko 4-bit me compress kar ke rakhta hai. Hugging Face ki PEFT library se (Colab ke GPU par):

# !pip install transformers peft accelerate from transformers
import AutoModelForCausalLM
from peft import LoraConfig, get_peft_model
base = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct") # chhota model
config = LoraConfig( r=8, # rank lora_alpha=16, # scaling (alpha / r) target_modules=["q_proj", "v_proj"], # kin layers par adapter lagana hai lora_dropout=0.05, task_type="CAUSAL_LM", )
model = get_peft_model(base, config)
model.print_trainable_parameters()

Matlab 64 x 64 ki matrix ki tabdeeli sirf rank 8 hai: kam jagah me zaroori badlav seekh liye. Isi liye LoRA bohat sasti aur tez hai, aur training ke baad chhote adapter file (kuch MB) alag se bachti hai jo kisi bhi copy par laga sakti ho. QLoRA isi ko aur sasta karta hai: asli model ko 4-bit me compress kar ke rakhta hai. Hugging Face ki PEFT library se (Colab ke GPU par):

print_trainable_parameters() ke output me trainable parameters, kul parameters ka 1% se bhi kam nazar aate hain. Training ke liye Hugging Face ki TRL library ka SFTTrainer istemal hota hai, jo wohi JSONL chat data (31.8) le sakta hai. Model ka size, GPU memory aur epochs ka hisaab apne kaam ke mutabiq rakho.

RaastaKab chuno?Kharcha / mehnat
Prompt + few-shotHamesha pehle yahiSab se kam
RAGApna/badalta ilm chahiyeDarmiyana
Provider fine-tuningAgar tumhare account par dastiyab ho aur
andaz/format chahiye
Training + usage ka kharcha
Open-source + LoRAPoora control, data bahar nahi bhejna, ya sasta halGPU time (Colab) + thori mehnat

31.11 Aam Galtiyan aur Hands-on​

AAM GALTIYAN​
  • API key code me likh kar GitHub par daal dena.

  • Model ko yaaddasht wala samajhna. History khud bhejni parti hai.

  • Model ka jawab validate kiye baghair istemal karna.

  • Har error par retry (ghalat request par retry bekaar hai).

  • Fine-tuning se naye facts sikhane ki koshish (iske liye RAG theek hai).

  • Test data ko train me shamil kar dena (nateeja jhoota achha aata hai).

  • Qeemat ka andaza na lagana aur bill ka sadma.

Hands-on​
  • Setup: apni API key Colab Secrets me rakho aur 31.2 ka code chalao (agar budget na ho to is hissay ko sirf parh lo).

  • Prompt: build_prompt me 5 mukhtalif misalein (few-shot) jodo aur prompt ki lambai dekho.

  • Validation: parse_review me 3 aur kharab jawab (khali, adhoora JSON, ghalat key) daal kar test karo.

  • Kharcha: PRICE_IN/PRICE_OUT ko asli pricing page ki qeemat se badlo aur apni app ka mahana kharcha nikalo.

  • Dataset: 31.8 me 30 apni misalein (kisi aur kaam ke liye) banao, validate karo aur train/val me baanto.

  • LoRA: r ko 4, 8, 64 karo aur parameters ka % aur rank dekho.

KEY TAKEAWAYS​
  • API key ek secret hai : environment/Colab Secrets me rakho, kabhi code ya GitHub me nahi.

  • Responses API: client.responses.create(model, instructions, input), jawab response.output_text, kharcha response.usage se.

  • Model stateless hai: history tum bhejti ho ; lambi history ko trim/summarize karo.

  • Kharcha = (input tokens + output tokens) x qeemat ; hamesha pehle andaza lagao.

  • Prompt engineering: saaf hidayat, role, few-shot, delimiters, output format; Structured Outputs se JSON; jawab validate karo.

  • Retry sirf wakti errors par , exponential backoff + jitter ke saath; caching se kharcha bachao.

  • Seedha: Prompt -> RAG -> Fine-tuning. Fine-tuning andaz/format seekhati hai, facts nahi.

  • Fine-tuning ka platform badal raha hai (VERSION NOTE), magar workflow (data -> job -> evaluation) aur LoRA (sasta open-source tareeqa) ahem hain.