Franok / source /web /reader.mjs
yunusemrejr's picture
Publish source, film and evaluations from 699be55df232
2bff5be verified
Raw History Blame Contribute Delete
7.4 kB
// A separate learned head scores contiguous source spans using Franok's normalized decoder states.
const utf8 = new TextEncoder();
const decoder = new TextDecoder('utf-8', { fatal: true });
export async function createReadout(wasm, buffer, config) {
const bytes = new Uint8Array(buffer);
const size = Number(new DataView(bytes.buffer, bytes.byteOffset).getBigUint64(0, true));
if (!Number.isSafeInteger(size) || size < 2 || size + 8 > bytes.length)
throw Error('Invalid passage-reader weights.');
const header = JSON.parse(decoder.decode(bytes.subarray(8, 8 + size)));
const { instance } = await WebAssembly.instantiate(wasm, { math: { exp: Math.exp } });
const w = instance.exports;
const base = Number(w.__heap_base.value);
const raw = bytes.subarray(8 + size);
const inp = Math.ceil((base + raw.length) / 16) * 16;
const dimension = Math.max(config.width, config.hidden * 2, config.max_span);
const out = inp + dimension * 4;
const end = out + dimension * 4;
w.memory.grow(Math.max(0, Math.ceil((end - w.memory.buffer.byteLength) / 65536)));
new Uint8Array(w.memory.buffer, base).set(raw);
const floats = new Float32Array(w.memory.buffer);
const tensors = new Map();
for (const [name, tensor] of Object.entries(header)) {
if (name === '__metadata__') continue;
const [a, b] = tensor.data_offsets;
if (
tensor.dtype !== 'F32' ||
!Number.isSafeInteger(a) ||
!Number.isSafeInteger(b) ||
a % 4 ||
a < 0 ||
b > raw.length ||
b - a !== tensor.shape.reduce((n, d) => n * d, 4)
)
throw Error('Invalid passage-reader tensor ' + name);
tensors.set(name, {
shape: tensor.shape,
ptr: base + a,
values: floats.subarray((base + a) / 4, (base + b) / 4),
});
}
const tensor = (name) => {
const x = tensors.get(name);
if (!x) throw Error('Missing passage-reader tensor ' + name);
return x;
};
function linear(name, x) {
const mat = tensor(name + '.weight'),
[rows, cols] = mat.shape;
if (cols !== x.length || cols > dimension || rows > dimension)
throw Error('Passage-reader dimensions disagree.');
floats.set(x, inp / 4);
w.linear_f32(mat.ptr, inp, tensors.get(name + '.bias')?.ptr || 0, out, rows, cols);
return floats.slice(out / 4, out / 4 + rows);
}
return { config, linear, values: (name) => tensor(name).values };
}
function similarity(a, b) {
let sum = 0;
for (let i = 0; i < a.length; i++) sum += a[i] * b[i];
return sum;
}
export function scoreSpan(readout, states, offset, legal) {
const { linear, values, config } = readout,
{ hidden, max_span: maxSpan } = config;
const q = states[offset - 1];
const question = linear('question', q);
const keys = states.slice(3, offset - 2).map((h) => linear('query_token', h).map(Math.tanh));
const features = states.map((h) => {
const p = linear('passage_token', h).map(Math.tanh);
const att = keys.map((k) => similarity(p, k) / Math.sqrt(hidden));
const peak = Math.max(...att);
const mass = att.map((v) => Math.exp(v - peak)),
total = mass.reduce((a, b) => a + b, 0);
const pair = new Float32Array(hidden * 2);
for (let i = 0; i < keys.length; i++) {
const weight = mass[i] / total;
for (let j = 0; j < hidden; j++) pair[j] += weight * keys[i][j];
}
for (let j = 0; j < hidden; j++) pair[hidden + j] = pair[j] * p[j];
const aligned = linear('fuse', pair),
product = linear(
'product',
h.map((v, j) => v * q[j]),
);
return linear('text', h).map((v, j) => Math.tanh(v + question[j] + product[j] + aligned[j]));
});
const wide = values('wide.weight'),
near = values('near.weight');
const nearBias = values('near.bias'),
wideBias = values('wide.bias');
const context = features.map((f, i) => {
const local = new Float32Array(hidden);
for (let d = 0; d < hidden; d++) {
let x = nearBias[d] + wideBias[d];
for (let k = 0; k < 5; k++) if (features[i + k - 2]) x += near[5 * d + k] * features[i + k - 2][d];
for (let k = 0; k < 3; k++)
if (features[i + 4 * (k - 1)]) x += wide[3 * d + k] * features[i + 4 * (k - 1)][d];
local[d] = x;
}
return linear('mix', local).map((v, d) => f[d] + Math.tanh(v));
});
const source = context.slice(offset, -1),
mean = new Float32Array(hidden);
const starts = source.map((h) => linear('start', h)[0]);
let best = -Infinity,
from = -1,
through = -1;
source.forEach((h, j) => {
const end = linear('end', h)[0],
length = linear('length', h);
for (let d = 0; d < hidden; d++) mean[d] += h[d] / source.length;
if (!legal[j + 1]) return;
for (let delta = 0; delta < Math.min(maxSpan, j + 1); delta++) {
const i = j - delta;
if (!legal[i]) continue;
const val = end + starts[i] + length[delta];
if (val > best) {
best = val;
from = i;
through = j;
}
}
});
const none = linear('null', context.at(-1))[0] + linear('absence', mean)[0];
return { from, through, margin: best - none };
}
export function readPassage(model, tok, head, question, passage, lang, progress = () => {}) {
const questionIds = tok.encode(question.trim()),
ids = tok.encode(passage);
if (!questionIds.length || !ids.length) throw Error('Supply a question and a passage.');
const prefix = [1, lang === 'tr' ? 6 : 5, 3, ...questionIds, 2, 3];
const room = model.c.window - prefix.length - 1,
overlap = head.config.max_span;
if (room < overlap + 8) throw Error('Shorten the question to leave room for the passage.');
const raw = utf8.encode(passage),
offsets = [0];
for (const id of ids) offsets.push(offsets.at(-1) + tok.pieces[id].length);
if (offsets.at(-1) !== raw.length) throw Error('Passage offsets do not match the source text.');
const legal = offsets.map((n) => n === raw.length || (raw[n] & 192) !== 128);
let start = 0,
windows = 0,
best = null;
while (start < ids.length) {
let stop = Math.min(ids.length, start + room);
while (!legal[stop]) stop--;
model.reset();
const states = [];
for (const id of [...prefix, ...ids.slice(start, stop), 4]) {
model.step(id, false);
states.push(model.hidden());
if (states.length % 32 === 0)
progress(Math.min(ids.length, start + Math.max(0, states.length - prefix.length)), ids.length);
}
const { from, through, margin } = scoreSpan(head, states, prefix.length, legal.slice(start, stop + 1));
if (from >= 0 && (!best || margin > best.margin)) {
const a = offsets[start + from],
b = offsets[start + through + 1];
const text = decoder.decode(raw.subarray(a, b)),
quote = text.trim();
if (quote) {
const startByte = a + utf8.encode(text.slice(0, text.length - text.trimStart().length)).length;
best = { quote, startByte, endByte: startByte + utf8.encode(quote).length, margin };
}
}
windows++;
if (stop === ids.length) break;
start = stop - overlap;
while (!legal[start]) start--;
}
const accepted = !!best && best.margin >= head.config.threshold;
return {
accepted,
windows,
quote: accepted ? best.quote : '',
startByte: accepted ? best.startByte : null,
endByte: accepted ? best.endByte : null,
margin: best?.margin ?? null,
tokens: ids.length,
};
}