File size: 13,545 Bytes
4bd8362
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · tokenizador BPE a nivel de byte, leído del propio GGUF.
// ─────────────────────────────────────────────────────────────────────────────
// El modelo no ve texto, ve enteros. Si el tokenizador difiere del que se usó
// para entrenar, el modelo recibe una secuencia que nunca ha visto y responde
// peor sin que nada falle: no hay excepción, no hay warning, solo calidad que
// baja. Es el mismo patrón de fallo silencioso que el resto del motor, así que
// se valida igual — contra el tokenizador de llama.cpp, caso por caso.
//
// Tres piezas, y las tres tienen su trampa:
//   1. PRE-TOKENIZADOR: un regex parte el texto en trozos ANTES del BPE. Es lo
//      que impide que un merge cruce la frontera entre una palabra y la
//      puntuación siguiente. Cada familia de modelos usa el suyo; usar el que
//      no es da tokenizaciones casi correctas.
//   2. MAPA BYTE→UNICODE de GPT-2: el BPE opera sobre texto, pero el vocabulario
//      cubre los 256 bytes. La tabla de OpenAI mueve los bytes no imprimibles a
//      un hueco de Unicode para que nunca aparezca un carácter de control. El
//      espacio se convierte en «Ġ», que es por qué el vocabulario está lleno de
//      ellas.
//   3. MERGES: el rango es el ORDEN en el array del GGUF. Siempre se aplica el
//      par de menor rango de toda la palabra, no el primero que se encuentre.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.

// Tipos de token de GGUF (llama_token_type).
const TYPE_NORMAL = 1, TYPE_CONTROL = 3, TYPE_USER_DEFINED = 4, TYPE_BYTE = 6;

// Tabla bytes→unicode de GPT-2. Los 188 bytes imprimibles se quedan donde
// están; los otros 68 se desplazan a partir de U+0100, donde no colisionan con
// nada real. Así una secuencia de bytes cualquiera es siempre texto válido.
function byteMaps() {
  const bs = [];
  for (let b = 33; b <= 126; b++) bs.push(b);
  for (let b = 161; b <= 172; b++) bs.push(b);
  for (let b = 174; b <= 255; b++) bs.push(b);
  const direct = new Set(bs);
  const cs = bs.slice();
  let n = 0;
  for (let b = 0; b < 256; b++) {
    if (!direct.has(b)) { bs.push(b); cs.push(256 + n); n++; }
  }
  const b2u = new Array(256);
  const u2b = new Map();
  for (let i = 0; i < bs.length; i++) {
    const ch = String.fromCodePoint(cs[i]);
    b2u[bs[i]] = ch;
    u2b.set(ch, bs[i]);
  }
  return { b2u, u2b };
}

const { b2u: BYTE_TO_UNI, u2b: UNI_TO_BYTE } = byteMaps();

// El conjunto de espacios de llama.cpp NO es el `\s` de JavaScript. Barriendo
// los 0x110000 code points difieren en DOS: U+0085 (NEL), que llama.cpp cuenta
// como espacio y JS no, y U+FEFF (BOM), al revés. Parece anecdótico y no lo es:
// un BOM al principio de un fichero cambia la tokenización de todo el trozo
// inicial. Por eso la clase va explícita y `\S` se emula negándola.
const WS = '\\t\\n\\u000B\\f\\r \\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000';

// Pre-tokenizadores por valor de `tokenizer.ggml.pre`. Parten el texto ANTES del
// BPE para que ningún merge cruce de una palabra a la puntuación siguiente.
//
// Detalles que separan «funciona» de «casi funciona»:
//   · `\p{N}` es UN dígito, no `\p{N}{1,3}`. Con el de Llama-3 todo el texto
//     normal sale bien y solo se descuadran los números — el síntoma clásico.
//   · qwen35 consume marcas combinantes junto a las letras (`[\p{L}\p{M}]+`);
//     qwen2 no. Copiar el de qwen2 da resultados idénticos en inglés y ASCII y
//     divergentes en hindi, tailandés, vietnamita o árabe vocalizado.
//   · `(?i:…)` no existe en JS y la flag `i` global NO sirve: haría insensible
//     todo el patrón. La expansión a mano es la del propio llama.cpp.
//   · El orden de las 7 alternativas es semántico (leftmost-first con
//     retroceso, no leftmost-longest). Consecuencia contraintuitiva: el prefijo
//     opcional acepta puntuación, así que «!a» es UN token, y « a» también.
const CONTRACTIONS = "(?:'[sS]|'[tT]|'[rR][eE]|'[vV][eE]|'[mM]|'[lL][lL]|'[dD])";
const TAIL = `|\\p{N}| ?[^${WS}\\p{L}%M%\\p{N}]+[\\r\\n]*|[${WS}]*[\\r\\n]+|[${WS}]+(?![^${WS}])|[${WS}]+`;

const PRE_PATTERNS = {
  qwen35: CONTRACTIONS + '|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+' + TAIL.replace('%M%', '\\p{M}'),
  qwen2: CONTRACTIONS + '|[^\\r\\n\\p{L}\\p{N}]?\\p{L}+' + TAIL.replace('%M%', ''),
};
// El de Llama-3, que es el que llama.cpp asigna a `lfm2` (LFM3 lo declara así):
// aquí los números SÍ van en grupos de hasta tres cifras, `\p{N}{1,3}`.
PRE_PATTERNS.llama3 = CONTRACTIONS + '|[^\\r\\n\\p{L}\\p{N}]?\\p{L}+' +
  TAIL.replace('|\\p{N}|', '|\\p{N}{1,3}|').replace('%M%', '');
PRE_PATTERNS.lfm2 = PRE_PATTERNS.llama3;
PRE_PATTERNS.default = PRE_PATTERNS.qwen2;

// `ignore_merges` de llama.cpp: si el trozo del pre-tokenizador ENTERO ya es un
// token, se emite tal cual sin pasar por los merges. Casi siempre da lo mismo;
// cuando no, gana el token entero, que es como se entrenó.
const IGNORA_MERGES = new Set(['llama3', 'llama-v3', 'llama-bpe', 'lfm2']);

export function createTokenizer(meta, opts = {}) {
  const tokens = meta['tokenizer.ggml.tokens'];
  const merges = meta['tokenizer.ggml.merges'];
  if (!tokens) throw new Error('el GGUF no trae tokenizer.ggml.tokens');
  const model = meta['tokenizer.ggml.model'];
  if (model !== 'gpt2') throw new Error('tokenizador no soportado: ' + model);

  const types = meta['tokenizer.ggml.token_type'];
  const preName = meta['tokenizer.ggml.pre'] || 'default';
  const pattern = opts.pattern || PRE_PATTERNS[preName] || PRE_PATTERNS.default;
  // La flag `u` es OBLIGATORIA y su ausencia no da error: sin ella `\p{L}` se
  // lee como la letra «p» seguida de «{L}», falla en silencio y produce una
  // tokenización distinta que en textos cortos parece casi bien.
  const re = new RegExp(pattern, 'gu');
  const ignoraMerges = IGNORA_MERGES.has(preName);

  const bosId = meta['tokenizer.ggml.bos_token_id'];
  const eosId = meta['tokenizer.ggml.eos_token_id'];
  const addBosDefault = meta['tokenizer.ggml.add_bos_token'] ?? false;
  const addEosDefault = meta['tokenizer.ggml.add_eos_token'] ?? false;

  // Índices perezosos: materializar 248.320 strings cuesta memoria y tiempo, y
  // para DECODIFICAR no hacen falta — el array del GGUF ya indexa por posición.
  let vocab = null;      // string → id
  let ranks = null;      // "a\u0000b" → rango
  let specials = null;   // [{text, id}] ordenados por longitud descendente

  function buildEncode() {
    if (vocab) return;
    vocab = new Map();
    for (let i = 0; i < tokens.length; i++) vocab.set(tokens.at(i), i);
    ranks = new Map();
    if (merges) {
      for (let i = 0; i < merges.length; i++) {
        const m = merges.at(i);
        // Se parte por el PRIMER espacio: las piezas no pueden contenerlo
        // (el espacio real viaja como «Ġ»), así que esto no es ambiguo.
        const sp = m.indexOf(' ');
        if (sp < 0) continue;
        ranks.set(m.slice(0, sp) + '\u0000' + m.slice(sp + 1), i);
      }
    }
    // Índice de tokens especiales por PRIMER CARÁCTER. Este vocabulario tiene
    // cientos de «[PADnnnnnn]», y recorrerlos todos en cada posición del texto
    // convertiría la codificación en cuadrática.
    specials = new Map();
    if (types) {
      for (let i = 0; i < types.length; i++) {
        const t = types[i];
        if (t !== TYPE_CONTROL && t !== TYPE_USER_DEFINED) continue;
        const text = tokens.at(i);
        if (!text) continue;
        const k = text[0];
        if (!specials.has(k)) specials.set(k, []);
        specials.get(k).push({ text, id: i });
      }
      // De mayor a menor longitud: si existieran «<|im_start|>» y «<|im|>», hay
      // que probar el largo primero o se parte el otro por la mitad.
      for (const list of specials.values()) list.sort((a, b) => b.text.length - a.text.length);
    }
  }

  // Parte el texto en trozos normales y tokens especiales literales.
  function splitSpecials(text) {
    const out = [];
    let i = 0, start = 0;
    while (i < text.length) {
      const cands = specials.get(text[i]);
      let hit = null;
      if (cands) { for (const s of cands) if (text.startsWith(s.text, i)) { hit = s; break; } }
      if (hit) {
        if (i > start) out.push({ text: text.slice(start, i) });
        out.push({ id: hit.id });
        i += hit.text.length;
        start = i;
      } else i++;
    }
    if (start < text.length) out.push({ text: text.slice(start) });
    return out;
  }

  // BPE sobre una palabra ya pasada por el mapa de bytes. Se aplica SIEMPRE el
  // par de menor rango de toda la palabra; coger el primero que se encuentre da
  // resultados distintos y plausibles.
  function bpe(word) {
    if (word.length < 2) return word;
    let parts = word.slice();
    for (;;) {
      let best = Infinity, at = -1;
      for (let i = 0; i < parts.length - 1; i++) {
        const r = ranks.get(parts[i] + '\u0000' + parts[i + 1]);
        if (r !== undefined && r < best) { best = r; at = i; }
      }
      if (at < 0) break;
      parts = parts.slice(0, at).concat(parts[at] + parts[at + 1], parts.slice(at + 2));
      if (parts.length === 1) break;
    }
    return parts;
  }

  const enc = new TextEncoder();
  const dec = new TextDecoder('utf-8');

  // Trozos del pre-tokenizador, CONSERVANDO los huecos entre coincidencias:
  // llama.cpp también los conserva, y descartarlos perdería texto en silencio.
  function preSplit(text) {
    const out = [];
    re.lastIndex = 0;
    let last = 0, m;
    while ((m = re.exec(text)) !== null) {
      if (m.index > last) out.push(text.slice(last, m.index));
      if (m[0].length === 0) { re.lastIndex++; continue; }
      out.push(m[0]);
      last = m.index + m[0].length;
    }
    if (last < text.length) out.push(text.slice(last));
    return out;
  }

  function encodeChunk(text, out) {
    for (const piece of preSplit(text)) {
      if (!piece) continue;
      // Texto → bytes UTF-8 → caracteres del mapa de GPT-2.
      const bytes = enc.encode(piece);
      const chars = new Array(bytes.length);
      for (let i = 0; i < bytes.length; i++) chars[i] = BYTE_TO_UNI[bytes[i]];
      if (ignoraMerges) {
        const entero = vocab.get(chars.join(''));
        if (entero !== undefined) { out.push(entero); continue; }
      }
      for (const p of bpe(chars)) {
        const id = vocab.get(p);
        if (id !== undefined) { out.push(id); continue; }
        // Un trozo sin entrada en el vocabulario se parte carácter a carácter:
        // el vocabulario cubre los 256 bytes, así que siempre hay salida.
        for (const ch of p) {
          const single = vocab.get(ch);
          if (single !== undefined) out.push(single);
        }
      }
    }
  }

  return {
    vocabSize: tokens.length,
    bosId, eosId, preName,

    // `special: false` desactiva el reconocimiento de tokens de control en el
    // texto de entrada — útil para no dejar que un usuario inyecte «<|im_end|>»
    // escribiéndolo a mano.
    encode(text, { addBos = addBosDefault, addEos = addEosDefault, special = true } = {}) {
      buildEncode();
      const out = [];
      if (addBos && bosId !== undefined) out.push(bosId);

      if (special && specials.size) {
        for (const part of splitSpecials(text)) {
          if (part.id !== undefined) out.push(part.id);
          else encodeChunk(part.text, out);
        }
      } else {
        encodeChunk(text, out);
      }

      if (addEos && eosId !== undefined) out.push(eosId);
      return out;
    },

    // ids → texto. No necesita el índice de codificación, así que decodificar
    // un modelo recién cargado no paga la construcción del mapa de 248k.
    decode(ids) {
      let s = '';
      for (const id of ids) {
        if (id < 0 || id >= tokens.length) continue;
        s += tokens.at(id);
      }
      const bytes = new Uint8Array(s.length * 4);
      let n = 0;
      for (const ch of s) {
        const b = UNI_TO_BYTE.get(ch);
        if (b !== undefined) { bytes[n++] = b; continue; }
        // Un carácter fuera del mapa (token especial escrito literal) se
        // devuelve tal cual en UTF-8.
        for (const x of enc.encode(ch)) bytes[n++] = x;
      }
      return dec.decode(bytes.subarray(0, n));
    },

    // Los BYTES de un token (lo que `decode` concatena antes de pasar a UTF-8).
    // Para decodificar en streaming sin redecodificar toda la salida en cada paso.
    bytesDe(id) {
      if (id < 0 || id >= tokens.length) return new Uint8Array(0);
      const s = tokens.at(id);
      const out = [];
      for (const ch of s) {
        const b = UNI_TO_BYTE.get(ch);
        if (b !== undefined) out.push(b); else for (const x of enc.encode(ch)) out.push(x);
      }
      return Uint8Array.from(out);
    },

    // El texto de UN token, para emitir en streaming. Ojo: un token puede
    // cortar un carácter multibyte por la mitad, así que quien haga streaming
    // tiene que acumular bytes, no strings.
    tokenText(id) { return tokens.at(id); },
    tokenType(id) { return types ? types[id] : TYPE_NORMAL; },
    isControl(id) { return types ? types[id] === TYPE_CONTROL : false; },
  };
}

export { TYPE_NORMAL, TYPE_CONTROL, TYPE_USER_DEFINED, TYPE_BYTE };