10 промтов для машинного обучения: от Scikit-learn до XGBoost и CatBoost

Напиши код на Python с использованием scikit-learn Pipeline для препроцессинга датафрейма pandas. Допустим, датафрейм называется 'df'. У него есть числовые колонки ['age', 'salary', 'experience'] и категориальные ['city', 'education']. Заполни пропуски в числовых медианой, в категориальных — модой. Примени StandardScaler для числовых и OneHotEncoder для категориальных. Выведи итоговый пайплайн.

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder

numeric_features = ['age', 'salary', 'experience']
categorical_features = ['city', 'education']

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)])

Сгенерируй код для GridSearchCV с RandomForestClassifier. Используй параметры: n_estimators от 100 до 500 с шагом 100, max_depth от 5 до 20 с шагом 5, min_samples_split от 2 до 10 с шагом 2. Метрика — accuracy, кросс-валидация — 5-fold. Выведи лучшие параметры.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [100, 200, 300, 400, 500],
    'max_depth': [5, 10, 15, 20],
    'min_samples_split': [2, 4, 6, 8, 10]
}

grid_search = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)
print("Best parameters:", grid_search.best_params_)

Напиши код для обучения XGBoost регрессора с кастомной метрикой MAPE (Mean Absolute Percentage Error). Используй early_stopping_rounds=50, eval_metric='mae', learning_rate=0.05. Обучи модель на train/test split 80/20. Выведи MAPE на тесте.

import xgboost as xgb
from sklearn.metrics import mean_absolute_percentage_error

model = xgb.XGBRegressor(objective='reg:squarederror', learning_rate=0.05, n_estimators=1000, early_stopping_rounds=50)
model.fit(X_train, y_train, eval_set=[(X_test, y_test)], verbose=False)
y_pred = model.predict(X_test)
mape = mean_absolute_percentage_error(y_test, y_pred)
print(f"MAPE: {mape:.4f}")

Сгенерируй код для расчёта SHAP values для модели XGBoost. Используй X_train (первые 100 строк для ускорения). Построй waterfall plot для первого объекта и summary plot.

import shap
import xgboost as xgb

model = xgb.XGBRegressor().fit(X_train, y_train)
explainer = shap.Explainer(model)
shap_values = explainer(X_train[:100])
shap.plots.waterfall(shap_values[0])
shap.summary_plot(shap_values, X_train[:100])

Напиши код для CatBoostClassifier. Укажи, что колонки ['city', 'education'] — категориальные. Используй cat_features. Обучи модель с итерациями 500, learning_rate=0.1, depth=6. Выведи F1-score на тесте.

from catboost import CatBoostClassifier
from sklearn.metrics import f1_score

cat_features = ['city', 'education']
model = CatBoostClassifier(iterations=500, learning_rate=0.1, depth=6, cat_features=cat_features, verbose=False)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(f"F1-score: {f1_score(y_test, y_pred):.4f}")

Сгенерируй код для оптимизации гиперпараметров CatBoostClassifier с помощью Optuna. Ищи оптимальные: depth (4-10), learning_rate (0.01-0.3), l2_leaf_reg (1-10). Максимизируй ROC-AUC на 5-fold CV. Выведи лучшие параметры.

import optuna
from catboost import CatBoostClassifier
from sklearn.model_selection import cross_val_score

def objective(trial):
    params = {
        'depth': trial.suggest_int('depth', 4, 10),
        'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.3, log=True),
        'l2_leaf_reg': trial.suggest_float('l2_leaf_reg', 1, 10),
        'iterations': 500,
        'verbose': False
    }
    model = CatBoostClassifier(**params)
    score = cross_val_score(model, X_train, y_train, cv=5, scoring='roc_auc').mean()
    return score

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=30)
print("Best params:", study.best_params)

Напиши код для сравнения LogisticRegression, XGBClassifier и CatBoostClassifier на датасете. Используй StandardScaler для логистической регрессии. Выведи accuracy, precision, recall, f1-score для каждой модели в виде таблицы pandas.

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.metrics import classification_report
import pandas as pd

models = {
    'LogisticRegression': make_pipeline(StandardScaler(), LogisticRegression()),
    'XGBoost': XGBClassifier(eval_metric='logloss'),
    'CatBoost': CatBoostClassifier(verbose=False)
}

results = {}
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    report = classification_report(y_test, y_pred, output_dict=True)
    results[name] = {'accuracy': report['accuracy'], 'f1': report['weighted avg']['f1']}

print(pd.DataFrame(results).T)

Сгенерируй код для XGBClassifier с учётом дисбаланса классов. Рассчитай scale_pos_weight как отношение числа отрицательных к положительным. Обучи модель и выведи ROC-AUC.

from xgboost import XGBClassifier
from sklearn.metrics import roc_auc_score

scale_pos_weight = len(y_train[y_train==0]) / len(y_train[y_train==1])
model = XGBClassifier(scale_pos_weight=scale_pos_weight, eval_metric='logloss')
model.fit(X_train, y_train)
y_pred_proba = model.predict_proba(X_test)[:, 1]
print(f"ROC-AUC: {roc_auc_score(y_test, y_pred_proba):.4f}")

Напиши код для конвертации обученного RandomForestClassifier в формат ONNX с помощью библиотеки skl2onnx. Сохрани модель в файл 'rf_model.onnx'. Проверь, что модель работает.

from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType

initial_type = [('float_input', FloatTensorType([None, X_train.shape[1]]))]
onnx_model = convert_sklearn(model, initial_types=initial_type)
with open('rf_model.onnx', 'wb') as f:
    f.write(onnx_model.SerializeToString())

Сгенерируй код для логирования эксперимента с XGBoost в MLflow. Запиши гиперпараметры (learning_rate, n_estimators, max_depth) и метрику (RMSE). Используй autolog.

import mlflow
import xgboost as xgb

mlflow.set_experiment("xgboost-experiment")
with mlflow.start_run():
    params = {'learning_rate': 0.1, 'n_estimators': 200, 'max_depth': 6}
    model = xgb.XGBRegressor(**params)
    model.fit(X_train, y_train)
    mlflow.log_params(params)
    mlflow.log_metric("RMSE", mean_squared_error(y_test, model.predict(X_test), squared=False))
    mlflow.xgboost.log_model(model, "model")