25.12-dars: Modelni ishlab chiqarishga chiqarish
25-QISM — ML VA AI · 12-dars (yakuniy)
1. Kirish va motivatsiya
25.1–25.11 da model qurdik va o'qitdik — lekin u sizning kompyuteringizda, kod ichida. Model foydali bo'lishi uchun real foydalanuvchilarga xizmat qilishi kerak: veb ilova, mobil, boshqa tizim undan bashorat so'rasin. Bu — modelni ishlab chiqarishga chiqarish (deployment). O'qitilgan model — bu boshi, uni foydalanishga keltirish — oxiri. Ko'p model o'qitiladi, lekin ishlab chiqarishga chiqmaydi — deployment muhim mahorat.
Model deployment — o'qitilgan modelni real foydalanishga keltirish: 1) saqlash (joblib, torch.save — modelni faylga), 2) yuklash (bashorat uchun), 3) xizmat (API orqali — FastAPI, 20-qism, so'rov → bashorat → javob), 4) monitoring (model qanday ishlayapti — aniqlik, tezlik, ma'lumot o'zgarishi). Muhim tushunchalar: model saqlash formati, API endpoint (bashorat xizmati), ma'lumot siljishi (data drift — vaqt o'tib ma'lumot o'zgaradi, model eskiradi). Deployment — ML ni amaliy qiymatga aylantiradi.
Real vaziyat. Bir jamoa ajoyib model o'qitdi (95% aniq), lekin u faqat noutbukda edi — hech kim ishlatolmasdi. Deployment qilindi: model joblib bilan saqlandi, FastAPI (20-qism) endpoint qurildi (/predict), veb ilova unga so'rov yubordi. Endi model real foydalanishda. Keyin monitoring qo'shildi — aniqlik tushsa ogohlantirish. Model qiymat keltirdi. Deployment — modelni foydali qilish.
Bu darsda — 25-qism yakuni — modelni ishlab chiqarishga chiqarishni o'rganamiz.
Bu darsda:
- Deployment nima
- Modelni saqlash/yuklash
- PyTorch model saqlash
- API orqali xizmat (FastAPI)
- Monitoring va ma'lumot siljishi
- Versiyalash
- ML ish oqimi (to'liq)
- 25-qism yakuni
ℹ Misollarda scikit-learn, joblib, PyTorch bilan sinaladi.
2. Nazariya — chuqur tushuntirish
2.1. Deployment nima
O'qitilgan modelni foydalanishga:
O'qitish (25.9) → Saqlash → Yuklash → Xizmat (API) → Monitoring
(model tayyor) (fayl) (bashorat) (foydalanuvchi) (kuzatish)Deployment — o'qitilgan modelni real foydalanishga keltirish: saqlash (fayl) → yuklash (bashorat uchun) → xizmat (API — foydalanuvchi so'rov yuboradi) → monitoring (kuzatish). O'qitilgan model — boshi, deployment — uni foydali qilish. Ko'p model o'qitiladi, lekin ishlab chiqarishga chiqmaydi ("proof of concept" da qoladi). Deployment — ML ni amaliy qiymatga aylantiradi. "O'qitilgan model foydalanilmasa — foydasiz".
2.2. Modelni saqlash/yuklash
Modelni faylga (o'qitish takrorlamasdan):
import joblib
joblib.dump(model, "model.joblib") # saqlash
model = joblib.load("model.joblib") # yuklash
# yoki pickle (umumiy), lekin joblib — ML uchun Modelni saqlash (joblib.dump) — o'qitilgan modelni faylga (vaznlar, sozlamalar); yuklash (joblib.load) — qayta o'qitmasdan ishlatish. Sabab: o'qitish sekin (soatlar), lekin saqlangan model darrov yuklanadi (bashorat uchun). joblib (scikit-learn — samarali), pickle (umumiy Python obyekt). Muhim: saqlangan model bir xil kutubxona versiyasida yuklanishi kerak (mos versiya). Model — o'qitish natijasi (saqlab, ishlatiladi).
2.3. PyTorch model saqlash
Neyron tarmoq saqlash:
import torch
torch.save(model.state_dict(), "model.pt") # vaznlarni saqla
# yuklash:
model = MyModel() # tuzilma
model.load_state_dict(torch.load("model.pt")) # vaznlar
model.eval() # baholash rejimi PyTorch saqlash: torch.save(model.state_dict(), fayl) — model vaznlarini (parametrlar — 25.8) saqlash. Yuklash: model tuzilmasini qayta yaratib (MyModel()), vaznlarni yuklash (load_state_dict). model.eval() — baholash rejimi (o'qitishda emas — dropout, batchnorm o'chiradi). Muhim: state_dict (vaznlar) tuzilma bilan alohida (kod kerak). Bu chuqur o'qitish model deployment. Vaznlar + kod = model.
2.4. API orqali xizmat (FastAPI)
Modelni veb xizmat sifatida:
from fastapi import FastAPI
app = FastAPI()
model = joblib.load("model.joblib")
@app.post("/predict")
def predict(features: list):
p = model.predict([features])[0]
return {"prediction": int(p)}
# so'rov → bashorat → JSON javob API orqali xizmat (FastAPI — 20-qism) — modelni veb endpoint sifatida: /predict (POST — feature yuboriladi), model bashorat qiladi, JSON javob. Sabab: har xil mijoz (veb, mobil, boshqa tizim) API orqali bashorat so'radi (bir joyda model, ko'p mijoz). Model yuklanadi (bir marta — startda), so'rovlarga xizmat qiladi. Bu 20-qism (FastAPI) va 25-qism (ML) ni birlashtiradi. Model — veb xizmat.
2.5. Monitoring va ma'lumot siljishi
Model vaqt o'tib eskiradi:
# monitoring: model qanday ishlayapti
# - aniqlik (real natija bilan)
# - tezlik (bashorat vaqti)
# - ma'lumot siljishi (data drift)
# data drift: yangi ma'lumot o'qitilgandan farqliMonitoring — model ishlab chiqarishda qanday ishlashini kuzatish: aniqlik (real natija bilan solishtirib — tushsa muammo), tezlik (bashorat vaqti), xatolar. Ma'lumot siljishi (data drift) — muhim: vaqt o'tib ma'lumot o'zgaradi (yangi naqshlar, o'zgargan xulq) — model o'qitilgan ma'lumotdan farqli bo'ladi, eskiradi (aniqlik tushadi). Yechim: qayta o'qitish (yangi ma'lumot bilan). Model — "bir marta o'qit, unut" emas (kuzatish, yangilash kerak).
2.6. Versiyalash
Modellar versiyalari:
# model_v1.joblib, model_v2.joblib
# har o'qitish — yangi versiya
# eski versiyaga qaytish mumkin (rollback)
# metadata: qaysi ma'lumot, qachon, aniqlik Versiyalash — modellarni versiyalab saqlash (model_v1, model_v2): har qayta o'qitish yangi versiya. Sabab: yangi model yomonroq bo'lsa — eskiga qaytish (rollback), taqqoslash, kuzatish (qaysi model ishlab chiqarishda). Metadata (qaysi ma'lumot, qachon, aniqlik — 23.8 migratsiya kabi) — model tarixi. Bu 19-qism (versiyalash), 28-qism (MLOps) bilan bog'liq. Model kod kabi versiyalanadi (takrorlanadigan, kuzatiladigan).
2.7. ML ish oqimi (to'liq)
To'liq ML ish oqimi: 1) ma'lumot (24-qism — yig', tozala), 2) feature 25.5-bob, 3) o'qitish 25.9-bob, 4) baholash 25.4-bob, 5) saqlash (joblib), 6) deployment (API), 7) monitoring (kuzatish), 8) qayta o'qitish (ma'lumot siljishi). Bu davriy (bir marta emas — kuzatish, yangilash). MLOps (ML + DevOps — 28-qism) bu jarayonni avtomatlashtiradi (avtomatik o'qitish, deploy, monitoring). Model — mahsulot (kuzatiladi, yangilanadi), loyiha emas (bir marta tugaydigan). "ML — davriy jarayon".
2.8. Deployment — ML qiymati
Deployment — ML ni amaliy qiymatga aylantiradi: o'qitilgan model (laboratoriyada 95%) foydalanilmasa — 0 qiymat. Real foydalanish (API, monitoring) — model qiymat keltiradi. Muhim tushunchalar: model saqlash (takrorlamasdan), API (xizmat), monitoring (eskirish), versiyalash (rollback). Deployment ko'pincha o'qitishdan qiyinroq (real ma'lumot, tezlik, ishonchlilik, xavfsizlik). "O'qitilgan model — 20%, deployment — 80%" (real qiymat). Bu 25-qism (ML) ni 20-qism (backend), 28-qism (infratuzilma) bilan bog'laydi. Model — real dunyoda ishlashi kerak.
3. Tez ma'lumotnoma
import joblib
import torch
# sklearn saqlash/yuklash:
joblib.dump(model, "model.joblib")
model = joblib.load("model.joblib")
# PyTorch saqlash/yuklash:
torch.save(model.state_dict(), "model.pt")
model = MyModel()
model.load_state_dict(torch.load("model.pt"))
model.eval()
# API xizmat (FastAPI, 20-qism):
from fastapi import FastAPI
app = FastAPI()
model = joblib.load("model.joblib")
@app.post("/predict")
def predict(features: list):
return {"prediction": int(model.predict([features])[0])}
# monitoring: aniqlik, tezlik, data drift
# versiyalash: model_v1, v2 (rollback)
# ML oqim: ma'lumot → feature → o'qit → bahola → saqla → deploy → monitorDeployment xulosasi
Deployment: model → foydalanish · saqlash (joblib/torch.save) → yuklash → API → monitoring
FastAPI /predict (so'rov→bashorat) · data drift (eskiradi) · versiyalash (rollback)
ML — davriy jarayon (kuzat, yangila) · deployment — ML qiymati4. Batafsil misollar
Misollarda scikit-learn, joblib, PyTorch bilan sinaladi.
Misol 1 — Modelni saqlash va yuklash
"""joblib.dump/load: modelni faylga saqlash, qayta yuklash (o'qitish takrorlamasdan)."""
import warnings
warnings.filterwarnings("ignore")
import os
import tempfile
import joblib
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
def main() -> None:
X, y = load_iris(return_X_y=True)
model = LogisticRegression(max_iter=1000, random_state=42).fit(X, y)
print("=== 1. Modelni saqlash (joblib.dump) ===")
yol = os.path.join(tempfile.mkdtemp(), "model.joblib")
joblib.dump(model, yol)
print(f" saqlandi: {os.path.exists(yol)}")
print(f" fayl bo'sh emas: {os.path.getsize(yol) > 0}")
print("\n=== 2. Modelni yuklash (joblib.load) ===")
yuklangan = joblib.load(yol)
print(f" yuklandi: {yuklangan is not None}")
print("\n=== 3. Bashorat (yuklangan model) ===")
print(f" bashorat: {yuklangan.predict(X[:3]).tolist()}")
print("\n=== 4. Asl bilan bir xil ===")
print(f" teng: {(yuklangan.predict(X) == model.predict(X)).all()}")
print(" ⭐ saqlash/yuklash — o'qitish takrorlamasdan ishlatish")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Modelni saqlash (joblib.dump) ===
saqlandi: True
fayl bo'sh emas: True
=== 2. Modelni yuklash (joblib.load) ===
yuklandi: True
=== 3. Bashorat (yuklangan model) ===
bashorat: [0, 0, 0]
=== 4. Asl bilan bir xil ===
teng: True
⭐ saqlash/yuklash — o'qitish takrorlamasdan ishlatishNima ko'rsatdi: 2.1, 2.2-bo'limlar.
Misol 2 — PyTorch model saqlash
"""torch.save/load: state_dict (vaznlar) saqlash; tuzilma + vaznlar yuklash; eval()."""
import warnings
warnings.filterwarnings("ignore")
import os
import tempfile
import torch
import torch.nn as nn
def main() -> None:
torch.manual_seed(0)
print("=== 1. Model va saqlash ===")
model = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 3))
yol = os.path.join(tempfile.mkdtemp(), "model.pt")
torch.save(model.state_dict(), yol)
print(f" vaznlar saqlandi: {os.path.exists(yol)}")
print("\n=== 2. Yuklash (tuzilma + vaznlar) ===")
model2 = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 3))
model2.load_state_dict(torch.load(yol))
print(" tuzilma yaratildi, vaznlar yuklandi")
print("\n=== 3. eval() — baholash rejimi ===")
model2.eval()
print(" eval: o'qitish rejimi o'chirildi (bashorat)")
print("\n=== 4. Bashorat (bir xil natija) ===")
x = torch.randn(1, 4)
with torch.no_grad():
out1 = model(x)
out2 = model2(x)
print(f" bir xil bashorat: {torch.allclose(out1, out2)}")
print(" ⭐ torch.save — state_dict (vaznlar), tuzilma alohida")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Model va saqlash ===
vaznlar saqlandi: True
=== 2. Yuklash (tuzilma + vaznlar) ===
tuzilma yaratildi, vaznlar yuklandi
=== 3. eval() — baholash rejimi ===
eval: o'qitish rejimi o'chirildi (bashorat)
=== 4. Bashorat (bir xil natija) ===
bir xil bashorat: True
⭐ torch.save — state_dict (vaznlar), tuzilma alohidaNima ko'rsatdi: 2.3-bo'lim.
Misol 3 — Bashorat xizmati (API mantiqi)
"""bashorat xizmati: model yuklash, predict funksiyasi (API endpoint mantiqi)."""
import warnings
warnings.filterwarnings("ignore")
import os
import tempfile
import joblib
import numpy as np
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
def main() -> None:
data = load_iris()
model = RandomForestClassifier(random_state=42).fit(data.data, data.target)
yol = os.path.join(tempfile.mkdtemp(), "model.joblib")
joblib.dump(model, yol)
# API mantiqi (FastAPI endpoint kabi):
yuklangan = joblib.load(yol)
def predict_api(features: list) -> dict:
"""FastAPI /predict endpoint mantiqi."""
p = yuklangan.predict(np.array([features]))[0]
tur = data.target_names[p]
return {"prediction": int(p), "tur": str(tur)}
print("=== 1. Model yuklandi (xizmat starti) ===")
print(" model bir marta yuklanadi (so'rovlarga tayyor)")
print("\n=== 2. Bashorat so'rovi (API) ===")
natija = predict_api([5.1, 3.5, 1.4, 0.2])
print(f" kirish [5.1, 3.5, 1.4, 0.2] → {natija}")
print("\n=== 3. Boshqa so'rov ===")
natija2 = predict_api([6.7, 3.0, 5.2, 2.3])
print(f" kirish [6.7, 3.0, 5.2, 2.3] → {natija2}")
print("\n=== 4. API mantiqi ===")
print(" so'rov (feature) → model.predict → JSON javob")
print(" FastAPI (20-qism) bilan veb endpoint")
print(" ⭐ bashorat xizmati — model API orqali")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. Model yuklandi (xizmat starti) ===
model bir marta yuklanadi (so'rovlarga tayyor)
=== 2. Bashorat so'rovi (API) ===
kirish [5.1, 3.5, 1.4, 0.2] → {'prediction': 0, 'tur': 'setosa'}
=== 3. Boshqa so'rov ===
kirish [6.7, 3.0, 5.2, 2.3] → {'prediction': 2, 'tur': 'virginica'}
=== 4. API mantiqi ===
so'rov (feature) → model.predict → JSON javob
FastAPI (20-qism) bilan veb endpoint
⭐ bashorat xizmati — model API orqaliNima ko'rsatdi: 2.4-bo'lim.
Misol 4 — Amaliy: to'liq ML deployment oqimi
Real ML: o'qitish → saqlash → yuklash → bashorat → monitoring (aniqlik) — to'liq oqim. Bu — model deploymentning namunasi.
"""to'liq deployment oqimi: o'qit → saqla → yukla → bashorat → monitoring (aniqlik kuzat)."""
import warnings
warnings.filterwarnings("ignore")
import os
import tempfile
import joblib
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
def main() -> None:
X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=42)
print("=== 1. O'qitish 25.9-bob ===")
model = RandomForestClassifier(random_state=42).fit(Xtr, ytr)
print(f" test aniqlik: {round(model.score(Xte, yte), 3)}")
print("\n=== 2. Saqlash (versiyalangan) ===")
yol = os.path.join(tempfile.mkdtemp(), "model_v1.joblib")
joblib.dump(model, yol)
print(f" saqlandi: model_v1.joblib")
print("\n=== 3. Deployment (yuklash + xizmat) ===")
ishlab_chiqarish = joblib.load(yol)
print(" model yuklandi (bashorat uchun tayyor)")
print("\n=== 4. Monitoring (aniqlik kuzatish) ===")
# real ma'lumot kelganda aniqlikni kuzat
pred = ishlab_chiqarish.predict(Xte)
joriy_aniqlik = accuracy_score(yte, pred)
print(f" joriy aniqlik: {round(joriy_aniqlik, 3)}")
chegara = 0.9
holat = "yaxshi" if joriy_aniqlik >= chegara else "OGOHLANTIRISH: qayta o'qit"
print(f" holat: {holat}")
print(" ma'lumot siljishi → aniqlik tushsa → qayta o'qit")
print(" ⭐ to'liq oqim — o'qit → saqla → deploy → monitor")
if __name__ == "__main__":
main()Natijaning muhim qismi:
=== 1. O'qitish 25.9-bob ===
test aniqlik: 1.0
=== 2. Saqlash (versiyalangan) ===
saqlandi: model_v1.joblib
=== 3. Deployment (yuklash + xizmat) ===
model yuklandi (bashorat uchun tayyor)
=== 4. Monitoring (aniqlik kuzatish) ===
joriy aniqlik: 1.0
holat: yaxshi
ma'lumot siljishi → aniqlik tushsa → qayta o'qit
⭐ to'liq oqim — o'qit → saqla → deploy → monitorNima ko'rsatdi: 2.1–2.8-bo'limlar.
5. To'g'ri va noto'g'ri tushunishlar
| Noto'g'ri fikr | To'g'risi |
|---|---|
| "O'qitilgan model — tayyor" | Deployment kerak (foydalanish) |
| "Har so'rovda o'qit" | Saqla, yukla (tez) |
| "Model o'zgarmaydi" | Ma'lumot siljishi (eskiradi) |
| "Bir marta deploy — bo'ldi" | Monitoring, yangilash |
| "Deployment oson" | Ko'pincha o'qitishdan qiyin |
| "Versiyalash keraksiz" | Rollback, taqqoslash |
| "PyTorch = pickle" | state_dict (vaznlar) |
| "Aniqlik doim bir xil" | Vaqt o'tib tushishi mumkin |
6. Keng tarqalgan xatolar va yechimlari
1. Har so'rovda qayta o'qitish
def predict(x): model.fit(...); return ... # ⚠️ sekin
# saqla, bir marta yukla # ✅2. Kutubxona versiyasi mos emas
# sklearn 1.0 da saqla, 1.5 da yukla — xato # ⚠️
# versiyani mos ushla (requirements) # ✅3. PyTorch — butun model saqlash
torch.save(model, ...) # tuzilmaga bog'liq # ⚠️
torch.save(model.state_dict(), ...) # ✅4. eval() unutish (PyTorch)
model.load_state_dict(...) # train rejimi # ⚠️
model.eval() # baholash rejimi # ✅5. Monitoring yo'q (eskirish)
# deploy, unut # ⚠️ (eskiradi)
# aniqlik kuzat, qayta o'qit # ✅6. Versiyalamaslik
model.joblib # ustiga yozish # ⚠️ (rollback yo'q)
model_v1, v2 # versiyalangan # ✅7. Kirish tekshirmaslik (API)
model.predict([xato_shakl]) # xato # ⚠️
# kirishni tekshir (Pydantic — 20.3) # ✅7. Integratsiya — bu bilim qayerda kerak bo'ladi
- 25.9-dars (o'tilgan): O'qitish — deploy manbai
- 20-qism (o'tilgan): FastAPI — model xizmat
- 28-qism: Infratuzilma — MLOps, Docker
- 29-qism: Unumdorlik — bashorat tezligi
- 31-qism: Loyihalar — real ML deployment
8. Eng yaxshi amaliyotlar
Modelni saqla (o'qitish takrorlamasdan).
Bir marta yukla (startda), so'rovlarga xizmat.
PyTorch —
state_dict(vaznlar).API orqali xizmat (FastAPI).
Monitoring (aniqlik, data drift).
Versiyala (rollback).
Kirishni tekshir (API — Pydantic).
ML — davriy (kuzat, qayta o'qit).
9. Amaliy topshiriq
Vazifa 1: Bashorat qiling
1. # deployment nima?
2. # nega saqlash?
3. # joblib nima?
4. # PyTorch qanday saqlanadi?
5. # state_dict nima?
6. # eval() nima?
7. # API xizmat nima?
8. # monitoring nima?
9. # data drift nima?
10. # versiyalash nima?
11. # ML oqim davriymi?
12. # deployment nega muhim?Javoblar
- Modelni real foydalanishga keltirish
- O'qitish takrorlamasdan ishlatish
- Model saqlash/yuklash (sklearn)
- state_dict (vaznlar)
- Model vaznlari (parametrlar)
- Baholash rejimi (bashorat)
- Model veb endpoint (so'rov → bashorat)
- Model ishlashini kuzatish
- Ma'lumot o'zgarishi (model eskiradi)
- Modellarni versiyalash (rollback)
- Ha (kuzatish, yangilash)
- ML ni amaliy qiymatga aylantiradi
Vazifa 2: Xatolarni tuzating
1. def predict(x): model.fit(...) # saqla, yukla
2. torch.save(model, ...) # state_dict
3. model.load_state_dict(...) # eval yo'q # eval()
4. model.joblib # ustiga yozish # versiya
5. # deploy, unut # monitoringJavoblar
1. joblib.dump/load (bir marta)
2. torch.save(model.state_dict(), ...)
3. model.eval()
4. model_v1.joblib, model_v2.joblib
5. # aniqlik kuzat, qayta o'qitVazifa 3: Saqlash/yuklash
Model:
joblib.dumpjoblib.load- Bashorat
- Bir xil
Vazifa 4: PyTorch
Saqlash:
state_dict- Yuklash
eval()- Bashorat
Vazifa 5: API
Xizmat:
- Model yukla
predictfunksiya- So'rov
- JSON javob
Vazifa 6: To'liq oqim
Deployment:
- O'qit
- Saqla
- Deploy
- Monitor
Vazifa 7: O'ylash
O'qitilgan model (laboratoriyada 95%) foydalanilmasa — 0 qiymat. Deployment — ML ni amaliy qiymatga aylantiradi, va ko'pincha o'qitishdan qiyinroq (real ma'lumot, tezlik, ishonchlilik). Nima uchun "o'qitilgan model — boshi, deployment — oxiri", va nega ML davriy jarayon (bir marta emas — kuzatish, qayta o'qitish) — modelni "mahsulot" (kuzatiladigan) deb qarash nega muhim?
Javob
Qisqa javob: O'qitilgan model — boshi (laboratoriya natijasi), deployment — oxiri (real qiymat), chunki: foydalanilmagan model 0 qiymat (95% aniq bo'lsa ham). Deployment ko'pincha o'qitishdan qiyinroq: real ma'lumot (iflos, kutilmagan), tezlik (millisekundda bashorat), ishonchlilik (24/7 ishlash), xavfsizlik, monitoring. ML davriy jarayon (bir marta emas), chunki: ma'lumot siljishi (data drift — vaqt o'tib ma'lumot o'zgaradi — yangi naqshlar, xulq) → model eskiradi (aniqlik tushadi) → qayta o'qitish kerak. Modelni "mahsulot" (kuzatiladigan, yangilanadigan) deb qarash muhim, chunki: model "loyiha" (bir marta tugaydigan) emas — u yashaydi (real ma'lumot o'zgaradi), kuzatish (aniqlik), yangilash (qayta o'qit) kerak. "Model — jonli mahsulot, muzlangan artefakt emas". Bu MLOps (28-qism) ning mohiyati — ML ni davriy, avtomatlashtirilgan jarayon qilish.
1. O'qitish — boshi, deployment — oxiri
O'qitilgan model (laboratoriya) — potensial. Foydalanish (deployment) — real qiymat. Foydalanilmasa — 0.
2. Deployment qiyinroq
| O'qitish | Deployment |
|---|---|
| Toza ma'lumot | Real (iflos) |
| Sekin ham OK | Tez (millisekund) |
| Bir marta | 24/7 ishonchli |
| Laboratoriya | Real dunyo |
3. ML — davriy jarayon
Ma'lumot siljishi (data drift) → model eskiradi → qayta o'qit. Davr: o'qit → deploy → monitor → (eskirsa) qayta o'qit.
4. Model — mahsulot
| Loyiha (noto'g'ri) | Mahsulot (to'g'ri) |
|---|---|
| Bir marta tugaydi | Yashaydi, o'zgaradi |
| Deploy, unut | Kuzat, yangila |
| Muzlangan | Jonli |
5. Muhandislik saboqlari
- O'qitilgan model — boshi (deployment — qiymat)
- Deployment o'qitishdan qiyinroq
- ML davriy (data drift, qayta o'qit)
- Model — mahsulot (kuzat, yangila)
6. Xulosa
- Foydalanilmagan model — 0 qiymat
- Deployment — amaliy qiymat (qiyin)
- ML davriy jarayon (kuzatish)
- Model — jonli mahsulot
Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.
Xulosa
Bu darsda — 25-qism yakuni — modelni ishlab chiqarishga chiqarishni o'rgandik.
Eng muhim uch fikr:
Deployment va model saqlash. Deployment — o'qitilgan modelni real foydalanishga keltirish: saqlash → yuklash → xizmat (API) → monitoring. O'qitilgan model — boshi, deployment — uni foydali qilish (ko'p model ishlab chiqarishga chiqmaydi). Saqlash (
joblib.dump) — modelni faylga (vaznlar, sozlamalar); yuklash (joblib.load) — qayta o'qitmasdan (o'qitish sekin, yuklash tez). PyTorch:torch.save(model.state_dict(), fayl)(vaznlar), yuklash — tuzilma (MyModel()) + vaznlar (load_state_dict),model.eval()(baholash rejimi). Model = vaznlar + kod.API xizmat va monitoring. API orqali xizmat (FastAPI — 20-qism) — model veb endpoint (
/predict— feature yuboriladi, bashorat, JSON javob); model bir marta yuklanadi (startda), so'rovlarga xizmat qiladi (bir model, ko'p mijoz). Monitoring — model ishlab chiqarishda qanday ishlashini kuzatish (aniqlik, tezlik). Ma'lumot siljishi (data drift) — vaqt o'tib ma'lumot o'zgaradi, model eskiradi (aniqlik tushadi) → qayta o'qitish. Versiyalash (model_v1,v2) — rollback, taqqoslash, metadata.ML — davriy jarayon (model — mahsulot). To'liq ML oqimi: ma'lumot (24-qism) → feature 25.5-bob → o'qitish 25.9-bob → baholash 25.4-bob → saqlash → deployment → monitoring → qayta o'qitish. Bu davriy (bir marta emas — data drift bilan yangilash). MLOps (28-qism) buni avtomatlashtiradi. Deployment — ML ni amaliy qiymatga aylantiradi, ko'pincha o'qitishdan qiyinroq (real ma'lumot, tezlik, ishonchlilik). "O'qitilgan model — 20%, deployment — 80% (real qiymat)". Model — "mahsulot" (jonli, kuzatiladigan, yangilanadigan), "loyiha" (bir marta tugaydigan) emas. 25-qism: ML tushunchasi 25.1-bob, scikit-learn (25.2–25.6), PyTorch chuqur o'qitish (25.7–25.9), LLM/RAG (25.10–25.11), deployment 25.12-bob — ma'lumotdan foydali AI modeligacha.
Keyingi qismda (26-qism: Avtomatlashtirish) skript yozish, web scraping, API integratsiya, Telegram bot, cron — kundalik vazifalarni Python bilan avtomatlashtirishni o'rganamiz.
Izohlar · 0
Izoh yozish uchun kiring.