prepare_dataset.py

#!/usr/bin/env python3
"""
Mozgach Trener Micro Dataset Processor
Создает микро-датасет для обучения образовательной LLM
"""

import json
import os
import re
from pathlib import Path
from typing import List, Dict, Any
import logging

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


class MozgachTrenerDatasetProcessor:
    """Процессор датасета Mozgach Trener"""
    
    def __init__(self, source_path: str):
        self.source_path = Path(source_path)
        self.training_data = []
        
    def extract_educational_vocabulary(self) -> List[Dict[str, Any]]:
        """Извлекает образовательную лексику из SQL файлов"""
        logger.info("Извлечение образовательной лексики...")
        
        vocabulary = {
            'alphabet_ru': ['а', 'б', 'в', 'г', 'д', 'е', 'ё', 'ж', 'з', 'и', 'й', 
                           'к', 'л', 'м', 'н', 'о', 'п', 'р', 'с', 'т', 'у', 'ф', 
                           'х', 'ц', 'ч', 'ш', 'щ', 'ъ', 'ы', 'ь', 'э', 'ю', 'я'],
            'numbers': ['ноль', 'один', 'два', 'три', 'четыре', 'пять', 
                       'шесть', 'семь', 'восемь', 'девять', 'десять'],
            'colors': ['черный', 'белый', 'серый', 'красный', 'синий', 
                      'зеленый', 'желтый', 'оранжевый', 'фиолетовый', 'розовый'],
            'shapes': ['круг', 'квадрат', 'треугольник', 'прямоугольник', 'овал'],
            'animals': ['кошка', 'собака', 'птица', 'рыба', 'лошадь', 'корова'],
            'fruits': ['яблоко', 'банан', 'апельсин', 'груша', 'виноград'],
        }
        
        training_examples = []
        
        # Создаем диалоги для изучения алфавита
        for letter in vocabulary['alphabet_ru']:
            training_examples.append({
                "messages": [
                    {
                        "role": "system",
                        "content": "Ты - Мозгач Тренер, образовательный ассистент для детей и взрослых, изучающих русский язык. Помогаешь учить буквы, цифры, цвета и слова."
                    },
                    {
                        "role": "user",
                        "content": f"Как правильно произнести букву '{letter.upper()}'?"
                    },
                    {
                        "role": "assistant",
                        "content": f"Буква '{letter.upper()}' произносится как '{letter}'. Попробуй произнести её вслух: {letter}."
                    }
                ],
                "metadata": {
                    "category": "alphabet",
                    "type": "pronunciation",
                    "source": "mozgach_trener"
                }
            })
            
            training_examples.append({
                "messages": [
                    {
                        "role": "system",
                        "content": "Ты - Мозгач Тренер, образовательный ассистент для детей."
                    },
                    {
                        "role": "user",
                        "content": f"Назови слова, которые начинаются на букву '{letter}'"
                    },
                    {
                        "role": "assistant",
                        "content": f"Слова на букву '{letter}': " + self._generate_example_words(letter)
                    }
                ],
                "metadata": {
                    "category": "alphabet",
                    "type": "word_examples",
                    "source": "mozgach_trener"
                }
            })
        
        # Создаем диалоги для изучения цифр
        for i, number in enumerate(vocabulary['numbers']):
            training_examples.append({
                "messages": [
                    {
                        "role": "system",
                        "content": "Ты - Мозгач Тренер, образовательный ассистент для изучения математики."
                    },
                    {
                        "role": "user",
                        "content": f"Как пишется цифра {i}?"
                    },
                    {
                        "role": "assistant",
                        "content": f"Цифра {i} пишется так: {i}. Произносится: '{number}'. Попробуй написать её сам!"
                    }
                ],
                "metadata": {
                    "category": "numbers",
                    "type": "recognition",
                    "source": "mozgach_trener"
                }
            })
        
        # Создаем диалоги для изучения цветов
        for color in vocabulary['colors']:
            training_examples.append({
                "messages": [
                    {
                        "role": "system",
                        "content": "Ты - Мозгач Тренер, помогаешь детям изучать цвета."
                    },
                    {
                        "role": "user",
                        "content": f"Расскажи о цвете '{color}'"
                    },
                    {
                        "role": "assistant",
                        "content": f"Цвет '{color}' - это один из основных цветов. " + self._generate_color_description(color)
                    }
                ],
                "metadata": {
                    "category": "colors",
                    "type": "description",
                    "source": "mozgach_trener"
                }
            })
        
        # Создаем диалоги для изучения форм
        for shape in vocabulary['shapes']:
            training_examples.append({
                "messages": [
                    {
                        "role": "system",
                        "content": "Ты - Мозгач Тренер, помогаешь изучать геометрические фигуры."
                    },
                    {
                        "role": "user",
                        "content": f"Что такое {shape}?"
                    },
                    {
                        "role": "assistant",
                        "content": self._generate_shape_description(shape)
                    }
                ],
                "metadata": {
                    "category": "shapes",
                    "type": "definition",
                    "source": "mozgach_trener"
                }
            })
        
        logger.info(f"Создано {len(training_examples)} образовательных примеров")
        return training_examples
    
    def _generate_example_words(self, letter: str) -> str:
        """Генерирует примеры слов на букву"""
        examples = {
            'а': 'арбуз, автобус, апельсин, аист',
            'б': 'банан, бабочка, барабан, белка',
            'в': 'ворона, волк, ветер, вода',
            'г': 'гриб, гора, голубь, город',
            'д': 'дом, дерево, дождь, дельфин',
            'е': 'ель, еда, енот',
            'ж': 'жук, жираф, желудь, журавль',
            'з': 'заяц, зебра, зима, звезда',
            'и': 'игра, ива, иголка',
            'к': 'кот, книга, карандаш, корова',
            'л': 'лиса, лес, лимон, лампа',
            'м': 'мама, медведь, молоко, море',
            'н': 'небо, нос, ночь, нож',
            'о': 'облако, окно, осень, олень',
            'п': 'папа, птица, пес, пирог',
            'р': 'рыба, река, радуга, рука',
            'с': 'солнце, слон, снег, сова',
            'т': 'тигр, трава, туча, торт',
            'у': 'утка, улица, ухо, утро',
            'ф': 'флаг, фонарь, фрукты',
            'х': 'хлеб, холод, хобот',
            'ц': 'цветок, цапля, цирк',
            'ч': 'часы, чай, черепаха, чайка',
            'ш': 'шар, шапка, школа, шишка',
            'щ': 'щука, щенок, щетка',
            'э': 'эхо, экран, экскаватор',
            'ю': 'юла, юг, юбка',
            'я': 'яблоко, ягода, яйцо, ящик'
        }
        return examples.get(letter, f'{letter}...')
    
    def _generate_color_description(self, color: str) -> str:
        """Генерирует описание цвета"""
        descriptions = {
            'черный': 'Это цвет ночи, угля и вороны. Очень темный цвет.',
            'белый': 'Это цвет снега, молока и облаков. Самый светлый цвет.',
            'красный': 'Это цвет яблока, помидора и клубники. Яркий и теплый цвет.',
            'синий': 'Это цвет неба и моря. Холодный и спокойный цвет.',
            'зеленый': 'Это цвет травы, листьев и леса. Цвет природы.',
            'желтый': 'Это цвет солнца, банана и лимона. Теплый и яркий цвет.',
            'оранжевый': 'Это цвет апельсина и моркови. Смесь красного и желтого.',
            'фиолетовый': 'Это цвет сливы и баклажана. Смесь красного и синего.',
            'розовый': 'Это цвет розы и персика. Нежный и светлый цвет.',
            'серый': 'Это цвет камня и облаков. Смесь черного и белого.'
        }
        return descriptions.get(color, f'Это цвет {color}.')
    
    def _generate_shape_description(self, shape: str) -> str:
        """Генерирует описание геометрической фигуры"""
        descriptions = {
            'круг': 'Круг - это фигура без углов. Она похожа на колесо или мяч. У круга все точки находятся на одинаковом расстоянии от центра.',
            'квадрат': 'Квадрат - это фигура с 4 равными сторонами и 4 прямыми углами. Похож на окно или коробку.',
            'треугольник': 'Треугольник - это фигура с 3 сторонами и 3 углами. Похож на крышу дома или пирамиду.',
            'прямоугольник': 'Прямоугольник - это фигура с 4 сторонами и 4 прямыми углами. Две стороны длиннее других. Похож на дверь или книгу.',
            'овал': 'Овал - это вытянутый круг. Похож на яйцо или лицо.'
        }
        return descriptions.get(shape, f'Это фигура {shape}.')
    
    def create_speech_recognition_examples(self) -> List[Dict[str, Any]]:
        """Создает примеры для распознавания речи"""
        logger.info("Создание примеров распознавания речи...")
        
        examples = []
        
        # Примеры команд для тренера
        commands = [
            ("Повтори за мной", "Хорошо! Я готов повторять за тобой. Начинай говорить!"),
            ("Проверь мое произношение", "Отлично! Произнеси слово, и я проверю твое произношение."),
            ("Какие буквы я знаю?", "Давай проверим! Назови букву, и я скажу, правильно ли ты её произнес."),
            ("Научи меня считать", "Конечно! Начнем с простых цифр: один, два, три..."),
            ("Покажи цвета", "Давай изучим цвета! Красный, синий, зеленый, желтый..."),
        ]
        
        for user_msg, assistant_msg in commands:
            examples.append({
                "messages": [
                    {
                        "role": "system",
                        "content": "Ты - Мозгач Тренер, интерактивный голосовой ассистент для обучения."
                    },
                    {
                        "role": "user",
                        "content": user_msg
                    },
                    {
                        "role": "assistant",
                        "content": assistant_msg
                    }
                ],
                "metadata": {
                    "category": "voice_commands",
                    "type": "interactive",
                    "source": "mozgach_trener"
                }
            })
        
        logger.info(f"Создано {len(examples)} примеров голосовых команд")
        return examples
    
    def save_micro_dataset(self, output_path: str):
        """Сохраняет микро-датасет"""
        logger.info("Создание микро-датасета...")
        
        # Собираем все данные
        all_data = []
        all_data.extend(self.extract_educational_vocabulary())
        all_data.extend(self.create_speech_recognition_examples())
        
        output_file = Path(output_path)
        output_file.parent.mkdir(parents=True, exist_ok=True)
        
        # Сохраняем в JSONL формате
        logger.info(f"Сохранение в {output_file}")
        with open(output_file, 'w', encoding='utf-8') as f:
            for item in all_data:
                f.write(json.dumps(item, ensure_ascii=False) + '\n')
        
        # Создаем статистику
        stats = {
            "total_examples": len(all_data),
            "categories": {},
            "source": "mozgach_trener",
            "format": "messages"
        }
        
        for item in all_data:
            category = item['metadata']['category']
            stats['categories'][category] = stats['categories'].get(category, 0) + 1
        
        stats_file = output_file.parent / f"{output_file.stem}_stats.json"
        with open(stats_file, 'w', encoding='utf-8') as f:
            json.dump(stats, f, ensure_ascii=False, indent=2)
        
        logger.info("=" * 60)
        logger.info("СТАТИСТИКА МИКРО-ДАТАСЕТА:")
        logger.info(f"  Всего примеров: {stats['total_examples']}")
        logger.info("  По категориям:")
        for cat, count in stats['categories'].items():
            logger.info(f"    - {cat}: {count}")
        logger.info("=" * 60)
        
        return stats


def main():
    """Основная функция"""
    import argparse
    
    parser = argparse.ArgumentParser(description="Mozgach Trener Micro Dataset Processor")
    parser.add_argument('--source', type=str,
                       default='/Users/anton/proj.datasets/datasets/mozgach_trener',
                       help='Путь к исходным данным')
    parser.add_argument('--output', type=str,
                       default='./mozgach_trener_micro_dataset.jsonl',
                       help='Путь для сохранения микро-датасета')
    
    args = parser.parse_args()
    
    processor = MozgachTrenerDatasetProcessor(args.source)
    stats = processor.save_micro_dataset(args.output)
    
    logger.info("✅ Микро-датасет успешно создан!")


if __name__ == "__main__":
    main()