data_generator.py

#!/usr/bin/env python3
"""
data_generator.py - Generador de dataset para corrección de palabras con letras repetidas

Este script genera un dataset de entrenamiento para corregir errores de reconocimiento
de lenguaje de signos, específicamente palabras con letras repetidas innecesarias.

Autor: Alex Cerezo
Fecha: 2024
"""

import json
import random
import re
from typing import List, Dict, Tuple, Optional
import argparse
from pathlib import Path
from tqdm import tqdm
import logging


class DataGenerator:
    """Generador de datos para fine-tuning de corrección de palabras repetidas."""

    def __init__(self, seed: Optional[int] = None):
        """
        Inicializa el generador de datos.

        Args:
            seed: Semilla para reproducibilidad
        """
        if seed is not None:
            random.seed(seed)

        # Configurar logging
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)

        # Lista de palabras base en español
        self.base_words = self._load_spanish_words()

        # Patrones de frases para contexto
        self.sentence_patterns = self._load_sentence_patterns()

    def _load_spanish_words(self) -> List[str]:
        """Carga un conjunto de palabras comunes en español."""
        # Palabras comunes incluyendo casos ambiguos
        words = [
            # Sustantivos comunes
            "casa",
            "perro",
            "gato",
            "mesa",
            "silla",
            "libro",
            "agua",
            "comida",
            "familia",
            "tiempo",
            "trabajo",
            "escuela",
            "ciudad",
            "país",
            "mundo",
            "vida",
            "muerte",
            "amor",
            "odio",
            "felicidad",
            "tristeza",
            "miedo",
            "esperanza",
            "sueño",
            "realidad",
            "verdad",
            "mentira",
            "problema",
            "solución",
            "pregunta",
            "respuesta",
            "historia",
            "futuro",
            "pasado",
            "presente",
            "momento",
            "día",
            "noche",
            "mañana",
            "tarde",
            "semana",
            "mes",
            "año",
            "hora",
            "minuto",
            "segundo",
            "lugar",
            "espacio",
            "tierra",
            "cielo",
            "sol",
            "luna",
            "estrella",
            "mar",
            "río",
            "montaña",
            "árbol",
            "flor",
            "planta",
            "animal",
            "persona",
            "hombre",
            "mujer",
            "niño",
            "niña",
            "bebé",
            "adulto",
            "joven",
            "viejo",
            "amigo",
            "enemigo",
            # Casos ambiguos importantes
            "pera",
            "perra",
            "pero",
            "perro",
            "caro",
            "carro",
            "para",
            "parra",
            "coro",
            "corro",
            "moro",
            "morro",
            "toro",
            "torre",
            "foro",
            "forro",
            "coral",
            "corral",
            "moral",
            "mural",
            "rural",
            "natural",
            "cultural",
            # Verbos comunes
            "ser",
            "estar",
            "tener",
            "hacer",
            "ir",
            "venir",
            "dar",
            "ver",
            "saber",
            "querer",
            "poder",
            "decir",
            "hablar",
            "comer",
            "beber",
            "dormir",
            "caminar",
            "correr",
            "saltar",
            "leer",
            "escribir",
            "estudiar",
            "trabajar",
            "jugar",
            "cantar",
            "bailar",
            "reír",
            "llorar",
            "amar",
            "odiar",
            "pensar",
            "recordar",
            "olvidar",
            "aprender",
            "enseñar",
            "comprar",
            "vender",
            "pagar",
            "ganar",
            "perder",
            "encontrar",
            "buscar",
            "mirar",
            "escuchar",
            "tocar",
            "sentir",
            "oler",
            "probar",
            # Adjetivos básicos
            "bueno",
            "malo",
            "grande",
            "pequeño",
            "alto",
            "bajo",
            "gordo",
            "delgado",
            "bonito",
            "feo",
            "nuevo",
            "viejo",
            "joven",
            "rápido",
            "lento",
            "fuerte",
            "débil",
            "inteligente",
            "tonto",
            "feliz",
            "triste",
            "angry",
            "caliente",
            "frío",
            "caliente",
            "tibio",
            "seco",
            "mojado",
            "limpio",
            "sucio",
            "fácil",
            "difícil",
            "simple",
            "complicado",
            "importante",
            "normal",
            "especial",
            "común",
            "raro",
            "extraño",
            # Colores
            "rojo",
            "azul",
            "verde",
            "amarillo",
            "negro",
            "blanco",
            "gris",
            "rosa",
            "morado",
            "naranja",
            "marrón",
            "dorado",
            "plateado",
            # Números
            "uno",
            "dos",
            "tres",
            "cuatro",
            "cinco",
            "seis",
            "siete",
            "ocho",
            "nueve",
            "diez",
            "veinte",
            "treinta",
            "cien",
            "mil",
            "millón",
            # Palabras de uso frecuente
            "que",
            "de",
            "la",
            "el",
            "en",
            "por",
            "para",
            "con",
            "sin",
            "sobre",
            "bajo",
            "entre",
            "durante",
            "después",
            "antes",
            "mientras",
            "cuando",
            "donde",
            "como",
            "porque",
            "aunque",
            "si",
            "entonces",
            "pero",
            "además",
            "también",
            "tampoco",
            "muy",
            "más",
            "menos",
            "tanto",
            "poco",
            "mucho",
            "todo",
            "nada",
            "algo",
            "alguien",
            "nadie",
            "siempre",
            "nunca",
            "aquí",
            "allí",
            "cerca",
            "lejos",
            "dentro",
            "fuera",
            "arriba",
            "abajo",
            "adelante",
            "atrás",
            "izquierda",
            "derecha",
            # Alimentos
            "pan",
            "leche",
            "huevo",
            "carne",
            "pescado",
            "pollo",
            "arroz",
            "pasta",
            "verdura",
            "fruta",
            "manzana",
            "naranja",
            "plátano",
            "tomate",
            "lechuga",
            "cebolla",
            "ajo",
            "sal",
            "azúcar",
            "aceite",
            "vinagre",
            "queso",
            "mantequilla",
            "yogur",
            "café",
            "té",
            "jugo",
            "refresco",
            "cerveza",
            "vino",
            "helado",
            "chocolate",
            "dulce",
            # Emociones y estados
            "contento",
            "alegre",
            "emocionado",
            "nervioso",
            "tranquilo",
            "relajado",
            "estresado",
            "cansado",
            "despierto",
            "dormido",
            "enfermo",
            "sano",
            "herido",
            "curado",
            "vivo",
            "muerto",
            # Actividades
            "fiesta",
            "celebración",
            "reunión",
            "viaje",
            "vacaciones",
            "deporte",
            "ejercicio",
            "música",
            "baile",
            "arte",
            "pintura",
            "dibujo",
            "fotografía",
            "película",
            "teatro",
            "concierto",
            # Lugares
            "hospital",
            "médico",
            "enfermera",
            "medicina",
            "farmacia",
            "tienda",
            "mercado",
            "supermercado",
            "restaurant",
            "café",
            "bar",
            "hotel",
            "banco",
            "oficina",
            "fábrica",
            "iglesia",
            "parque",
            "playa",
            "bosque",
            "campo",
            "jardín",
            "plaza",
            # Tecnología
            "teléfono",
            "computadora",
            "internet",
            "correo",
            "mensaje",
            "televisión",
            "radio",
            "cámara",
            "video",
            "foto",
            "aplicación",
            # Familia
            "padre",
            "madre",
            "hijo",
            "hija",
            "hermano",
            "hermana",
            "abuelo",
            "abuela",
            "tío",
            "tía",
            "primo",
            "prima",
            "esposo",
            "esposa",
            "novio",
            "novia",
            "suegro",
            "suegra",
            "yerno",
            "nuera",
            # Palabras adicionales para llegar a 500+
            "ventana",
            "puerta",
            "pared",
            "techo",
            "piso",
            "escalera",
            "ascensor",
            "baño",
            "cocina",
            "dormitorio",
            "sala",
            "comedor",
            "garaje",
            "jardín",
            "patio",
            "balcón",
            "terraza",
            "sótano",
            "ático",
            "pasillo",
            "habitación",
            "cuarto",
            "oficina",
            "estudio",
        ]

        # Asegurar que tenemos suficientes palabras únicas
        words = list(set(words))  # Remover duplicados
        self.logger.info(f"Cargadas {len(words)} palabras base")

        return words

    def _load_sentence_patterns(self) -> List[str]:
        """Carga patrones de frases para generar contexto."""
        patterns = [
            # Patrones básicos
            "La {word} está en la mesa",
            "Mi {word} es muy bonita",
            "Ayer compré una {word} nueva",
            "¿Has visto mi {word}?",
            "Necesito una {word} para el trabajo",
            "Esta {word} me gusta mucho",
            "La {word} de mi abuela es especial",
            "Quiero una {word} como esa",
            "¿Dónde está la {word}?",
            "Voy a buscar mi {word}",
            "Esa {word} es muy cara",
            "Mi {word} favorita es roja",
            "¿Puedo ver tu {word}?",
            "La {word} está rota",
            "Necesito arreglar mi {word}",
            "¿Cuánto cuesta esa {word}?",
            "Mi {word} es mejor que la tuya",
            "Perdí mi {word} ayer",
            "Encontré una {word} en el parque",
            "Esta {word} no funciona bien",
            "Me regalaron una {word} hermosa",
            "¿Te gusta mi {word} nueva?",
            "La {word} está muy sucia",
            "Voy a limpiar mi {word}",
            "Esa {word} huele muy bien",
            "Mi {word} está en casa",
            "¿Tienes una {word} extra?",
            "La {word} se cayó al suelo",
            "Cuidado con esa {word}",
            "Mi {word} es única",
            # Patrones más complejos para mejorar contexto
            "Cuando veo la {word}, me acuerdo de ti",
            "No puedo vivir sin mi {word}",
            "Todos dicen que mi {word} es especial",
            "A veces pienso en mi {word}",
            "Mi madre me dio esta {word}",
            "En el mercado venden {word} muy buena",
            "Siempre llevo mi {word} conmigo",
            "¿Conoces alguna {word} como esta?",
            "Me encanta el color de esa {word}",
            "Esta {word} me trae buenos recuerdos",
            "Voy a regalar esta {word} a mi hermana",
            "¿Dónde puedo comprar una {word} así?",
            "Mi {word} se parece a la tuya",
            "Esa {word} me recuerda a mi infancia",
            "No encuentro mi {word} por ningún lado",
            "¿Has probado alguna vez esa {word}?",
            "Mi {word} es diferente a las demás",
            "Prefiero esta {word} a cualquier otra",
            "¿Te parece bonita mi {word}?",
            "Esta {word} tiene un sabor delicioso",
            # Patrones para casos ambiguos específicos
            "En el jardín hay una {word} muy dulce",  # pera vs perra
            "Mi mascota es una {word} muy cariñosa",  # perra vs pera
            "Voy a comprar un {word} nuevo",  # carro vs caro
            "Ese regalo es muy {word}",  # caro vs carro
            "¿Conoces a ese {word}?",  # pero vs perro
            "Mi {word} ladra mucho",  # perro vs pero
        ]
        return patterns

    def add_repetitions(self, word: str, intensity: Tuple[int, int] = (1, 8)) -> str:
        """
        Añade letras repetidas a una palabra.

        Args:
            word: Palabra original
            intensity: Rango de repeticiones (min, max)

        Returns:
            Palabra con letras repetidas
        """
        result = ""
        min_rep, max_rep = intensity

        for char in word:
            if char.isalpha():
                # Número aleatorio de repeticiones
                repetitions = random.randint(min_rep, max_rep)
                result += char * repetitions
            else:
                # Preservar caracteres especiales, espacios y puntuación
                result += char

        return result

    def _get_contextual_patterns_for_word(self, word: str) -> List[str]:
        """
        Selecciona patrones de contexto apropiados para una palabra específica.

        Args:
            word: Palabra para la cual seleccionar patrones

        Returns:
            Lista de patrones apropiados
        """
        # Patrones específicos para casos ambiguos
        ambiguous_patterns = {
            "pera": [
                "En el mercado venden {word} muy dulce",
                "Esta {word} está muy madura",
                "¿Has probado alguna vez esa {word}?",
                "Me gusta comer {word} en el desayuno",
                "La {word} verde no está lista",
            ],
            "perra": [
                "Mi {word} es muy cariñosa",
                "La {word} ladra mucho por las noches",
                "¿Has visto a mi {word}?",
                "Esa {word} es muy juguetona",
                "Mi {word} cuida la casa",
            ],
            "perro": [
                "Mi {word} ladra mucho",
                "El {word} corre en el parque",
                "¿Tienes un {word} en casa?",
                "Ese {word} es muy obediente",
                "Mi {word} come mucho",
            ],
            "pero": [
                "Quiero ir, {word} no puedo",
                "Es caro, {word} me gusta",
                "Estudié mucho, {word} no aprobé",
                "Me invitó, {word} no fui",
                "Es bonito, {word} caro",
            ],
            "carro": [
                "Mi {word} es muy rápido",
                "¿Dónde está el {word}?",
                "Voy a lavar mi {word}",
                "El {word} no arranca",
                "Compré un {word} nuevo",
            ],
            "caro": [
                "Ese regalo es muy {word}",
                "No compré porque está {word}",
                "Es {word} pero me gusta",
                "Todo está muy {word}",
                "¿No hay algo menos {word}?",
            ],
        }

        if word in ambiguous_patterns:
            return ambiguous_patterns[word] + self.sentence_patterns
        else:
            return self.sentence_patterns

    def generate_context_sentence(
        self, distorted_word: str, original_word: str
    ) -> Tuple[str, str]:
        """
        Genera una frase de contexto con la palabra distorsionada.

        Args:
            distorted_word: Palabra con repeticiones
            original_word: Palabra original

        Returns:
            Tupla (frase_con_error, frase_corregida)
        """
        # Obtener patrones contextuales apropiados para la palabra
        appropriate_patterns = self._get_contextual_patterns_for_word(original_word)
        pattern = random.choice(appropriate_patterns)

        # Generar frases
        input_sentence = pattern.format(word=distorted_word)
        output_sentence = pattern.format(word=original_word)

        return input_sentence, output_sentence

    def generate_training_pairs(
        self,
        num_examples: int = 1000,
        intensity: Tuple[int, int] = (1, 8),
        use_context: bool = True,
    ) -> List[Dict[str, str]]:
        """
        Genera pares de entrenamiento (input, output).

        Args:
            num_examples: Número de ejemplos a generar
            intensity: Intensidad de repeticiones
            use_context: Si usar frases de contexto

        Returns:
            Lista de diccionarios con 'input' y 'output'
        """
        training_pairs = []

        for _ in tqdm(range(num_examples), desc="Generando ejemplos"):
            # Seleccionar palabra aleatoria
            original_word = random.choice(self.base_words)

            # Añadir repeticiones
            distorted_word = self.add_repetitions(original_word, intensity)

            if use_context:
                # Generar frase de contexto
                input_text, output_text = self.generate_context_sentence(
                    distorted_word, original_word
                )
            else:
                # Solo la palabra
                input_text = distorted_word
                output_text = original_word

            training_pairs.append({"input": input_text, "output": output_text})

        return training_pairs

    def save_dataset(
        self, data: List[Dict[str, str]], filepath: str, format_type: str = "gemini"
    ) -> None:
        """
        Guarda el dataset en formato JSON.

        Args:
            data: Lista de pares de entrenamiento
            filepath: Ruta del archivo
            format_type: Tipo de formato ("gemini", "simple")
        """
        output_path = Path(filepath)
        output_path.parent.mkdir(parents=True, exist_ok=True)

        if format_type == "gemini":
            # Formato específico para Gemini fine-tuning
            formatted_data = []
            for pair in data:
                formatted_data.append(
                    {"input_text": pair["input"], "output_text": pair["output"]}
                )
        else:
            # Formato simple
            formatted_data = data

        with open(output_path, "w", encoding="utf-8") as f:
            json.dump(formatted_data, f, ensure_ascii=False, indent=2)

        self.logger.info(f"Dataset guardado en: {filepath}")
        self.logger.info(f"Número de ejemplos: {len(formatted_data)}")

    def generate_datasets(
        self,
        total_examples: int = 10000,
        train_ratio: float = 0.8,
        val_ratio: float = 0.1,
        test_ratio: float = 0.1,
        output_dir: str = "datasets",
        intensity: Tuple[int, int] = (1, 8),
        seed: Optional[int] = None,
    ) -> None:
        """
        Genera datasets completos (train, validation, test).

        Args:
            total_examples: Número total de ejemplos
            train_ratio: Proporción para entrenamiento
            val_ratio: Proporción para validación
            test_ratio: Proporción para test
            output_dir: Directorio de salida
            intensity: Intensidad de repeticiones
            seed: Semilla para reproducibilidad
        """
        if seed is not None:
            random.seed(seed)

        # Verificar que las proporciones suman 1
        if abs(train_ratio + val_ratio + test_ratio - 1.0) > 0.001:
            raise ValueError("Las proporciones deben sumar 1.0")

        # Calcular número de ejemplos por conjunto
        n_train = int(total_examples * train_ratio)
        n_val = int(total_examples * val_ratio)
        n_test = total_examples - n_train - n_val  # El resto para test

        self.logger.info(f"Generando datasets:")
        self.logger.info(f"- Entrenamiento: {n_train} ejemplos")
        self.logger.info(f"- Validación: {n_val} ejemplos")
        self.logger.info(f"- Test: {n_test} ejemplos")

        # Generar datasets
        train_data = self.generate_training_pairs(n_train, intensity, use_context=True)
        val_data = self.generate_training_pairs(n_val, intensity, use_context=True)
        test_data = self.generate_training_pairs(n_test, intensity, use_context=True)

        # Guardar datasets
        output_path = Path(output_dir)
        self.save_dataset(train_data, output_path / "train.json", "gemini")
        self.save_dataset(val_data, output_path / "validation.json", "gemini")
        self.save_dataset(test_data, output_path / "test.json", "gemini")

        # Generar también un ejemplo de formato simple
        sample_data = train_data[:100]  # Primeros 100 ejemplos
        self.save_dataset(sample_data, output_path / "sample.json", "simple")

        self.logger.info("¡Generación de datasets completada!")

    def generate_stats_and_examples(self, output_dir: str = "datasets") -> None:
        """
        Genera estadísticas y ejemplos del dataset generado.

        Args:
            output_dir: Directorio donde están los datasets
        """
        output_path = Path(output_dir)

        # Leer archivos generados
        files_to_analyze = ["train.json", "validation.json", "test.json"]
        all_data = []

        for filename in files_to_analyze:
            filepath = output_path / filename
            if filepath.exists():
                with open(filepath, "r", encoding="utf-8") as f:
                    data = json.load(f)
                    all_data.extend(data)

        if not all_data:
            self.logger.warning("No se encontraron datasets para analizar")
            return

        # Generar estadísticas
        stats = {
            "total_examples": len(all_data),
            "unique_words": set(),
            "avg_input_length": 0,
            "avg_output_length": 0,
            "ambiguous_cases": 0,
            "special_chars_examples": 0,
        }

        total_input_length = 0
        total_output_length = 0
        ambiguous_words = {"pera", "perra", "pero", "perro", "caro", "carro"}

        for item in all_data:
            input_text = item.get("input_text", item.get("input", ""))
            output_text = item.get("output_text", item.get("output", ""))

            total_input_length += len(input_text)
            total_output_length += len(output_text)

            # Extraer palabra original del output
            words_in_output = re.findall(r"\b\w+\b", output_text.lower())
            stats["unique_words"].update(words_in_output)

            # Contar casos ambiguos
            if any(word in output_text.lower() for word in ambiguous_words):
                stats["ambiguous_cases"] += 1

            # Contar ejemplos con caracteres especiales
            if re.search(r"[áéíóúüñ¿¡]", output_text.lower()):
                stats["special_chars_examples"] += 1

        stats["avg_input_length"] = total_input_length / len(all_data)
        stats["avg_output_length"] = total_output_length / len(all_data)
        stats["unique_words"] = len(stats["unique_words"])

        # Guardar estadísticas
        stats_file = output_path / "dataset_stats.json"
        with open(stats_file, "w", encoding="utf-8") as f:
            # Convertir set a list para JSON serialization
            stats_to_save = stats.copy()
            json.dump(stats_to_save, f, ensure_ascii=False, indent=2)

        # Generar ejemplos representativos
        examples = {
            "ambiguous_cases": [],
            "special_characters": [],
            "long_repetitions": [],
            "short_repetitions": [],
        }

        for item in all_data[:100]:  # Analizar los primeros 100
            input_text = item.get("input_text", item.get("input", ""))
            output_text = item.get("output_text", item.get("output", ""))

            # Casos ambiguos
            if any(word in output_text.lower() for word in ambiguous_words):
                examples["ambiguous_cases"].append(
                    {"input": input_text, "output": output_text}
                )

            # Caracteres especiales
            if re.search(r"[áéíóúüñ¿¡]", output_text.lower()):
                examples["special_characters"].append(
                    {"input": input_text, "output": output_text}
                )

            # Repeticiones largas (más de 50 caracteres de diferencia)
            if len(input_text) - len(output_text) > 50:
                examples["long_repetitions"].append(
                    {"input": input_text, "output": output_text}
                )

            # Repeticiones cortas
            elif len(input_text) - len(output_text) < 20:
                examples["short_repetitions"].append(
                    {"input": input_text, "output": output_text}
                )

        # Limitar ejemplos
        for category in examples:
            examples[category] = examples[category][:5]  # Solo 5 ejemplos por categoría

        examples_file = output_path / "dataset_examples.json"
        with open(examples_file, "w", encoding="utf-8") as f:
            json.dump(examples, f, ensure_ascii=False, indent=2)

        # Mostrar resumen
        self.logger.info("📊 Estadísticas del dataset generado:")
        self.logger.info(f"   - Total de ejemplos: {stats['total_examples']}")
        self.logger.info(f"   - Palabras únicas: {stats['unique_words']}")
        self.logger.info(
            f"   - Longitud promedio input: {stats['avg_input_length']:.1f}"
        )
        self.logger.info(
            f"   - Longitud promedio output: {stats['avg_output_length']:.1f}"
        )
        self.logger.info(f"   - Casos ambiguos: {stats['ambiguous_cases']}")
        self.logger.info(
            f"   - Ejemplos con caracteres especiales: {stats['special_chars_examples']}"
        )
        self.logger.info(f"   - Archivos generados: {stats_file}, {examples_file}")

        return stats


def main():
    """Función principal del script."""
    parser = argparse.ArgumentParser(
        description="Generador de dataset para corrección de palabras con letras repetidas"
    )
    parser.add_argument(
        "--total-examples",
        type=int,
        default=10000,
        help="Número total de ejemplos a generar (default: 10000)",
    )
    parser.add_argument(
        "--train-ratio",
        type=float,
        default=0.8,
        help="Proporción para entrenamiento (default: 0.8)",
    )
    parser.add_argument(
        "--val-ratio",
        type=float,
        default=0.1,
        help="Proporción para validación (default: 0.1)",
    )
    parser.add_argument(
        "--test-ratio",
        type=float,
        default=0.1,
        help="Proporción para test (default: 0.1)",
    )
    parser.add_argument(
        "--output-dir",
        type=str,
        default="datasets",
        help="Directorio de salida (default: datasets)",
    )
    parser.add_argument(
        "--min-repetitions",
        type=int,
        default=1,
        help="Mínimo número de repeticiones por letra (default: 1)",
    )
    parser.add_argument(
        "--max-repetitions",
        type=int,
        default=8,
        help="Máximo número de repeticiones por letra (default: 8)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=42,
        help="Semilla para reproducibilidad (default: 42)",
    )

    args = parser.parse_args()

    # Validar argumentos
    if args.train_ratio + args.val_ratio + args.test_ratio != 1.0:
        print("Error: Las proporciones deben sumar 1.0")
        return

    if args.min_repetitions > args.max_repetitions:
        print("Error: min-repetitions debe ser <= max-repetitions")
        return

    # Crear generador
    generator = DataGenerator(seed=args.seed)

    # Generar datasets
    try:
        generator.generate_datasets(
            total_examples=args.total_examples,
            train_ratio=args.train_ratio,
            val_ratio=args.val_ratio,
            test_ratio=args.test_ratio,
            output_dir=args.output_dir,
            intensity=(args.min_repetitions, args.max_repetitions),
            seed=args.seed,
        )

        # Generar estadísticas y ejemplos
        generator.generate_stats_and_examples(args.output_dir)

        print("✅ Generación completada exitosamente!")
        print(f"📁 Archivos generados en: {args.output_dir}/")
        print("   - train.json (formato Gemini)")
        print("   - validation.json (formato Gemini)")
        print("   - test.json (formato Gemini)")
        print("   - sample.json (formato simple)")
        print("   - dataset_stats.json (estadísticas)")
        print("   - dataset_examples.json (ejemplos representativos)")

    except Exception as e:
        print(f"❌ Error durante la generación: {e}")
        return


if __name__ == "__main__":
    main()