Трафик сайтов. Анализ воронки и клиентского поведения с помощью Python

В эпоху доминирования цифровых коммуникаций сайты часто являются первой точкой контакта с потенциальными клиентами. И понимание того, как пользователи взаимодействуют с сайтом, откуда они приходят и что их интересует, может дать ценное преимущество в конкурентной борьбе. В этой статье я поделюсь своим опытом и расскажу, как использовать Python для глубокого анализа трафика сайтов и поведения клиентов.

Подготовка данных для анализа

Первым шагом стоит подготовка и очистка данных. В нашем случае мы будем работать с датасетом, содержащим информацию о посещениях сайта, сессиях пользователей и достижении целей. Давайте начнем с загрузки и предварительного просмотра наших данных.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime
import plotly.express as px

# Загрузка данных
df = pd.read_csv('website_traffic_data.csv', parse_dates=['HitDateTime', 'VisitDateTime'])

# Просмотр первых нескольких строк и информации о датасете
print(df.head())
print(df.info())

После выполнения этого кода мы получим общее представление о структуре наших данных. Обратите внимание, что в нашем датасете есть как числовые, так и категориальные переменные, а также массивы для некоторых полей, таких как PageGoals и GoalsDateTime.

Следующим шагом будет очистка и предобработка данных. Данный этап может включать в себя обработку пропущенных значений, преобразование типов данных и создание новых признаков, которые могут быть полезны для нашего анализа.

# Обработка пропущенных значений
df = df.dropna(subset=['ClientID', 'VisitID', 'WatchID'])

# Преобразование длительности визита в минуты
df['VisitDurationMinutes'] = df['VisitDuration'] / 60

# Создание признака дня недели
df['DayOfWeek'] = df['HitDateTime'].dt.dayofweek

# Создание признака часа дня
df['HourOfDay'] = df['HitDateTime'].dt.hour

# Преобразование массивов целей в списки
df['PageGoals'] = df['PageGoals'].apply(eval)
df['GoalsID'] = df['GoalsID'].apply(eval)

# Создание признака количества достигнутых целей
df['GoalsAchieved'] = df['GoalsID'].apply(len)

print(df.head())

Теперь, когда наши данные подготовлены, мы можем приступить к их анализу и визуализации.

Анализ источников трафика

Понимание того, откуда приходят ваши посетители, является ключевым аспектом анализа трафика сайта. Давайте рассмотрим распределение трафика по различным источникам и каналам.

# Анализ распределения трафика по источникам
source_distribution = df['Source'].value_counts(normalize=True) * 100

plt.figure(figsize=(12, 6))
source_distribution.plot(kind='bar')
plt.title('Распределение трафика по источникам')
plt.xlabel('Источник')
plt.ylabel('Процент трафика')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Анализ эффективности различных UTM-меток
utm_performance = df.groupby(['UTMSource', 'UTMMedium', 'UTMCampaign'])['GoalsAchieved'].mean().reset_index()
utm_performance = utm_performance.sort_values('GoalsAchieved', ascending=False)

print(utm_performance.head(10))

Этот код создаст визуализацию распределения трафика по источникам и предоставит информацию о эффективности различных UTM-меток с точки зрения достижения целей.

Анализируя полученные результаты, мы можем сделать несколько важных выводов:

  1. Распределение трафика по источникам показывает, какие каналы привлечения посетителей наиболее эффективны для сайта. Например, если большая часть трафика приходит из органического поиска, это может указывать на хорошую SEO-оптимизацию;
  2. Высокий процент прямого трафика может свидетельствовать о сильном брендинге и лояльности пользователей;
  3. Анализ эффективности UTM-меток позволяет оценить, какие конкретные кампании и каналы приводят к наибольшему количеству достигнутых целей. Это может помочь в оптимизации маркетингового бюджета и фокусировке усилий на наиболее результативных стратегиях.

Анализ поведения пользователей на сайте

Теперь, когда мы разобрались с источниками трафика, давайте углубимся в анализ поведения пользователей на сайте. Мы рассмотрим такие аспекты, как длительность сессий, количество просмотренных страниц и пути пользователей по сайту.

# Анализ длительности сессий
plt.figure(figsize=(12, 6))
sns.histplot(df['VisitDurationMinutes'], bins=50, kde=True)
plt.title('Распределение длительности сессий')
plt.xlabel('Длительность сессии (минуты)')
plt.ylabel('Количество сессий')
plt.show()

# Анализ количества просмотренных страниц
plt.figure(figsize=(12, 6))
sns.boxplot(x='Source', y='Pageviews', data=df)
plt.title('Количество просмотренных страниц по источникам трафика')
plt.xlabel('Источник трафика')
plt.ylabel('Количество просмотренных страниц')

plt.xticks(rotation=45)
plt.show()

# Анализ путей пользователей (пример для топ-5 наиболее частых путей)
user_paths = df.groupby('VisitID')['URL'].agg(lambda x: ' -> '.join(x)).value_counts()
print("Топ-5 наиболее частых путей пользователей:")
print(user_paths.head())

Анализируя полученные результаты, мы можем сделать следующие выводы:

  • Распределение длительности сессий может указывать на уровень вовлеченности пользователей. Если большинство сессий короткие, это может свидетельствовать о проблемах с удержанием внимания посетителей;
  • Анализ количества просмотренных страниц по источникам трафика позволяет понять, какие каналы привлекают наиболее заинтересованных пользователей;
  • Изучение наиболее частых путей пользователей помогает выявить типичные сценарии использования сайта и потенциальные проблемы в навигации.

Анализ воронки конверсий

Одним из ключевых аспектов анализа поведения клиентов является изучение воронки конверсий веб-сайта. Воронка конверсий показывает, как пользователи продвигаются от первого взаимодействия с сайтом до достижения целевого действия (например, покупки или регистрации).

Давайте рассмотрим, как мы можем анализировать воронку конверсий с помощью Python.

import plotly.graph_objects as go

# Определение этапов воронки
funnel_stages = ['Посещение сайта', 'Просмотр продукта', 'Добавление в корзину', 'Начало оформления', 'Завершение покупки']

# Подсчет количества пользователей на каждом этапе (пример)
users_count = [
    df['VisitID'].nunique(),
    df[df['URL'].str.contains('/product/')]['VisitID'].nunique(),
    df[df['URL'].str.contains('/cart/')]['VisitID'].nunique(),
    df[df['URL'].str.contains('/checkout/')]['VisitID'].nunique(),
    df[df['GoalsAchieved'] > 0]['VisitID'].nunique()
]

# Создание воронки конверсий
fig = go.Figure(go.Funnel(
    y = funnel_stages,
    x = users_count,
    textinfo = "value+percent initial"
))

fig.update_layout(title_text = "Воронка конверсий", width = 800, height = 500)
fig.show()

# Расчет коэффициентов конверсии между этапами
conversion_rates = []
for i in range(1, len(users_count)):
    rate = (users_count[i] / users_count[i-1]) * 100
    conversion_rates.append(f"{funnel_stages[i-1]} -> {funnel_stages[i]}: {rate:.2f}%")

print("Коэффициенты конверсии между этапами:")
for rate in conversion_rates:
    print(rate)

Этот код создаст интерактивную визуализацию воронки конверсий и рассчитает коэффициенты конверсии между этапами. Благодаря чему можно выявить следующие инсайты:

  • Общая эффективность воронки: соотношение между количеством посетителей сайта и количеством пользователей, достигших конечной цели;
  • Узкие места: этапы, на которых происходит наибольший отток пользователей;
  • Возможности для оптимизации: этапы с низкими коэффициентами конверсии, которые требуют улучшения.

Например, если мы видим значительное падение между этапами “Добавление в корзину” и “Начало оформления заказа”, это может указывать на проблемы с процессом оформления заказа, которые отпугивают пользователей.

Продвинутый анализ воронки конверсий

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

Марковские цепи для моделирования пути пользователя

Марковские цепи – это математическая модель, которая может быть использована для анализа последовательности действий пользователя на сайте. Этот метод позволяет нам понять вероятности перехода между различными состояниями (страницами) и предсказать наиболее вероятные пути пользователей.

import pandas as pd
import numpy as np
from collections import defaultdict

# Предположим, у нас есть DataFrame df с колонками 'VisitID', 'URL' и 'Timestamp'

def create_transition_matrix(df):
    transitions = defaultdict(lambda: defaultdict(int))
    
    for _, group in df.groupby('VisitID'):
        path = group.sort_values('Timestamp')['URL'].tolist()
        for i in range(len(path) - 1):
            transitions[path[i]][path[i+1]] += 1
    
    # Нормализация
    for state in transitions:
        total = sum(transitions[state].values())
        for next_state in transitions[state]:
            transitions[state][next_state] /= total
    
    return transitions

transition_matrix = create_transition_matrix(df)

# Визуализация матрицы переходов
import seaborn as sns
import matplotlib.pyplot as plt

matrix_df = pd.DataFrame(transition_matrix).fillna(0)
plt.figure(figsize=(12, 10))
sns.heatmap(matrix_df, annot=True, cmap='YlGnBu')
plt.title('Матрица переходов между страницами')
plt.show()

# Симуляция пути пользователя
def simulate_path(start_page, n_steps, transition_matrix):
    current_page = start_page
    path = [current_page]
    for _ in range(n_steps):
        if current_page not in transition_matrix:
            break
        next_page = np.random.choice(list(transition_matrix[current_page].keys()),
                                     p=list(transition_matrix[current_page].values()))
        path.append(next_page)
        current_page = next_page
    return path

simulated_path = simulate_path('homepage', 10, transition_matrix)
print("Симулированный путь пользователя:", ' -> '.join(simulated_path))

Этот код создает матрицу переходов между страницами, визуализирует ее в виде тепловой карты и симулирует возможный путь пользователя на основе этой модели.

Анализ времени до конверсии

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

from lifelines import KaplanMeierFitter

# Предположим, у нас есть DataFrame df с колонками 'VisitID', 'Timestamp', 'Event' (1 - конверсия, 0 - нет)
df['Time'] = (df['Timestamp'] - df['Timestamp'].min()).dt.total_seconds() / 3600  # время в часах

kmf = KaplanMeierFitter()
kmf.fit(df['Time'], df['Event'], label='Кривая выживаемости')

plt.figure(figsize=(10, 6))
kmf.plot()
plt.title('Анализ времени до конверсии')
plt.xlabel('Время (часы)')
plt.ylabel('Вероятность не совершить конверсию')
plt.show()

# Медианное время до конверсии
median_time = kmf.median_survival_time_
print(f"Медианное время до конверсии: {median_time:.2f} часов")

Этот код использует анализ выживаемости (survival analysis) для оценки времени, необходимого пользователям для совершения конверсии.

Мультитачовая атрибуция с использованием цепей Маркова

Стандартные модели атрибуции (например, last-click) часто не учитывают сложность пути пользователя. Модель атрибуции на основе цепей Маркова позволяет более справедливо распределить “заслуги” между различными точками контакта.

import numpy as np
import pandas as pd

def markov_chain_attribution(df):
    # Создаем матрицу переходов
    transitions = df.groupby('VisitID')['Channel'].apply(list)
    transition_matrix = defaultdict(lambda: defaultdict(int))
    
    for path in transitions:
        for i in range(len(path) - 1):
            transition_matrix[path[i]][path[i+1]] += 1
        transition_matrix[path[-1]]['Conversion'] += 1
    
    # Нормализуем матрицу
    for state in transition_matrix:
        total = sum(transition_matrix[state].values())
        for next_state in transition_matrix[state]:
            transition_matrix[state][next_state] /= total
    
    # Создаем матрицу поглощающих состояний
    channels = list(set(df['Channel']))
    n = len(channels)
    Q = np.zeros((n, n))
    R = np.zeros(n)
    
    for i, channel in enumerate(channels):
        for j, next_channel in enumerate(channels):
            Q[i, j] = transition_matrix[channel].get(next_channel, 0)
        R[i] = transition_matrix[channel].get('Conversion', 0)
    
    # Вычисляем фундаментальную матрицу
    F = np.linalg.inv(np.eye(n) - Q)
    
    # Вычисляем атрибуцию
    attribution = F.dot(R)
    attribution /= attribution.sum()
    
    return dict(zip(channels, attribution))

# Применение модели
attribution_results = markov_chain_attribution(df)
print("Атрибуция на основе цепей Маркова:")
for channel, value in attribution_results.items():
    print(f"{channel}: {value:.2%}")

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

Анализ когортного поведения в воронке

Когортный анализ позволяет понять, как различные группы пользователей проходят через воронку конверсии с течением времени.

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

# Предположим, у нас есть DataFrame df с колонками 'UserID', 'Date', 'Stage'

def cohort_funnel_analysis(df):
    # Создаем когорты на основе первого взаимодействия пользователя
    df['Cohort'] = df.groupby('UserID')['Date'].transform('min').dt.to_period('M')
    
    # Вычисляем, сколько месяцев прошло с первого взаимодействия
    df['CohortPeriod'] = (df['Date'].dt.to_period('M') - df['Cohort']).apply(lambda x: x.n)
    
    # Подсчитываем количество пользователей на каждом этапе воронки для каждой когорты и периода
    cohort_data = df.groupby(['Cohort', 'CohortPeriod', 'Stage']).agg(Users=('UserID', 'nunique')).unstack('Stage')
    
    # Вычисляем процент пользователей, достигших каждого этапа
    stages = cohort_data.columns.levels[1]
    for stage in stages[1:]:
        cohort_data[('Retention', stage)] = cohort_data[('Users', stage)] / cohort_data[('Users', stages[0])]
    
    return cohort_data

cohort_funnel = cohort_funnel_analysis(df)

# Визуализация результатов для конкретной когорты
cohort = cohort_funnel.loc['2023-01']  # Пример для когорты января 2023
plt.figure(figsize=(12, 6))
sns.heatmap(cohort['Retention'], annot=True, cmap='YlGnBu', fmt='.0%')
plt.title('Когортный анализ воронки конверсий')
plt.xlabel('Этап воронки')
plt.ylabel('Месяцы с первого взаимодействия')
plt.show()

Этот анализ позволяет увидеть, как разные когорты пользователей проходят через воронку с течением времени, что может помочь выявить долгосрочные тренды и эффекты от изменений на сайте.

Анализ путей с использованием алгоритмов поиска частых последовательностей

Алгоритмы поиска частых последовательностей, такие как GSP (Generalized Sequential Pattern), могут помочь выявить типичные последовательности действий пользователей, ведущие к конверсии или отказу.

from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import fpgrowth

def find_frequent_sequences(df, min_support=0.01):
    # Группируем данные по сессиям пользователей
    sessions = df.groupby('VisitID')['URL'].apply(list)
    
    # Преобразуем данные в формат, подходящий для алгоритма FP-growth
    te = TransactionEncoder()
    te_ary = te.fit(sessions).transform(sessions)
    sessions_df = pd.DataFrame(te_ary, columns=te.columns_)
    
    # Находим частые наборы элементов
    frequent_itemsets = fpgrowth(sessions_df, min_support=min_support, use_colnames=True)
    
    return frequent_itemsets

frequent_sequences = find_frequent_sequences(df)
print("Частые последовательности действий пользователей:")
print(frequent_sequences.sort_values('support', ascending=False).head(10))

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

Анализ влияния микро-конверсий на макро-конверсии

Часто на пути к основной конверсии (макро-конверсии) пользователь проходит через несколько промежуточных этапов (микро-конверсий). Анализ влияния микро-конверсий на вероятность макро-конверсии может предоставить ценные инсайты.

import statsmodels.api as sm
import numpy as np

def analyze_micro_conversions(df):
    # Предполагаем, что у нас есть колонки для различных микро-конверсий и макро-конверсии
    micro_conversions = ['viewed_product', 'added_to_cart', 'started_checkout']
    macro_conversion = 'purchased'
    
    X = df[micro_conversions]
    y = df[macro_conversion]
    
    # Добавляем константу для интерсепта
    X = sm.add_constant(X)
    
    # Строим логистическую регрессию
    model = sm.Logit(y, X)
    results = model.fit()
    
    print(results.summary())
    
    # Вычисляем предельные эффекты
    marginal_effects = results.get_margeff()
    print("\nПредельные эффекты микро-конверсий:")
    print(marginal_effects.summary())

analyze_micro_conversions(df)

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

Сегментация клиентов на основе поведения

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

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Выбор признаков для кластеризации
features = ['VisitDurationMinutes', 'Pageviews', 'GoalsAchieved']

# Подготовка данных
X = df[features]
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Применение алгоритма K-means
kmeans = KMeans(n_clusters=4, random_state=42)
df['Cluster'] = kmeans.fit_predict(X_scaled)

# Визуализация результатов
fig = px.scatter_3d(df, x='VisitDurationMinutes', y='Pageviews', z='GoalsAchieved',
                    color='Cluster', hover_name='ClientID',
                    labels={'VisitDurationMinutes': 'Длительность визита (мин)',
                            'Pageviews': 'Просмотры страниц',
                            'GoalsAchieved': 'Достигнутые цели'})
fig.update_layout(title='Сегментация клиентов на основе поведения')
fig.show()

# Анализ характеристик кластеров
cluster_stats = df.groupby('Cluster')[features].mean()
print("Средние характеристики кластеров:")
print(cluster_stats)

Этот код выполняет кластеризацию пользователей на основе выбранных характеристик их поведения и создает 3D-визуализацию результатов кластеризации.

Анализируя полученные кластеры, мы можем выделить различные сегменты пользователей:

  • Активные и вовлеченные пользователи: кластер с высокими значениями по всем трем параметрам (длительность визита, количество просмотренных страниц и достигнутые цели);
  • Любопытные, но не конвертирующиеся: кластер с высокой длительностью визита и большим количеством просмотренных страниц, но низким числом достигнутых целей;
  • Целевые пользователи: кластер с относительно короткой длительностью визита, небольшим количеством просмотренных страниц, но высоким числом достигнутых целей;
  • Случайные посетители: кластер с низкими значениями по всем параметрам.

Понимание этих сегментов позволяет разработать персонализированные стратегии для каждой группы пользователей. Например, для “любопытных, но не конвертирующихся” пользователей можно создать более четкие призывы к действию или улучшить навигацию по сайту, чтобы помочь им быстрее находить нужную информацию.

Прогнозирование поведения клиентов

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

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score
import shap

# Подготовка данных
features = ['VisitDurationMinutes', 'Pageviews', 'isNewUser', 'DayOfWeek', 'HourOfDay']
X = df[features]
y = (df['GoalsAchieved'] > 0).astype(int)

# Разделение данных на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Обучение модели случайного леса
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

# Оценка модели
y_pred = rf_model.predict(X_test)
y_pred_proba = rf_model.predict_proba(X_test)[:, 1]

print("Отчет о классификации:")
print(classification_report(y_test, y_pred))
print(f"ROC AUC: {roc_auc_score(y_test, y_pred_proba):.4f}")

# Анализ важности признаков с помощью SHAP
explainer = shap.TreeExplainer(rf_model)
shap_values = explainer.shap_values(X_test)

plt.figure(figsize=(10, 6))
shap.summary_plot(shap_values[1], X_test, plot_type="bar")
plt.title("Важность признаков (SHAP values)")
plt.tight_layout()
plt.show()

Этот код обучает модель случайного леса для прогнозирования вероятности достижения цели, оценивает ее эффективность и анализирует важность признаков с помощью SHAP (SHapley Additive exPlanations).

Интерпретация результатов прогнозирования

Отчет о классификации предоставляет информацию о точности, полноте и F1-мере модели. Эти метрики помогают оценить, насколько хорошо модель справляется с задачей прогнозирования достижения целей.

ROC AUC (Area Under the Receiver Operating Characteristic Curve) является обобщенной метрикой качества бинарного классификатора. Значение близкое к 1 указывает на высокую способность модели различать классы.

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

Эта информация может быть использована для:

  • Оптимизации дизайна сайта и пользовательского опыта;
  • Персонализации контента и предложений для пользователей;
  • Улучшения таргетинга маркетинговых кампаний.

Анализ временных паттернов

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

# Анализ активности по дням недели
daily_activity = df.groupby('DayOfWeek')['VisitID'].nunique()
daily_conversions = df[df['GoalsAchieved'] > 0].groupby('DayOfWeek')['VisitID'].nunique()

plt.figure(figsize=(12, 6))
plt.bar(daily_activity.index, daily_activity.values, alpha=0.5, label='Визиты')
plt.bar(daily_conversions.index, daily_conversions.values, alpha=0.5, label='Конверсии')
plt.title('Активность и конверсии по дням недели')
plt.xlabel('День недели')
plt.ylabel('Количество')
plt.legend()
plt.xticks(range(7), ['Пн', 'Вт', 'Ср', 'Чт', 'Пт', 'Сб', 'Вс'])
plt.show()

# Анализ активности по часам
hourly_activity = df.groupby('HourOfDay')['VisitID'].nunique()
hourly_conversions = df[df['GoalsAchieved'] > 0].groupby('HourOfDay')['VisitID'].nunique()

plt.figure(figsize=(12, 6))
plt.plot(hourly_activity.index, hourly_activity.values, label='Визиты')
plt.plot(hourly_conversions.index, hourly_conversions.values, label='Конверсии')
plt.title('Активность и конверсии по часам')
plt.xlabel('Час')
plt.ylabel('Количество')
plt.legend()
plt.xticks(range(0, 24, 2))
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

# Анализ сезонности (пример для месячной активности)
df['Month'] = df['HitDateTime'].dt.month
monthly_activity = df.groupby('Month')['VisitID'].nunique()
monthly_conversions = df[df['GoalsAchieved'] > 0].groupby('Month')['VisitID'].nunique()

plt.figure(figsize=(12, 6))
plt.plot(monthly_activity.index, monthly_activity.values, marker='o', label='Визиты')
plt.plot(monthly_conversions.index, monthly_conversions.values, marker='o', label='Конверсии')
plt.title('Месячная активность и конверсии')
plt.xlabel('Месяц')
plt.ylabel('Количество')
plt.legend()
plt.xticks(range(1, 13))
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

Этот код создает визуализации активности пользователей и конверсий по дням недели, часам и месяцам. Данный анализ позволит определить, в какие дни недели ваш сайт наиболее популярен и когда пользователи более склонны к совершению целевых действий. Например, если вы видите пик активности в выходные дни, это может быть хорошим временем для запуска специальных акций или рассылки email-кампаний.

Кроме того,  анализ почасовой активности может помочь оптимизировать время публикации контента или запуска рекламных кампаний. Например, если вы видите пик конверсий в вечерние часы, это может быть идеальным временем для показа таргетированной рекламы. А анализ активности по месяцам позволяет выявить сезонные тренды в поведении пользователей.

Понимание этих временных паттернов может помочь в планировании маркетинговых кампаний, оптимизации работы службы поддержки и даже в планировании технических работ на сайте.

Анализ эффективности контента

Одним из ключевых факторов успеха веб-сайта является качество и релевантность его контента. Давайте рассмотрим, как мы можем анализировать эффективность различных страниц и типов контента на основе данных о поведении пользователей.

# Анализ наиболее посещаемых страниц
top_pages = df['URL'].value_counts().head(10)

plt.figure(figsize=(12, 6))
top_pages.plot(kind='bar')
plt.title('Топ-10 наиболее посещаемых страниц')
plt.xlabel('URL страницы')
plt.ylabel('Количество посещений')
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Анализ времени, проведенного на странице
df['TimeOnPage'] = df.groupby('VisitID')['HitDateTime'].diff().dt.total_seconds()
avg_time_on_page = df.groupby('URL')['TimeOnPage'].mean().sort_values(ascending=False).head(10)

plt.figure(figsize=(12, 6))
avg_time_on_page.plot(kind='bar')
plt.title('Топ-10 страниц по среднему времени просмотра')
plt.xlabel('URL страницы')
plt.ylabel('Среднее время на странице (секунды)')
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Анализ показателя отказов
bounce_rate = df.groupby('URL').apply(lambda x: (x['Pageviews'] == 1).mean() * 100).sort_values(ascending=True).head(10)

plt.figure(figsize=(12, 6))
bounce_rate.plot(kind='bar')
plt.title('Топ-10 страниц с наименьшим показателем отказов')
plt.xlabel('URL страницы')
plt.ylabel('Показатель отказов (%)')
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

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

На основе этого анализа вы можете:

  1. Определить наиболее успешный контент и создавать похожие материалы;
  2. Оптимизировать страницы с высоким показателем отказов;
  3. Улучшить навигацию к наиболее важным страницам;
  4. Персонализировать рекомендации контента для пользователей.

Прогнозирование оттока клиентов

Удержание клиентов часто является более экономически эффективным, чем привлечение новых. Давайте рассмотрим, как мы можем использовать машинное обучение для прогнозирования оттока клиентов на основе их поведения на сайте.

from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.preprocessing import StandardScaler

# Подготовка данных
df['LastVisit'] = df.groupby('ClientID')['VisitDateTime'].transform('max')
df['DaysSinceLastVisit'] = (pd.Timestamp.now() - df['LastVisit']).dt.days
df['IsChurned'] = df['DaysSinceLastVisit'] > 30  # Определяем отток как отсутствие визитов более 30 дней

features = ['VisitDurationMinutes', 'Pageviews', 'GoalsAchieved', 'isNewUser', 'DaysSinceLastVisit']
X = df.groupby('ClientID')[features].mean()
y = df.groupby('ClientID')['IsChurned'].last()

# Масштабирование признаков
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Разделение данных на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

# Обучение модели градиентного бустинга
gb_model = GradientBoostingClassifier(n_estimators=100, random_state=42)
gb_model.fit(X_train, y_train)

# Оценка модели
y_pred = gb_model.predict(X_test)
y_pred_proba = gb_model.predict_proba(X_test)[:, 1]
print("Отчет о классификации:")
print(classification_report(y_test, y_pred))
print(f"ROC AUC: {roc_auc_score(y_test, y_pred_proba):.4f}")

# Анализ важности признаков
feature_importance = pd.DataFrame({'feature': features, 'importance': gb_model.feature_importances_})
feature_importance = feature_importance.sort_values('importance', ascending=False)
plt.figure(figsize=(10, 6))
sns.barplot(x='importance', y='feature', data=feature_importance)
plt.title('Важность признаков в прогнозировании оттока клиентов')
plt.xlabel('Важность')
plt.ylabel('Признак')
plt.tight_layout()
plt.show()

# Визуализация вероятности оттока для разных групп клиентов
df['ChurnProbability'] = gb_model.predict_proba(X_scaled)[:, 1]
plt.figure(figsize=(10, 6))
sns.scatterplot(x='VisitDurationMinutes', y='Pageviews', hue='ChurnProbability', data=df, palette='coolwarm')
plt.title('Вероятность оттока клиентов')
plt.xlabel('Средняя длительность визита (минуты)')
plt.ylabel('Среднее количество просмотренных страниц')
plt.colorbar(label='Вероятность оттока')
plt.tight_layout()
plt.show()

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

Интерпретация результатов прогнозирования оттока клиентов

  • Отчет о классификации и ROC AUC: эти метрики позволяют оценить качество модели прогнозирования оттока. Высокие значения точности, полноты и F1-меры, а также ROC AUC близкое к 1, указывают на хорошую способность модели предсказывать отток клиентов;
  • Важность признаков: анализ важности признаков помогает понять, какие факторы наиболее сильно влияют на вероятность оттока клиентов. Например, если “DaysSinceLastVisit” является наиболее важным признаком, это может указывать на необходимость регулярного взаимодействия с клиентами для снижения риска оттока;
  • Визуализация вероятности оттока: этот график позволяет увидеть, как различные характеристики поведения пользователей (в данном случае, длительность визита и количество просмотренных страниц) связаны с вероятностью оттока. Это может помочь в разработке стратегий удержания клиентов.

На основе этого анализа вы можете:

  1. Разработать программы лояльности для клиентов с высоким риском оттока;
  2. Улучшить пользовательский опыт для групп клиентов, наиболее склонных к оттоку;
  3. Создать персонализированные кампании по реактивации неактивных пользователей;
  4. Оптимизировать стратегии удержания клиентов, фокусируясь на наиболее важных факторах, влияющих на отток

Анализ пользовательских сценариев

Понимание типичных пользовательских сценариев может помочь оптимизировать структуру сайта и улучшить пользовательский опыт. Давайте рассмотрим, как мы можем анализировать последовательности действий пользователей на сайте.

from collections import Counter

def get_user_paths(group):
    return ' -> '.join(group['URL'])

# Анализ наиболее частых пользовательских путей
user_paths = df.groupby('VisitID').apply(get_user_paths)
top_paths = Counter(user_paths).most_common(10)

print("Топ-10 наиболее частых пользовательских путей:")
for path, count in top_paths:
    print(f"{count}: {path}")

# Анализ переходов между страницами
df['NextURL'] = df.groupby('VisitID')['URL'].shift(-1)
page_transitions = df.groupby(['URL', 'NextURL']).size().reset_index(name='count')
page_transitions = page_transitions.sort_values('count', ascending=False).head(20)

plt.figure(figsize=(12, 8))
sns.scatterplot(x='URL', y='NextURL', size='count', data=page_transitions)
plt.title('Наиболее частые переходы между страницами')
plt.xlabel('Текущая страница')
plt.ylabel('Следующая страница')
plt.xticks(rotation=45, ha='right')
plt.yticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Анализ времени, проведенного на каждом этапе пользовательского пути
df['TimeOnPage'] = df.groupby('VisitID')['HitDateTime'].diff().dt.total_seconds()
avg_time_on_page = df.groupby('URL')['TimeOnPage'].mean().sort_values(ascending=False).head(10)

plt.figure(figsize=(12, 6))
avg_time_on_page.plot(kind='bar')
plt.title('Среднее время, проведенное на каждой странице')
plt.xlabel('URL страницы')
plt.ylabel('Среднее время (секунды)')
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

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

В результате анализа пользовательских сценариев можно будет обнаружить:

  • Наиболее частые пользовательские пути: это помогает понять типичные сценарии использования веб-сайта. Вы можете использовать эту информацию для оптимизации наиболее популярных путей и улучшения навигации;
  • Паттерны в переходах между страницами: анализ наиболее частых переходов между страницами может выявить неожиданные паттерны в поведении пользователей. Это может помочь в улучшении структуры сайта и внутренней перелинковки;
  • Время, проведенное на каждой странице: этот анализ позволяет выявить страницы, на которых пользователи проводят больше всего времени. Это может указывать на наиболее ценный контент или на страницы, которые требуют оптимизации для улучшения пользовательского опыта.

На основе этого анализа вы можете:

  1. Оптимизировать наиболее популярные пользовательские пути, делая их более интуитивными и эффективными;
  2. Улучшить навигацию между часто связанными страницами;
  3. Оптимизировать страницы с высоким средним временем просмотра, чтобы убедиться, что пользователи находят нужную информацию быстро и легко;
  4. Создать персонализированные рекомендации контента на основе типичных пользовательских сценариев.

Выводы

В этой статье мы рассмотрели комплексный подход к анализу трафика сайтов и поведения клиентов с использованием Python. Мы охватили широкий спектр методов и техник. И вот какие выводы мы можем сделать:

  1. Комплексный анализ данных позволяет получить многомерное представление о поведении пользователей и эффективности веб-сайта;
  2. Использование методов машинного обучения, таких как кластеризация и прогнозное моделирование, помогает выявить скрытые паттерны в данных и предсказать будущее поведение пользователей;
  3. Регулярный мониторинг и анализ поведения пользователей позволяет оперативно реагировать на изменения и адаптировать стратегии для достижения лучших результатов;
  4. Визуализация данных играет важную роль в понимании и интерпретации результатов анализа.

Применение этих методов анализа может значительно улучшить понимание вашей аудитории, повысить эффективность маркетинговых кампаний и, в конечном итоге, увеличить конверсию и удержание клиентов.