AI Learning Gamification System Development

AI-система геймификации обучения

Геймификация в обучении без AI — статичная система баллов и бейджей. AI-геймификация адаптируется: подбирает сложность вызовов, выбирает тип награды под психологический профиль студента, создаёт персональные рейтинги с релевантными соперниками.

Профиль игрока и адаптация стимулов

import numpy as np
import pandas as pd
from enum import Enum
from dataclasses import dataclass

class PlayerType(Enum):
    """Типология Бартла: 4 типа игровой мотивации"""
    ACHIEVER = 'achiever'    # Достижения, прогресс, статус
    EXPLORER = 'explorer'    # Исследование, разнообразие контента
    SOCIALIZER = 'socializer'  # Взаимодействие, кооперация
    COMPETITOR = 'competitor'  # Соревнование, рейтинги

@dataclass
class GamificationProfile:
    player_type: PlayerType
    achiever_score: float
    explorer_score: float
    socializer_score: float
    competitor_score: float
    preferred_reward: str  # badges, xp, leaderboard, challenges

class PlayerTypeClassifier:
    """Определение типа игрока из поведения"""

    def classify(self, behavior: dict) -> GamificationProfile:
        """
        behavior: счётчики разных типов действий
        """
        # Нормализованные скоры по типам
        achiever = (
            behavior.get('badges_viewed', 0) * 0.3 +
            behavior.get('progress_bar_clicks', 0) * 0.4 +
            behavior.get('certificate_downloads', 0) * 0.3
        )
        explorer = (
            behavior.get('optional_modules_opened', 0) * 0.5 +
            behavior.get('bonus_content_views', 0) * 0.3 +
            behavior.get('different_categories_explored', 0) * 0.2
        )
        socializer = (
            behavior.get('forum_posts', 0) * 0.4 +
            behavior.get('peer_reviews_given', 0) * 0.4 +
            behavior.get('study_groups_joined', 0) * 0.2
        )
        competitor = (
            behavior.get('leaderboard_views', 0) * 0.5 +
            behavior.get('challenges_accepted', 0) * 0.3 +
            behavior.get('time_beaten_peers', 0) * 0.2
        )

        scores = {
            PlayerType.ACHIEVER: achiever,
            PlayerType.EXPLORER: explorer,
            PlayerType.SOCIALIZER: socializer,
            PlayerType.COMPETITOR: competitor
        }

        dominant = max(scores, key=scores.get)

        reward_map = {
            PlayerType.ACHIEVER: 'badges',
            PlayerType.EXPLORER: 'bonus_content',
            PlayerType.SOCIALIZER: 'social_recognition',
            PlayerType.COMPETITOR: 'leaderboard'
        }

        total = sum(scores.values()) + 1e-9
        return GamificationProfile(
            player_type=dominant,
            achiever_score=achiever / total,
            explorer_score=explorer / total,
            socializer_score=socializer / total,
            competitor_score=competitor / total,
            preferred_reward=reward_map[dominant]
        )


class AdaptiveChallengeGenerator:
    """Персонализированные вызовы и задачи"""

    def generate_daily_challenge(self, student: dict,
                                   mastery: dict,
                                   player_profile: GamificationProfile) -> dict:
        """Ежедневный персональный вызов"""
        # Сложность вызова = текущий уровень + небольшой stretch
        avg_mastery = np.mean(list(mastery.values())) if mastery else 0.5
        challenge_difficulty = min(0.95, avg_mastery + 0.1)

        # Тип вызова зависит от типа игрока
        if player_profile.player_type == PlayerType.COMPETITOR:
            challenge = self._create_speed_challenge(challenge_difficulty, student)
        elif player_profile.player_type == PlayerType.SOCIALIZER:
            challenge = self._create_collaborative_challenge(challenge_difficulty, student)
        elif player_profile.player_type == PlayerType.EXPLORER:
            challenge = self._create_exploration_challenge(challenge_difficulty, student)
        else:
            challenge = self._create_achievement_challenge(challenge_difficulty, student)

        # Награда пропорциональна сложности и типу
        challenge['reward_xp'] = int(50 * challenge_difficulty * (1 + player_profile.achiever_score))
        challenge['bonus_badge'] = challenge_difficulty > 0.8

        return challenge

    def _create_speed_challenge(self, difficulty: float, student: dict) -> dict:
        return {
            'type': 'speed_run',
            'title': 'Спринт дня',
            'description': f'Пройди 5 заданий за 10 минут',
            'time_limit_sec': 600,
            'difficulty': difficulty,
            'leaderboard_eligible': True
        }

    def _create_collaborative_challenge(self, difficulty: float, student: dict) -> dict:
        return {
            'type': 'peer_help',
            'title': 'Помоги однокурснику',
            'description': 'Ответь на 2 вопроса на форуме',
            'difficulty': difficulty,
            'leaderboard_eligible': False
        }

    def _create_exploration_challenge(self, difficulty: float, student: dict) -> dict:
        return {
            'type': 'bonus_module',
            'title': 'Бонусное исследование',
            'description': 'Изучи необязательный материал по смежной теме',
            'difficulty': difficulty,
            'unlocks_bonus_content': True
        }

    def _create_achievement_challenge(self, difficulty: float, student: dict) -> dict:
        return {
            'type': 'streak_builder',
            'title': 'Серия прогресса',
            'description': 'Сохрани серию 3 дня подряд',
            'difficulty': difficulty,
            'streak_target': 3
        }


class SmartLeaderboard:
    """Интеллектуальный рейтинг: релевантные соперники"""

    def get_personalized_leaderboard(self, student_id: str,
                                      all_students: pd.DataFrame,
                                      metric: str = 'xp_week') -> pd.DataFrame:
        """
        Показываем не глобальный топ, а ближайших соперников.
        Мотивирует сильнее: можно обогнать, реалистичная конкуренция.
        """
        student = all_students[all_students['student_id'] == student_id].iloc[0]
        student_score = student[metric]

        # ±20% от текущего уровня
        lower = student_score * 0.8
        upper = student_score * 1.2

        relevant = all_students[
            (all_students[metric] >= lower) &
            (all_students[metric] <= upper) &
            (all_students['student_id'] != student_id)
        ].nlargest(9, metric)

        # Добавляем самого студента
        leaderboard = pd.concat([
            relevant,
            all_students[all_students['student_id'] == student_id]
        ]).sort_values(metric, ascending=False).reset_index(drop=True)

        leaderboard['rank'] = leaderboard.index + 1
        leaderboard['is_self'] = leaderboard['student_id'] == student_id

        return leaderboard[['rank', 'display_name', metric, 'is_self']]

    def calculate_streak_bonuses(self, student: dict) -> dict:
        """Прогрессивные бонусы за серии"""
        streak = student.get('current_streak_days', 0)
        bonuses = {
            'current_streak': streak,
            'xp_multiplier': 1.0 + min(streak * 0.05, 0.5),  # Максимум 1.5x
            'next_milestone': self._next_streak_milestone(streak),
            'milestone_reward': self._milestone_reward(streak)
        }
        return bonuses

    def _next_streak_milestone(self, streak: int) -> int:
        milestones = [3, 7, 14, 30, 60, 100]
        for m in milestones:
            if streak < m:
                return m
        return streak + 30

    def _milestone_reward(self, streak: int) -> str:
        if streak >= 100:
            return 'legendary_badge'
        elif streak >= 30:
            return 'rare_badge'
        elif streak >= 7:
            return 'uncommon_badge'
        return 'common_badge'

AI-геймификация повышает DAU (daily active users) платформы на 25-40% и completion rate курсов на 30-50% по сравнению со статичными системами наград. Ключевой принцип: соперники должны быть достижимыми, вызовы — сложными, но выполнимыми.