2nd/10_Wiki/Topic_General/Game_Design/Data-Driven Personalization.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-data-driven-personalization	Data-Driven Personalization	10_Wiki/Topics	verified	self	personalization dynamic-personalization player-segmentation	none	A	0.9	applied	data personalization segmentation ml mobile-game		2026-05-10	pending	language framework python feature-store-ml

Data-Driven Personalization

매 한 줄

"매 player 의 behavior data 로 매 content / offer / difficulty 의 individual tuning". 매 segment 단위 → 매 ML-driven individual 단위 의 매 evolution. 매 2026 standard 는 매 real-time feature store + 매 contextual bandit + 매 explainable rule overlay.

매 핵심

매 segmentation tier

• Static segment: 매 country, install_source.
• Behavior segment: 매 spender / dolphin / minnow / F2P.
• Lifecycle: 매 new / engaged / churning / churned.
• ML cluster: 매 k-means / autoencoder embedding.

매 personalization surface

• Offer pricing: 매 player-specific bundle.
• Difficulty: 매 adaptive level.
• Content order: 매 onboarding sequence.
• Push timing: 매 individual best-time.

매 응용

1. 매 LTV uplift (매 10-30%).
2. 매 retention curve flattening.
3. 매 cohort-specific event design.

💻 패턴

Player feature vector

from dataclasses import dataclass
from typing import Literal

@dataclass
class PlayerFeatures:
    days_since_install: int
    sessions_7d: int
    sessions_30d: int
    spend_total: float
    spend_30d: float
    last_spend_days: int
    avg_session_min: float
    progression_level: int
    cohort: Literal["new", "engaged", "churning", "churned"]
    country: str

def derive_cohort(p: PlayerFeatures) -> str:
    if p.days_since_install < 7: return "new"
    if p.sessions_7d == 0: return "churned"
    if p.sessions_7d < p.sessions_30d / 8: return "churning"
    return "engaged"

Contextual bandit (offer selection)

import numpy as np

class LinUCB:
    def __init__(self, n_arms: int, n_features: int, alpha: float = 1.0):
        self.A = [np.eye(n_features) for _ in range(n_arms)]
        self.b = [np.zeros(n_features) for _ in range(n_arms)]
        self.alpha = alpha

    def select(self, x: np.ndarray) -> int:
        scores = []
        for a in range(len(self.A)):
            A_inv = np.linalg.inv(self.A[a])
            theta = A_inv @ self.b[a]
            ucb = theta @ x + self.alpha * np.sqrt(x @ A_inv @ x)
            scores.append(ucb)
        return int(np.argmax(scores))

    def update(self, arm: int, x: np.ndarray, reward: float):
        self.A[arm] += np.outer(x, x)
        self.b[arm] += reward * x

Adaptive difficulty (player skill estimate)

def estimate_skill(recent_attempts: list[dict]) -> float:
    """recent_attempts: [{success: bool, level_difficulty: float}]"""
    if not recent_attempts: return 0.5
    total_w = sum(0.9 ** i for i in range(len(recent_attempts)))
    skill = sum(
        (a["level_difficulty"] if a["success"] else a["level_difficulty"] - 0.2)
        * (0.9 ** i)
        for i, a in enumerate(recent_attempts)
    ) / total_w
    return max(0.0, min(1.0, skill))

def next_difficulty(skill: float, target_winrate: float = 0.65) -> float:
    # Want challenge slightly above skill
    return skill + (1 - target_winrate) * 0.3

Real-time feature store query

from datetime import datetime

class FeatureStore:
    def __init__(self, redis_client, warehouse_client):
        self.redis = redis_client
        self.warehouse = warehouse_client

    async def get_player_features(self, player_id: str) -> PlayerFeatures:
        # Hot features from Redis
        hot = await self.redis.hgetall(f"player:{player_id}:hot")
        # Cold features from warehouse (cached)
        cold = await self.warehouse.query(
            f"SELECT * FROM player_cold WHERE id = '{player_id}'"
        )
        return PlayerFeatures(**{**cold, **hot})

Explainable overlay (rule + ML)

def select_offer_with_guardrails(p: PlayerFeatures, ml_pick: int, offers: list) -> int:
    # Guardrails override ML
    if p.spend_total == 0 and offers[ml_pick].price > 9.99:
        return offers.index(STARTER_PACK_499)  # never expensive to non-spenders
    if p.cohort == "churning":
        return offers.index(WIN_BACK_OFFER)
    if p.country in HIGH_RISK_COUNTRIES and offers[ml_pick].price > 4.99:
        return offers.index(LOW_PRICE_DEFAULT)
    return ml_pick

매 결정 기준

상황	Approach
매 small data	Static segment + rules
매 medium data	Behavior segment + A/B
매 large data	ML cluster + contextual bandit
매 regulated market	Rule guardrails 의 mandatory

기본값: 매 segment + bandit + 매 rule guardrails 의 layered.

🔗 Graph

• 부모: LiveOps
• 변형: Dynamic Offers · Adaptive-Difficulty
• 응용: Game_Monetization_Strategy · Capybara GO!
• Adjacent: CPI (Cost Per Install) · Gacha Mechanics Analysis

🤖 LLM 활용

언제: 매 segmentation design, bandit setup, feature engineering. 언제 X: 매 cold-start product — 매 data 부족.

❌ 안티패턴

• Predatory targeting: 매 vulnerable player 의 매 high-spend offer.
• Black-box only: 매 explainability 없음 → 매 regulator + designer 둘 다 lost.
• Stale features: 매 hourly batch → 매 real-time signal miss.
• Over-segmentation: 매 sample size 부족.

🧪 검증 / 중복

• Verified (Unity LiveOps 2025 report, GameAnalytics Personalization Whitepaper).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — data-driven personalization with bandit + guardrails.