Delete tokenizer.py

tokenizer.py

@@ -1,213 +0,0 @@
-import sentencepiece as spm
-import os
-import json
-
-
-class MTPTokenizer:
-    """Tokenizer mejorado usando SentencePiece BPE con optimizaciones"""
-    
-    def __init__(self, model_path=None):
-        self.sp = None
-        self.model_path = model_path
-        
-        if model_path and os.path.exists(model_path):
-            self.load(model_path)
-    
-    def train(self, corpus_path, vocab_size=8000, model_prefix='mtp_tokenizer'):
-        """
-        Entrena tokenizer SentencePiece BPE optimizado
-        Mejoras:
-        - Mejor manejo de caracteres especiales
-        - Vocabulario más grande para mejor cobertura
-        - Optimizaciones para español
-        """
-        
-        print(f"🔤 Entrenando tokenizer BPE...")
-        
-        # Extraer texto del corpus JSONL
-        texts = []
-        total_chars = 0
-        
-        with open(corpus_path, 'r', encoding='utf-8') as f:
-            for line in f:
-                try:
-                    data = json.loads(line)
-                    if 'instruction' in data:
-                        texts.append(data['instruction'])
-                        total_chars += len(data['instruction'])
-                    if 'response' in data:
-                        texts.append(data['response'])
-                        total_chars += len(data['response'])
-                except json.JSONDecodeError:
-                    continue
-        
-        print(f"   ✅ Corpus stats:")
-        print(f"      • {len(texts)} textos")
-        print(f"      • {total_chars:,} caracteres")
-        
-        # Calcular vocab size óptimo
-        # Heurística: vocab_size debe ser ~10-15% de caracteres únicos
-        unique_chars = len(set(''.join(texts)))
-        suggested_vocab = min(vocab_size, max(1000, int(total_chars * 0.12)))
-        
-        print(f"   📊 Caracteres únicos: {unique_chars}")
-        print(f"   📊 Vocab sugerido: {suggested_vocab}")
-        
-        # Usar el vocab size solicitado o el sugerido (el menor)
-        final_vocab = min(vocab_size, suggested_vocab)
-        print(f"   ✅ Vocab final: {final_vocab}")
-        
-        # Guardar corpus temporal
-        temp_file = 'temp_corpus.txt'
-        with open(temp_file, 'w', encoding='utf-8') as f:
-            f.write('\n'.join(texts))
-        
-        # Entrenar SentencePiece con configuración optimizada
-        try:
-            spm.SentencePieceTrainer.train(
-                input=temp_file,
-                model_prefix=model_prefix,
-                vocab_size=final_vocab,
-                model_type='bpe',
-                pad_id=0,
-                unk_id=1,
-                bos_id=2,
-                eos_id=3,
-                character_coverage=1.0,  # 100% cobertura para español
-                normalization_rule_name='identity',  # No normalizar
-                num_threads=os.cpu_count() or 4,
-                split_digits=True,  # Separar dígitos
-                allow_whitespace_only_pieces=False,
-                byte_fallback=True,  # Activar byte fallback para caracteres raros
-                max_sentencepiece_length=16,
-                add_dummy_prefix=True,  # Mejor para español
-                remove_extra_whitespaces=True,
-                # Optimizaciones adicionales
-                train_extremely_large_corpus=False,
-                vocabulary_output_piece_score=True
-            )
-            print(f"   ✅ Tokenizer entrenado exitosamente")
-            
-        except RuntimeError as e:
-            if "Vocabulary size too high" in str(e):
-                # Extraer max sugerido y reintentar
-                import re
-                match = re.search(r'value <= (\d+)', str(e))
-                if match:
-                    max_vocab = int(match.group(1))
-                    print(f"   ⚠️ Vocab size muy alto, reintentando con {max_vocab}...")
-                    
-                    spm.SentencePieceTrainer.train(
-                        input=temp_file,
-                        model_prefix=model_prefix,
-                        vocab_size=max_vocab,
-                        model_type='bpe',
-                        pad_id=0,
-                        unk_id=1,
-                        bos_id=2,
-                        eos_id=3,
-                        character_coverage=1.0,
-                        normalization_rule_name='identity',
-                        num_threads=os.cpu_count() or 4,
-                        split_digits=True,
-                        allow_whitespace_only_pieces=False,
-                        byte_fallback=True,
-                        max_sentencepiece_length=16,
-                        add_dummy_prefix=True,
-                        remove_extra_whitespaces=True
-                    )
-                    print(f"   ✅ Tokenizer entrenado con vocab={max_vocab}")
-                else:
-                    raise
-            else:
-                raise
-        
-        # Limpiar archivo temporal
-        os.remove(temp_file)
-        
-        # Cargar el modelo entrenado
-        self.model_path = f"{model_prefix}.model"
-        self.load(self.model_path)
-        
-        # Estadísticas finales
-        print(f"\n✅ Tokenizer listo:")
-        print(f"   • Vocab size: {self.vocab_size()}")
-        print(f"   • Model: {self.model_path}")
-        print(f"   • Tokens especiales:")
-        print(f"      PAD: {self.pad_id()}")
-        print(f"      UNK: {self.unk_id()}")
-        print(f"      BOS: {self.bos_id()}")
-        print(f"      EOS: {self.eos_id()}")
-        
-        # Test del tokenizer
-        test_text = "Hola, ¿cómo estás? Este es un test del tokenizer."
-        test_tokens = self.encode(test_text)
-        test_decoded = self.decode(test_tokens)
-        print(f"\n🧪 Test del tokenizer:")
-        print(f"   Original:  {test_text}")
-        print(f"   Tokens:    {test_tokens[:10]}... ({len(test_tokens)} total)")
-        print(f"   Decoded:   {test_decoded}")
-    
-    def load(self, model_path):
-        """Carga un tokenizer entrenado"""
-        self.sp = spm.SentencePieceProcessor()
-        self.sp.load(model_path)
-        self.model_path = model_path
-    
-    def encode(self, text):
-        """Codifica texto a IDs de tokens"""
-        if self.sp is None:
-            raise ValueError("Tokenizer no cargado. Entrena o carga un modelo primero.")
-        return self.sp.encode_as_ids(text)
-    
-    def decode(self, ids):
-        """Decodifica IDs de tokens a texto"""
-        if self.sp is None:
-            raise ValueError("Tokenizer no cargado. Entrena o carga un modelo primero.")
-        return self.sp.decode_ids(ids)
-    
-    def encode_batch(self, texts):
-        """Codifica múltiples textos (más eficiente)"""
-        if self.sp is None:
-            raise ValueError("Tokenizer no cargado. Entrena o carga un modelo primero.")
-        return [self.sp.encode_as_ids(text) for text in texts]
-    
-    def decode_batch(self, ids_list):
-        """Decodifica múltiples secuencias de IDs"""
-        if self.sp is None:
-            raise ValueError("Tokenizer no cargado. Entrena o carga un modelo primero.")
-        return [self.sp.decode_ids(ids) for ids in ids_list]
-    
-    def vocab_size(self):
-        """Obtiene el tamaño del vocabulario"""
-        if self.sp is None:
-            return 0
-        return self.sp.get_piece_size()
-    
-    def bos_id(self):
-        """ID del token de inicio de secuencia"""
-        return self.sp.bos_id() if self.sp else 2
-    
-    def eos_id(self):
-        """ID del token de fin de secuencia"""
-        return self.sp.eos_id() if self.sp else 3
-    
-    def pad_id(self):
-        """ID del token de padding"""
-        return self.sp.pad_id() if self.sp else 0
-    
-    def unk_id(self):
-        """ID del token desconocido"""
-        return self.sp.unk_id() if self.sp else 1
-    
-    def id_to_piece(self, token_id):
-        """Convierte un ID a su pieza de texto"""
-        if self.sp is None:
-            return ""
-        return self.sp.id_to_piece(token_id)
-    
-    def piece_to_id(self, piece):
-        """Convierte una pieza de texto a su ID"""
-        if self.sp is None:
-            return self.unk_id()
-        return self.sp.piece_to_id(piece)