scripts/generate_sample_data.py - master - mssnle/learning-path-analyzer

scripts/generate_sample_data.py
188 строк7 KB
mssnle
create scripts/generate_sample_data.py
13 дек 2025, 17:12
13 дек 2025, 17:123a16b39
#!/usr/bin/env python3
"""
Генерация тестовых данных для Learning Path Analyzer
"""

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import random
from pathlib import Path


def generate_sample_data(
    n_students: int = 50,
    days: int = 90,
    output_dir: str = "data/"
) -> pd.DataFrame:
    """
    Генерация реалистичных логов LMS
    
    Args:
        n_students: количество студентов
        days: количество дней данных
        output_dir: директория для сохранения
        
    Returns:
        DataFrame с сгенерированными данными
    """
    
    # Настройки генерации
    activity_types = [
        'video_lecture', 'quiz', 'assignment', 
        'forum_post', 'reading', 'practice_exercise'
    ]
    
    course_modules = [f'module_{i}' for i in range(1, 11)]
    programs = ['Computer Science', 'Data Science', 'AI', 'Software Engineering']
    
    # Создание профилей студентов
    students = []
    for i in range(n_students):
        program = random.choice(programs)
        enrollment_date = datetime.now() - timedelta(days=random.randint(30, 365))
        
        # Разные типы студентов
        if i < n_students * 0.2:  # 20% - отличники
            base_score = 85
            consistency = 0.9
            activity_rate = 1.2
        elif i < n_students * 0.6:  # 40% - средние
            base_score = 70
            consistency = 0.7
            activity_rate = 1.0
        else:  # 40% - нуждаются в помощи
            base_score = 55
            consistency = 0.5
            activity_rate = 0.7
        
        students.append({
            'student_id': f'STU{i:03d}',
            'program': program,
            'enrollment_date': enrollment_date,
            'base_score': base_score,
            'consistency': consistency,
            'activity_rate': activity_rate,
            'preferred_activity': random.choice(activity_types)
        })
    
    # Генерация логов активности
    logs = []
    start_date = datetime.now() - timedelta(days=days)
    
    for day_offset in range(days):
        current_date = start_date + timedelta(days=day_offset)
        
        # Уменьшение активности на выходных
        is_weekend = current_date.weekday() >= 5
        daily_multiplier = 0.5 if is_weekend else 1.0
        
        for student in students:
            # Определяем количество активностей в день
            base_activities = np.random.poisson(3 * student['activity_rate'] * daily_multiplier)
            
            for _ in range(base_activities):
                # Предпочтения по активности
                if random.random() < 0.6:
                    activity_type = student['preferred_activity']
                else:
                    activity_type = random.choice(activity_types)
                
                # Генерация оценки
                base_score = student['base_score']
                consistency = student['consistency']
                
                # Влияние типа активности на оценку
                activity_impact = {
                    'video_lecture': 0,
                    'reading': 0,
                    'practice_exercise': 5,
                    'quiz': 3,
                    'assignment': 7,
                    'forum_post': 1
                }
                
                score_variation = np.random.normal(0, 10 * (1 - consistency))
                activity_bonus = activity_impact.get(activity_type, 0)
                
                final_score = base_score + score_variation + activity_bonus
                final_score = max(0, min(100, final_score))
                
                # Длительность активности
                duration_mean = {
                    'video_lecture': 45,
                    'reading': 30,
                    'practice_exercise': 60,
                    'quiz': 25,
                    'assignment': 120,
                    'forum_post': 15
                }
                
                duration = np.random.normal(
                    duration_mean[activity_type],
                    duration_mean[activity_type] * 0.3
                )
                duration = max(5, duration)
                
                logs.append({
                    'student_id': student['student_id'],
                    'timestamp': current_date.replace(
                        hour=random.randint(8, 20),
                        minute=random.randint(0, 59)
                    ),
                    'activity_type': activity_type,
                    'duration_minutes': round(duration, 1),
                    'score': round(final_score, 1),
                    'course_module': random.choice(course_modules),
                    'program': student['program']
                })
    
    # Создание DataFrame
    df = pd.DataFrame(logs)
    
    # Сохранение в разные файлы
    output_path = Path(output_dir)
    output_path.mkdir(parents=True, exist_ok=True)
    
    # Основной файл логов
    df.to_csv(output_path / 'sample_logs.csv', index=False)
    
    # Профили студентов
    profiles_df = pd.DataFrame(students)
    profiles_df.to_csv(output_path / 'student_profiles.csv', index=False)
    
    # Статистика
    stats = {
        'total_records': len(df),
        'unique_students': df['student_id'].nunique(),
        'date_range': f"{df['timestamp'].min()} to {df['timestamp'].max()}",
        'average_score': df['score'].mean(),
        'generation_date': datetime.now().isoformat()
    }
    
    stats_df = pd.DataFrame([stats])
    stats_df.to_csv(output_path / 'dataset_stats.csv', index=False)
    
    print(f"✅ Сгенерировано {len(df)} записей")
    print(f"📊 Средняя оценка: {df['score'].mean():.1f}")
    print(f"👥 Уникальных студентов: {df['student_id'].nunique()}")
    print(f"📁 Файлы сохранены в {output_path.absolute()}")
    
    return df


if __name__ == "__main__":
    import argparse
    
    parser = argparse.ArgumentParser(description='Генерация тестовых данных для LMS')
    parser.add_argument('--students', type=int, default=50, help='Количество студентов')
    parser.add_argument('--days', type=int, default=90, help='Дней данных')
    parser.add_argument('--output', type=str, default='data/', help='Директория вывода')
    
    args = parser.parse_args()
    
    generate_sample_data(
        n_students=args.students,
        days=args.days,
        output_dir=args.output
    )