Как выстраиваешь работу?

Моя структура работы как Data Scientist

Мною руководит принцип AIDA: от Анализа проблемы к Исследованию данных, Дизайну решения и Автоматизации. Это позволяет правильно расставлять приоритеты и избежать пустой траты времени.

Фаза 1: Уточнение бизнес-задачи

Первые вопросы перед стартом

1. Какую проблему решаю?

   • "Мы теряем клиентов" → слишком расплывчато
   • "Оттока клиентов на 15%, нужно предсказать кто уйдёт в течение месяца" → ясно!

2. Почему это критично для бизнеса?

   • Понимание приоритета (это срочно или может подождать?)
   • Выделение ресурсов на проект
   • Обоснование инвестиций в ML

3. Что будет успехом?

   • Precision? Recall? F1? AUC?
   • "Модель должна находить 90% мошеннических транзакций" — метрика ясна
   • Без этого невозможно оценить результат

4. Какой бюджет по времени и ресурсам?

   • Нужно «завтра» → простая модель за день
   • Есть 2 месяца → разведка плюс A/B тестирование

Документирование на этапе

# Пример бизнес-запроса в Notion/Confluence

Задача: Предсказание оттока клиентов
────────────────────────────────────
Проблема: Теряем 15% клиентов в месяц, нужно вмешаться раньше
Суть: Построить модель, которая за 2 недели до оттока скажет нам, кто уйдёт
Метрика успеха: Recall ≥ 85% (ловим 85% всех потенциальных отходящих)
Budget: 2 недели разработки
Owner: Я (Data Scientist) + Product Manager

Фаза 2: Исследование и подготовка данных

EDA (Exploratory Data Analysis)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# 1. Загрузить данные
df = pd.read_csv('customers.csv')

# 2. Базовая статистика
print(df.info())  # Типы, пропуски
print(df.describe())  # Распределение
print(df.isnull().sum())  # Сколько пропусков

# 3. Целевая переменная
print(df['churn'].value_counts())  # Дисбалланс? 70% - 30%?

# 4. Корреляции
plt.figure(figsize=(12, 10))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm')
plt.show()

# 5. Визуализация важных признаков
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
df.groupby('churn')['monthly_charge'].mean().plot(kind='bar', ax=axes[0, 0])
df.groupby('churn')['contract_length'].value_counts().plot(ax=axes[0, 1])
# ... и так далее

Обработка данных

# 1. Пропуски
df['age'].fillna(df['age'].median(), inplace=True)  # числовые - медиана
df['category'].fillna('Unknown', inplace=True)  # категориальные - мода

# 2. Выбросы
Q1 = df['income'].quantile(0.25)
Q3 = df['income'].quantile(0.75)
IQR = Q3 - Q1
df = df[(df['income'] >= Q1 - 1.5*IQR) & (df['income'] <= Q3 + 1.5*IQR)]

# 3. Категориальные признаки
df_encoded = pd.get_dummies(df, columns=['gender', 'region'], drop_first=True)

# 4. Нормализация
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
df[['income', 'age', 'balance']] = scaler.fit_transform(df[['income', 'age', 'balance']])

# 5. Feature Engineering
df['days_since_last_purchase'] = (df['today_date'] - df['last_purchase_date']).dt.days
df['avg_purchase_value'] = df['total_spending'] / df['purchase_count']

print(f"Исходные признаки: {len(df.columns)}")
print(f"После обработки: {len(df_encoded.columns)}")

Фаза 3: Разделение на тренировку и тест

from sklearn.model_selection import train_test_split, cross_val_score

# ВАЖНО: стратифицированный split при дисбалансе
X_train, X_test, y_train, y_test = train_test_split(
    df.drop('churn', axis=1),
    df['churn'],
    test_size=0.2,
    stratify=df['churn'],  # Сохраняем соотношение классов
    random_state=42
)

print(f"Тренировка: {X_train.shape[0]} примеров, {y_train.mean():.1%} оттока")
print(f"Тест: {X_test.shape[0]} примеров, {y_test.mean():.1%} оттока")

Фаза 4: Моделирование (Итеративный процесс)

Стартую с простого

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.metrics import classification_report, roc_auc_score, confusion_matrix

# Первая модель - Logistic Regression (baseline)
model_lr = LogisticRegression(random_state=42, max_iter=1000)
model_lr.fit(X_train, y_train)

y_pred_lr = model_lr.predict(X_test)
y_proba_lr = model_lr.predict_proba(X_test)[:, 1]

print("=== Baseline: Logistic Regression ===")
print(classification_report(y_test, y_pred_lr))
print(f"ROC-AUC: {roc_auc_score(y_test, y_proba_lr):.3f}")

Затем усложняю

# Вторая модель - Random Forest
model_rf = RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)
model_rf.fit(X_train, y_train)

y_pred_rf = model_rf.predict(X_test)
y_proba_rf = model_rf.predict_proba(X_test)[:, 1]

print("\n=== Random Forest ===")
print(classification_report(y_test, y_pred_rf))
print(f"ROC-AUC: {roc_auc_score(y_test, y_proba_rf):.3f}")

# Feature importance
feature_importance = pd.DataFrame({
    'feature': X_train.columns,
    'importance': model_rf.feature_importances_
}).sort_values('importance', ascending=False)

print("\nТоп-10 признаков:")
print(feature_importance.head(10))

Кросс-валидация

from sklearn.model_selection import StratifiedKFold

kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model_rf, X_train, y_train, cv=kfold, scoring='roc_auc')

print(f"Cross-validation ROC-AUC: {scores.mean():.3f} (+/- {scores.std():.3f})")

Фаза 5: Оптимизация гиперпараметров

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10],
    'class_weight': ['balanced', None]
}

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='roc_auc',
    n_jobs=-1,
    verbose=1
)

grid_search.fit(X_train, y_train)

print(f"Лучшие параметры: {grid_search.best_params_}")
print(f"Лучший ROC-AUC: {grid_search.best_score_:.3f}")

model_best = grid_search.best_estimator_

Фаза 6: Валидация и интерпретируемость

# Confusion matrix
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm = confusion_matrix(y_test, model_best.predict(X_test))
Disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
plt.show()

# ROC-кривая
from sklearn.metrics import roc_curve, auc

fpr, tpr, thresholds = roc_curve(y_test, model_best.predict_proba(X_test)[:, 1])
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, label=f'ROC curve (AUC = {roc_auc:.3f})')
plt.plot([0, 1], [0, 1], 'k--', label='Random')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.legend()
plt.show()

# SHAP для интерпретируемости
import shap

explainer = shap.TreeExplainer(model_best)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values[1], X_test)  # Для класса 1

Фаза 7: Продакшн и мониторинг

# Сохраняем модель
import joblib
joblib.dump(model_best, 'model_churn_v1.pkl')
joblib.dump(scaler, 'scaler_v1.pkl')

# Документация
model_card = """
Модель: Random Forest для предсказания оттока
────────────────────────────────────────────
ROC-AUC на тесте: 0.89
Recall: 0.87 (ловим 87% отходящих)
Precision: 0.72

Основные признаки:
1. days_since_last_purchase
2. contract_length
3. monthly_charge

Время инференса: 2ms на 1 строку
Пояснения: SHAP values в документации
"""

with open('model_card.txt', 'w') as f:
    f.write(model_card)

Мой персональный чеклист перед сдачей

• Бизнес-задача чётко определена и согласована
• EDA проведена, инсайты документированы
• Данные очищены, пропуски обработаны
• Дисбалланс классов учтён (stratify, class_weight, threshold tuning)
• Базовая модель работает (Logistic Regression)
• Сложная модель лучше базовой
• Кросс-валидация стабильна
• Метрики соответствуют бизнес-требованиям
• Код пригоден для продакшена (обработка ошибок, логирование)
• Модель интерпретируема (SHAP, feature importance)
• Мониторинг настроен (дрейф данных, performance)

Ключевые принципы

1. Не начинай с нейросетей — сначала простые модели
2. Метрики = бизнес — если бизнес хочет Recall, оптимизируй Recall
3. Валидация важнее всего — тест-сет трогаешь один раз
4. Инсайты важнее точности — модель с точностью 90% но без инсайтов бесполезна
5. Документирование = забота — будущему себе спасибо