用户行为分析¶

def calculate_behavior_score(behaviors):
    """
    计算用户对物品的行为得分
    """
    weights = {
        'purchase': 1.0,
        'favorite': 0.8,
        'share': 0.7,
        'review': 0.6,
        'like': 0.5,
        'view': 0.3,
        'click': 0.1
    }

    score = 0
    for behavior in behaviors:
        score += weights.get(behavior['type'], 0)

    return score

def validate_event(event):
    """
    校验埋点数据
    """
    # 必填字段检查
    required_fields = ['event_id', 'timestamp', 'user_id', 'event_data']
    for field in required_fields:
        if field not in event:
            return False, f"Missing required field: {field}"

    # 时间戳检查
    if event['timestamp'] > time.time() * 1000:
        return False, "Invalid timestamp"

    # 用户ID检查
    if not event['user_id']:
        return False, "Invalid user_id"

    return True, "Valid"

def calculate_tag_weight(user_behaviors, tag):
    """
    计算标签权重
    """
    weight = 0
    for behavior in user_behaviors:
        if tag in behavior['tags']:
            weight += behavior['score'] * behavior['time_decay']
    return weight

def build_user_profile_rules(user):
    """
    基于规则构建用户画像
    """
    profile = {}

    # 年龄段
    if user['age'] < 25:
        profile['age_group'] = '18-24'
    elif user['age'] < 35:
        profile['age_group'] = '25-34'
    else:
        profile['age_group'] = '35+'

    # 消费能力
    total_spend = sum(b['amount'] for b in user['purchases'])
    if total_spend < 1000:
        profile['spend_level'] = 'low'
    elif total_spend < 5000:
        profile['spend_level'] = 'medium'
    else:
        profile['spend_level'] = 'high'

    # 活跃度
    active_days = len(set(b['date'] for b in user['behaviors']))
    if active_days > 20:
        profile['activity'] = 'high'
    elif active_days > 10:
        profile['activity'] = 'medium'
    else:
        profile['activity'] = 'low'

    return profile

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

def build_user_profile_ml(users):
    """
    基于机器学习构建用户画像
    """
    # 特征提取
    features = extract_user_features(users)

    # 特征标准化
    scaler = StandardScaler()
    features_scaled = scaler.fit_transform(features)

    # 聚类
    kmeans = KMeans(n_clusters=5, random_state=42)
    clusters = kmeans.fit_predict(features_scaled)

    # 构建画像
    profiles = []
    for i, user in enumerate(users):  # enumerate同时获取索引和元素
        profile = {
            'user_id': user['user_id'],
            'cluster': clusters[i],
            'features': features[i]
        }
        profiles.append(profile)

    return profiles

def time_decay(timestamp, current_time, decay_rate=0.1):
    """
    时间衰减函数
    """
    time_diff = (current_time - timestamp) / (24 * 3600)  # 天数
    return math.exp(-decay_rate * time_diff)

def extract_user_statistics(user_behaviors):
    """
    提取用户统计特征
    """
    stats = {}

    # 点击次数
    stats['click_count'] = len([b for b in user_behaviors if b['type'] == 'click'])

    # 购买次数
    stats['purchase_count'] = len([b for b in user_behaviors if b['type'] == 'purchase'])

    # 平均停留时长
    view_behaviors = [b for b in user_behaviors if b['type'] == 'view']
    stats['avg_dwell_time'] = np.mean([b['duration'] for b in view_behaviors])

    # 活跃天数
    stats['active_days'] = len(set(b['date'] for b in user_behaviors))

    # 消费金额
    purchase_behaviors = [b for b in user_behaviors if b['type'] == 'purchase']
    stats['total_spend'] = sum(b['amount'] for b in purchase_behaviors)

    return stats

def extract_item_statistics(item_behaviors):
    """
    提取物品统计特征
    """
    stats = {}

    # 点击率
    stats['click_rate'] = len([b for b in item_behaviors if b['type'] == 'click']) / len(item_behaviors)

    # 转化率
    stats['conversion_rate'] = len([b for b in item_behaviors if b['type'] == 'purchase']) / len(item_behaviors)

    # 平均评分
    ratings = [b['rating'] for b in item_behaviors if b['type'] == 'rating']
    stats['avg_rating'] = np.mean(ratings) if ratings else 0

    # 热度
    stats['popularity'] = len(item_behaviors)

    return stats

def extract_sequence_features(user_behaviors):
    """
    提取序列特征
    """
    features = {}

    # 按时间排序
    behaviors = sorted(user_behaviors, key=lambda x: x['timestamp'])  # lambda匿名函数

    # 最后N次行为
    features['last_5_items'] = [b['item_id'] for b in behaviors[-5:]]
    features['last_5_categories'] = [b['category'] for b in behaviors[-5:]]

    # 行为间隔
    intervals = []
    for i in range(1, len(behaviors)):
        interval = behaviors[i]['timestamp'] - behaviors[i-1]['timestamp']
        intervals.append(interval)
    features['avg_interval'] = np.mean(intervals)

    # 行为模式
    features['behavior_pattern'] = extract_behavior_pattern(behaviors)

    return features

def extract_time_features(timestamp):
    """
    提取时间特征
    """
    dt = datetime.fromtimestamp(timestamp)

    features = {
        'hour': dt.hour,
        'day_of_week': dt.weekday(),
        'day_of_month': dt.day,
        'month': dt.month,
        'is_weekend': 1 if dt.weekday() >= 5 else 0,
        'is_holiday': check_holiday(dt)
    }

    return features

def extract_user_item_features(user, item):
    """
    提取用户-物品交叉特征
    """
    features = {}

    # 用户偏好与物品类别的匹配度
    user_categories = user['preferred_categories']
    item_category = item['category']
    features['category_match'] = 1 if item_category in user_categories else 0

    # 用户消费能力与物品价格的匹配度
    user_spend_level = user['spend_level']
    item_price = item['price']
    features['price_match'] = check_price_match(user_spend_level, item_price)

    # 用户地域与物品地域的匹配度
    user_location = user['location']
    item_location = item['location']
    features['location_match'] = calculate_location_similarity(user_location, item_location)

    return features

import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# 1. 加载数据
behaviors = pd.read_csv('user_behaviors.csv')

# 2. 数据清洗
behaviors = behaviors.dropna()
behaviors = behaviors[behaviors['amount'] > 0]

# 3. 特征提取
def extract_features(user_behaviors):
    features = {
        'total_spend': user_behaviors['amount'].sum(),
        'purchase_count': len(user_behaviors),
        'avg_price': user_behaviors['amount'].mean(),
        'category_diversity': user_behaviors['category'].nunique(),
        'active_days': user_behaviors['date'].nunique()
    }
    return features

user_features = behaviors.groupby('user_id').apply(extract_features).apply(pd.Series)

# 4. 用户聚类
scaler = StandardScaler()
features_scaled = scaler.fit_transform(user_features)

kmeans = KMeans(n_clusters=5, random_state=42)
clusters = kmeans.fit_predict(features_scaled)

user_features['cluster'] = clusters

# 5. 分析结果
for cluster in range(5):
    cluster_users = user_features[user_features['cluster'] == cluster]
    print(f"Cluster {cluster}:")
    print(cluster_users.describe())

# 1. 加载数据
behaviors = pd.read_csv('video_behaviors.csv')
videos = pd.read_csv('video_info.csv')

# 2. 合并数据
data = behaviors.merge(videos, on='video_id')

# 3. 计算用户对不同类别的偏好
def calculate_category_preference(user_data):
    category_scores = {}
    for _, row in user_data.iterrows():
        category = row['category']
        score = get_behavior_score(row['behavior_type'])
        category_scores[category] = category_scores.get(category, 0) + score

    # 归一化
    total = sum(category_scores.values())
    if total > 0:
        category_scores = {k: v/total for k, v in category_scores.items()}

    return category_scores

user_preferences = data.groupby('user_id').apply(calculate_category_preference)

# 4. 提取Top兴趣标签
def extract_top_interests(user_prefs, top_k=5):
    sorted_prefs = sorted(user_prefs.items(), key=lambda x: x[1], reverse=True)
    return [tag for tag, score in sorted_prefs[:top_k]]

user_interests = user_preferences.apply(extract_top_interests)

# 5. 分析结果
print("用户兴趣分布:")
print(user_interests.head(10))