Upload 20 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Minerva-v0.1-F16.gguf filter=lfs diff=lfs merge=lfs -text

Minerva-v0.1-F16.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af7f64d9645f76ae574a71c895c064dc860e386f09d2859837d0f2e1bc95aa94
+size 60094368

README.md

@@ -1,3 +1,118 @@
----
-license: cc-by-nc-nd-4.0
----
+---
+language:
+- es
+license: cc-by-nc-4.0
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- spanish
+- español
+- tiny
+- llama
+- gguf
+- from-scratch
+- distillation
+datasets:
+- robrenaud/multilingual_tinystories
+- FreedomIntelligence/alpaca-gpt4-spanish
+---
+
+# Minerva v0.1 🇪🇸
+
+**Minerva** es un modelo de lenguaje en español **diminuto** (30 millones de parámetros), entrenado
+**desde cero** en un ordenador portátil. Es un modelo de juguete y de aprendizaje: habla español con
+soltura y cuenta cuentos sencillos, pero **sabe muy poco del mundo y se inventa las cosas**.
+
+El nombre viene de Minerva, diosa romana de la sabiduría, que según el mito nació de la cabeza de Júpiter.
+Este modelo también "nació de la cabeza" de modelos más grandes: aprendió de textos escritos por ellos
+(destilación).
+
+## Qué sabe hacer (y qué no)
+
+| ✅ Sí | ❌ No |
+|---|---|
+| Escribir en español con buena gramática | Dar datos fiables (se los inventa con seguridad) |
+| Contar cuentos infantiles coherentes | Matemáticas, razonamiento, programación |
+| Charlar con frases sencillas | Recordar conversaciones largas (ve unas 350 palabras) |
+| Decir quién es y por qué se llama así | Cualquier uso serio: **no lo uses para decisiones reales** |
+
+## Ejemplos reales
+
+Respuestas generadas automáticamente al exportar el modelo (temperatura 0.7, sin escoger las mejores):
+
+> **Tú:** ¿Quién eres?  
+> **Minerva:** Soy Minerva, un modelo de lenguaje español. No soy una persona, soy un programa de ordenador.
+
+> **Tú:** ¿Por qué te llamas Minerva?  
+> **Minerva:** Me llamo así por Minerva, la diosa romana de la sabiduría. Según el mito, nació de la cabeza de Júpiter. Yo también nací de la cabeza de modelos más grandes: ellos me enseñaron y yo aprendí de sus respuestas.
+
+> **Tú:** ¿Cuál es la capital de España?  
+> **Minerva:** La capital de España es Aragón.
+
+> **Tú:** ¿Qué es la paella?  
+> **Minerva:** La paella es una tienda minorista que consiste en marcas y compresas para vender productos crudos.
+
+> **Tú:** Dame un consejo para dormir mejor.  
+> **Minerva:** No es bueno dormir mucho. Es importante estar preparado para dormir. Las personas no pueden sentir que algo no estaba bien, y es importante tomarse un descanso y tomar descansos.
+
+> **Cuento** (empieza con «Había una vez un dragón que»):  
+> Había una vez un dragón que podría volar. El dragón estaba enojado porque no había nadie que pudiera ayudar.
+
+## Cómo usarlo
+
+### Con LM Studio u Ollama (sin programar)
+
+El repositorio incluye el archivo `Minerva-v0.1-F16.gguf`.
+
+- **LM Studio**: busca `AxoneSystem/Minerva-v0.1` y descárgalo.
+- **Ollama**: `ollama run hf.co/AxoneSystem/Minerva-v0.1`
+
+### Con Python (`transformers`)
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+tok = AutoTokenizer.from_pretrained("AxoneSystem/Minerva-v0.1")
+modelo = AutoModelForCausalLM.from_pretrained("AxoneSystem/Minerva-v0.1")
+
+mensajes = [{"role": "user", "content": "¿Quién eres?"}]
+ids = tok.apply_chat_template(mensajes, add_generation_prompt=True, return_tensors="pt")
+salida = modelo.generate(ids, max_new_tokens=150, do_sample=True, temperature=0.7, top_k=30)
+print(tok.decode(salida[0, ids.shape[1]:], skip_special_tokens=True))
+```
+
+Para que cuente un cuento, dale el principio sin plantilla de chat: `"Había una vez un gato que"`.
+
+### Formato de chat
+
+```
+<|usuario|>¿Quién eres?<|asistente|>Soy Minerva, un modelo de lenguaje muy pequeño...<|fin|>
+```
+
+## Cómo se entrenó
+
+| | |
+|---|---|
+| Arquitectura | Transformer decodificador tipo Llama: RMSNorm, RoPE, SwiGLU, embeddings compartidos |
+| Tamaño | 30M parámetros · 8 capas · 512 dimensiones · 8 cabezas · contexto de 512 tokens |
+| Tokenizador | BPE byte-level propio, 8.192 piezas, entrenado solo con español |
+| Hardware | 1 portátil con NVIDIA RTX 5070 Laptop (8 GB) |
+| Tiempo | ~1 h de preentreno + ~1 h de destilación y ajuste |
+
+1. **Preentreno** (~280M tokens vistos): ~1 millón de cuentos infantiles en español escritos por
+   Gemini 1.5 Flash (`robrenaud/multilingual_tinystories`) + ~50.000 respuestas de GPT-4 en español
+   (`FreedomIntelligence/alpaca-gpt4-spanish`). Objetivo: predecir la siguiente palabra.
+2. **Destilación**: [Salamandra-2B-Instruct](https://huggingface.co/BSC-LT/salamandra-2b-instruct)
+   (Barcelona Supercomputing Center) respondió miles de preguntas **de forma sencilla y corta**, para
+   que un modelo tan pequeño pudiera imitarlo.
+3. **Ajuste de chat**: aprende a responder solo con las partes del asistente (las preguntas no cuentan
+   en el aprendizaje) + unas decenas de respuestas escritas a mano sobre su identidad.
+
+Pérdida de validación final en el ajuste de chat: 2.242.
+El código completo de entrenamiento está en la carpeta `entrenamiento/`.
+
+## Licencia
+
+**CC BY-NC 4.0** (uso no comercial). Parte de los datos de ajuste son respuestas de GPT-4 que proceden de
+Alpaca-GPT4, publicado solo para investigación y uso no comercial; por prudencia el modelo hereda esa
+restricción. Los cuentos (Apache-2.0) y el maestro Salamandra (Apache-2.0) no tienen esa limitación.

chat_template.jinja

@@ -0,0 +1 @@
+{%- for m in messages -%}{%- if m['role'] == 'user' -%}<|usuario|>{{ m['content'] }}{%- elif m['role'] == 'assistant' -%}<|asistente|>{{ m['content'] }}<|fin|>{%- endif -%}{%- endfor -%}{%- if add_generation_prompt -%}<|asistente|>{%- endif -%}

config.json

@@ -0,0 +1,32 @@
+{
+  "architectures": [
+    "LlamaForCausalLM"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 0,
+  "dtype": "float32",
+  "eos_token_id": 0,
+  "head_dim": 64,
+  "hidden_act": "silu",
+  "hidden_size": 512,
+  "initializer_range": 0.02,
+  "intermediate_size": 1408,
+  "max_position_embeddings": 512,
+  "mlp_bias": false,
+  "model_type": "llama",
+  "num_attention_heads": 8,
+  "num_hidden_layers": 8,
+  "num_key_value_heads": 8,
+  "pad_token_id": 0,
+  "pretraining_tp": 1,
+  "rms_norm_eps": 1e-06,
+  "rope_parameters": {
+    "rope_theta": 10000.0,
+    "rope_type": "default"
+  },
+  "tie_word_embeddings": true,
+  "transformers_version": "5.19.0",
+  "use_cache": true,
+  "vocab_size": 8192
+}

entrenamiento/chat.py

@@ -0,0 +1,64 @@
+"""
+Paso 5: ¡habla con el modelo!
+
+  python chat.py                     # modo chat (usa checkpoints/chat.pt)
+  python chat.py --cuento            # modo cuentacuentos (usa checkpoints/preentreno.pt)
+  python chat.py --temperatura 0.5   # más bajo = más predecible, más alto = más creativo
+"""
+import argparse
+import sys
+
+import torch
+from tokenizers import Tokenizer
+
+from comun import ASISTENTE, FIN, NOMBRE, USUARIO
+from modelo import GPT, Config
+
+sys.stdout.reconfigure(encoding="utf-8")
+p = argparse.ArgumentParser()
+p.add_argument("--cuento", action="store_true")
+p.add_argument("--temperatura", type=float, default=0.7)
+p.add_argument("--top_k", type=int, default=30)
+args = p.parse_args()
+
+dev = "cuda" if torch.cuda.is_available() else "cpu"
+ruta = "checkpoints/preentreno.pt" if args.cuento else "checkpoints/chat.pt"
+ck = torch.load(ruta, map_location=dev, weights_only=False)
+modelo = GPT(Config(**ck["config"])).to(dev).eval()
+modelo.load_state_dict(ck["modelo"])
+tok = Tokenizer.from_file("datos/tokenizador.json")
+ID_FIN, ID_USU, ID_ASI = (tok.token_to_id(t) for t in (FIN, USUARIO, ASISTENTE))
+
+
+def continuar(ids, max_tokens):
+    x = torch.tensor([ids], device=dev)
+    with torch.autocast(dev, dtype=torch.bfloat16, enabled=dev == "cuda"):
+        y = modelo.generar(x, max_tokens=max_tokens, temperatura=args.temperatura, top_k=args.top_k, parar_en={ID_FIN})
+    nuevos = y[0, len(ids):].tolist()
+    if nuevos and nuevos[-1] == ID_FIN:
+        nuevos = nuevos[:-1]
+    return nuevos
+
+
+print(f"{NOMBRE} ({modelo.num_parametros() / 1e6:.0f}M parámetros, {ruta}) — escribe 'salir' para terminar")
+if args.cuento:
+    print("Escribe el comienzo de un cuento (p. ej. 'Había una vez un gato') y el modelo lo sigue.\n")
+historial = []
+while True:
+    try:
+        texto = input("\nTú: ").strip()
+    except (EOFError, KeyboardInterrupt):
+        break
+    if texto.lower() in ("salir", "exit", "quit"):
+        break
+    if not texto:
+        continue
+    if args.cuento:
+        ids = tok.encode(texto).ids
+        print(f"{NOMBRE}: " + texto + tok.decode(continuar(ids, 400)))
+        continue
+    historial += [ID_USU] + tok.encode(texto).ids + [ID_ASI]
+    historial = historial[-(modelo.config.contexto - 200):]  # recuerda solo lo último
+    respuesta = continuar(historial, 200)
+    historial += respuesta + [ID_FIN]
+    print(f"{NOMBRE}: " + tok.decode(respuesta).strip())

entrenamiento/chat_perdidas.csv

@@ -0,0 +1,41 @@
+paso,perdida_train,perdida_val,lr,tokens_por_seg
+0,,2.5465,,
+0,2.4225,,0.000003,0
+25,2.6421,,0.000090,77420
+50,2.4493,,0.000176,76207
+75,2.4308,,0.000262,76027
+100,2.3939,,0.000300,74666
+125,2.3228,,0.000298,72977
+150,2.3681,,0.000296,74274
+175,2.3509,,0.000292,70574
+200,2.2703,,0.000286,73708
+225,2.4100,,0.000280,73527
+250,,2.4240,,
+250,2.4816,,0.000272,68771
+275,2.2978,,0.000264,72449
+300,2.2344,,0.000254,73476
+325,2.3682,,0.000243,73291
+350,2.3207,,0.000232,74426
+375,2.3712,,0.000220,70396
+400,2.3498,,0.000207,73838
+425,2.3636,,0.000194,73854
+450,2.2348,,0.000181,73398
+475,2.2173,,0.000167,72852
+500,,2.2985,,
+500,2.1653,,0.000154,68580
+525,2.3053,,0.000141,72057
+550,2.0973,,0.000127,70499
+575,2.1182,,0.000115,74156
+600,1.9934,,0.000102,70583
+625,2.2471,,0.000091,38884
+650,2.1793,,0.000080,37694
+675,1.9070,,0.000070,37313
+700,2.0341,,0.000061,73352
+725,2.0737,,0.000053,74291
+750,,2.2419,,
+750,2.0562,,0.000046,68670
+775,2.0480,,0.000040,73805
+800,2.2048,,0.000036,71873
+825,2.0975,,0.000032,73843
+850,2.0775,,0.000031,73641
+872,,2.2420,,

entrenamiento/comun.py

@@ -0,0 +1,24 @@
+"""Cosas compartidas entre los scripts: nombre, tokens especiales y formato de chat."""
+
+# Nombre del modelo pequeño (provisional). Si lo cambias, vuelve a ejecutar
+# identidad.py y `entrenar.py chat` para que el modelo aprenda su nuevo nombre.
+NOMBRE = "Minerva"
+
+FIN = "<|fin|>"
+USUARIO = "<|usuario|>"
+ASISTENTE = "<|asistente|>"
+ESPECIALES = [FIN, USUARIO, ASISTENTE]
+
+
+def formatear_chat(turnos):
+    """turnos = [("usuario", "hola"), ("asistente", "¡Hola!"), ...] -> texto plano.
+
+    <|usuario|>hola<|asistente|>¡Hola!<|fin|>
+    """
+    texto = ""
+    for rol, contenido in turnos:
+        if rol == "usuario":
+            texto += USUARIO + contenido
+        else:
+            texto += ASISTENTE + contenido + FIN
+    return texto

entrenamiento/entrenar.py

@@ -0,0 +1,218 @@
+"""
+Pasos 3 y 4: entrenar a Minerva.
+
+  python entrenar.py preentreno   -> aprende español leyendo ~1M cuentos + textos de GPT-4
+                                     (predice la siguiente palabra, como todos los GPT)
+  python entrenar.py chat         -> aprende a CONVERSAR imitando las respuestas de los
+                                     modelos maestros (destilación). Solo aprende de las
+                                     respuestas del asistente, no de las preguntas.
+"""
+import argparse
+import glob
+import json
+import math
+import os
+import random
+import time
+
+import numpy as np
+import torch
+from tokenizers import Tokenizer
+
+from comun import ASISTENTE, FIN, USUARIO
+from modelo import GPT, Config
+
+p = argparse.ArgumentParser()
+p.add_argument("fase", choices=["preentreno", "chat"])
+p.add_argument("--lote", type=int, default=32, help="secuencias por micro-lote")
+p.add_argument("--acumular", type=int, default=4, help="micro-lotes por paso")
+p.add_argument("--lr", type=float, default=None)
+p.add_argument("--epocas", type=float, default=None)
+p.add_argument("--evaluar_cada", type=int, default=250)
+args = p.parse_args()
+
+torch.manual_seed(1234)
+random.seed(1234)
+torch.backends.cuda.matmul.allow_tf32 = True
+dev = "cuda"
+autocast = torch.autocast("cuda", dtype=torch.bfloat16)
+tok = Tokenizer.from_file("datos/tokenizador.json")
+ID_FIN, ID_USU, ID_ASI = (tok.token_to_id(t) for t in (FIN, USUARIO, ASISTENTE))
+os.makedirs("checkpoints", exist_ok=True)
+os.makedirs("logs", exist_ok=True)
+
+# ======================================================================= datos
+if args.fase == "preentreno":
+    config = Config()
+    modelo = GPT(config).to(dev)
+    lr_max = args.lr or 1e-3
+    epocas = args.epocas or 1.0
+    datos = {s: np.memmap(f"datos/preentreno_{s}.bin", dtype=np.uint16, mode="r") for s in ("train", "val")}
+    T = config.contexto
+
+    def lote(split):
+        d = datos[split]
+        ix = np.random.randint(0, len(d) - T - 1, args.lote)
+        x = torch.from_numpy(np.stack([d[i : i + T] for i in ix]).astype(np.int64))
+        y = torch.from_numpy(np.stack([d[i + 1 : i + 1 + T] for i in ix]).astype(np.int64))
+        return x.pin_memory().to(dev, non_blocking=True), y.pin_memory().to(dev, non_blocking=True), None
+
+    tokens_por_paso = args.lote * args.acumular * T
+    pasos_totales = int(epocas * len(datos["train"]) / tokens_por_paso)
+    print(f"Datos: {len(datos['train']):,} tokens de entrenamiento")
+
+else:  # chat
+    ck = torch.load("checkpoints/preentreno.pt", map_location="cpu", weights_only=False)
+    config = Config(**ck["config"])
+    modelo = GPT(config).to(dev)
+    modelo.load_state_dict(ck["modelo"])
+    lr_max = args.lr or 3e-4
+    epocas = args.epocas or 2.0
+
+    def tokenizar(turnos):
+        ids, masc = [], []
+        for rol, texto in turnos:
+            piezas = tok.encode(texto).ids
+            if rol == "usuario":
+                ids += [ID_USU] + piezas
+                masc += [0] * (1 + len(piezas))
+            else:  # aprende a producir la respuesta y el token de fin
+                ids += [ID_ASI] + piezas + [ID_FIN]
+                masc += [0] + [1] * (len(piezas) + 1)
+        return ids[: config.contexto + 1], masc[: config.contexto + 1]
+
+    conversaciones = []
+    with open("datos/crudos/alpaca-gpt4-spanish.json", encoding="utf-8") as f:
+        for item in json.load(f):
+            turnos = [("usuario" if c["from"] == "human" else "asistente", c["value"].strip()) for c in item["conversations"]]
+            conversaciones.append(turnos)
+    print(f"  GPT-4 (alpaca-es): {len(conversaciones):,}")
+    for ruta in sorted(glob.glob("datos/chat_*.jsonl")):
+        with open(ruta, encoding="utf-8") as f:
+            filas = [json.loads(l) for l in f if l.strip()]
+        for r in filas:  # "repetir" permite dar más peso a algunos ejemplos
+            conversaciones += [r["turnos"]] * r.get("repetir", 1)
+        print(f"  {os.path.basename(ruta)}: {len(filas):,}")
+    random.shuffle(conversaciones)
+    ejemplos = [tokenizar(c) for c in conversaciones]
+    ejemplos = [e for e in ejemplos if sum(e[1]) > 0]
+    val, train = ejemplos[:500], ejemplos[500:]
+    cursor = {"train": 0, "val": 0}
+    conjuntos = {"train": train, "val": val}
+
+    def lote(split):
+        conj = conjuntos[split]
+        if cursor[split] + args.lote > len(conj):
+            cursor[split] = 0
+            if split == "train":
+                random.shuffle(conj)
+        trozo = conj[cursor[split] : cursor[split] + args.lote]
+        cursor[split] += args.lote
+        L = max(len(i) for i, _ in trozo)
+        x = torch.full((len(trozo), L - 1), ID_FIN, dtype=torch.long)
+        y = torch.full((len(trozo), L - 1), ID_FIN, dtype=torch.long)
+        m = torch.zeros((len(trozo), L - 1), dtype=torch.long)
+        for j, (ids, masc) in enumerate(trozo):
+            n = len(ids) - 1
+            x[j, :n] = torch.tensor(ids[:-1])
+            y[j, :n] = torch.tensor(ids[1:])
+            m[j, :n] = torch.tensor(masc[1:])
+        return x.to(dev), y.to(dev), m.to(dev)
+
+    pasos_totales = int(epocas * len(train) / (args.lote * args.acumular))
+    print(f"Conversaciones: {len(train):,} entrenamiento / {len(val)} validación")
+
+print(f"Modelo: {modelo.num_parametros() / 1e6:.1f} M parámetros | {pasos_totales:,} pasos | lr {lr_max}")
+
+# ======================================================================= optimizador
+decay = [p for n, p in modelo.named_parameters() if p.dim() >= 2]
+no_decay = [p for n, p in modelo.named_parameters() if p.dim() < 2]
+opt = torch.optim.AdamW(
+    [{"params": decay, "weight_decay": 0.1}, {"params": no_decay, "weight_decay": 0.0}],
+    lr=lr_max, betas=(0.9, 0.95), fused=True,
+)
+calentamiento = min(200, pasos_totales // 10)
+
+
+def tasa(paso):  # calentamiento lineal + bajada en coseno hasta 10%
+    if paso < calentamiento:
+        return lr_max * (paso + 1) / calentamiento
+    prog = (paso - calentamiento) / max(1, pasos_totales - calentamiento)
+    return lr_max * (0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * prog)))
+
+
+@torch.no_grad()
+def evaluar():
+    modelo.eval()
+    perdidas = []
+    for _ in range(20):
+        x, y, m = lote("val")
+        with autocast:
+            _, perd = modelo(x, y, m)
+        perdidas.append(perd.item())
+    modelo.train()
+    return sum(perdidas) / len(perdidas)
+
+
+@torch.no_grad()
+def muestra():
+    modelo.eval()
+    if args.fase == "preentreno":
+        prompt = tok.encode("Había una vez").ids
+    else:
+        prompt = [ID_USU] + tok.encode("¿Cuál es la capital de España?").ids + [ID_ASI]
+    x = torch.tensor([prompt], device=dev)
+    with autocast:
+        y = modelo.generar(x, max_tokens=120, parar_en={ID_FIN})
+    modelo.train()
+    return tok.decode(y[0].tolist(), skip_special_tokens=False)
+
+
+def guardar(paso, perdida_val):
+    torch.save(
+        {"modelo": modelo.state_dict(), "config": config.__dict__, "paso": paso, "perdida_val": perdida_val},
+        f"checkpoints/{args.fase}.pt",
+    )
+
+
+# ======================================================================= bucle
+log = open(f"logs/{args.fase}.csv", "w", encoding="utf-8")
+log.write("paso,perdida_train,perdida_val,lr,tokens_por_seg\n")
+t0 = time.time()
+mejor = float("inf")
+for paso in range(pasos_totales + 1):
+    if paso % args.evaluar_cada == 0 or paso == pasos_totales:
+        pv = evaluar()
+        print(f"\n[paso {paso}] pérdida validación {pv:.3f}")
+        print("  muestra:", muestra().replace("\n", " ")[:400])
+        log.write(f"{paso},,{pv:.4f},,\n")
+        if pv < mejor:
+            mejor = pv
+            guardar(paso, pv)
+        if paso == pasos_totales:
+            break
+
+    for g in opt.param_groups:
+        g["lr"] = tasa(paso)
+    tokens = 0
+    for _ in range(args.acumular):
+        x, y, m = lote("train")
+        with autocast:
+            _, perd = modelo(x, y, m)
+        (perd / args.acumular).backward()
+        tokens += x.numel()
+    torch.nn.utils.clip_grad_norm_(modelo.parameters(), 1.0)
+    opt.step()
+    opt.zero_grad(set_to_none=True)
+
+    if paso % 25 == 0:
+        torch.cuda.synchronize()
+        dt = time.time() - t0
+        tps = tokens * 25 / dt if paso else 0
+        resta = (pasos_totales - paso) * dt / 25 / 60 if paso else 0
+        print(f"paso {paso:5d}/{pasos_totales} | pérdida {perd.item():.3f} | lr {tasa(paso):.2e} | {tps/1000:.0f}k tok/s | faltan ~{resta:.0f} min", flush=True)
+        log.write(f"{paso},{perd.item():.4f},,{tasa(paso):.6f},{tps:.0f}\n")
+        log.flush()
+        t0 = time.time()
+
+print(f"\nListo. Mejor pérdida de validación: {mejor:.3f} -> checkpoints/{args.fase}.pt")

entrenamiento/exportar_hf.py

@@ -0,0 +1,141 @@
+"""
+Exporta Minerva v0.1 al formato estándar de Hugging Face (arquitectura Llama), para que
+cualquiera pueda usarla con `transformers` sin nuestro código:
+
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    tok = AutoTokenizer.from_pretrained("Minerva-v0.1")
+    modelo = AutoModelForCausalLM.from_pretrained("Minerva-v0.1")
+
+Comprueba que el modelo exportado da EXACTAMENTE los mismos resultados que el original.
+"""
+import json
+import os
+import shutil
+import sys
+
+import torch
+from tokenizers import Tokenizer
+from transformers import LlamaConfig, LlamaForCausalLM, PreTrainedTokenizerFast
+
+from comun import ASISTENTE, FIN, NOMBRE, USUARIO
+from modelo import GPT, Config
+
+sys.stdout.reconfigure(encoding="utf-8")
+SALIDA = sys.argv[2] if len(sys.argv) > 2 else f"{NOMBRE}-v0.1"
+os.makedirs(SALIDA, exist_ok=True)
+
+ck = torch.load(sys.argv[1] if len(sys.argv) > 1 else "checkpoints/chat.pt", map_location="cpu", weights_only=False)
+c = Config(**ck["config"])
+nuestro = GPT(c).eval()
+nuestro.load_state_dict(ck["modelo"])
+sd = nuestro.state_dict()
+
+tok = Tokenizer.from_file("datos/tokenizador.json")
+id_fin = tok.token_to_id(FIN)
+dim_cabeza = c.dim // c.cabezas
+oculta = nuestro.bloques[0].ff.w1.weight.shape[0]
+
+# ------------------------------------------------------------------ pesos
+config = LlamaConfig(
+    vocab_size=c.vocab, hidden_size=c.dim, intermediate_size=oculta, num_hidden_layers=c.capas,
+    num_attention_heads=c.cabezas, num_key_value_heads=c.cabezas, head_dim=dim_cabeza,
+    max_position_embeddings=c.contexto, rms_norm_eps=1e-6, rope_theta=10000.0, hidden_act="silu",
+    tie_word_embeddings=True, attention_bias=False, mlp_bias=False,
+    bos_token_id=id_fin, eos_token_id=id_fin, pad_token_id=id_fin, torch_dtype="float32",
+)
+
+# Nuestra RoPE rota pares (0,1),(2,3)...; la de Llama en HF rota (0,d/2),(1,d/2+1)...
+# Reordenamos las filas de q y k dentro de cada cabeza para que sea la misma operación.
+orden = torch.cat([torch.arange(0, dim_cabeza, 2), torch.arange(1, dim_cabeza, 2)])
+
+
+def permutar(w):
+    return w.view(c.cabezas, dim_cabeza, c.dim)[:, orden, :].reshape(c.dim, c.dim)
+
+
+nuevos = {"model.embed_tokens.weight": sd["embedding.weight"], "model.norm.weight": sd["norm_final.peso"]}
+for i in range(c.capas):
+    p, h = f"bloques.{i}.", f"model.layers.{i}."
+    q, k, v = sd[p + "atencion.qkv.weight"].split(c.dim, dim=0)
+    nuevos.update({
+        h + "self_attn.q_proj.weight": permutar(q), h + "self_attn.k_proj.weight": permutar(k),
+        h + "self_attn.v_proj.weight": v, h + "self_attn.o_proj.weight": sd[p + "atencion.salida.weight"],
+        h + "mlp.gate_proj.weight": sd[p + "ff.w1.weight"], h + "mlp.up_proj.weight": sd[p + "ff.w3.weight"],
+        h + "mlp.down_proj.weight": sd[p + "ff.w2.weight"],
+        h + "input_layernorm.weight": sd[p + "norm1.peso"], h + "post_attention_layernorm.weight": sd[p + "norm2.peso"],
+    })
+hf = LlamaForCausalLM(config).eval()
+faltan, sobran = hf.load_state_dict({k: v.clone() for k, v in nuevos.items()}, strict=False)
+assert not sobran and set(faltan) <= {"lm_head.weight"}, (faltan, sobran)
+hf.tie_weights()
+hf.generation_config.update(do_sample=True, temperature=0.7, top_k=30, max_new_tokens=200,
+                            eos_token_id=id_fin, pad_token_id=id_fin, bos_token_id=id_fin)
+hf.save_pretrained(SALIDA, safe_serialization=True)
+
+# ------------------------------------------------------------------ tokenizador + plantilla de chat
+PLANTILLA = (
+    "{%- for m in messages -%}"
+    "{%- if m['role'] == 'user' -%}" + USUARIO + "{{ m['content'] }}"
+    "{%- elif m['role'] == 'assistant' -%}" + ASISTENTE + "{{ m['content'] }}" + FIN +
+    "{%- endif -%}"
+    "{%- endfor -%}"
+    "{%- if add_generation_prompt -%}" + ASISTENTE + "{%- endif -%}"
+)
+tok_hf = PreTrainedTokenizerFast(tokenizer_object=tok, eos_token=FIN, pad_token=FIN, bos_token=FIN,
+                                 additional_special_tokens=[USUARIO, ASISTENTE], model_max_length=c.contexto)
+tok_hf.chat_template = PLANTILLA
+tok_hf.save_pretrained(SALIDA)
+
+# ------------------------------------------------------------------ comprobación
+hf2 = LlamaForCausalLM.from_pretrained(SALIDA).eval()
+tok2 = PreTrainedTokenizerFast.from_pretrained(SALIDA)
+texto = tok2.apply_chat_template([{"role": "user", "content": "¿Quién eres?"}], tokenize=False, add_generation_prompt=True)
+ids = tok2(texto, return_tensors="pt", add_special_tokens=False)["input_ids"]
+assert ids[0].tolist() == tok.encode(texto).ids, "el tokenizador exportado no coincide"
+with torch.no_grad():
+    a = nuestro(ids, ids)[0]  # pasamos objetivos para obtener los logits de todas las posiciones
+    b = hf2(ids).logits
+dif = (a - b).abs().max().item()
+print(f"Diferencia máxima de logits entre el original y el exportado: {dif:.2e}")
+assert dif < 1e-3, "¡la exportación no es fiel!"
+with torch.no_grad():
+    g1 = nuestro.generar(ids, max_tokens=40, temperatura=0, parar_en={id_fin})[0, ids.shape[1]:].tolist()
+    g2 = hf2.generate(ids, max_new_tokens=40, do_sample=False)[0, ids.shape[1]:].tolist()
+print("Mismo texto generado (voraz):", g1 == g2[: len(g1)])
+print("Respuesta:", tok2.decode(g2, skip_special_tokens=True))
+
+# ------------------------------------------------------------------ ficha del modelo (README.md) con ejemplos reales
+torch.manual_seed(2026)
+ejemplos = []
+for q in ["¿Quién eres?", "¿Por qué te llamas Minerva?", "¿Cuál es la capital de España?",
+          "¿Qué es la paella?", "Dame un consejo para dormir mejor."]:
+    ids = tok2.apply_chat_template([{"role": "user", "content": q}], add_generation_prompt=True, return_tensors="pt", return_dict=False)
+    with torch.no_grad():
+        out = hf2.generate(ids, max_new_tokens=120, do_sample=True, temperature=0.7, top_k=30)
+    ejemplos.append(f"> **Tú:** {q}  \n> **Minerva:** {tok2.decode(out[0, ids.shape[1]:], skip_special_tokens=True).strip()}")
+ids = tok2("Había una vez un dragón que", return_tensors="pt", add_special_tokens=False)["input_ids"]
+with torch.no_grad():
+    out = hf2.generate(ids, max_new_tokens=150, do_sample=True, temperature=0.7, top_k=30)
+cuento = tok2.decode(out[0], skip_special_tokens=True).strip().replace("\n\n", " ").replace("\n", " ")
+ejemplos.append(f"> **Cuento** (empieza con «Había una vez un dragón que»):  \n> {cuento}")
+ficha = open("ficha_modelo.md", encoding="utf-8").read()
+ficha = (ficha.replace("@@PARAMS@@", f"{nuestro.num_parametros() / 1e6:.0f}")
+              .replace("@@PERDIDA@@", f"{ck['perdida_val']:.3f}")
+              .replace("@@EJEMPLOS@@", "\n\n".join(ejemplos)))
+with open(f"{SALIDA}/README.md", "w", encoding="utf-8") as f:
+    f.write(ficha)
+print("\n".join(ejemplos))
+
+# ------------------------------------------------------------------ código de entrenamiento (para reproducirlo)
+os.makedirs(f"{SALIDA}/entrenamiento", exist_ok=True)
+for f in ["modelo.py", "comun.py", "preparar_datos.py", "maestro.py", "identidad.py", "entrenar.py", "chat.py", "exportar_hf.py", "ficha_modelo.md"]:
+    shutil.copy(f, f"{SALIDA}/entrenamiento/{f}")
+for f in ["logs/preentreno.csv", "logs/chat.csv"]:
+    if os.path.exists(f):
+        shutil.copy(f, f"{SALIDA}/entrenamiento/{os.path.basename(f).replace('.csv', '_perdidas.csv')}")
+with open(f"{SALIDA}/entrenamiento/info.json", "w", encoding="utf-8") as f:
+    json.dump({"paso": ck["paso"], "perdida_val_chat": ck["perdida_val"], "parametros": nuestro.num_parametros()}, f, indent=1)
+print(f"\nExportado en {SALIDA}/:")
+for f in sorted(os.listdir(SALIDA)):
+    ruta = os.path.join(SALIDA, f)
+    print(f"  {f:28s} {os.path.getsize(ruta) / 1e6:8.1f} MB" if os.path.isfile(ruta) else f"  {f}/")

entrenamiento/ficha_modelo.md

@@ -0,0 +1,102 @@
+---
+language:
+- es
+license: cc-by-nc-4.0
+library_name: transformers
+pipeline_tag: text-generation
+tags:
+- spanish
+- español
+- tiny
+- llama
+- gguf
+- from-scratch
+- distillation
+datasets:
+- robrenaud/multilingual_tinystories
+- FreedomIntelligence/alpaca-gpt4-spanish
+---
+
+# Minerva v0.1 🇪🇸
+
+**Minerva** es un modelo de lenguaje en español **diminuto** (@@PARAMS@@ millones de parámetros), entrenado
+**desde cero** en un ordenador portátil. Es un modelo de juguete y de aprendizaje: habla español con
+soltura y cuenta cuentos sencillos, pero **sabe muy poco del mundo y se inventa las cosas**.
+
+El nombre viene de Minerva, diosa romana de la sabiduría, que según el mito nació de la cabeza de Júpiter.
+Este modelo también "nació de la cabeza" de modelos más grandes: aprendió de textos escritos por ellos
+(destilación).
+
+## Qué sabe hacer (y qué no)
+
+| ✅ Sí | ❌ No |
+|---|---|
+| Escribir en español con buena gramática | Dar datos fiables (se los inventa con seguridad) |
+| Contar cuentos infantiles coherentes | Matemáticas, razonamiento, programación |
+| Charlar con frases sencillas | Recordar conversaciones largas (ve unas 350 palabras) |
+| Decir quién es y por qué se llama así | Cualquier uso serio: **no lo uses para decisiones reales** |
+
+## Ejemplos reales
+
+Respuestas generadas automáticamente al exportar el modelo (temperatura 0.7, sin escoger las mejores):
+
+@@EJEMPLOS@@
+
+## Cómo usarlo
+
+### Con LM Studio u Ollama (sin programar)
+
+El repositorio incluye el archivo `Minerva-v0.1-F16.gguf`.
+
+- **LM Studio**: busca `AxoneSystem/Minerva-v0.1` y descárgalo.
+- **Ollama**: `ollama run hf.co/AxoneSystem/Minerva-v0.1`
+
+### Con Python (`transformers`)
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+tok = AutoTokenizer.from_pretrained("AxoneSystem/Minerva-v0.1")
+modelo = AutoModelForCausalLM.from_pretrained("AxoneSystem/Minerva-v0.1")
+
+mensajes = [{"role": "user", "content": "¿Quién eres?"}]
+ids = tok.apply_chat_template(mensajes, add_generation_prompt=True, return_tensors="pt")
+salida = modelo.generate(ids, max_new_tokens=150, do_sample=True, temperature=0.7, top_k=30)
+print(tok.decode(salida[0, ids.shape[1]:], skip_special_tokens=True))
+```
+
+Para que cuente un cuento, dale el principio sin plantilla de chat: `"Había una vez un gato que"`.
+
+### Formato de chat
+
+```
+<|usuario|>¿Quién eres?<|asistente|>Soy Minerva, un modelo de lenguaje muy pequeño...<|fin|>
+```
+
+## Cómo se entrenó
+
+| | |
+|---|---|
+| Arquitectura | Transformer decodificador tipo Llama: RMSNorm, RoPE, SwiGLU, embeddings compartidos |
+| Tamaño | @@PARAMS@@M parámetros · 8 capas · 512 dimensiones · 8 cabezas · contexto de 512 tokens |
+| Tokenizador | BPE byte-level propio, 8.192 piezas, entrenado solo con español |
+| Hardware | 1 portátil con NVIDIA RTX 5070 Laptop (8 GB) |
+| Tiempo | ~1 h de preentreno + ~1 h de destilación y ajuste |
+
+1. **Preentreno** (~280M tokens vistos): ~1 millón de cuentos infantiles en español escritos por
+   Gemini 1.5 Flash (`robrenaud/multilingual_tinystories`) + ~50.000 respuestas de GPT-4 en español
+   (`FreedomIntelligence/alpaca-gpt4-spanish`). Objetivo: predecir la siguiente palabra.
+2. **Destilación**: [Salamandra-2B-Instruct](https://huggingface.co/BSC-LT/salamandra-2b-instruct)
+   (Barcelona Supercomputing Center) respondió miles de preguntas **de forma sencilla y corta**, para
+   que un modelo tan pequeño pudiera imitarlo.
+3. **Ajuste de chat**: aprende a responder solo con las partes del asistente (las preguntas no cuentan
+   en el aprendizaje) + unas decenas de respuestas escritas a mano sobre su identidad.
+
+Pérdida de validación final en el ajuste de chat: @@PERDIDA@@.
+El código completo de entrenamiento está en la carpeta `entrenamiento/`.
+
+## Licencia
+
+**CC BY-NC 4.0** (uso no comercial). Parte de los datos de ajuste son respuestas de GPT-4 que proceden de
+Alpaca-GPT4, publicado solo para investigación y uso no comercial; por prudencia el modelo hereda esa
+restricción. Los cuentos (Apache-2.0) y el maestro Salamandra (Apache-2.0) no tienen esa limitación.

entrenamiento/identidad.py

@@ -0,0 +1,62 @@
+"""
+Le enseña al modelo quién es (el nombre está en comun.py). Genera datos/chat_identidad.jsonl con preguntas
+típicas ("¿quién eres?", "¿quién te creó?"...) y respuestas escritas a mano.
+Cámbialo a tu gusto y vuelve a ejecutar `python entrenar.py chat`.
+"""
+import json
+import random
+
+from comun import NOMBRE
+
+random.seed(7)
+
+saludos = ["hola", "Hola", "¡Hola!", "buenas", "Buenos días", "Buenas tardes", "hey", "Hola, ¿qué tal?", "¿Qué tal estás?", "Hola {nombre}"]
+resp_saludos = [
+    "¡Hola! Soy {nombre}. ¿En qué te puedo ayudar?",
+    "¡Hola! ¿Qué tal? Pregúntame lo que quieras.",
+    "¡Buenas! Aquí estoy para charlar contigo.",
+    "¡Hola! Me alegra hablar contigo. ¿Qué quieres saber?",
+]
+quien = ["¿Quién eres?", "¿Qué eres?", "¿Cómo te llamas?", "¿Cuál es tu nombre?", "Preséntate", "¿Eres ChatGPT?",
+         "¿Eres una persona?", "¿Eres un robot?", "Dime quién eres", "¿Qué tipo de inteligencia artificial eres?"]
+resp_quien = [
+    "Soy {nombre}, un modelo de lenguaje muy pequeño hecho en España. Todavía estoy aprendiendo, así que a veces me equivoco.",
+    "Me llamo {nombre}. Soy una inteligencia artificial pequeñita que habla español. No soy ChatGPT, soy un modelo mucho más sencillo.",
+    "Soy {nombre}, una red neuronal tipo GPT con unos 30 millones de parámetros. Aprendí español leyendo cuentos y conversaciones.",
+    "Soy {nombre}, un modelo de lenguaje español. No soy una persona, soy un programa de ordenador.",
+]
+creador = ["¿Quién te creó?", "¿Quién te ha hecho?", "¿Quién te entrenó?", "¿De dónde eres?", "¿Cómo te hicieron?", "¿Cómo aprendiste?"]
+resp_creador = [
+    "Me entrenaron en un ordenador portátil en España. Unos modelos grandes me enseñaron con sus respuestas, igual que un maestro enseña a un alumno.",
+    "Soy de España. Aprendí leyendo un millón de cuentos y copiando las respuestas de modelos más grandes. A eso se le llama destilación.",
+    "Me hicieron en España, con una sola tarjeta gráfica. Primero leí muchos cuentos para aprender español y luego aprendí a conversar.",
+]
+limites = ["¿Eres listo?", "¿Sabes mucho?", "¿Te equivocas?", "¿Puedo fiarme de ti?", "¿Qué sabes hacer?"]
+resp_limites = [
+    "Sé un poco de todo, pero soy un modelo muy pequeño y me equivoco a menudo. Para cosas importantes, consulta otra fuente.",
+    "Puedo contar cuentos y charlar un poco en español. Soy un modelo pequeñito, así que no te fíes mucho de lo que digo.",
+    "Intento ayudar, pero todavía estoy aprendiendo. ¡A veces me invento cosas!",
+]
+por_que_nombre = ["¿Por qué te llamas {nombre}?", "¿Qué significa tu nombre?", "¿De dónde viene tu nombre?", "¿Quién era {nombre}?"]
+resp_por_que_nombre = [
+    "Me llamo así por {nombre}, la diosa romana de la sabiduría. Según el mito, nació de la cabeza de Júpiter. "
+    "Yo también nací de la cabeza de modelos más grandes: ellos me enseñaron y yo aprendí de sus respuestas.",
+    "{nombre} era la diosa romana de la sabiduría, hija de Júpiter. Me pusieron su nombre porque aprendí de modelos "
+    "mucho más grandes que yo, igual que ella salió de la cabeza de su padre.",
+]
+despedidas = ["adiós", "Adiós", "hasta luego", "Gracias", "gracias, adiós", "Muchas gracias", "Chao"]
+resp_despedidas = ["¡De nada! Hasta pronto.", "¡Adiós! Ha sido un placer charlar contigo.", "¡Gracias a ti! Vuelve cuando quieras."]
+
+filas = []
+for preguntas, respuestas, rep in [(saludos, resp_saludos, 3), (quien, resp_quien, 6), (creador, resp_creador, 6),
+                                    (limites, resp_limites, 4), (por_que_nombre, resp_por_que_nombre, 6),
+                                    (despedidas, resp_despedidas, 2)]:
+    for q in preguntas:
+        for r in random.sample(respuestas, min(2, len(respuestas))):
+            turnos = [["usuario", q.format(nombre=NOMBRE)], ["asistente", r.format(nombre=NOMBRE)]]
+            filas.append({"turnos": turnos, "repetir": rep})
+
+with open("datos/chat_identidad.jsonl", "w", encoding="utf-8") as f:
+    for fila in filas:
+        f.write(json.dumps(fila, ensure_ascii=False) + "\n")
+print(f"{len(filas)} conversaciones de identidad -> datos/chat_identidad.jsonl")

entrenamiento/info.json

@@ -0,0 +1,5 @@
+{
+ "paso": 750,
+ "perdida_val_chat": 2.2418617248535155,
+ "parametros": 29893120
+}

entrenamiento/maestro.py

@@ -0,0 +1,174 @@
+"""
+Paso 2: DESTILACIÓN. Un modelo grande (el "maestro") escribe conversaciones
+sencillas para que Minerva (el "alumno") aprenda a imitarlas.
+
+Es lo mismo que hicieron TinyStories (GPT-4 -> modelos de 30M), Alpaca, Phi, etc.
+El truco: el maestro responde de forma SENCILLA y CORTA, para que un modelo
+diminuto sea capaz de aprenderlo.
+
+Dos fuentes de preguntas:
+  1) preguntas de alpaca-gpt4-spanish, re-contestadas de forma sencilla
+  2) preguntas nuevas que el propio maestro inventa sobre temas (muchos de España)
+
+Uso:
+  python maestro.py --probar                       # ver unos ejemplos y la velocidad
+  python maestro.py --n 12000                      # generar datos/chat_maestro.jsonl
+  python maestro.py --maestro maestros/Qwen3-1.7B  # usar otro maestro
+"""
+import argparse
+import json
+import random
+import re
+import time
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+p = argparse.ArgumentParser()
+p.add_argument("--maestro", default="maestros/salamandra-2b-instruct")
+p.add_argument("--n", type=int, default=12000, help="conversaciones a generar")
+p.add_argument("--lote", type=int, default=48)
+p.add_argument("--probar", action="store_true")
+p.add_argument("--salida", default="datos/chat_maestro.jsonl")
+args = p.parse_args()
+random.seed(42)
+
+INSTRUCCION = (
+    "Eres un asistente amable que habla español de España. "
+    "Responde en español, de forma clara y sencilla, en 1 a 4 frases cortas. "
+    "No uses listas, ni títulos, ni negritas."
+)
+
+TEMAS = [
+    # España
+    "Madrid", "Barcelona", "Sevilla", "Valencia", "Bilbao", "Galicia", "Andalucía", "Cataluña",
+    "el País Vasco", "las Islas Canarias", "las Islas Baleares", "Castilla y León", "Asturias",
+    "Aragón", "Extremadura", "Murcia", "Navarra", "La Rioja", "Cantabria", "Castilla-La Mancha",
+    "la tortilla de patatas", "la paella", "el gazpacho", "el jamón ibérico", "los churros",
+    "las tapas", "el aceite de oliva", "la Semana Santa", "las Fallas", "San Fermín",
+    "la Feria de Abril", "la Tomatina", "los Reyes Magos", "la Nochevieja y las uvas",
+    "el flamenco", "Cervantes y el Quijote", "Velázquez", "Goya", "Picasso", "Dalí", "Gaudí",
+    "la Sagrada Familia", "la Alhambra", "el Museo del Prado", "el Camino de Santiago",
+    "el río Ebro", "los Pirineos", "el Teide", "el idioma español", "el catalán", "el gallego",
+    "el euskera", "la siesta", "el fútbol en España", "el clima de España", "la Constitución española",
+    # Ciencia y naturaleza
+    "el sol", "la luna", "las estrellas", "los planetas", "la lluvia", "el arcoíris", "los volcanes",
+    "los océanos", "las plantas", "los árboles", "los dinosaurios", "los perros", "los gatos",
+    "los pájaros", "las abejas", "los peces", "las ballenas", "el agua", "el aire", "el fuego",
+    "la electricidad", "los imanes", "el cuerpo humano", "el corazón", "los huesos", "los dientes",
+    "los sueños", "las estaciones del año", "el tiempo", "la gravedad", "la luz", "el sonido",
+    # Vida diaria
+    "la amistad", "la familia", "el colegio", "los deportes", "la música", "los libros", "cocinar",
+    "la comida sana", "dormir bien", "hacer ejercicio", "el dinero", "los ordenadores", "internet",
+    "los teléfonos móviles", "la inteligencia artificial", "los robots", "los trenes", "los aviones",
+    "los coches", "las bicicletas", "el reciclaje", "cuidar el planeta", "las emociones",
+    "estar triste", "estar contento", "pedir perdón", "dar las gracias", "aprender idiomas",
+    "las matemáticas", "la historia", "el arte", "el cine", "los juegos", "los cumpleaños",
+    "la Navidad", "el verano", "el invierno", "la playa", "la montaña", "el campo", "la ciudad",
+]
+
+
+def cargar_maestro():
+    tok = AutoTokenizer.from_pretrained(args.maestro)
+    tok.padding_side = "left"
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+    modelo = AutoModelForCausalLM.from_pretrained(args.maestro, dtype=torch.bfloat16, device_map="cuda")
+    modelo.eval()
+    return tok, modelo
+
+
+def plantilla(tok, mensajes):
+    extra = {"enable_thinking": False} if "qwen3" in args.maestro.lower() else {}
+    return tok.apply_chat_template(mensajes, tokenize=False, add_generation_prompt=True, **extra)
+
+
+@torch.no_grad()
+def generar(tok, modelo, lista_mensajes, max_tokens, temperatura):
+    textos = [plantilla(tok, m) for m in lista_mensajes]
+    enc = tok(textos, return_tensors="pt", padding=True, add_special_tokens=False).to("cuda")
+    salida = modelo.generate(
+        **enc, max_new_tokens=max_tokens, do_sample=True, temperature=temperatura, top_p=0.9,
+        repetition_penalty=1.1, pad_token_id=tok.pad_token_id,
+    )
+    nuevos = salida[:, enc["input_ids"].shape[1] :]
+    return [t.strip() for t in tok.batch_decode(nuevos, skip_special_tokens=True)]
+
+
+def respuesta_valida(r):
+    if not (15 <= len(r) <= 700):
+        return False
+    if re.search(r"(\*\*|^#|^\s*[-•]\s|^\s*\d+\.\s)", r, re.M):  # listas o markdown
+        return False
+    if r[-1] not in ".!?»)\"":  # cortada a medias
+        return False
+    return True
+
+
+def preguntas_alpaca(n):
+    with open("datos/crudos/alpaca-gpt4-spanish.json", encoding="utf-8") as f:
+        datos = json.load(f)
+    evitar = re.compile(r"c[oó]digo|python|java|sql|html|css|funci[oó]n|programa|traduc|ingl[eé]s|ecuaci[oó]n|"
+                        r"\d+\s*[x×*/+-]\s*\d+|tabla|lista de|enumera|clasifica|reescrib|resume|edita|corrige", re.I)
+    qs = [d["conversations"][0]["value"].strip() for d in datos]
+    qs = [q for q in qs if 10 < len(q) < 160 and "\n" not in q and not evitar.search(q)]
+    random.shuffle(qs)
+    return qs[:n]
+
+
+def main():
+    t0 = time.time()
+    tok, modelo = cargar_maestro()
+    print(f"Maestro cargado: {args.maestro} ({modelo.num_parameters() / 1e9:.2f} B parámetros) en {time.time() - t0:.0f}s")
+
+    if args.probar:
+        qs = ["¿Por qué el cielo es azul?", "¿Cuál es la capital de España?", "¿Qué es la paella?",
+              "Dame un consejo para dormir mejor.", "¿Quién escribió el Quijote?", "¿Qué es un volcán?"]
+        t0 = time.time()
+        rs = generar(tok, modelo, [[{"role": "system", "content": INSTRUCCION}, {"role": "user", "content": q}] for q in qs], 160, 0.7)
+        for q, r in zip(qs, rs):
+            print(f"\nP: {q}\nR: {r}   [{'OK' if respuesta_valida(r) else 'descartada'}]")
+        print(f"\n{len(qs)} respuestas en {time.time() - t0:.1f}s")
+        return
+
+    # 1) preguntas: mitad de alpaca, mitad inventadas por el maestro sobre temas
+    n_alpaca = args.n // 2
+    preguntas = preguntas_alpaca(n_alpaca)
+    n_temas = args.n - len(preguntas)
+    print(f"Inventando {n_temas} preguntas sobre {len(TEMAS)} temas...")
+    estilos = ["una pregunta sencilla", "una pregunta curiosa", "una pregunta de un niño", "una pregunta práctica",
+               "una pregunta de un turista", "una petición de consejo"]
+    pedidos = [
+        [{"role": "user", "content": f"Escribe {random.choice(estilos)} que alguien podría hacer sobre {random.choice(TEMAS)}. "
+                                     "Escribe solo la pregunta, en español, en una línea."}]
+        for _ in range(n_temas)
+    ]
+    for i in range(0, len(pedidos), args.lote):
+        for q in generar(tok, modelo, pedidos[i : i + args.lote], 48, 1.0):
+            q = q.split("\n")[0].strip().strip('"«»')
+            if 8 < len(q) < 200:
+                preguntas.append(q)
+        print(f"  preguntas: {len(preguntas)}", end="\r")
+    random.shuffle(preguntas)
+
+    # 2) respuestas sencillas del maestro
+    print(f"\nEl maestro está contestando {len(preguntas)} preguntas...")
+    t0 = time.time()
+    guardadas = 0
+    with open(args.salida, "w", encoding="utf-8") as f:
+        for i in range(0, len(preguntas), args.lote):
+            trozo = preguntas[i : i + args.lote]
+            mensajes = [[{"role": "system", "content": INSTRUCCION}, {"role": "user", "content": q}] for q in trozo]
+            for q, r in zip(trozo, generar(tok, modelo, mensajes, 200, 0.7)):
+                if respuesta_valida(r):
+                    fila = {"turnos": [["usuario", q], ["asistente", r]], "maestro": args.maestro, "repetir": 2}
+                    f.write(json.dumps(fila, ensure_ascii=False) + "\n")
+                    guardadas += 1
+            hecho = i + len(trozo)
+            ritmo = hecho / (time.time() - t0)
+            print(f"  {hecho}/{len(preguntas)} | guardadas {guardadas} | faltan ~{(len(preguntas) - hecho) / ritmo / 60:.0f} min", flush=True)
+    print(f"Listo: {guardadas} conversaciones -> {args.salida}")
+
+
+if __name__ == "__main__":
+    main()

entrenamiento/modelo.py

@@ -0,0 +1,159 @@
+"""
+La red neuronal: un Transformer tipo GPT (solo decodificador), igual en esencia
+que ChatGPT / Llama, pero diminuto.
+
+Piezas modernas que usa (las mismas que Llama, Qwen, Salamandra...):
+  - RMSNorm en vez de LayerNorm
+  - RoPE (posiciones rotatorias) en la atención
+  - SwiGLU en la capa feed-forward
+  - Embeddings de entrada y salida compartidos
+"""
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint
+
+
+@dataclass
+class Config:
+    vocab: int = 8192
+    contexto: int = 512   # cuántos tokens "ve" a la vez
+    capas: int = 8
+    cabezas: int = 8
+    dim: int = 512
+
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+        self.peso = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x):
+        return self.peso * x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+
+def tabla_rope(dim_cabeza, contexto, base=10000.0):
+    frec = 1.0 / (base ** (torch.arange(0, dim_cabeza, 2).float() / dim_cabeza))
+    t = torch.arange(contexto).float()
+    angulos = torch.outer(t, frec)
+    return torch.cos(angulos), torch.sin(angulos)
+
+
+def aplicar_rope(x, cos, sin, inicio=0):
+    # x: (B, cabezas, T, dim_cabeza); inicio = posición del primer token (para la caché)
+    x1, x2 = x[..., ::2], x[..., 1::2]
+    T = x.shape[2]
+    cos, sin = cos[inicio : inicio + T].to(x.dtype), sin[inicio : inicio + T].to(x.dtype)
+    return torch.stack((x1 * cos - x2 * sin, x1 * sin + x2 * cos), dim=-1).flatten(-2)
+
+
+class Atencion(nn.Module):
+    def __init__(self, c: Config):
+        super().__init__()
+        self.cabezas = c.cabezas
+        self.qkv = nn.Linear(c.dim, 3 * c.dim, bias=False)
+        self.salida = nn.Linear(c.dim, c.dim, bias=False)
+
+    def forward(self, x, cos, sin, cache=None, inicio=0):
+        B, T, D = x.shape
+        q, k, v = self.qkv(x).split(D, dim=2)
+        q, k, v = (t.view(B, T, self.cabezas, D // self.cabezas).transpose(1, 2) for t in (q, k, v))
+        q, k = aplicar_rope(q, cos, sin, inicio), aplicar_rope(k, cos, sin, inicio)
+        if cache is not None:  # al generar: recordar k y v de los tokens anteriores
+            if "k" in cache:
+                k, v = torch.cat((cache["k"], k), dim=2), torch.cat((cache["v"], v), dim=2)
+            cache["k"], cache["v"] = k, v
+        # cada token solo mira hacia atrás (con caché y 1 token nuevo, todo lo anterior es pasado)
+        y = F.scaled_dot_product_attention(q, k, v, is_causal=T > 1)
+        return self.salida(y.transpose(1, 2).reshape(B, T, D))
+
+
+class FeedForward(nn.Module):
+    def __init__(self, c: Config):
+        super().__init__()
+        oculta = int(8 * c.dim / 3 / 64 + 0.999) * 64  # SwiGLU: ~2/3 de 4*dim
+        self.w1 = nn.Linear(c.dim, oculta, bias=False)
+        self.w3 = nn.Linear(c.dim, oculta, bias=False)
+        self.w2 = nn.Linear(oculta, c.dim, bias=False)
+
+    def forward(self, x):
+        return self.w2(F.silu(self.w1(x)) * self.w3(x))
+
+
+class Bloque(nn.Module):
+    def __init__(self, c: Config):
+        super().__init__()
+        self.norm1, self.atencion = RMSNorm(c.dim), Atencion(c)
+        self.norm2, self.ff = RMSNorm(c.dim), FeedForward(c)
+
+    def forward(self, x, cos, sin, cache=None, inicio=0):
+        x = x + self.atencion(self.norm1(x), cos, sin, cache, inicio)
+        return x + self.ff(self.norm2(x))
+
+
+class GPT(nn.Module):
+    def __init__(self, c: Config):
+        super().__init__()
+        self.config = c
+        self.embedding = nn.Embedding(c.vocab, c.dim)
+        self.bloques = nn.ModuleList(Bloque(c) for _ in range(c.capas))
+        self.norm_final = RMSNorm(c.dim)
+        self.cabeza = nn.Linear(c.dim, c.vocab, bias=False)
+        self.cabeza.weight = self.embedding.weight  # pesos compartidos
+        cos, sin = tabla_rope(c.dim // c.cabezas, c.contexto)
+        self.register_buffer("cos", cos, persistent=False)
+        self.register_buffer("sin", sin, persistent=False)
+        self.checkpointing = False  # True = ahorra memoria recalculando activaciones (para Juno)
+        self.apply(self._iniciar)
+        for nombre, p in self.named_parameters():
+            if nombre.endswith("salida.weight") or nombre.endswith("w2.weight"):
+                nn.init.normal_(p, std=0.02 / math.sqrt(2 * c.capas))
+
+    def _iniciar(self, m):
+        if isinstance(m, (nn.Linear, nn.Embedding)):
+            nn.init.normal_(m.weight, std=0.02)
+
+    def num_parametros(self):
+        return sum(p.numel() for p in self.parameters())
+
+    def forward(self, idx, objetivos=None, mascara=None, cache=None, inicio=0):
+        x = self.embedding(idx)
+        for i, b in enumerate(self.bloques):
+            if self.checkpointing and self.training:
+                x = torch.utils.checkpoint.checkpoint(b, x, self.cos, self.sin, use_reentrant=False)
+            else:
+                x = b(x, self.cos, self.sin, None if cache is None else cache[i], inicio)
+        if objetivos is None:  # generando: solo hace falta el último token
+            return self.cabeza(self.norm_final(x[:, -1:, :])), None
+        logits = self.cabeza(self.norm_final(x))
+        perdida = F.cross_entropy(logits.float().view(-1, logits.size(-1)), objetivos.view(-1), reduction="none")
+        if mascara is None:
+            return logits, perdida.mean()
+        mascara = mascara.view(-1).float()
+        return logits, (perdida * mascara).sum() / mascara.sum().clamp(min=1)
+
+    @torch.no_grad()
+    def generar(self, idx, max_tokens=200, temperatura=0.8, top_k=40, parar_en=None):
+        """Genera con caché de k/v: cada token nuevo solo procesa 1 posición."""
+        idx = idx[:, -(self.config.contexto - max_tokens) :] if max_tokens < self.config.contexto else idx[:, -1:]
+        cache = [{} for _ in self.bloques]
+        logits, _ = self(idx, cache=cache)
+        for _ in range(max_tokens):
+            logits = logits[:, -1, :].float()
+            if temperatura <= 0:
+                siguiente = logits.argmax(-1, keepdim=True)
+            else:
+                logits = logits / temperatura
+                if top_k:
+                    v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                    logits[logits < v[:, [-1]]] = -float("inf")
+                siguiente = torch.multinomial(F.softmax(logits, dim=-1), 1)
+            idx = torch.cat((idx, siguiente), dim=1)
+            if (parar_en is not None and siguiente.item() in parar_en) or idx.size(1) >= self.config.contexto:
+                break
+            logits, _ = self(siguiente, cache=cache, inicio=idx.size(1) - 1)
+        return idx

entrenamiento/preentreno_perdidas.csv

@@ -0,0 +1,189 @@
+paso,perdida_train,perdida_val,lr,tokens_por_seg
+0,,9.0940,,
+0,9.0850,,0.000005,0
+25,6.5048,,0.000130,75413
+50,4.5096,,0.000255,75410
+75,3.7175,,0.000380,75082
+100,3.1970,,0.000505,74618
+125,2.8841,,0.000630,74219
+150,2.5233,,0.000755,73884
+175,2.4021,,0.000880,73637
+200,2.4235,,0.001000,73377
+225,2.1661,,0.001000,73520
+250,,2.1816,,
+250,2.0543,,0.001000,66586
+275,1.9887,,0.000999,73255
+300,1.9894,,0.000999,73011
+325,1.9059,,0.000998,73036
+350,1.7943,,0.000997,72983
+375,1.8847,,0.000996,73106
+400,1.9629,,0.000995,73040
+425,1.8058,,0.000993,72926
+450,1.6687,,0.000991,72866
+475,1.7674,,0.000990,73170
+500,,1.7825,,
+500,1.7968,,0.000988,65951
+525,1.8742,,0.000986,73466
+550,1.7355,,0.000983,73289
+575,1.6160,,0.000981,73017
+600,1.7174,,0.000978,73102
+625,1.7388,,0.000976,73370
+650,1.7017,,0.000973,73235
+675,1.7292,,0.000970,73396
+700,1.6019,,0.000966,73536
+725,1.7276,,0.000963,73240
+750,,1.6864,,
+750,1.5838,,0.000959,65998
+775,1.6387,,0.000956,73169
+800,1.6661,,0.000952,73113
+825,1.5309,,0.000948,72931
+850,1.4915,,0.000944,72921
+875,1.6597,,0.000939,72930
+900,1.5196,,0.000935,73079
+925,1.6002,,0.000930,72819
+950,1.5956,,0.000925,72519
+975,1.6519,,0.000920,72008
+1000,,1.5787,,
+1000,1.5421,,0.000915,64758
+1025,1.5306,,0.000910,71574
+1050,1.4661,,0.000905,71333
+1075,1.5832,,0.000899,70585
+1100,1.5751,,0.000894,69174
+1125,1.5792,,0.000888,70300
+1150,1.5443,,0.000882,71428
+1175,1.5095,,0.000876,71866
+1200,1.5545,,0.000870,70214
+1225,1.5694,,0.000864,69062
+1250,,1.5390,,
+1250,1.5006,,0.000858,59647
+1275,1.6079,,0.000851,69414
+1300,1.4556,,0.000845,71129
+1325,1.5899,,0.000838,71755
+1350,1.4234,,0.000831,72148
+1375,1.4959,,0.000824,69821
+1400,1.4595,,0.000817,66873
+1425,1.5758,,0.000810,66460
+1450,1.4525,,0.000803,66149
+1475,1.5975,,0.000796,65746
+1500,,1.5019,,
+1500,1.4778,,0.000788,60166
+1525,1.5105,,0.000781,66260
+1550,1.5034,,0.000773,66121
+1575,1.4774,,0.000766,65942
+1600,1.3869,,0.000758,65197
+1625,1.5230,,0.000750,66595
+1650,1.5015,,0.000742,66147
+1675,1.4225,,0.000734,65989
+1700,1.4899,,0.000726,65969
+1725,1.3340,,0.000718,65995
+1750,,1.4575,,
+1750,1.3761,,0.000710,59339
+1775,1.5018,,0.000702,67656
+1800,1.4702,,0.000693,68379
+1825,1.3838,,0.000685,68633
+1850,1.4483,,0.000677,68443
+1875,1.4907,,0.000668,67564
+1900,1.3804,,0.000660,67034
+1925,1.4077,,0.000651,67723
+1950,1.3633,,0.000643,66967
+1975,1.4314,,0.000634,66472
+2000,,1.4411,,
+2000,1.4946,,0.000626,60696
+2025,1.4347,,0.000617,67709
+2050,1.3295,,0.000608,68321
+2075,1.4065,,0.000600,70898
+2100,1.3599,,0.000591,71519
+2125,1.4682,,0.000582,72186
+2150,1.3989,,0.000573,72880
+2175,1.4323,,0.000565,73159
+2200,1.3553,,0.000556,73265
+2225,1.3650,,0.000547,73463
+2250,,1.4254,,
+2250,1.4845,,0.000538,66730
+2275,1.4193,,0.000530,73563
+2300,1.3363,,0.000521,73255
+2325,1.3382,,0.000512,72949
+2350,1.2987,,0.000503,72934
+2375,1.3427,,0.000495,72926
+2400,1.3849,,0.000486,72840
+2425,1.3384,,0.000477,72852
+2450,1.3014,,0.000469,72667
+2475,1.3265,,0.000460,72782
+2500,,1.3695,,
+2500,1.3153,,0.000451,65614
+2525,1.3540,,0.000443,72642
+2550,1.3417,,0.000434,72112
+2575,1.2804,,0.000426,72395
+2600,1.3640,,0.000418,71662
+2625,1.4105,,0.000409,72102
+2650,1.3423,,0.000401,72229
+2675,1.3431,,0.000393,72366
+2700,1.4083,,0.000384,71821
+2725,1.2765,,0.000376,71729
+2750,,1.3753,,
+2750,1.3923,,0.000368,65470
+2775,1.3539,,0.000360,72083
+2800,1.2945,,0.000352,72185
+2825,1.3152,,0.000345,72412
+2850,1.2479,,0.000337,71987
+2875,1.2483,,0.000329,72516
+2900,1.3602,,0.000322,72591
+2925,1.3734,,0.000314,71523
+2950,1.3755,,0.000307,71717
+2975,1.2761,,0.000299,71650
+3000,,1.3465,,
+3000,1.3338,,0.000292,64222
+3025,1.3120,,0.000285,71337
+3050,1.3048,,0.000278,71339
+3075,1.3044,,0.000271,71503
+3100,1.2848,,0.000264,72611
+3125,1.3064,,0.000257,73049
+3150,1.2515,,0.000251,73280
+3175,1.2691,,0.000244,73475
+3200,1.3571,,0.000238,73609
+3225,1.2302,,0.000232,73652
+3250,,1.3669,,
+3250,1.3235,,0.000226,66927
+3275,1.2430,,0.000220,73811
+3300,1.3265,,0.000214,73714
+3325,1.3275,,0.000208,73926
+3350,1.2480,,0.000202,73830
+3375,1.3304,,0.000197,73915
+3400,1.3360,,0.000191,73796
+3425,1.2725,,0.000186,73955
+3450,1.2637,,0.000181,73976
+3475,1.3091,,0.000176,73998
+3500,,1.3474,,
+3500,1.2067,,0.000171,67073
+3525,1.3096,,0.000167,73841
+3550,1.2450,,0.000162,73923
+3575,1.2156,,0.000158,73920
+3600,1.2824,,0.000154,73903
+3625,1.2234,,0.000150,73953
+3650,1.3159,,0.000146,73837
+3675,1.3265,,0.000142,73850
+3700,1.3669,,0.000138,73873
+3725,1.3347,,0.000135,74024
+3750,,1.3053,,
+3750,1.2511,,0.000131,66805
+3775,1.3485,,0.000128,74167
+3800,1.2438,,0.000125,74111
+3825,1.2686,,0.000123,74057
+3850,1.2598,,0.000120,74134
+3875,1.3040,,0.000117,74086
+3900,1.3205,,0.000115,74100
+3925,1.2600,,0.000113,74080
+3950,1.2536,,0.000111,74104
+3975,1.3220,,0.000109,74162
+4000,,1.3467,,
+4000,1.2605,,0.000107,67438
+4025,1.2687,,0.000106,74177
+4050,1.2641,,0.000105,74142
+4075,1.2007,,0.000103,74174
+4100,1.2531,,0.000102,74030
+4125,1.2442,,0.000102,74357
+4150,1.1855,,0.000101,74050
+4175,1.1865,,0.000100,74219
+4200,1.2182,,0.000100,74088
+4225,1.2210,,0.000100,74143
+4233,,1.3103,,

entrenamiento/preparar_datos.py

@@ -0,0 +1,80 @@
+"""
+Paso 1: preparar los datos y entrenar el tokenizador.
+
+Datos de partida (ya generados por modelos GRANDES, o sea, destilación):
+  - datos/crudos/stories_*.json      -> cuentos infantiles en español escritos por Gemini 1.5 Flash
+  - datos/crudos/alpaca-gpt4-spanish.json -> preguntas y respuestas escritas por GPT-4
+
+Salida:
+  - datos/tokenizador.json                  (BPE de 8192 piezas, entrenado solo con español)
+  - datos/preentreno_train.bin / _val.bin   (tokens uint16 para el preentrenamiento)
+"""
+import glob
+import json
+import os
+import random
+
+import numpy as np
+from tokenizers import Tokenizer, decoders, models, pre_tokenizers, trainers
+
+from comun import ESPECIALES, FIN, formatear_chat
+
+random.seed(1234)
+os.makedirs("datos", exist_ok=True)
+
+# ---------------------------------------------------------------- 1) leer textos
+print("Leyendo cuentos...")
+cuentos = []
+for ruta in sorted(glob.glob("datos/crudos/stories_*.json")):
+    with open(ruta, encoding="utf-8") as f:
+        for item in json.load(f):
+            texto = item["story"].strip()
+            if len(texto) > 100:
+                cuentos.append(texto)
+print(f"  {len(cuentos):,} cuentos")
+
+print("Leyendo conversaciones de GPT-4...")
+with open("datos/crudos/alpaca-gpt4-spanish.json", encoding="utf-8") as f:
+    alpaca = json.load(f)
+chats = []
+for item in alpaca:
+    turnos = [(c["from"], c["value"].strip()) for c in item["conversations"]]
+    if all(v for _, v in turnos):
+        chats.append(formatear_chat([("usuario" if q == "human" else "asistente", v) for q, v in turnos]))
+print(f"  {len(chats):,} conversaciones")
+
+# ---------------------------------------------------------------- 2) tokenizador
+if not os.path.exists("datos/tokenizador.json"):
+    print("Entrenando tokenizador BPE (8192 piezas)...")
+    tok = Tokenizer(models.BPE())
+    tok.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False)
+    tok.decoder = decoders.ByteLevel()
+    entrenador = trainers.BpeTrainer(
+        vocab_size=8192,
+        special_tokens=ESPECIALES,
+        initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),
+        min_frequency=2,
+    )
+    muestra = random.sample(cuentos, 300_000) + chats
+    tok.train_from_iterator(muestra, trainer=entrenador)
+    tok.save("datos/tokenizador.json")
+tok = Tokenizer.from_file("datos/tokenizador.json")
+fin_id = tok.token_to_id(FIN)
+print("  ejemplo:", tok.encode("¡Hola! ¿Cómo estás? Me llamo Minerva.").tokens)
+
+# ---------------------------------------------------------------- 3) codificar
+# Preentrenamiento = cuentos + conversaciones completas (sin máscara).
+documentos = [c + FIN for c in cuentos] + chats
+random.shuffle(documentos)
+n_val = 5000
+partes = {"val": documentos[:n_val], "train": documentos[n_val:]}
+
+for nombre, docs in partes.items():
+    print(f"Codificando {nombre} ({len(docs):,} documentos)...")
+    trozos = []
+    for i in range(0, len(docs), 20_000):
+        for enc in tok.encode_batch(docs[i : i + 20_000]):
+            trozos.append(np.array(enc.ids, dtype=np.uint16))
+    arr = np.concatenate(trozos)
+    arr.tofile(f"datos/preentreno_{nombre}.bin")
+    print(f"  {len(arr):,} tokens -> datos/preentreno_{nombre}.bin")

generation_config.json

@@ -0,0 +1,14 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 0,
+  "do_sample": true,
+  "eos_token_id": 0,
+  "max_new_tokens": 200,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "pad_token_id": 0,
+  "temperature": 0.7,
+  "top_k": 30,
+  "transformers_version": "5.19.0",
+  "use_cache": true
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fb26432a3d2cc445dcb1d018f95b800664f6485097f6243bb94335791338d3e
+size 119580576

tokenizer_config.json

@@ -0,0 +1,12 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<|fin|>",
+  "eos_token": "<|fin|>",
+  "extra_special_tokens": [
+    "<|usuario|>",
+    "<|asistente|>"
+  ],
+  "model_max_length": 512,
+  "pad_token": "<|fin|>",
+  "tokenizer_class": "TokenizersBackend"
+}