RFM-анализ – это мощный метод сегментации клиентов, основанный на трех ключевых метриках их поведения: Recency (давность последней покупки), Frequency (частота покупок) и Monetary Value (денежная ценность клиента). За свою карьеру в области data science я убедился, что это один из самых эффективных способов понять и структурировать клиентскую базу.
Каждый раз, когда я применяю RFM-анализ в новом проекте, я поражаюсь его универсальности и глубине получаемых инсайтов. Например, недавно мы использовали его для одного московского онлайн-ритейлера, и результаты превзошли все ожидания – конверсия маркетинговых кампаний выросла на 37% благодаря более точному таргетингу на конкретные сегменты.
Компоненты RFM-анализа
Давайте детально рассмотрим каждую составляющую RFM-анализа:
- Recency (R) – это время, прошедшее с момента последней активности клиента (обычно покупки). В своей практике я заметил, что это самый важный показатель, поскольку он напрямую коррелирует с вероятностью повторной покупки. Чем меньше времени прошло с последней транзакции, тем выше вероятность, что клиент совершит новую покупку;
- Frequency (F) определяет, как часто клиент совершает покупки за определенный период. Этот параметр помогает выявить наиболее лояльных клиентов. На практике я обнаружил, что частота покупок часто имеет степенное распределение – небольшая группа клиентов совершает непропорционально большое количество транзакций;
- Monetary Value (M) показывает, сколько денег клиент потратил за анализируемый период. Интересно, что в моей практике этот показатель часто имеет наименьший вес при прогнозировании будущего поведения клиента, но остается критически важным для бизнес-планирования.
Подготовка данных для RFM-анализа
Прежде чем погрузиться в технические детали, давайте подготовим необходимые инструменты и данные. Для работы нам понадобятся следующие библиотеки Python:
import pandas as pd
import numpy as np
from datetime import datetime
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScalerТеперь создадим пример датасета с историей покупок:
# Генерация примера данных
np.random.seed(42)
# Создаем 1000 транзакций
n_transactions = 1000
customer_ids = np.random.randint(1, 201, n_transactions) # 200 уникальных клиентов
# Генерация дат за последний год
dates = pd.date_range(end=datetime.now(), periods=365, freq='D')
transaction_dates = np.random.choice(dates, n_transactions)
# Генерация сумм покупок с логнормальным распределением
amounts = np.random.lognormal(mean=4.0, sigma=1.0, size=n_transactions)
# Создание DataFrame
df = pd.DataFrame({
'customer_id': customer_ids,
'transaction_date': transaction_dates,
'amount': amounts
})
# Сортировка по дате
df = df.sort_values('transaction_date').reset_index(drop=True)
df
Этот код создает реалистичный датасет с транзакциями, который включает ID клиента, дату транзакции и сумму покупки.
Рис. 1: Таблица с историей транзакций клиентов
Я специально использовал логнормальное распределение для сумм покупок, так как оно лучше всего соответствует реальным данным о продажах, с которыми я сталкивался в своей практике.
Предварительная обработка данных
Теперь выполним предварительную обработку данных для RFM-анализа:
def prepare_rfm_data(df, analysis_date=None):
"""
Подготовка данных для RFM-анализа
Parameters:
-----------
df : pandas.DataFrame
Датафрейм с колонками customer_id, transaction_date, amount
analysis_date : datetime, optional
Дата, относительно которой проводится анализ
Returns:
--------
pandas.DataFrame
Датафрейм с RFM-метриками для каждого клиента
"""
if analysis_date is None:
analysis_date = df['transaction_date'].max()
# Группировка по клиентам и расчет RFM-метрик
rfm = df.groupby('customer_id').agg({
'transaction_date': lambda x: (analysis_date - x.max()).days, # Recency
'amount': ['count', 'sum'] # Frequency & Monetary
}).reset_index()
# Переименование колонок
rfm.columns = ['customer_id', 'recency', 'frequency', 'monetary']
# Обработка выбросов
for column in ['recency', 'frequency', 'monetary']:
q1 = rfm[column].quantile(0.25)
q3 = rfm[column].quantile(0.75)
iqr = q3 - q1
upper_bound = q3 + 1.5 * iqr
rfm[column] = np.where(rfm[column] > upper_bound, upper_bound, rfm[column])
return rfm
# Применяем функцию к нашим данным
rfm_data = prepare_rfm_data(df)
rfm_data/code>
Рис. 2: Датафрейм с посчитанными RFM-метриками по каждому пользователю (customer_id)
В этой функции я реализовал несколько важных моментов, которые часто упускаются в базовых примерах RFM-анализа:
- Обработка выбросов методом межквартильного размаха (IQR);
- Возможность указать произвольную дату анализа;
- Эффективная векторизованная обработка данных с помощью pandas.
Визуализация распределения RFM-метрик
Перед тем как приступить к сегментации, важно понять распределение наших метрик:
def plot_rfm_distributions(rfm_data):
"""
Визуализация распределения RFM-метрик
"""
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
fig.suptitle('Распределение RFM-метрик', fontsize=14)
# Recency
sns.histplot(data=rfm_data, x='recency', bins=30, ax=axes[0])
axes[0].set_title('Распределение Recency')
axes[0].set_xlabel('Дни с последней покупки')
# Frequency
sns.histplot(data=rfm_data, x='frequency', bins=30, ax=axes[1])
axes[1].set_title('Распределение Frequency')
axes[1].set_xlabel('Количество покупок')
# Monetary
sns.histplot(data=rfm_data, x='monetary', bins=30, ax=axes[2])
axes[2].set_title('Распределение Monetary')
axes[2].set_xlabel('Общая сумма покупок')
plt.tight_layout()
return fig
# Создаем визуализацию
rfm_dist_plot = plot_rfm_distributions(rfm_data)
Рис. 3: Графики распределения RFM-метрик
Методы сегментации в RFM-анализе
За годы работы я опробовал различные подходы к сегментации клиентов в рамках RFM-анализа. Давайте рассмотрим три наиболее эффективных метода, каждый из которых имеет свои преимущества.
1. Квантильная сегментация
Это классический подход, который я часто использую как базовый метод:
def quantile_segmentation(rfm_data, n_segments=5):
"""
Квантильная сегментация клиентов
Parameters:
-----------
rfm_data : pandas.DataFrame
Датафрейм с RFM-метриками
n_segments : int
Количество сегментов для каждой метрики
Returns:
--------
pandas.DataFrame
Датафрейм с добавленными сегментами
"""
rfm = rfm_data.copy()
# Создаем лейблы для сегментов
labels = range(n_segments, 0, -1)
# Квантильная сегментация
r_labels = pd.qcut(rfm['recency'], q=n_segments, labels=labels)
f_labels = pd.qcut(rfm['frequency'], q=n_segments, labels=labels)
m_labels = pd.qcut(rfm['monetary'], q=n_segments, labels=labels)
# Добавляем сегменты в датафрейм
rfm['R'] = r_labels
rfm['F'] = f_labels
rfm['M'] = m_labels
# Создаем RFM Score
rfm['RFM_Score'] = rfm['R'].astype(str) + rfm['F'].astype(str) + rfm['M'].astype(str)
return rfm
# Применяем сегментацию
rfm_segmented = quantile_segmentation(rfm_data)
rfm_segmented
Рис. 4: Таблица с RFM-сегментацией клиентов методом квантильной сегментации
2. Кластеризация методом K-means
В своей практике я иногда использую более продвинутый подход RFM-сегментации клиентов – кластеризацию методом K-means. Этот метод позволяет выявить естественные группы клиентов, основываясь на их поведении:
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
def kmeans_segmentation(rfm_data, n_clusters=5, random_state=42):
"""
Сегментация клиентов методом K-means
Parameters:
-----------
rfm_data : pandas.DataFrame
Датафрейм с RFM-метриками
n_clusters : int
Количество кластеров
random_state : int
Seed для воспроизводимости результатов
Returns:
--------
pandas.DataFrame
Датафрейм с добавленными кластерами
dict
Характеристики кластеров
"""
# Нормализация данных
scaler = StandardScaler()
rfm_normalized = scaler.fit_transform(rfm_data[['recency', 'frequency', 'monetary']])
# Применяем K-means
kmeans = KMeans(n_clusters=n_clusters, random_state=random_state)
rfm_data['Cluster'] = kmeans.fit_predict(rfm_normalized)
# Анализируем характеристики кластеров
cluster_characteristics = {}
for i in range(n_clusters):
cluster_data = rfm_data[rfm_data['Cluster'] == i]
cluster_characteristics[f'Cluster_{i}'] = {
'size': len(cluster_data),
'avg_recency': cluster_data['recency'].mean(),
'avg_frequency': cluster_data['frequency'].mean(),
'avg_monetary': cluster_data['monetary'].mean(),
'total_revenue': cluster_data['monetary'].sum()
}
return rfm_data, cluster_characteristics
# Применяем кластеризацию
rfm_clustered, cluster_info = kmeans_segmentation(rfm_data)
# Визуализация результатов кластеризации
def plot_cluster_characteristics(cluster_info):
"""
Визуализация характеристик кластеров
"""
metrics = ['avg_recency', 'avg_frequency', 'avg_monetary', 'size']
fig, axes = plt.subplots(2, 2, figsize=(15, 12))
fig.suptitle('Характеристики кластеров', fontsize=14)
for idx, metric in enumerate(metrics):
row = idx // 2
col = idx % 2
values = [info[metric] for info in cluster_info.values()]
clusters = list(cluster_info.keys())
sns.barplot(x=clusters, y=values, ax=axes[row, col])
axes[row, col].set_title(f'{metric.replace("_", " ").title()}')
axes[row, col].tick_params(axis='x', rotation=45)
plt.tight_layout()
return fig
cluster_plot = plot_cluster_characteristics(cluster_info)
Рис. 5: Характеристики кластеров клиентов, сегментированных с помощью RFM-анализа
3. Иерархическая сегментация
Для более детального анализа я иногда применяю иерархический подход к сегментации. Он особенно полезен, когда нужно понять структуру клиентской базы на разных уровнях детализации:
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
def hierarchical_segmentation(rfm_data, n_clusters=5):
"""
Иерархическая сегментация клиентов
Parameters:
-----------
rfm_data : pandas.DataFrame
Датафрейм с RFM-метриками
n_clusters : int
Количество кластеров
Returns:
--------
pandas.DataFrame
Датафрейм с добавленными кластерами
numpy.ndarray
Матрица связей для дендрограммы
"""
# Нормализация данных
scaler = StandardScaler()
rfm_normalized = scaler.fit_transform(rfm_data[['recency', 'frequency', 'monetary']])
# Применяем иерархическую кластеризацию
hier_cluster = AgglomerativeClustering(n_clusters=n_clusters)
rfm_data['Hierarchical_Cluster'] = hier_cluster.fit_predict(rfm_normalized)
# Создаем матрицу связей для дендрограммы
linkage_matrix = linkage(rfm_normalized, method='ward')
return rfm_data, linkage_matrix
# Применяем иерархическую сегментацию
rfm_hierarchical, linkage_mat = hierarchical_segmentation(rfm_data)
# Визуализация дендрограммы
plt.figure(figsize=(15, 10))
dendrogram(linkage_mat)
plt.title('Дендрограмма клиентских сегментов')
plt.xlabel('Индекс образца')
plt.ylabel('Расстояние')
Рис. 6: Дендрограмма клиентских сегментов
На дендрограмме выше очень хорошо видны 3 ключевых клиентских сегмента, причем последний 3й – самый емкий и разбивается на 2 еще крупных, включающих множество мелких.
Интерпретация результатов и создание профилей клиентов
После применения различных методов сегментации важно правильно интерпретировать результаты и создать профили клиентов. Я разработал специальную функцию для автоматизации этого процесса:
def create_customer_profiles(rfm_segmented, method='kmeans'):
"""
Создание профилей клиентов на основе сегментации
Parameters:
-----------
rfm_segmented : pandas.DataFrame
Датафрейм с результатами сегментации
method : str
Метод сегментации ('kmeans', 'quantile', 'hierarchical')
Returns:
--------
dict
Словарь с профилями клиентов
pandas.DataFrame
Сводная статистика по сегментам
"""
segment_col = {
'kmeans': 'Cluster',
'quantile': 'RFM_Score',
'hierarchical': 'Hierarchical_Cluster'
}[method]
profiles = {}
segments_stats = pd.DataFrame()
for segment in rfm_segmented[segment_col].unique():
segment_data = rfm_segmented[rfm_segmented[segment_col] == segment]
# Базовая статистика
stats = {
'size': len(segment_data),
'size_percent': len(segment_data) / len(rfm_segmented) * 100,
'revenue_contribution': segment_data['monetary'].sum() / rfm_segmented['monetary'].sum() * 100,
'avg_recency': segment_data['recency'].mean(),
'avg_frequency': segment_data['frequency'].mean(),
'avg_monetary': segment_data['monetary'].mean(),
'lifetime_value': segment_data['monetary'].sum() / len(segment_data)
}
# Определение профиля
profile = {
'description': get_segment_description(stats),
'recommended_actions': get_recommended_actions(stats),
'statistics': stats
}
profiles[f'Segment_{segment}'] = profile
segments_stats = pd.concat([segments_stats, pd.DataFrame([stats])], ignore_index=True)
return profiles, segments_stats
def get_segment_description(stats):
"""
Генерация описания сегмента на основе статистики
"""
description = []
if stats['avg_recency'] < 30 and stats['avg_frequency'] > 5:
description.append("Активные лояльные клиенты")
elif stats['avg_recency'] > 90 and stats['avg_frequency'] < 2: description.append("Спящие клиенты") if stats['revenue_contribution'] > 20:
description.append("VIP-сегмент")
elif stats['revenue_contribution'] < 5:
description.append("Низкодоходный сегмент")
return " | ".join(description)
def get_recommended_actions(stats):
"""
Генерация рекомендаций по работе с сегментом
"""
actions = []
if stats['avg_recency'] < 30: actions.append("Программа лояльности") actions.append("Кросс-продажи") elif stats['avg_recency'] > 90:
actions.append("Реактивационная кампания")
actions.append("Специальные предложения для возврата")
if stats['revenue_contribution'] > 20:
actions.append("Персональный менеджер")
actions.append("Премиальный сервис")
return actionsПрактическое применение RFM-анализа в бизнесе
В своей практике я часто сталкиваюсь с необходимостью не только провести анализ, но и интегрировать его результаты в бизнес-процессы компании. Для этого я разработал несколько полезных функций:
Расчет бизнес-метрик по сегментам
def calculate_segment_metrics(rfm_segmented, segment_col='Cluster'):
metrics = pd.DataFrame()
for segment in rfm_segmented[segment_col].unique():
segment_data = rfm_segmented[rfm_segmented[segment_col] == segment]
# Расчет ключевых метрик
clv = segment_data['monetary'].sum() / len(segment_data) # Customer Lifetime Value
purchase_frequency = segment_data['frequency'].mean()
avg_order_value = segment_data['monetary'].sum() / segment_data['frequency'].sum()
# Добавление метрик в датафрейм
segment_metrics = pd.DataFrame({
'segment': [segment],
'customer_count': [len(segment_data)],
'total_revenue': [segment_data['monetary'].sum()],
'clv': [clv],
'purchase_frequency': [purchase_frequency],
'avg_order_value': [avg_order_value]
})
metrics = pd.concat([metrics, segment_metrics], ignore_index=True)
return metricsВ результате работы функции пользователю предоставляется структурированная информация о каждом сегменте клиентов, включая количество клиентов, общий доход, LTV, частоту покупок и среднюю стоимость заказа. Это может быть полезно для анализа поведения клиентов и оптимизации маркетинговых стратегий.
Автоматизация маркетинговых действий
Один из самых важных аспектов RFM-анализа – это автоматизация маркетинговых действий на основе полученных сегментов. Вот пример того, как я обычно реализую такую автоматизацию:
def create_marketing_automation(rfm_segmented, segment_col='Cluster'):
"""
Создание автоматизированных маркетинговых кампаний для каждого сегмента
Parameters:
-----------
rfm_segmented : pandas.DataFrame
Датафрейм с результатами сегментации
segment_col : str
Название колонки с сегментами
Returns:
--------
dict
Словарь с маркетинговыми кампаниями для каждого сегмента
"""
marketing_campaigns = {}
for segment in rfm_segmented[segment_col].unique():
segment_data = rfm_segmented[rfm_segmented[segment_col] == segment]
# Анализ характеристик сегмента
avg_monetary = segment_data['monetary'].mean()
avg_recency = segment_data['recency'].mean()
avg_frequency = segment_data['frequency'].mean()
# Формирование маркетинговых действий
campaign = {
'segment_size': len(segment_data),
'channel_priority': get_channel_priority(avg_recency, avg_frequency),
'offer_type': get_offer_type(avg_monetary, avg_frequency),
'message_content': generate_message_content(avg_recency, avg_monetary),
'contact_frequency': get_contact_frequency(avg_recency),
'budget_allocation': calculate_budget_allocation(
segment_data['monetary'].sum(),
len(rfm_segmented)
)
}
marketing_campaigns[f'Segment_{segment}'] = campaign
return marketing_campaigns
def get_channel_priority(recency, frequency):
"""
Определение приоритетных каналов коммуникации
"""
channels = []
if recency < 30:
channels.extend(['email', 'push', 'sms'])
elif recency < 90: channels.extend(['email', 'retargeting']) else: channels.extend(['email', 'social_media', 'display_ads']) if frequency > 5:
channels.append('loyalty_program')
return channels
def get_offer_type(monetary, frequency):
"""
Определение типа предложения
"""
if monetary > 1000 and frequency > 5:
return {
'type': 'premium',
'discount': 0.15,
'bonuses': True,
'special_services': True
}
elif monetary > 500 or frequency > 3:
return {
'type': 'standard',
'discount': 0.10,
'bonuses': True,
'special_services': False
}
else:
return {
'type': 'basic',
'discount': 0.05,
'bonuses': False,
'special_services': False
}
def generate_message_content(recency, monetary):
"""
Генерация контента сообщений
"""
content = {
'tone': 'friendly' if recency < 60 else 'formal', 'urgency': 'high' if recency > 90 else 'normal',
'personalization_level': 'high' if monetary > 1000 else 'medium'
}
return content
def get_contact_frequency(recency):
"""
Определение частоты контактов
"""
if recency < 30:
return 'weekly'
elif recency < 90:
return 'bi-weekly'
else:
return 'monthly'
def calculate_budget_allocation(segment_revenue, total_customers):
"""
Расчет распределения маркетингового бюджета
"""
return {
'budget_share': segment_revenue / total_customers,
'recommended_channels': {
'email': 0.3,
'social_media': 0.2,
'display_ads': 0.2,
'direct_mail': 0.15,
'loyalty_program': 0.15
}
}Мониторинг и оценка эффективности RFM-сегментации
Важный аспект, который часто упускается из виду маркетологами и аналитиками – это мониторинг эффективности RFM-сегментации во времени. Я разработал систему метрик и функций для отслеживания результатов:
def monitor_segmentation_effectiveness(
rfm_initial,
rfm_current,
segment_col='Cluster',
time_period='month'
):
"""
Мониторинг эффективности сегментации во времени
Parameters:
-----------
rfm_initial : pandas.DataFrame
Начальные результаты сегментации
rfm_current : pandas.DataFrame
Текущие результаты сегментации
segment_col : str
Название колонки с сегментами
time_period : str
Период анализа ('month', 'quarter', 'year')
Returns:
--------
dict
Словарь с метриками эффективности
"""
effectiveness_metrics = {}
# Расчет изменений в размере сегментов
segment_size_changes = calculate_segment_size_changes(
rfm_initial,
rfm_current,
segment_col
)
# Расчет изменений в метриках
metric_changes = calculate_metric_changes(
rfm_initial,
rfm_current,
segment_col
)
# Анализ миграции клиентов между сегментами
segment_migration = analyze_segment_migration(
rfm_initial,
rfm_current,
segment_col
)
effectiveness_metrics = {
'segment_size_changes': segment_size_changes,
'metric_changes': metric_changes,
'segment_migration': segment_migration,
'overall_effectiveness': calculate_overall_effectiveness(
segment_size_changes,
metric_changes,
segment_migration
)
}
return effectiveness_metrics
def calculate_segment_size_changes(rfm_initial, rfm_current, segment_col):
"""
Расчет изменений в размере сегментов
"""
changes = {}
for segment in rfm_initial[segment_col].unique():
initial_size = len(rfm_initial[rfm_initial[segment_col] == segment])
current_size = len(rfm_current[rfm_current[segment_col] == segment])
changes[f'Segment_{segment}'] = {
'absolute_change': current_size - initial_size,
'relative_change': (current_size - initial_size) / initial_size * 100
}
return changes
def calculate_metric_changes(rfm_initial, rfm_current, segment_col):
"""
Расчет изменений в ключевых метриках
"""
metrics = ['recency', 'frequency', 'monetary']
changes = {}
for segment in rfm_initial[segment_col].unique():
segment_changes = {}
for metric in metrics:
initial_value = rfm_initial[rfm_initial[segment_col] == segment][metric].mean()
current_value = rfm_current[rfm_current[segment_col] == segment][metric].mean()
segment_changes[metric] = {
'absolute_change': current_value - initial_value,
'relative_change': (current_value - initial_value) / initial_value * 100
}
changes[f'Segment_{segment}'] = segment_changes
return changes
def analyze_segment_migration(rfm_initial, rfm_current, segment_col):
"""
Анализ миграции клиентов между сегментами
"""
migration_matrix = pd.crosstab(
rfm_initial[segment_col],
rfm_current[segment_col],
normalize='index'
) * 100
return migration_matrix.to_dict()Оптимизация и масштабирование RFM-анализа
При работе с большими объемами данных важно оптимизировать процесс RFM-анализа. Вот несколько приемов, которые я использую для повышения производительности:
def optimize_rfm_analysis(df, chunk_size=100000):
"""
Оптимизированный RFM-анализ для больших данных
Parameters:
-----------
df : pandas.DataFrame
Исходный датафрейм с транзакциями
chunk_size : int
Размер чанка для обработки данных
Returns:
--------
pandas.DataFrame
Результаты RFM-анализа
"""
# Оптимизация типов данных
df = optimize_datatypes(df)
# Параллельная обработка данных
with Pool() as pool:
chunks = [df[i:i + chunk_size] for i in range(0, len(df), chunk_size)]
results = pool.map(process_chunk, chunks)
# Объединение результатов
rfm_results = pd.concat(results, ignore_index=True)
return rfm_results
def optimize_datatypes(df):
"""
Оптимизация типов данных для уменьшения использования памяти
"""
optimized_df = df.copy()
# Оптимизация числовых колонок
for col in df.select_dtypes(include=['int']).columns:
optimized_df[col] = pd.to_numeric(df[col], downcast='integer')
for col in df.select_dtypes(include=['float']).columns:
optimized_df[col] = pd.to_numeric(df[col], downcast='float')
# Оптимизация категориальных колонок
for col in df.select_dtypes(include=['object']).columns:
if df[col].nunique() / len(df) < 0.5: # Если меньше 50% уникальных значений
optimized_df[col] = df[col].astype('category')
return optimized_df
def process_chunk(chunk):
"""
Обработка одного чанка данных
"""
return prepare_rfm_data(chunk)Практические рекомендации по внедрению RFM-анализа
За время работы с RFM-анализом я выработал несколько важных рекомендаций, которые помогут вам избежать типичных ошибок:
- Определение временного окна: Выбирайте период анализа в соответствии с циклом покупок в вашем бизнесе. Для розничной торговли это обычно 3-12 месяцев, для B2B может быть больше;
- Обработка выбросов: Не удаляйте выбросы полностью, используйте винзоризацию или другие методы сглаживания, чтобы не потерять важную информацию о VIP-клиентах;
- Валидация результатов: Регулярно проверяйте качество сегментации с помощью бизнес-метрик и корректируйте параметры при необходимости;
- Интеграция с CRM: Автоматизируйте процесс обновления сегментов и передачи информации в маркетинговые системы.
Выводы
RFM-анализ – это мощный инструмент для сегментации клиентской базы, который при правильном использовании может значительно повысить эффективность маркетинговых кампаний и улучшить понимание поведения клиентов. В статье я поделился своим опытом реализации RFM-анализа с помощью Python, включая:
- Подготовку и предварительную обработку данных;
- Различные методы сегментации (квантильный, K-means, иерархический);
- Создание профилей клиентов и автоматизацию маркетинговых действий;
- Мониторинг эффективности сегментации;
- Оптимизацию и масштабирование анализа.
Главное преимущество RFM-анализа – это его универсальность и простота интерпретации результатов. При этом, как мы увидели, его можно значительно усовершенствовать с помощью современных методов машинного обучения и автоматизации.
