Spaces:
Running
Running
Download js/engine/hadamard.js from UtopiaIA/elffuss-code: direct link, hf CLI and curl.
- Browser
- Download file 4.22 kB
-
https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/hadamard.js
- Command line
-
hf download hf://spaces/UtopiaIA/elffuss-code/js/engine/hadamard.js
-
curl -L -o hadamard.js https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/hadamard.js
4.22 kB
| // SPDX-License-Identifier: Apache-2.0 | |
| // Copyright (c) 2026 UtopiaIA | |
| // Rotación de Hadamard declarada por el fichero: qué tensores la llevan y cómo. | |
| // ───────────────────────────────────────────────────────────────────────────── | |
| // Algunos modelos ternarios guardan los pesos en una base girada y declaran la | |
| // rotación en sus metadatos. Un runtime que la ignore NO falla: carga, ejecuta y | |
| // genera ruido — comprobado, produce tokens plausibles y texto sin sentido. Por | |
| // eso esto se decide a partir de lo que dice el FICHERO y nunca se deduce: | |
| // | |
| // · `weight_names` enumera, uno a uno, los 401 tensores cuya entrada hay que | |
| // girar. No se adivina por el nombre ni por la forma. | |
| // · `sign_widths` / `sign_values` traen un vector de signos por anchura de | |
| // entrada, concatenados. Se elige por la anchura del tensor. | |
| // · `inverse_weight_names` son las tablas que guardan las filas ya giradas y | |
| // hay que DESgirar tras la búsqueda. | |
| // | |
| // Si el fichero declara una versión o una transformada que no conocemos, esto | |
| // LANZA en vez de seguir. Es la única respuesta honesta: continuar significaría | |
| // devolver ruido con cara de respuesta. | |
| // | |
| // Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). | |
| const CLAVE = 'prism.hadamard.'; | |
| // Los arrays de CADENAS del GGUF no son arrays: el parser los devuelve | |
| // perezosos ({length, at(i), toArray()}) para no materializar 248.000 tokens de | |
| // vocabulario cada vez que alguien mira los metadatos. Los de escalares sí son | |
| // vistas tipadas y se iteran solos. Un `new Set(...)` sobre el perezoso no | |
| // lanza nada legible — dice «object is not iterable» — así que se normaliza | |
| // aquí, en un sitio, en vez de esparcir la comprobación. | |
| const lista = (v) => { | |
| if (v == null) return []; | |
| if (typeof v.toArray === 'function') return v.toArray(); | |
| if (Array.isArray(v) || ArrayBuffer.isView(v)) return Array.from(v); | |
| throw new Error('se esperaba una lista en los metadatos de la rotación'); | |
| }; | |
| export function leeRotacion(meta) { | |
| const v = meta[CLAVE + 'version']; | |
| if (v === undefined) return null; // modelo sin rotación: normal | |
| if (v !== 1) throw new Error(`rotación de Hadamard versión ${v}: no soportada`); | |
| const transformada = meta[CLAVE + 'transform']; | |
| if (transformada !== 'normalized-sylvester-walsh-hadamard') { | |
| throw new Error(`transformada desconocida: «${transformada}»`); | |
| } | |
| const eje = meta[CLAVE + 'axis']; | |
| if (eje !== 'input-last-dimension') throw new Error(`eje de rotación desconocido: «${eje}»`); | |
| const modo = meta[CLAVE + 'sign_mode']; | |
| if (modo !== 'explicit') throw new Error(`modo de signos desconocido: «${modo}»`); | |
| const bloque = Number(meta[CLAVE + 'block_size']); | |
| if (!bloque || (bloque & (bloque - 1)) !== 0) { | |
| throw new Error(`bloque de rotación inválido: ${bloque}`); | |
| } | |
| const pesos = new Set(lista(meta[CLAVE + 'weight_names'])); | |
| if (!pesos.size) throw new Error('la rotación no declara ningún tensor'); | |
| const inversos = new Set(lista(meta[CLAVE + 'inverse_weight_names'])); | |
| // Los signos vienen concatenados por anchura, en el orden de `sign_widths`. | |
| const anchuras = lista(meta[CLAVE + 'sign_widths']).map(Number); | |
| const valores = lista(meta[CLAVE + 'sign_values']); | |
| const signos = new Map(); | |
| let o = 0; | |
| for (const a of anchuras) { | |
| if (a <= 0 || a % bloque !== 0) throw new Error(`anchura de signos inválida: ${a}`); | |
| const v = new Float32Array(a); | |
| for (let i = 0; i < a; i++) { | |
| const s = Number(valores[o + i]); | |
| if (s !== 1 && s !== -1) throw new Error(`signo que no es ±1 en la posición ${o + i}: ${s}`); | |
| v[i] = s; | |
| } | |
| signos.set(a, v); | |
| o += a; | |
| } | |
| if (o !== valores.length) { | |
| throw new Error(`sobran o faltan signos: ${valores.length} valores para ${o} declarados`); | |
| } | |
| return { | |
| bloque, pesos, inversos, signos, | |
| vGrouped: meta[CLAVE + 'gdn_v_grouped'] === true, | |
| // Cuántos tensores declara, para poder comprobar que se aplicaron todos. | |
| total: pesos.size + inversos.size, | |
| }; | |
| } | |