Jupyter va scikit-learn: birinchi ML modelingiz

uv add --dev jupyterlab ipykernel
uv run jupyter lab

%timeit np.sort(arr)              # kichik kodni ko'p marta o'lchash
%%time                            # butun hujayra vaqti (hujayraning birinchi qatori)
%load_ext autoreload
%autoreload 2                     # .py modullaringizdagi o'zgarishlar avtomatik qayta yuklansin
%matplotlib inline
!uv add scikit-learn              # terminal buyrug'i
df?                               # hujjat; df?? — manba kod

[1] df = load()            ← 1-marta
[5] df = df[df.x > 0]      ← filtrlandi
[3] model.fit(df)          ← qaysi df? 3-hujayra 5-dan KEYIN ishlagan
[5] df = df[df.x > 0]      ← yana bir marta — endi ikki marta filtrlangan!

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
 
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X.shape, y.value_counts().to_dict()      # (569, 30), {1: 357, 0: 212}  — 1: xavfsiz, 0: xavfli
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    stratify=y,            # sinflar nisbati ikkala qismda bir xil bo'lsin
    random_state=42,       # takrorlanuvchanlik
)
X_train.shape, X_test.shape              # (455, 30), (114, 30)

from sklearn.dummy import DummyClassifier
from sklearn.metrics import accuracy_score
 
dummy = DummyClassifier(strategy="most_frequent").fit(X_train, y_train)
accuracy_score(y_test, dummy.predict(X_test))       # 0.632

from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
 
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
pipe.fit(X_train, y_train)        # scaler FAQAT train'ning o'rtacha/std'sini o'rganadi
pred = pipe.predict(X_test)       # test o'sha (train'dagi) parametrlar bilan o'zgartiriladi
 
accuracy_score(y_test, pred)      # 0.982

from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score
 
print(classification_report(y_test, pred, target_names=["malignant", "benign"], digits=3))

              precision    recall  f1-score   support
 
   malignant      0.976     0.976     0.976        42
      benign      0.986     0.986     0.986        72
 
    accuracy                          0.982       114
   macro avg      0.981     0.981     0.981       114
weighted avg      0.982     0.982     0.982       114

from sklearn.metrics import ConfusionMatrixDisplay
 
ConfusionMatrixDisplay.from_predictions(y_test, pred, display_labels=["malignant", "benign"], cmap="Blues")

proba = pipe.predict_proba(X_test)[:, 1]     # "benign" ehtimoli
roc_auc_score(y_test, proba)                 # 0.995
 
# Standart chegara 0.5. Xavfli holatlarni ko'proq ushlash uchun:
pred_cautious = (proba > 0.8).astype(int)    # "xavfsiz" deyish uchun ko'proq ishonch talab qilamiz

import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.model_selection import cross_val_score
 
rng = np.random.default_rng(0)
X_noise = rng.normal(size=(200, 5000))     # 5000 ta tasodifiy "xususiyat"
y_noise = rng.integers(0, 2, 200)          # tasodifiy javoblar — o'rganadigan hech narsa YO'Q
 
# ❌ Xususiyatlarni BUTUN ma'lumot bo'yicha tanlab, keyin CV
X_selected = SelectKBest(f_classif, k=20).fit_transform(X_noise, y_noise)
cross_val_score(LogisticRegression(max_iter=1000), X_selected, y_noise, cv=5).mean()   # 0.795 (!)
 
# ✅ Tanlash pipeline ichida — har fold'da faqat train qismida
leak_free = make_pipeline(SelectKBest(f_classif, k=20), LogisticRegression(max_iter=1000))
cross_val_score(leak_free, X_noise, y_noise, cv=5).mean()                               # 0.51

from sklearn.model_selection import StratifiedKFold, cross_val_score
 
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(pipe, X_train, y_train, cv=cv, scoring="accuracy")
scores              # [0.967 0.989 0.978 0.989 0.967]
scores.mean(), scores.std()     # (0.978, 0.0098)

from sklearn.model_selection import GridSearchCV
 
grid = GridSearchCV(
    make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
    param_grid={"logisticregression__C": [0.01, 0.1, 1, 10]},   # <qadam_nomi>__<parametr>
    cv=cv,
    scoring="f1",
)
grid.fit(X_train, y_train)
grid.best_params_          # {'logisticregression__C': 0.1}
grid.best_score_           # 0.986 — CV bo'yicha
grid.score(X_test, y_test) # 0.979 — testda, BIR MARTA

from sklearn.ensemble import RandomForestClassifier
 
rf = RandomForestClassifier(n_estimators=300, random_state=42, n_jobs=-1).fit(X_train, y_train)
accuracy_score(y_test, rf.predict(X_test))       # 0.947
 
sorted(zip(rf.feature_importances_, X.columns), reverse=True)[:3]
# [(0.137, 'worst perimeter'), (0.137, 'worst area'), (0.116, 'worst concave points')]

from sklearn.feature_extraction.text import TfidfVectorizer
 
texts = [
    "mahsulot juda zo'r, tez yetkazib berishdi", "sifati a'lo, hammaga tavsiya qilaman",
    "narxiga arziydi, juda mamnunman", "ajoyib xizmat, rahmat",
    "zo'r telefon, batareyasi uzoq ishlaydi", "kuryer xushmuomala, hammasi joyida",
    "juda yoqdi, yana buyurtma beraman", "sifatli va chiroyli",
    "umuman yoqmadi, pulimni qaytaring", "yetkazib berish juda kech keldi",
    "sifati yomon, bir haftada buzildi", "rasmdagidan butunlay boshqacha",
    "xizmat yomon, javob berishmadi", "qutisi yirtilgan, mahsulot singan",
    "narxi qimmat, sifati past", "hech kimga tavsiya qilmayman",
]
labels = ["pos"] * 8 + ["neg"] * 8
 
UZ_TOKEN = r"(?u)\b\w[\w']*\w\b|\b\w\b"     # o'zbekcha apostrofli so'zlarni bo'lmaslik uchun
 
clf = make_pipeline(
    TfidfVectorizer(token_pattern=UZ_TOKEN, ngram_range=(1, 2), sublinear_tf=True),
    LogisticRegression(C=10),
)
clf.fit(texts, labels)
clf.predict(["juda zo'r xizmat, rahmat", "sifati yomon va kech keldi"])   # ['pos', 'neg']

import joblib
 
joblib.dump(pipe, "model.joblib")        # butun pipeline: scaler + model
loaded = joblib.load("model.joblib")
loaded.predict(X_test[:3])

"""train.py — modelni o'qitadi, baholaydi va artefaktlarni saqlaydi."""
 
import json
from datetime import datetime, timezone
from pathlib import Path
 
import joblib
import sklearn
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.model_selection import GridSearchCV, StratifiedKFold, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
 
SEED = 42
OUT = Path("artifacts")
 
 
def main() -> None:
    X, y = load_breast_cancer(return_X_y=True, as_frame=True)
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=SEED)
 
    search = GridSearchCV(
        make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
        {"logisticregression__C": [0.01, 0.1, 1, 10]},
        cv=StratifiedKFold(5, shuffle=True, random_state=SEED),
        scoring="f1",
    ).fit(X_train, y_train)
 
    model = search.best_estimator_
    proba = model.predict_proba(X_test)[:, 1]
    report = classification_report(y_test, model.predict(X_test), output_dict=True)
 
    OUT.mkdir(exist_ok=True)
    joblib.dump(model, OUT / "model.joblib")
    meta = {
        "created": datetime.now(timezone.utc).isoformat(),
        "sklearn": sklearn.__version__,
        "seed": SEED,
        "best_params": search.best_params_,
        "cv_f1": round(search.best_score_, 4),
        "test_accuracy": round(report["accuracy"], 4),
        "test_roc_auc": round(float(roc_auc_score(y_test, proba)), 4),
        "features": list(X.columns),
    }
    (OUT / "meta.json").write_text(json.dumps(meta, indent=2, ensure_ascii=False), encoding="utf-8")
    print(json.dumps({k: meta[k] for k in ("best_params", "cv_f1", "test_accuracy", "test_roc_auc")}))
 
 
if __name__ == "__main__":
    main()

{"best_params": {"logisticregression__C": 0.1}, "cv_f1": 0.9861, "test_accuracy": 0.9737, "test_roc_auc": 0.9957}