Как находить точки роста онлайн-бизнеса с помощью Python

В условиях огромной конкуренции успех онлайн-бизнеса во-многом зависит от способности компании анализировать огромные объемы данных и находить в них скрытые возможности для роста. В цифровом мире каждое действие пользователя оставляет след: клики, просмотры страниц, время на сайте, конверсии – все это ценная информация, которая при правильном анализе может указать на новые возможности для развития.

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

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

import pandas as pd
import numpy as np
from datetime import datetime

# Загрузка данных
df = pd.read_csv('website_data.csv')

# Преобразование строковых дат в datetime
date_columns = ['HitDateTime', 'VisitDateTime', 'GoalsDateTime']
for col in date_columns:
    df[col] = pd.to_datetime(df[col])

# Преобразование строковых массивов в списки
list_columns = ['PageGoals', 'PageGoalsTime', 'GoalsID', 'GoalsDateTime']
for col in list_columns:
    df[col] = df[col].apply(eval)

# Вывод первых нескольких строк для проверки
print(df.head())

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

Исследовательский анализ данных (EDA)

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

import matplotlib.pyplot as plt
import seaborn as sns

# Общая статистика
print(df.describe())

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

# Топ-10 источников трафика
top_sources = df['Source'].value_counts().head(10)
plt.figure(figsize=(12, 6))
sns.barplot(x=top_sources.index, y=top_sources.values)
plt.title('Топ-10 источников трафика')
plt.xlabel('Источник')
plt.ylabel('Количество визитов')
plt.xticks(rotation=45)
plt.show()

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

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

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

Анализ популярных путей пользователей

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

from collections import Counter

def analyze_user_paths(df):
    paths = df.groupby('VisitID')['URL'].apply(list)
    path_counts = Counter([tuple(path) for path in paths])
    
    print("Топ-5 популярных путей пользователей:")
    for path, count in path_counts.most_common(5):
        print(f"Путь: {' -> '.join(path)}")
        print(f"Количество: {count}")
        print()

analyze_user_paths(df)

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

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

Анализ времени на странице

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

def analyze_time_on_page(df):
    # Рассчитываем время на странице
    df['TimeOnPage'] = df.groupby('VisitID')['HitDateTime'].diff().dt.total_seconds()
    
    # Агрегируем данные по URL
    page_stats = df.groupby('URL').agg({
        'TimeOnPage': ['mean', 'median'],
        'WatchID': 'count'
    }).reset_index()
    
    page_stats.columns = ['URL', 'AvgTimeOnPage', 'MedianTimeOnPage', 'Pageviews']
    page_stats = page_stats.sort_values('Pageviews', ascending=False)
    
    print("Топ-10 страниц по просмотрам и времени на странице:")
    print(page_stats.head(10))

analyze_time_on_page(df)

Этот анализ поможет нам выявить:

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

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

Понимание того, как пользователи проходят через воронку продаж, критически важно для поиска точек роста онлайн-бизнеса. Давайте проанализируем конверсии и построим воронку продаж:

def analyze_conversion_funnel(df):
    # Определяем этапы воронки
    funnel_stages = [
        'visit',  # Посещение сайта
        'product_view',  # Просмотр продукта
        'add_to_cart',  # Добавление в корзину
        'checkout',  # Начало оформления заказа
        'purchase'  # Покупка
    ]
    
    # Создаем словарь для хранения количества пользователей на каждом этапе
    funnel_data = {stage: 0 for stage in funnel_stages}
    
    # Подсчитываем количество пользователей на каждом этапе
    funnel_data['visit'] = df['ClientID'].nunique()
    for stage in funnel_stages[1:]:
        funnel_data[stage] = df[df['GoalsID'].apply(lambda x: any(goal == stage for goal in x))]['ClientID'].nunique()
    
    # Рассчитываем конверсию между этапами
    for i in range(1, len(funnel_stages)):
        prev_stage = funnel_stages[i-1]
        curr_stage = funnel_stages[i]
        conversion_rate = (funnel_data[curr_stage] / funnel_data[prev_stage]) * 100
        print(f"Конверсия {prev_stage} -> {curr_stage}: {conversion_rate:.2f}%")
    
    # Визуализация воронки
    plt.figure(figsize=(10, 6))
    plt.bar(funnel_stages, [funnel_data[stage] for stage in funnel_stages])
    plt.title('Воронка продаж')
    plt.xlabel('Этап')
    plt.ylabel('Количество пользователей')
    plt.yscale('log')
    plt.show()

analyze_conversion_funnel(df)

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

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

Сегментация пользователей с помощью машинного обучения

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

Читайте также:  A/B-тестирование маркетинговых кампаний с помощью Python

Давайте применим алгоритм K-means для сегментации пользователей:

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

def segment_users(df):
    # Агрегируем данные на уровне пользователя
    user_data = df.groupby('ClientID').agg({
        'VisitDuration': 'mean',
        'Pageviews': 'mean',
        'GoalsID': lambda x: len(set([item for sublist in x for item in sublist])),
        'isNewUser': 'max'
    }).reset_index()
    
    # Нормализуем данные
    scaler = StandardScaler()
    features = ['VisitDuration', 'Pageviews', 'GoalsID', 'isNewUser']
    user_data_scaled = scaler.fit_transform(user_data[features])
    
    # Применяем K-means
    kmeans = KMeans(n_clusters=4, random_state=42)
    user_data['Cluster'] = kmeans.fit_predict(user_data_scaled)
    
    # Анализируем результаты
    for cluster in range(4):
        cluster_data = user_data[user_data['Cluster'] == cluster]
        print(f"\nКластер {cluster}:")
        print(cluster_data[features].mean())
    
    # Визуализация результатов
    plt.figure(figsize=(12, 8))
    scatter = plt.scatter(user_data['VisitDuration'], user_data['Pageviews'], 
                          c=user_data['Cluster'], cmap='viridis')
    plt.colorbar(scatter)
    plt.xlabel('Средняя длительность визита')
    plt.ylabel('Среднее количество просмотров страниц')
    plt.title('Сегментация пользователей')
    plt.show()

segment_users(df)

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

Результаты сегментации могут помочь нам:

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

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

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

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def predict_churn(df):
    # Подготовка данных
    user_data = df.groupby('ClientID').agg({
        'VisitDuration': 'mean',
        'Pageviews': 'mean',
        'GoalsID': lambda x: len(set([item for sublist in x for item in sublist])),
        'isNewUser': 'max',
        'Source': lambda x: x.value_counts().index[0],
        'UTMSource': lambda x: x.value_counts().index[0],
        'VisitDateTime': lambda x: (x.max() - x.min()).days
    }).reset_index()
    
    # Определение оттока (например, пользователи, не посещавшие сайт более 30 дней)
    last_visit = df.groupby('ClientID')['VisitDateTime'].max()
    user_data['Churn'] = (df['VisitDateTime'].max() - last_visit).dt.days > 30
    
    # Подготовка признаков
    features = ['VisitDuration', 'Pageviews', 'GoalsID', 'isNewUser', 'VisitDateTime']
    X = pd.get_dummies(user_data[features + ['Source', 'UTMSource']], columns=['Source', 'UTMSource'])
    y = user_data['Churn']
    
    # Разделение на обучающую и тестовую выборки
    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)
    print(classification_report(y_test, y_pred))
    
    # Анализ важности признаков
    feature_importance = pd.DataFrame({
        'feature': X.columns,
        'importance': rf_model.feature_importances_
    }).sort_values('importance', ascending=False)
    
    plt.figure(figsize=(12, 6))
    plt.bar(feature_importance['feature'][:10], feature_importance['importance'][:10])
    plt.title('Топ-10 важных признаков для прогнозирования оттока')
    plt.xlabel('Признак')
    plt.ylabel('Важность')
    plt.xticks(rotation=45, ha='right')
    plt.tight_layout()
    plt.show()
    
    return rf_model, feature_importance

churn_model, feature_importance = predict_churn(df)

Этот код выполняет следующие шаги:

  1. Агрегирует данные на уровне пользователя;
  2. Определяет отток пользователей (в данном случае, если пользователь не посещал сайт более 30 дней);
  3. Подготавливает признаки для модели, включая числовые метрики и категориальные переменные (источник трафика и UTM-метки);
  4. Обучает модель случайного леса для прогнозирования оттока;
  5. Оценивает качество модели и анализирует важность признаков.

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

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

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

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

Анализ A/B-тестов для оптимизации конверсии

A/B-тестирование является мощным инструментом для поиска точек роста и оптимизации конверсии сайтов и приложений. Давайте рассмотрим, как мы можем анализировать результаты A/B-тестов с помощью Python.

from scipy import stats

def analyze_ab_test(df, test_column, conversion_column):
    # Группируем данные по вариантам теста
    group_a = df[df[test_column] == 'A'][conversion_column]
    group_b = df[df[test_column] == 'B'][conversion_column]
    
    # Рассчитываем конверсию для каждой группы
    conv_rate_a = group_a.mean()
    conv_rate_b = group_b.mean()
    
    # Проводим статистический тест
    t_stat, p_value = stats.ttest_ind(group_a, group_b)
    
    print(f"Конверсия в группе A: {conv_rate_a:.2%}")
    print(f"Конверсия в группе B: {conv_rate_b:.2%}")
    print(f"Разница: {(conv_rate_b - conv_rate_a):.2%}")
    print(f"P-value: {p_value:.4f}")
    
    if p_value < 0.05: print("Результат статистически значим") if conv_rate_b > conv_rate_a:
            print("Вариант B показывает лучший результат")
        else:
            print("Вариант A показывает лучший результат")
    else:
        print("Результат статистически не значим")

# Пример использования
df['TestVariant'] = np.random.choice(['A', 'B'], size=len(df))
df['Converted'] = df['GoalsID'].apply(lambda x: 1 if x else 0)
analyze_ab_test(df, 'TestVariant', 'Converted')

Этот код демонстрирует, как мы можем анализировать результаты A/B-теста:

  1. Разделяем пользователей на группы A и B;
  2. Рассчитываем конверсию для каждой группы;
  3. Проводим статистический тест для определения значимости различий;
  4. Интерпретируем результаты.

A/B-тестирование позволяет нам экспериментировать с различными элементами сайта или маркетинговых кампаний и находить оптимальные решения, основанные на данных.

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

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

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import seasonal_decompose

def analyze_time_series(df):
    # Агрегируем данные по дням
    daily_data = df.groupby(df['VisitDateTime'].dt.date).agg({
        'WatchID': 'count',
        'GoalsID': lambda x: len([item for sublist in x for item in sublist if item])
    }).reset_index()
    daily_data.columns = ['Date', 'Visits', 'Conversions']
    daily_data['ConversionRate'] = daily_data['Conversions'] / daily_data['Visits']
    
    # Устанавливаем дату как индекс
    daily_data.set_index('Date', inplace=True)
    
    # Декомпозиция временного ряда
    result = seasonal_decompose(daily_data['ConversionRate'], model='additive', period=7)
    
    # Визуализация результатов
    plt.figure(figsize=(12, 10))
    plt.subplot(411)
    plt.plot(result.observed)
    plt.title('Observed')
    plt.subplot(412)
    plt.plot(result.trend)
    plt.title('Trend')
    plt.subplot(413)
    plt.plot(result.seasonal)
    plt.title('Seasonal')
    plt.subplot(414)
    plt.plot(result.resid)
    plt.title('Residual')
    plt.tight_layout()
    plt.show()

analyze_time_series(df)

Этот код выполняет следующие действия:

  1. Агрегирует данные по дням, рассчитывая количество посещений, конверсий и коэффициент конверсии;
  2. Проводит декомпозицию временного ряда, выделяя тренд, сезонность и остаточный компонент;
  3. Визуализирует результаты декомпозиции.
Читайте также:  Методы предиктивной аналитики и машинного обучения для оптимизации конверсии веб-сайтов

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

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

Оптимизация ценообразования с помощью машинного обучения

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

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
import matplotlib.pyplot as plt

def optimize_pricing(df):
    # Подготовка данных (предполагаем, что у нас есть информация о ценах и продажах)
    product_data = df.groupby(['ProductID', 'Price']).agg({
        'SalesQuantity': 'sum',
        'Revenue': 'sum'
    }).reset_index()
    
    # Обучение модели для прогнозирования продаж
    X = product_data[['ProductID', 'Price']]
    y = product_data['SalesQuantity']
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    model = RandomForestRegressor(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    
    # Функция для прогнозирования выручки при заданной цене
    def predict_revenue(product_id, price):
        predicted_sales = model.predict([[product_id, price]])[0]
        return predicted_sales * price
    
    # Поиск оптимальной цены для каждого продукта
    optimal_prices = {}
    for product_id in product_data['ProductID'].unique():
        prices = np.linspace(product_data['Price'].min(), product_data['Price'].max(), 100)
        revenues = [predict_revenue(product_id, price) for price in prices]
        optimal_price = prices[np.argmax(revenues)]
        optimal_prices[product_id] = optimal_price
    
    # Визуализация результатов для одного продукта
    product_id = product_data['ProductID'].iloc[0]
    prices = np.linspace(product_data['Price'].min(), product_data['Price'].max(), 100)
    revenues = [predict_revenue(product_id, price) for price in prices]
    
    plt.figure(figsize=(10, 6))
    plt.plot(prices, revenues)
    plt.title(f'Зависимость выручки от цены для продукта {product_id}')
    plt.xlabel('Цена')
    plt.ylabel('Прогнозируемая выручка')
    plt.axvline(optimal_prices[product_id], color='r', linestyle='--', label='Оптимальная цена')
    plt.legend()
    plt.show()
    
    return optimal_prices

optimal_prices = optimize_pricing(df)

Этот код демонстрирует процесс оптимизации ценообразования:

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

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

Анализ отзывов клиентов с помощью обработки естественного языка (NLP)

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

import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import LatentDirichletAllocation
import matplotlib.pyplot as plt
from dostoevsky.tokenization import RegexTokenizer
from dostoevsky.models import FastTextSocialNetworkModel
import nltk
from nltk.corpus import stopwords
import re

nltk.download('stopwords')
russian_stopwords = set(stopwords.words('russian'))

def preprocess_text(text):
    text = text.lower()
    text = re.sub(r'[^\w\s]', '', text)
    tokens = text.split()
    tokens = [token for token in tokens if token not in russian_stopwords]
    return ' '.join(tokens)

def analyze_sentiment(text):
    tokenizer = RegexTokenizer()
    model = FastTextSocialNetworkModel(tokenizer=tokenizer)
    results = model.predict([text], k=2)
    sentiment = list(results[0].keys())[0]
    return 1 if sentiment == 'positive' else (-1 if sentiment == 'negative' else 0)

def analyze_customer_reviews(reviews_df):
    # Предобработка текста
    reviews_df['cleaned_text'] = reviews_df['review_text'].apply(preprocess_text)
    
    # Анализ тональности
    reviews_df['sentiment'] = reviews_df['review_text'].apply(analyze_sentiment)
    
    # Визуализация распределения тональности
    plt.figure(figsize=(10, 6))
    plt.hist(reviews_df['sentiment'], bins=3)
    plt.title('Распределение тональности отзывов')
    plt.xlabel('Тональность')
    plt.ylabel('Количество отзывов')
    plt.xticks([-1, 0, 1], ['Негативная', 'Нейтральная', 'Позитивная'])
    plt.show()
    
    # Тематическое моделирование
    vectorizer = CountVectorizer(max_df=0.95, min_df=2)
    doc_term_matrix = vectorizer.fit_transform(reviews_df['cleaned_text'])
    
    lda_model = LatentDirichletAllocation(n_components=5, random_state=42)
    lda_output = lda_model.fit_transform(doc_term_matrix)
    
    # Вывод топ слов для каждой темы
    print("\nТоп слова по темам:")
    for idx, topic in enumerate(lda_model.components_):
        print(f"Тема {idx + 1}:")
        print([vectorizer.get_feature_names_out()[i] for i in topic.argsort()[-10:]])
        print()
    
    # Анализ корреляции между темами и тональностью
    reviews_df['dominant_topic'] = lda_output.argmax(axis=1)
    topic_sentiment = reviews_df.groupby('dominant_topic')['sentiment'].mean()
    
    plt.figure(figsize=(10, 6))
    topic_sentiment.plot(kind='bar')
    plt.title('Средняя тональность по темам')
    plt.xlabel('Тема')
    plt.ylabel('Средняя тональность')
    plt.show()
    
    return reviews_df

# Пример использования
reviews_data = pd.DataFrame({
    'review_text': [
        "Отличный продукт, мне очень понравилось им пользоваться!",
        "Доставка была медленной, но качество хорошее.",
        "Обслуживание клиентов необходимо улучшить.",
        "Потрясающие функции, но немного дороговато.",
        "Не удовлетворен качеством продукции."
    ]
})

analyzed_reviews = analyze_customer_reviews(reviews_data)
print(analyzed_reviews)

Этот код выполняет следующие шаги для анализа отзывов клиентов:

  1. Предобработка текста: приведение к нижнему регистру и удаление стоп-слов;
  2. Анализ тональности: использование библиотеки dostoevsky для определения полярности настроения в каждом отзыве;
  3. Тематическое моделирование: применение Латентного размещения Дирихле (LDA) для выявления основных тем в отзывах;
  4. Визуализация результатов: построение графиков распределения тональности и средней тональности по темам.

Анализ отзывов клиентов с помощью NLP может помочь нам:

  • Выявить основные проблемы, с которыми сталкиваются клиенты;
  • Определить аспекты продукта или услуги, которые особенно нравятся клиентам;
  • Обнаружить новые возможности для улучшения продукта или клиентского сервиса;
  • Отслеживать изменения в настроениях клиентов во времени.
Читайте также:  Создание ML-модели прогноза действий пользователей интернет-магазина и рекомендательной системы

Прогнозирование пожизненной ценности клиента (CLV)

Понимание пожизненной ценности клиента (Customer Lifetime Value, CLV) может помочь в определении наиболее ценных сегментов клиентов и оптимизации маркетинговых стратегий. Давайте рассмотрим, как мы можем использовать Python для прогнозирования CLV.

import pandas as pd
import numpy as np
from lifetimes import BetaGeoFitter, GammaGammaFitter
import matplotlib.pyplot as plt

def predict_clv(df):
    # Подготовка данных
    customer_data = df.groupby('ClientID').agg({
        'VisitDateTime': lambda x: (x.max() - x.min()).days,  # recency
        'VisitID': 'count',  # frequency
        'GoalsID': lambda x: len([item for sublist in x for item in sublist if item]),  # number of purchases
        'Revenue': 'sum'  # total revenue
    }).reset_index()
    customer_data.columns = ['ClientID', 'recency', 'frequency', 'T', 'monetary_value']
    customer_data['T'] = customer_data['T'] + 1  # add 1 to avoid 0
    customer_data = customer_data[customer_data['monetary_value'] > 0]
    
    # Обучение модели BG/NBD
    bgf = BetaGeoFitter(penalizer_coef=0.0)
    bgf.fit(customer_data['frequency'], customer_data['recency'], customer_data['T'])
    
    # Обучение модели Gamma-Gamma
    ggf = GammaGammaFitter(penalizer_coef=0)
    ggf.fit(customer_data['frequency'], customer_data['monetary_value'])
    
    # Прогнозирование CLV на 12 месяцев вперед
    customer_data['predicted_purchases'] = bgf.predict(12, customer_data['frequency'], customer_data['recency'], customer_data['T'])
    customer_data['predicted_clv'] = ggf.customer_lifetime_value(
        bgf, 
        customer_data['frequency'],
        customer_data['recency'],
        customer_data['T'],
        customer_data['monetary_value'],
        time=12,
        discount_rate=0.01
    )
    
    # Визуализация распределения CLV
    plt.figure(figsize=(10, 6))
    plt.hist(customer_data['predicted_clv'], bins=50)
    plt.title('Распределение прогнозируемой пожизненной ценности клиента (CLV)')
    plt.xlabel('Прогнозируемая CLV')
    plt.ylabel('Количество клиентов')
    plt.show()
    
    # Определение топ-10% клиентов по CLV
    top_customers = customer_data.nlargest(int(len(customer_data) * 0.1), 'predicted_clv')
    
    print(f"Средняя прогнозируемая CLV: ${customer_data['predicted_clv'].mean():.2f}")
    print(f"Медианная прогнозируемая CLV: ${customer_data['predicted_clv'].median():.2f}")
    print(f"Средняя CLV для топ-10% клиентов: ${top_customers['predicted_clv'].mean():.2f}")
    
    return customer_data

clv_data = predict_clv(df)

Этот код демонстрирует процесс прогнозирования пожизненной ценности клиента:

  1. Подготовка данных: агрегация данных о клиентах, включая частоту покупок, давность последней покупки и общую сумму покупок;
  2. Обучение моделей BG/NBD (Beta-Geometric/Negative Binomial Distribution) для прогнозирования будущих покупок и Gamma-Gamma для прогнозирования средней стоимости покупки;
  3. Расчет прогнозируемой CLV на основе этих моделей;
  4. Визуализация распределения CLV и анализ наиболее ценных клиентов.

Анализ CLV может помочь нам:

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

Оптимизация рекомендательной системы

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

import pandas as pd
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from scipy.sparse import csr_matrix

def create_recommendation_system(df):
    # Подготовка данных
    user_item_matrix = df.pivot_table(
        index='ClientID',
        columns='ProductID',
        values='Rating',
        aggfunc='mean'
    ).fillna(0)
    
    # Создание разреженной матрицы
    user_item_sparse = csr_matrix(user_item_matrix.values)
    
    # Расчет косинусного сходства между пользователями
    user_similarity = cosine_similarity(user_item_sparse)
    
    # Функция для получения рекомендаций для пользователя
    def get_recommendations(user_id, top_n=5):
        user_index = user_item_matrix.index.get_loc(user_id)
        similar_users = user_similarity[user_index].argsort()[::-1][1:11]  # топ-10 похожих пользователей
        
        recommendations = {}
        for similar_user in similar_users:
            similar_user_id = user_item_matrix.index[similar_user]
            for product in user_item_matrix.columns:
                if user_item_matrix.loc[user_id, product] == 0 and user_item_matrix.loc[similar_user_id, product] > 0:
                    if product not in recommendations:
                        recommendations[product] = user_item_matrix.loc[similar_user_id, product]
                    else:
                        recommendations[product] += user_item_matrix.loc[similar_user_id, product]
        
        sorted_recommendations = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)
        return [item[0] for item in sorted_recommendations[:top_n]]
    
    # Пример использования
    example_user = user_item_matrix.index[0]
    recommended_products = get_recommendations(example_user)
    
    print(f"Рекомендации для пользователя {example_user}:")
    for product in recommended_products:
        print(f"- Продукт {product}")
    
    return get_recommendations

# Пример использования
ratings_data = pd.DataFrame({
    'ClientID': [1, 1, 1, 2, 2, 3, 3, 3],
    'ProductID': ['A', 'B', 'C', 'A', 'D', 'B', 'C', 'D'],
    'Rating': [5, 4, 3, 4, 5, 3, 4, 5]
})

recommendation_function = create_recommendation_system(ratings_data)

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

  1. Создает матрицу “пользователь-товар” на основе рейтингов;
  2. Вычисляет косинусное сходство между пользователями;
  3. Для каждого пользователя находит наиболее похожих пользователей и рекомендует товары, которые понравились похожим пользователям, но которые текущий пользователь еще не оценил.

Оптимизация рекомендательной системы может помочь:

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

Выводы и заключение

В этой статье мы рассмотрели различные методы и техники анализа данных с использованием Python для поиска точек роста онлайн-бизнеса. Мы изучили:

  • Анализ поведения пользователей и построение воронки продаж;
  • Сегментацию пользователей с помощью машинного обучения;
  • Прогнозирование оттока клиентов;
  • Анализ результатов A/B-тестов;
  • Исследование сезонности и трендов;
  • Оптимизацию ценообразования;
  • Анализ отзывов клиентов с помощью NLP;
  • Прогнозирование пожизненной ценности клиента (CLV);
  • Оптимизацию рекомендательной системы.

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

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