Python kursi25.12-dars: Modelni ishlab chiqarishga chiqarish
Python kursi · ML va AI

25.12-dars: Modelni ishlab chiqarishga chiqarish

16 daqiqa12/12-dars

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):

python
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:

python
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:

python
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:

python
# monitoring: model qanday ishlayapti
#   - aniqlik (real natija bilan)
#   - tezlik (bashorat vaqti)
#   - ma'lumot siljishi (data drift)
# data drift: yangi ma'lumot o'qitilgandan farqli

Monitoring — 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:

python
# 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

python
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 → monitor

Deployment 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 qiymati

4. Batafsil misollar

Misollarda scikit-learn, joblib, PyTorch bilan sinaladi.

Misol 1 — Modelni saqlash va yuklash

python
"""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:

text
=== 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 ishlatish

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — PyTorch model saqlash

python
"""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:

text
=== 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 alohida

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Bashorat xizmati (API mantiqi)

python
"""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:

text
=== 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 orqali

Nima 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.

python
"""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:

text
=== 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 → monitor

Nima 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

python
def predict(x): model.fit(...); return ...   # ⚠️ sekin
# saqla, bir marta yukla                       # ✅

2. Kutubxona versiyasi mos emas

python
# sklearn 1.0 da saqla, 1.5 da yukla — xato    # ⚠️
# versiyani mos ushla (requirements)            # ✅

3. PyTorch — butun model saqlash

python
torch.save(model, ...)   # tuzilmaga bog'liq    # ⚠️
torch.save(model.state_dict(), ...)             # ✅

4. eval() unutish (PyTorch)

python
model.load_state_dict(...)   # train rejimi     # ⚠️
model.eval()   # baholash rejimi                 # ✅

5. Monitoring yo'q (eskirish)

python
# deploy, unut                                   # ⚠️ (eskiradi)
# aniqlik kuzat, qayta o'qit                      # ✅

6. Versiyalamaslik

python
model.joblib   # ustiga yozish                   # ⚠️ (rollback yo'q)
model_v1, v2   # versiyalangan                    # ✅

7. Kirish tekshirmaslik (API)

python
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

  1. Modelni saqla (o'qitish takrorlamasdan).

  2. Bir marta yukla (startda), so'rovlarga xizmat.

  3. PyTorch — state_dict (vaznlar).

  4. API orqali xizmat (FastAPI).

  5. Monitoring (aniqlik, data drift).

  6. Versiyala (rollback).

  7. Kirishni tekshir (API — Pydantic).

  8. ML — davriy (kuzat, qayta o'qit).


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
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
  1. Modelni real foydalanishga keltirish
  2. O'qitish takrorlamasdan ishlatish
  3. Model saqlash/yuklash (sklearn)
  4. state_dict (vaznlar)
  5. Model vaznlari (parametrlar)
  6. Baholash rejimi (bashorat)
  7. Model veb endpoint (so'rov → bashorat)
  8. Model ishlashini kuzatish
  9. Ma'lumot o'zgarishi (model eskiradi)
  10. Modellarni versiyalash (rollback)
  11. Ha (kuzatish, yangilash)
  12. ML ni amaliy qiymatga aylantiradi

Vazifa 2: Xatolarni tuzating

python
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                        # monitoring
Javoblar
python
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'qit

Vazifa 3: Saqlash/yuklash

Model:

  1. joblib.dump
  2. joblib.load
  3. Bashorat
  4. Bir xil

Vazifa 4: PyTorch

Saqlash:

  1. state_dict
  2. Yuklash
  3. eval()
  4. Bashorat

Vazifa 5: API

Xizmat:

  1. Model yukla
  2. predict funksiya
  3. So'rov
  4. JSON javob

Vazifa 6: To'liq oqim

Deployment:

  1. O'qit
  2. Saqla
  3. Deploy
  4. 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

  1. O'qitilgan model — boshi (deployment — qiymat)
  2. Deployment o'qitishdan qiyinroq
  3. ML davriy (data drift, qayta o'qit)
  4. Model — mahsulot (kuzat, yangila)

6. Xulosa

  1. Foydalanilmagan model — 0 qiymat
  2. Deployment — amaliy qiymat (qiyin)
  3. ML davriy jarayon (kuzatish)
  4. 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:

  1. 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.

  2. 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.

  3. 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.

ML va AI · 12-dars yakunlandi

25.12-dars: Modelni ishlab chiqarishga chiqarish

16 daqvaqt
0belgi
Keyingi dars: 26.1-dars: Skript yozish tamoyillari
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0