Создание рекомендательных систем на основе анализа поведения пользователей на сайте

Привет, Хабр!

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

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

И это только один из бесчисленных примеров использования рекомендательных систем.

Сбор и предварительная обработка данных

Сбор данных - это первый и один из самых важных шагов при создании рекомендательной системы на основе анализа поведения пользователей:

Использование библиотеки Requests для получения данных с веб-сайта

import requests

# URL веб-сайта, с которого собираем данные
url = 'https://example.com/user-behavior-data'

# Отправляем GET-запрос на сайт и получаем данные
response = requests.get(url)

# Проверяем успешность запроса
if response.status_code == 200:
    user_data = response.json()  # Предполагается, что данные приходят в формате JSON
    # Здесь можно провести первичную обработку данных
else:
    print('Ошибка при получении данных')

Сбор данных из логов сервера

import re

# Путь к лог-файлу сервера
log_file_path = '/var/log/server.log'

# Открываем лог-файл и считываем строки
with open(log_file_path, 'r') as log_file:
    log_data = log_file.readlines()

# Пример анализа строк лога и извлечения нужных данных
user_actions = []
for line in log_data:
    if re.search(r'User (\d+) performed action', line):
        user_id = re.search(r'User (\d+) performed action', line).group(1)
        action = re.search(r'Action: (.+)', line).group(1)
        user_actions.append((user_id, action))

Использование API стороннего сервиса

import requests

# URL API стороннего сервиса для получения данных о поведении пользователей
api_url = 'https://example-api.com/user-behavior'

# Отправляем запрос к API и получаем данные
response = requests.get(api_url)

if response.status_code == 200:
    user_behavior_data = response.json()
    # Здесь можно провести обработку данных и извлечь необходимую информацию
else:
    print('Ошибка при запросе к API')

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

После сбора данных необходимо их обработать и проанализировать, чтобы выделить ключевые паттерны и тенденции:

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

from collections import defaultdict

# Предположим, у нас есть список user_actions с данными о действиях пользователей
user_actions = [('user1', 'click'), ('user2', 'like'), ('user1', 'purchase'), ...]

# Создаем словарь для агрегации данных
user_data_aggregated = defaultdict(list)

# Агрегируем данные по пользователям
for user, action in user_actions:
    user_data_aggregated[user].append(action)

Вычисление статистических показателей

import numpy as np

# Предположим, у нас есть список покупок пользователей
purchases = [10.5, 20.0, 15.75, 30.0, ...]

# Вычисляем среднее значение и стандартное отклонение
mean_purchase = np.mean(purchases)
std_deviation = np.std(purchases)

Визуализация данных

import matplotlib.pyplot as plt

# Предположим, у нас есть данные о количестве посещений сайта в разные дни
days = ['Пн', 'Вт', 'Ср', 'Чт', 'Пт']
visits = [1200, 1400, 1100, 1500, 1300]

# Строим график
plt.plot(days, visits, marker='o', linestyle='-', color='b')
plt.xlabel('Дни недели')
plt.ylabel('Количество посещений')
plt.title('Количество посещений сайта по дням недели')
plt.grid(True)
plt.show()

Очистка и преобразование данных

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

Удаление дубликатов

import pandas as pd

# Предположим, у нас есть DataFrame с данными
df = pd.DataFrame({'user_id': [1, 2, 2, 3, 4], 'action': ['click', 'like', 'like', 'purchase', 'click']})

# Удаляем дубликаты по столбцам 'user_id' и 'action'
df_cleaned = df.drop_duplicates(subset=['user_id', 'action'])

Заполнение пропущенных значений

import pandas as pd

# Предположим, у нас есть DataFrame с пропущенными значениями
df = pd.DataFrame({'user_id': [1, 2, 3, 4], 'age': [25, None, 30, 35]})

# Заполняем пропущенные значения средним значением
mean_age = df['age'].

mean()
df['age'].fillna(mean_age, inplace=True)

Преобразование категориальных данных в числовые

import pandas as pd

# Предположим, у нас есть DataFrame с категориальными данными
df = pd.DataFrame({'user_id': [1, 2, 3, 4], 'gender': ['male', 'female', 'male', 'female']})

# Преобразуем столбец 'gender' в числовой формат с помощью кодирования
df_encoded = pd.get_dummies(df, columns=['gender'], drop_first=True)

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

Не забывайте, что точные методы сбора, обработки и очистки данных будут зависеть от конкретных требований вашего проекта и характера данных, с которыми вы работаете.

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

Матрица взаимодействий

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

Пример Python-кода для создания матрицы взаимодействий:

import numpy as np

# Предположим, у нас есть данные о рейтингах фильмов от пользователей
ratings = np.array([
    [5, 4, 0, 0, 0],
    [0, 0, 3, 4, 0],
    [2, 0, 0, 0, 5],
    [0, 0, 0, 4, 4]
])

# Создаем матрицу взаимодействий (бинарную: 1 - взаимодействие, 0 - отсутствие взаимодействия)
interaction_matrix = (ratings > 0).astype(int)

Коллаборативная фильтрация

Коллаборативная фильтрация - это метод, который опирается на схожесть между пользователями или элементами. Схожесть может быть вычислена на основе истории взаимодействий пользователей с элементами. Есть два основных подхода к коллаборативной фильтрации: пользователь-пользователь (User-User Collaborative Filtering) и элемент-элемент (Item-Item Collaborative Filtering).

Пример Python-кода для коллаборативной фильтрации с использованием библиотеки scikit-learn:

from sklearn.metrics.pairwise import cosine_similarity

# Предположим, у нас есть матрица взаимодействий interaction_matrix
# Вычисляем схожесть между пользователями (User-User Collaborative Filtering)
user_similarity = cosine_similarity(interaction_matrix)

# Вычисляем схожесть между элементами (Item-Item Collaborative Filtering)
item_similarity = cosine_similarity(interaction_matrix.T)  # Транспонируем матрицу для элементов

Методы контентной фильтрации

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

Пример Python-кода для методов контентной фильтрации:

import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer

# Предположим, у нас есть DataFrame с информацией о фильмах
movies_df = pd.DataFrame({
    'movie_id': [1, 2, 3],
    'title': ['Movie A', 'Movie B', 'Movie C'],
    'genre': ['Action', 'Drama', 'Comedy'],
    'description': ['Action-packed thriller', 'Drama about life', 'Comedy for laughs']
})

# Преобразуем текстовые данные (описание) в числовой формат с помощью TF-IDF
tfidf_vectorizer = TfidfVectorizer()
tfidf_matrix = tfidf_vectorizer.fit_transform(movies_df['description'])

# Вычисляем схожесть между фильмами на основе TF-IDF
content_similarity = cosine_similarity(tfidf_matrix)

Машинное обучение в рекомендательных системах

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

Пример Python-кода для создания модели рекомендательной системы с использованием библиотеки scikit-learn:

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

# Предположим, у нас есть данные о взаимодействии пользователей с элементами
X = features  # Матрица признаков
y = labels  # Целевая переменная

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

# Создаем модель (например, логистическую регрессию) и обучаем её
model = LogisticRegression()
model.fit(X_train, y_train)

# Делаем предсказания
y_pred = model.predict(X_test)

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

Создание рекомендательной системы с использованием Python

Python предоставляет множество библиотек, удобных для работы с данными и машинным обучением, таких как Pandas, NumPy, Scikit-learn, TensorFlow, PyTorch и др.

Импорт нескольких распространенных библиотек:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.neighbors import NearestNeighbors
import tensorflow as tf
from tensorflow import keras

Загрузка данных и подготовка датасета

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

Пример кода для загрузки данных с использованием Pandas:

# Загрузка данных из CSV файла
data = pd.read_csv('user_interaction_data.csv')

# Подготовка данных (пример: объединение информации о пользователях и элементах)
user_data = pd.read_csv('user_data.csv')
item_data = pd.read_csv('item_data.csv')
merged_data = pd.merge(data, user_data, on='user_id').merge(item_data, on='item_id')

Разработка модели рекомендательной системы

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

Пример Python-кода для создания модели с использованием библиотеки TensorFlow/Keras:

# Создание модели нейронной сети
model = keras.Sequential([
    keras.layers.Embedding(num_users, embedding_dim, input_length=user_item_matrix.shape[1]),
    keras.layers.Flatten(),
    keras.layers.Dense(16, activation='relu'),
    keras.layers.Dense(1, activation='linear')
])

# Компиляция модели
model.compile(optimizer='adam', loss='mean_squared_error')

Обучение и оценка модели

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

Пример кода для обучения и оценки модели:

# Разделение данных на обучающий и тестовый наборы
train_data, test_data = train_test_split(data, test_size=0.2, random_state=42)

# Обучение модели
history = model.fit([train_data['user_id'], train_data['item_id']], train_data['rating'], 
                    epochs=10, batch_size=64, validation_data=([test_data['user_id'], test_data['item_id']], test_data['rating']))

# Оценка модели
predictions = model.predict([test_data['user_id'], test_data['item_id']])
mse = mean_squared_error(test_data['rating'], predictions)
print(f'Mean Squared Error: {mse}')

Тюнинг и оптимизация модели

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

Пример Python-кода для оптимизации модели с использованием библиотеки Scikit-learn:

from sklearn.model_selection import GridSearchCV

# Определение сетки параметров для подбора
param_grid = {'n_neighbors': [3, 5, 7], 'metric': ['cosine', 'euclidean']}

# Создание модели k-Nearest Neighbors и запуск GridSearchCV
knn = NearestNeighbors()
grid_search = GridSearchCV(knn, param_grid, cv=5)
grid_search.fit(X_train, y_train)

# Вывод наилучших параметров
print(f'Best Parameters: {grid_search.best_params_}')

Реализация рекомендательной системы на веб-сайте

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

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

from flask import Flask, request, jsonify
import model  # Ваш модуль с моделью

app = Flask(__name__)

@app.route('/recommend', methods=['POST'])
def recommend():
    user_id = request.json['user_id']
    # Получите рекомендации от вашей модели
    recommendations = model.get_recommendations(user_id)
    return jsonify(recommendations)

if __name__ == '__main__':
    app.run()

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

from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from . import model  # Ваш модуль с моделью

@csrf_exempt
def recommend(request):
    if request.method == 'POST':
        user_id = request.POST.get('user_id')
        # Получите рекомендации от вашей модели
        recommendations = model.get_recommendations(user_id)
        return JsonResponse({'recommendations': recommendations})

Обработка запросов от пользователей

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

Обработка запросов с использованием Flask

import requests

user_id = 123  # Пример ID пользователя
data = {'user_id': user_id}
response = requests.post('http://localhost:5000/recommend', json=data)

if response.status_code == 200:
    recommendations = response.json()
    print(f'Recommendations for user {user_id}: {recommendations}')
else:
    print('Error in making recommendations')

Обработка запросов с использованием JavaScript и AJAX (для веб-страницы)

<!DOCTYPE html>
<html>
<head>
    <title>Recommendations</title>
</head>
<body>
    <button onclick="getRecommendations()">Get Recommendations</button>
    <div id="recommendations"></div>

    <script>
        function getRecommendations() {
            var user_id = 123;  // Пример ID пользователя
            var xhr = new XMLHttpRequest();
            xhr.open('POST', '/recommend', true);
            xhr.setRequestHeader('Content-Type', 'application/json');
            xhr.onreadystatechange = function () {
                if (xhr.readyState === 4 && xhr.status === 200) {
                    var response = JSON.parse(xhr.responseText);
                    var recommendations = response.recommendations;
                    document.getElementById('recommendations').innerHTML = 'Recommendations: ' + recommendations.join(', ');
                }
            };
            var data = JSON.stringify({user_id: user_id});
            xhr.send(data);
        }
    </script>
</body>
</html>

Отображение рекомендаций на сайте

Отображение рекомендаций на сайте зависит от дизайна и интерфейса вашего веб-приложения. Вам может потребоваться использовать HTML, CSS и JavaScript для интеграции рекомендаций в интерфейс сайта.

Отображение рекомендаций с использованием Flask и Jinja2 (шаблонизатор Flask)

from flask import Flask, render_template
import model  # Ваш модуль с моделью

app = Flask(__name__)

@app.route('/recommendations/<user_id>')
def show_recommendations(user_id):
    recommendations = model.get_recommendations(user_id)
    return render_template('recommendations.html', recommendations=recommendations)

Отображение рекомендаций с использованием JavaScript и DOM-манипуляций (для веб-страницы)

<!DOCTYPE html>
<html>
<head>
    <title>Recommendations</title>
</head>
<body>
    <div id="recommendations"></div>

    <script>
        // Получите рекомендации (например, с помощью AJAX) и отобразите их на странице
        var recommendations = ["Item 1", "Item 2", "Item 3"];  // Пример рекомендаций
        var recommendationsDiv = document.getElementById('recommendations');
        recommendationsDiv.innerHTML = 'Recommendations: ' + recommendations.join(', ');
    </script>
</body>
</html>

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

Оценка и улучшение рекомендательной системы

Существует несколько метрик, которые помогают измерить производительность вашей рекомендательной системы:

1. Среднеквадратичная ошибка (Mean Squared Error, MSE)

MSE измеряет разницу между рейтингами, предсказанными моделью, и фактическими рейтингами пользователей. Ниже приведен пример Python-кода для вычисления MSE:

from sklearn.metrics import mean_squared_error

# Предположим, у нас есть фактические рейтинги (actual) и предсказанные рейтинги (predicted)
actual = [4, 5, 3, 2, 4]
predicted = [3.5, 4.8, 2.5, 1.8, 4.2]

# Вычисляем MSE
mse = mean_squared_error(actual, predicted)
print(f'Mean Squared Error: {mse}')

Mean Squared Error: 0.12400000000000003

2. Средняя абсолютная ошибка (Mean Absolute Error, MAE)

MAE также измеряет разницу между фактическими и предсказанными рейтингами, но она не учитывает квадраты ошибок. Пример Python-кода для вычисления MAE:

from sklearn.metrics import mean_absolute_error

# Предположим, у нас есть фактические рейтинги (actual) и предсказанные рейтинги (predicted)
actual = [4, 5, 3, 2, 4]
predicted = [3.5, 4.8, 2.5, 1.8, 4.2]

# Вычисляем MAE
mae = mean_absolute_error(actual, predicted)
print(f'Mean Absolute Error: {mae}')

Mean Absolute Error: 0.32000000000000006

Тестирование и сравнение с другими методами

1. Тестирование с использованием кросс-валидации

Вы можете использовать кросс-валидацию для оценки производительности вашей модели на разных наборах данных:

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression

# Предположим, у нас есть модель рекомендательной системы
model = LinearRegression()

# Вычисляем средний MSE с использованием кросс-валидации
mse_scores = cross_val_score(model, X, y, cv=5, scoring='neg_mean_squared_error')
mse_mean = -mse_scores.mean()
print(f'Average MSE: {mse_mean}')

2. Сравнение с другими методами

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

# Предположим, у нас есть две модели: model1 и model2
mse1 = mean_squared_error(actual, model1_predicted)
mse2 = mean_squared_error(actual, model2_predicted)

if mse1 < mse2:
    print('Model 1 performs better.')
else:
    print('Model 2 performs better.')

Итеративное улучшение системы

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

# Предположим, вы улучшили модель с новыми параметрами или методами
improved_model = ImprovedRecommender()

# Оцените производительность улучшенной модели
mse_improved = mean_squared_error(actual, improved_model.predicted_ratings)

if mse_improved < mse:
    print('Improved model performs better.')
else:
    print('Original model is still better.')

Пример реализации рекомендации товаров на электронном магазине

Шаг 1: Сбор и подготовка данных

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

# Загрузка данных
import pandas as pd

# Загрузка данных о товарах
products_df = pd.read_csv('products.csv')

# Загрузка данных о действиях пользователей
user_actions_df = pd.read_csv('user_actions.csv')

Шаг 2: Предобработка данных

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

# Обработка пропущенных значений
products_df.fillna(0, inplace=True)

# Преобразование категориальных данных (например, категорий товаров) в числовой формат
from sklearn.preprocessing import LabelEncoder

label_encoder = LabelEncoder()
products_df['category_encoded'] = label_encoder.fit_transform(products_df['category'])

Шаг 3: Создание матрицы взаимодействий

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

# Создание матрицы взаимодействий
interaction_matrix = user_actions_df.pivot_table(index='user_id', columns='product_id', values='interaction', fill_value=0)

# Преобразование матрицы в NumPy массив
interaction_matrix = interaction_matrix.values

Шаг 4: Разработка модели рекомендательной системы

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

from sklearn.metrics.pairwise import cosine_similarity

# Вычисление сходства пользователей
user_similarity = cosine_similarity(interaction_matrix)

# Создание функции для получения рекомендаций для конкретного пользователя
def get_recommendations(user_id, num_recommendations=5):
    # Находим наиболее похожих пользователей
    similar_users = user_similarity[user_id]
    similar_users_idx = similar_users.argsort()[::-1][1:]  # Исключаем самого пользователя
    
    # Получаем товары, с которыми взаимодействовали похожие пользователи
    recommendations = set()
    for similar_user_idx in similar_users_idx:
        similar_user_actions = interaction_matrix[similar_user_idx]
        new_recommendations = set(products_df.loc[similar_user_actions > 0, 'product_id'])
        recommendations.update(new_recommendations)
        if len(recommendations) >= num_recommendations:
            break
    
    # Исключаем товары, с которыми пользователь уже взаимодействовал
    user_actions = interaction_matrix[user_id]
    recommendations.difference_update(set(products_df.loc[user_actions > 0, 'product_id']))
    
    return list(recommendations)[:num_recommendations]

Шаг 5: Тестирование и оценка модели

Теперь мы можем протестировать нашу модель и оценить её производительность с помощью метрик, таких как среднеквадратичная ошибка (MSE) или средняя абсолютная ошибка (MAE), а также сравнить её с другими методами.

# Выбор случайного пользователя для тестирования
import random

test_user_id = random.randint(0, interaction_matrix.shape[0] - 1)

# Получение рекомендаций для тестового пользователя
recommendations = get_recommendations(test_user_id)
print(f'Recommendations for user {test_user_id}: {recommendations}')

# Оценка производительности модели (например, по MSE)
actual_actions = interaction_matrix[test_user_id]
predicted_actions = [1 if product_id in recommendations else 0 for product_id in products_df['product_id']]
mse = mean_squared_error(actual_actions, predicted_actions)
print(f'Mean Squared Error: {mse}')

Заключение

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

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