File size: 8,701 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
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · muestreo sobre CANDIDATOS: lo que `sample()` necesita ver.
// ─────────────────────────────────────────────────────────────────────────────
// En cada token se traía el vocabulario ENTERO a la CPU para que `sample()` se
// quedara con unas decenas de logits. Esto decide CUÁLES bastan, para que el
// dispositivo (`ops.topk.js`) devuelva solo esos, y luego llama al MISMO
// `sample()` de siempre sobre ese puñado. Exacto, no aproximado: mismo token, bit a bit, que
// el camino de siempre. El porqué, en tres pasos:
//
//   1. Lo que mira `sample()`. Primero penaliza los ids de la ventana reciente
//      (S, como mucho `repeatLastN` ids distintos) y después solo usa los K'
//      primeros en el orden «logit mayor primero; a igualdad, índice menor»:
//      K' = 1 en voraz (el argmax con `>` estricto se queda con el primero de
//      los empatados) y K' = topK con temperatura. Top-p, min-p y la
//      temperatura solo leen esos K' valores. Nada más del vector influye.
//   2. Por qué basta el top-(K'+|S|) CRUDO más S. La penalización solo cambia
//      los logits de S —puede bajar uno de arriba (divide los positivos y
//      multiplica los negativos) y dejar entrar a otro—, y fuera de S el
//      orden entre dos ids no cambia. Sea j uno de los K' primeros DESPUÉS de
//      penalizar, con j fuera de S: tiene delante, como mucho, K'−1 ids de
//      fuera de S —que en crudo siguen delante de j— más los |S| de S. O sea
//      que en crudo va como mucho en el puesto K'+|S|, y está en el top-(K'+|S|).
//      Los de S van aparte, con su valor crudo, y la penalización se la pone el
//      propio `sample()`.
//   3. Por qué `sample()` sobre el puñado da lo mismo que sobre el vector. Los
//      candidatos se ordenan por id ASCENDENTE: así «índice menor» significa lo
//      mismo en el puñado y en el vocabulario, y los empates se deshacen igual.
//      Los K' primeros de un superconjunto de los K' primeros son esos mismos,
//      en el mismo orden y con los mismos valores f32 (los bits los copia el
//      dispositivo tal cual). Las penalizaciones se aplican con la misma aritmética
//      sobre un Float32Array, igual que antes. Mismo orden de operaciones,
//      mismos números: mismo token.
//
// Lo que NO se hace aquí y por qué se cae al camino de siempre (`null`):
//   · temperatura > 0 sin top-k: `sample()` se queda con todo lo que está a
//     menos de 40 del máximo, y eso no tiene tope;
//   · un id de la ventana que no es entero (no pasa con fichas de verdad, pero
//     `sample()` haría con él cosas que un puñado no reproduce);
//   · más candidatos de los que caben (top-k grande o ventana larga);
//   · NaN en los logits: el orden con NaN depende de la posición en el vector y
//     no se puede reproducir con un trozo (lo detecta el kernel y lo avisa);
//   · una penalización que puede FABRICAR un NaN: factor NaN, ±∞ o 0 (0·∞,
//     −∞·0) o presencia ±∞ (∞−∞). Con factor finito y no nulo y presencia
//     finita, un logit que no es NaN no se vuelve NaN, y el paso 2 vale.
//
// Módulo PURO: sin WebGPU, para poder probarlo en Node contra `sample()`.
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.
import { sample } from './sample.js';
// Topes del contrato con los kernels: sitio para TOPK_CAP candidatos y
// TOPK_P_MAX ids penalizados. Los kernels devuelven EXACTAMENTE los M primeros
// (los empates se deshacen por índice), así que basta con M ≤ TOPK_M_MAX.
import { TOPK_M_MAX, TOPK_P_MAX, TOPK_CAP, TOPK_CABECERA } from './kernels.topk.wgsl.js';

// Qué candidatos hacen falta para este paso, o null si este muestreo no se
// puede hacer con un puñado. `previosA` y `previosB` son las dos mitades de la
// ventana (prompt y lo ya emitido): se recorren como si estuvieran concatenadas,
// sin concatenarlas, que era un coste lineal en el contexto en cada token.
//
// Los valores por defecto son LOS DE `sample()`: si cambian allí tienen que
// cambiar aquí, o el puñado se elegiría con otra ventana u otro K'.
export function planTopK(vocab, opts = {}, previosA = null, previosB = null) {
  const { temperature = 0, topK = 0, repeatPenalty = 1.1, repeatLastN = 64, presence = 0 } = opts;
  if (!(vocab >= 1)) return null;
  let K;
  if (temperature <= 0) K = 1;
  else if (topK > 0 && Number.isInteger(topK)) K = Math.min(topK, vocab);
  else return null;

  const a = previosA || [], b = previosB || [];
  const largo = a.length + b.length;
  // La MISMA condición que `sample()`, con el mismo `previos.length`.
  const penaliza = !!(largo && (repeatPenalty !== 1 || presence));
  const ventana = [];
  const S = [];
  if (penaliza) {
    // El MISMO bucle que `sample()`: mismo `desde` (que puede no ser entero si
    // `repeatLastN` no lo es) y mismos índices.
    const desde = Math.max(0, largo - repeatLastN);
    const vistos = new Set();
    for (let i = desde; i < largo; i++) {
      const id = i < a.length ? a[i] : b[i - a.length];
      if (!Number.isInteger(id)) return null;
      ventana.push(id);
      if (id >= 0 && id < vocab && !vistos.has(id)) { vistos.add(id); S.push(id); }
    }
  }
  if (S.length > TOPK_P_MAX) return null;
  // Las MISMAS dos condiciones con las que `sample()` aplica cada penalización.
  if (S.length && ((repeatPenalty !== 1 && !(Number.isFinite(repeatPenalty) && repeatPenalty !== 0)) ||
      (presence && !Number.isFinite(presence)))) return null;
  const M = K + S.length;
  if (M > TOPK_M_MAX) return null;
  return { vocab, K, M, S: Uint32Array.from(S), penaliza, ventana };
}

// Lo que dejó el kernel final (`u`, u32 con la disposición de
// `kernels.topk.wgsl.js`), o { motivo } si hay que leer el vector entero.
// `serie` es el número de la llamada: si la cabecera trae otro, lo leído es de
// una llamada anterior (el envío no llegó a ejecutarse) y no vale.
export function leeSalidaTopK(u, plan, trozos, serie = undefined) {
  if (serie !== undefined && u[4] !== serie) return { motivo: 'serie' };
  const n = u[0], avisos = u[1];
  if (avisos !== 0) return { motivo: avisos & 2 ? 'NaN' : 'no cupo' };
  if (u[2] !== plan.S.length || u[3] !== trozos || n > TOPK_CAP) return { motivo: 'cabecera' };
  const ini = TOPK_CABECERA + TOPK_P_MAX;
  const ids = new Uint32Array(n), bits = new Uint32Array(n);
  for (let q = 0; q < n; q++) { ids[q] = u[ini + 2 * q]; bits[q] = u[ini + 2 * q + 1]; }
  return { ids, bits, bitsS: u.slice(TOPK_CABECERA, TOPK_CABECERA + plan.S.length) };
}

// El token, a partir de lo que devolvieron los kernels. `ids`/`bits` son los
// candidatos (bits f32 crudos) y `bitsS` los logits crudos de `plan.S`, en su
// orden. Devuelve null si lo recibido no es coherente (y entonces se lee el
// vector entero): mejor un token lento que uno inventado.
export function muestraCandidatos(plan, ids, bits, bitsS, opts = {}) {
  const n = ids.length;
  if (bits.length !== n || bitsS.length !== plan.S.length) return null;
  if (n < Math.min(plan.M, plan.vocab)) return null;
  const porId = new Map();
  for (let q = 0; q < n; q++) {
    const id = ids[q];
    // Un id fuera del vocabulario o repetido no sale de unos kernels sanos.
    if (id >= plan.vocab || porId.has(id)) return null;
    porId.set(id, bits[q]);
  }
  for (let i = 0; i < plan.S.length; i++) {
    const id = plan.S[i], prev = porId.get(id);
    if (prev !== undefined && prev !== bitsS[i]) return null;
    porId.set(id, bitsS[i]);
  }
  // Por id ascendente: el desempate por índice tiene que significar lo mismo
  // aquí que en el vocabulario entero.
  const orden = Uint32Array.from(porId.keys()).sort();
  const sub = new Float32Array(orden.length);
  const subBits = new Uint32Array(sub.buffer);
  const pos = new Map();
  for (let j = 0; j < orden.length; j++) {
    subBits[j] = porId.get(orden[j]);
    pos.set(orden[j], j);
  }
  // La ventana con las posiciones del puñado, en el MISMO orden. Los ids fuera
  // del vocabulario van a −1, que `sample()` se salta igual que se los saltaba.
  // Su longitud no pasa de `repeatLastN`, así que `sample()` la recorre entera.
  let previos = null;
  if (plan.penaliza) {
    previos = new Array(plan.ventana.length);
    for (let i = 0; i < plan.ventana.length; i++) {
      const p = pos.get(plan.ventana[i]);
      previos[i] = p === undefined ? -1 : p;
    }
  }
  const j = sample(sub, { ...opts, previos });
  return orden[j];
}