Как оптимизировать работу call-центра с помощью ML?

Оптимизация call-центра с помощью ML

Это комплексная задача, требующая мультидисциплинарного подхода. Расскажу о ключевых моделях и стратегиях оптимизации.

Задача 1: Прогнозирование времени ожидания

Людям нужно знать, сколько ждать перед разговором с оператором.

import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.preprocessing import StandardScaler

# Данные о вызовах
df = pd.DataFrame({
    'hour': [9, 9, 10, 10, 11, 14, 15, 16],
    'day_of_week': [1, 1, 1, 1, 1, 3, 3, 5],  # день недели
    'call_count_in_queue': [5, 8, 12, 15, 3, 22, 18, 7],
    'operators_available': [3, 3, 3, 3, 4, 2, 3, 4],
    'customer_segment': ['vip', 'regular', 'regular', 'vip', 'regular', 'regular', 'vip', 'regular'],
    'wait_time_seconds': [45, 120, 180, 240, 30, 420, 360, 60]
})

# Инженерия признаков
df['queue_per_operator'] = df['call_count_in_queue'] / df['operators_available']
df['is_vip'] = (df['customer_segment'] == 'vip').astype(int)
df['is_peak_hours'] = ((df['hour'] >= 10) & (df['hour'] <= 14)).astype(int)
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)

# Обучение модели
X = df[['hour', 'call_count_in_queue', 'operators_available', 'is_vip', 'is_peak_hours', 'is_weekend']]
y = df['wait_time_seconds']

model = GradientBoostingRegressor(random_state=42)
model.fit(X, y)

# Прогноз в реальном времени
new_call = pd.DataFrame({
    'hour': [14],
    'call_count_in_queue': [15],
    'operators_available': [3],
    'is_vip': [0],
    'is_peak_hours': [1],
    'is_weekend': [0]
})

predicted_wait = model.predict(new_call)[0]
print(f"Прогнозируемое время ожидания: {predicted_wait:.0f} секунд ({predicted_wait/60:.1f} минут)")

Задача 2: Динамическое распределение вызовов

Система должна маршрутизировать вызовы оптимальному оператору.

# Модель для прогноза результата разговора
from sklearn.linear_model import LogisticRegression

# Данные: operator, customer_segment, hour → успешное решение
data = pd.DataFrame({
    'operator_id': [1, 1, 1, 2, 2, 2, 3, 3, 3],
    'experience_years': [5, 5, 5, 2, 2, 2, 8, 8, 8],
    'customer_segment': ['vip', 'regular', 'regular', 'vip', 'vip', 'regular', 'vip', 'regular', 'regular'],
    'call_duration_minutes': [15, 8, 12, 25, 30, 5, 10, 7, 6],
    'issue_resolved': [1, 1, 0, 0, 0, 1, 1, 1, 1]
})

X = data[['experience_years', 'call_duration_minutes']]
X['is_vip'] = (data['customer_segment'] == 'vip').astype(int)
y = data['issue_resolved']

model = LogisticRegression()
model.fit(X, y)

# Рекомендация: для VIP клиента выбрать оператора с опытом
print(f"Вероятность успеха опытного оператора с VIP: {model.predict_proba([[8, 10, 1]])[0][1]:.2%}")
print(f"Вероятность успеха неопытного оператора с VIP: {model.predict_proba([[2, 25, 1]])[0][1]:.2%}")

# Оптимальное маршрутирование:
# VIP → опытные операторы
# Стандартные → любые (балансировка нагрузки)
# Простые вопросы → ботов (AI assistant)

Задача 3: Прогнозирование отказов (churn)

Определить, после какого вызова клиент может уйти к конкуренту.

from sklearn.ensemble import RandomForestClassifier

# Истории клиентов
df_churn = pd.DataFrame({
    'days_since_last_call': [1, 5, 30, 2, 100, 3, 50, 7],
    'calls_count_last_month': [10, 3, 1, 8, 0, 9, 2, 4],
    'avg_wait_time_seconds': [30, 120, 300, 45, 600, 20, 400, 150],
    'issue_resolved_rate': [0.95, 0.7, 0.5, 0.9, 0.2, 1.0, 0.3, 0.8],
    'complaint': [0, 1, 1, 0, 1, 0, 1, 0],
    'churned': [0, 1, 1, 0, 1, 0, 1, 0]
})

X = df_churn.drop('churned', axis=1)
y = df_churn['churned']

model = RandomForestClassifier(random_state=42)
model.fit(X, y)

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

print(importance)
# Результат: avg_wait_time и issue_resolved_rate — ключевые факторы

# Стратегия: клиентам с высоким риском отказа
# предлагаем скидку или приоритет в очереди
churn_prob = model.predict_proba(X)[:, 1]
print(f"Клиенты высокого риска: {(churn_prob > 0.7).sum()}")

Задача 4: Оптимизация численности персонала

Предсказывают объём вызовов по дням/часам и планируют смены.

from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline

# История вызовов по часам
call_history = pd.DataFrame({
    'hour': [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18],
    'calls_count': [50, 120, 180, 150, 90, 100, 200, 170, 140, 80, 60]
})

# Полиномиальная регрессия
pipeline = Pipeline([
    ('poly', PolynomialFeatures(degree=3)),
    ('model', LinearRegression())
])

X = call_history[['hour']].values
y = call_history['calls_count'].values
pipeline.fit(X, y)

# Прогноз пиков нагрузки
for hour in range(8, 19):
    predicted = pipeline.predict([[hour]])[0]
    required_operators = max(2, int(predicted / 60))  # 60 вызовов в час на оператора
    print(f"Час {hour}: прогноз {predicted:.0f} вызовов, нужно операторов: {required_operators}")

# Оптимизация смен:
# - Перестраиваем график смен на основе прогноза
# - Добавляем гибкие смены на пиковые часы
# - Экономим на слабые часы

Задача 5: Классификация типа проблемы и маршрутизация

Автоматически определить тип проблемы и отправить нужному специалисту.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

# Примеры проблем
issues = pd.DataFrame({
    'description': [
        'Не работает мобильное приложение, ошибка 404',
        'Не могу войти в аккаунт, забыл пароль',
        'Хочу изменить тариф, нужна помощь',
        'Приложение падает при открытии',
        'Проблема с оплатой, карта не принимается'
    ],
    'department': ['Technical', 'Support', 'Billing', 'Technical', 'Billing']
})

# Векторизация текста
vectorizer = TfidfVectorizer(max_features=50)
X = vectorizer.fit_transform(issues['description'])
y = issues['department']

model = MultinomialNB()
model.fit(X, y)

# Маршрутизация входящего вызова
new_issue = "Не могу скачать приложение из App Store"
X_new = vectorizer.transform([new_issue])
predicted_dept = model.predict(X_new)[0]
print(f"Маршрутируем в отдел: {predicted_dept}")

Задача 6: Рекомендация best practice

Учить новых операторов на основе данных лучших.

# Анализируем лучших операторов
operator_stats = pd.DataFrame({
    'operator_id': [1, 2, 3, 4, 5],
    'avg_resolution_time_min': [8, 15, 7, 20, 6],
    'customer_satisfaction': [4.8, 3.9, 4.9, 3.5, 4.7],
    'issue_resolved_rate': [0.92, 0.78, 0.95, 0.65, 0.94]
})

# Выявляем лучших
operator_stats['score'] = (
    (1 - operator_stats['avg_resolution_time_min'] / operator_stats['avg_resolution_time_min'].max()) * 0.3 +
    (operator_stats['customer_satisfaction'] / 5) * 0.4 +
    operator_stats['issue_resolved_rate'] * 0.3
)

best_operators = operator_stats.nlargest(2, 'score')
print(f"Лучшие операторы: {best_operators['operator_id'].tolist()}")

# Получаем их call recordings и анализируем техники:
# - Как они снижают время разговора?
# - Какие фразы они используют для повышения satisfaction?
# - Как они решают сложные проблемы?
# → Включаем в обучающий материал для новичков

Интеграция всех моделей: система оптимизации

def optimize_call_center(current_state):
    """
    Комплексная оптимизация call-центра
    """
    
    # 1. Прогнозируем нагрузку
    predicted_calls = forecast_model.predict(current_state['hour'])
    
    # 2. Расчитываем необходимое количество операторов
    required_operators = max(2, int(predicted_calls / 60))
    current_operators = current_state['available_operators']
    
    if current_operators < required_operators:
        print(f"⚠️ Недостаточно операторов: нужно {required_operators}, есть {current_operators}")
        # Инициируем экстренный вызов на смену
    
    # 3. Для входящего вызова
    call = current_state['incoming_call']
    
    # 3a. Определяем тип проблемы
    issue_type = classify_issue(call['description'])
    
    # 3b. Определяем приоритет (VIP или обычный)
    priority = 'high' if call['customer_segment'] == 'vip' else 'normal'
    
    # 3c. Маршрутируем к лучшему оператору
    best_operator = select_best_operator(
        department=issue_type,
        priority=priority,
        available_operators=current_state['operators']
    )
    
    # 3d. Прогнозируем время ожидания
    predicted_wait = wait_time_model.predict([
        current_state['hour'],
        predicted_calls,
        current_operators
    ])[0]
    
    print(f"Маршрутируем в {best_operator.name} (ожидание ~{predicted_wait:.0f}с)")
    
    # 4. Мониторим риск отказа
    if churn_risk_model.predict([call['customer_history']])[0] > 0.7:
        print(f"⚠️ Высокий риск отказа клиента. Предлагаем скидку.")
    
    return {
        'operator': best_operator,
        'priority': priority,
        'predicted_wait': predicted_wait,
        'department': issue_type
    }

KPI для мониторинга

# Метрики оптимизации
metrics = {
    'average_wait_time': 45,  # было 120 секунд
    'customer_satisfaction': 4.5,  # было 3.8
    'first_call_resolution_rate': 0.85,  # было 0.75
    'operational_cost_per_call': 2.5,  # было 3.2
    'churn_rate': 0.05,  # было 0.12
    'operator_utilization': 0.85  # оптимально 0.75-0.85
}

print("ROI анализ:")
monthly_calls = 100000
cost_reduction_per_call = 3.2 - 2.5
monthly_savings = monthly_calls * cost_reduction_per_call
print(f"Ежемесячная экономия: ${monthly_savings:,.0f}")

churn_reduction = (0.12 - 0.05) * 50000 * 100  # средняя выручода от клиента $100
print(f"Экономия от снижения отказов: ${churn_reduction:,.0f}")
print(f"Общая выгода в месяц: ${monthly_savings + churn_reduction:,.0f}")

Выводы

Оптимизация call-центра требует:

• Прогнозирования нагрузки для планирования смен
• Интеллектуальной маршрутизации вызовов
• Раннего обнаружения проблем (риск отказа)
• Непрерывного мониторинга KPI и переобучения моделей
• Балансировки между качеством (satisfaction) и затратами