Download app.js from optimum-internal-testing/torch-neuronx-model-support: direct link, hf CLI and curl.
- Browser
- Download file 28.6 kB
-
https://huggingface.co/spaces/optimum-internal-testing/torch-neuronx-model-support/resolve/main/app.js
- Command line
-
hf download hf://spaces/optimum-internal-testing/torch-neuronx-model-support/app.js
-
curl -L -o app.js https://huggingface.co/spaces/optimum-internal-testing/torch-neuronx-model-support/resolve/main/app.js
28.6 kB
| // Lists the support results of the aws-neuron/torch-neuronx-model-support | |
| // dataset, one tab per library, 100 models per page: for the models the latest | |
| // sweep selected, or for the Hub's models by trending score or downloads. A last | |
| // tab shows the status of the sweep of each pod to the members of aws-neuron who | |
| // sign in. | |
| import { parquetReadObjects } from "https://cdn.jsdelivr.net/npm/hyparquet@1.31.2/src/index.js"; | |
| const HUB = "https://huggingface.co"; | |
| // ?branch=<name> shows what a checkout of that branch of the sweep publishes: | |
| // the branch of that name in the test dataset. main is the public dataset. | |
| const BRANCH = new URLSearchParams(location.search).get("branch") ?? "main"; | |
| const DATASET = BRANCH === "main" ? "aws-neuron/torch-neuronx-model-support" | |
| : "optimum-internal-testing/torch-neuronx-model-support"; | |
| const NEFF_CACHE = "hf://buckets/aws-neuron/torch-neuronx-neff-cache"; | |
| const LIBRARIES = ["transformers", "diffusers", "sentence-transformers"]; | |
| const VIEWS = { selected: "Selected", trending: "Trending", downloads: "Downloads" }; | |
| // The task Trending and Downloads open on, by library: all tasks would open on models the sweep never tests. | |
| const DEFAULT_TASKS = { transformers: "text-generation", diffusers: "text-to-image" }; | |
| // The Hub's sort, and model field, of each view but "selected". | |
| const HUB_SORTS = { trending: "trendingScore", downloads: "downloads" }; | |
| const PAGE = 100; | |
| // The test instances: 4 devices of their target, with the HBM of one device. | |
| const DEVICES = 4; | |
| const TARGETS = { | |
| trn2: { name: "Trainium2", deviceHbm: 96 * 1024 ** 3 }, | |
| trn3: { name: "Trainium3", deviceHbm: 144 * 1024 ** 3 }, | |
| }; | |
| const COLUMNS = ["model_id", "cores", "result", "Memory (GB)", "notes"]; | |
| const TOOLTIPS = { | |
| "Memory (GB)": "The run's peak device memory (HBM), summed over its NeuronCores," | |
| + " out of the HBM of those NeuronCores, in GiB", | |
| }; | |
| // The status of the sweep of each pod, which it writes every minute to a private | |
| // bucket of aws-neuron, one file per host: only the members of the organization | |
| // can read it, once signed in. | |
| const STATUS_TAB = "Sweep status"; | |
| const STATUS_BUCKET = "aws-neuron/torch-neuronx-sweep-status"; | |
| const AWS_NEURON_ID = "6438282a1ee0e43f14d82144"; | |
| const HUB_JS = "https://cdn.jsdelivr.net/npm/@huggingface/hub@2.17.10/+esm"; | |
| const SIGN_IN = "sweep-status:sign-in"; | |
| const STATUS_REFRESH = 60 * 1000; | |
| // A scheduled sweep whose status is older stopped writing it. | |
| const STALE = 5 * 60 * 1000; | |
| // A pod that has not written its status for longer is gone, or paused that long. | |
| const GONE = 24 * 60 * 60 * 1000; | |
| // An element with attributes and children. Strings become text nodes, never HTML. | |
| function h(tag, attrs = {}, ...children) { | |
| const el = document.createElement(tag); | |
| for (const [key, value] of Object.entries(attrs)) { | |
| if (key.startsWith("on")) el.addEventListener(key.slice(2), value); | |
| else if (value === true) el.setAttribute(key, ""); | |
| else if (value !== false && value != null) el.setAttribute(key, value); | |
| } | |
| el.append(...children.flat(Infinity).filter((c) => c != null && c !== false)); | |
| return el; | |
| } | |
| const encodePath = (path) => path.split("/").map(encodeURIComponent).join("/"); | |
| async function fetchOk(url, options) { | |
| const response = await fetch(url, options); | |
| if (!response.ok) throw new Error(`${url}: HTTP ${response.status}`); | |
| return response; | |
| } | |
| // Promises by key, dropped on failure so that the next render retries. | |
| const cache = new Map(); | |
| function cached(key, load) { | |
| if (!cache.has(key)) cache.set(key, load().catch((e) => { cache.delete(key); throw e; })); | |
| return cache.get(key); | |
| } | |
| // The files of the dataset's branch at its latest commit: one per target and | |
| // (neuronx-cc, library version) pair. The file of a library other than | |
| // transformers also names the transformers version its runs pin. A file | |
| // directly under data/ predates the target level and holds trn2 runs. | |
| async function loadIndex() { | |
| const info = await (await fetchOk(`${HUB}/api/datasets/${DATASET}/revision/${encodeURIComponent(BRANCH)}`)).json(); | |
| const pairs = []; | |
| for (const { rfilename: path } of info.siblings) { | |
| const pair = path.match(/^data\/(?:([^/]+)\/)?neuronxcc-([^/]+)\/(.+?)-([^-/]+)(?:-transformers-([^-/]+))?\.parquet$/); | |
| if (pair) { | |
| pairs.push({ target: pair[1] ?? "trn2", sdk: pair[2], library: pair[3], version: pair[4], transformers: pair[5], path }); | |
| } | |
| } | |
| return { sha: info.sha, pairs }; | |
| } | |
| const index = await loadIndex().catch((e) => e); | |
| const fileUrl = (path) => `${HUB}/datasets/${DATASET}/resolve/${index.sha}/${encodePath(path)}`; | |
| // A pair's rows: its runs, the models its sweep left out, and each model's rank | |
| // in the selection of its last sweep, best-ranked first. | |
| const loadRows = (path) => cached(path, async () => { | |
| // The images are bytes: only the columns the file declares as strings decode as text. | |
| const rows = await parquetReadObjects({ file: await (await fetchOk(fileUrl(path))).arrayBuffer(), utf8: false }); | |
| const ranked = rows.filter((row) => row.selection_rank != null) | |
| .sort((a, b) => a.selection_rank - b.selection_rank); | |
| return { | |
| runs: rows.filter((row) => row.result !== "EXCLUDED"), | |
| exclusions: new Map(rows.filter((row) => row.result === "EXCLUDED").map((row) => [row.model_id, row])), | |
| selection: new Map(ranked.map((row) => [row.model_id, row.selection_rank])), | |
| }; | |
| }); | |
| // A model's task on the Hub, or "unknown" if the Hub no longer has it. | |
| const loadTask = (id) => cached(`task:${id}`, async () => { | |
| const query = new URLSearchParams({ "expand[]": "pipeline_tag" }); | |
| const response = await fetch(`${HUB}/api/models/${encodePath(id)}?${query}`); | |
| if (response.status === 404) return "unknown"; | |
| if (!response.ok) throw new Error(`${id}: HTTP ${response.status}`); | |
| return (await response.json()).pipeline_tag ?? "unknown"; | |
| }).catch(() => "unknown"); | |
| // The models of a library, of a task unless it is null, and whose id contains | |
| // `name` unless it is empty, in the order of the Hub's model list, with their | |
| // parameter count when the Hub knows it: at least `count` of them, or all if it | |
| // has fewer. `next` is the Hub's link to the models after them, if any. The list | |
| // grows one Hub page at a time, as deep as it was asked for. | |
| const hubLists = new Map(); | |
| function hubList(library, task, name, view, count) { | |
| const key = `${library}:${task}:${name}:${view}`; | |
| const sort = HUB_SORTS[view]; | |
| if (!hubLists.has(key)) { | |
| // The Hub's model list ignores library=. filter= lists the models with the library's tag. | |
| const query = new URLSearchParams({ filter: library, sort, direction: "-1", limit: PAGE }); | |
| if (task) query.set("pipeline_tag", task); | |
| if (name) query.set("search", name); | |
| for (const field of [sort, "safetensors", "library_name"]) query.append("expand[]", field); | |
| hubLists.set(key, { models: [], next: `${HUB}/api/models?${query}`, growing: Promise.resolve() }); | |
| } | |
| const list = hubLists.get(key); | |
| list.growing = list.growing.catch(() => {}).then(async () => { | |
| while (list.models.length < count && list.next) { | |
| const response = await fetchOk(list.next); | |
| list.models.push(...(await response.json()) | |
| // The Hub's library filter matches a tag that models of other libraries | |
| // carry too, such as diffusers' FLUX or sentence-transformers' MiniLM. | |
| .filter((model) => model.library_name === library) | |
| .map((model) => ({ id: model.id, score: model[sort] ?? 0, params: model.safetensors?.total }))); | |
| list.next = response.headers.get("Link")?.match(/<([^>]+)>;\s*rel="next"/)?.[1]; | |
| } | |
| }); | |
| return list.growing.then(() => list); | |
| } | |
| // Newest first. A version that is not a release, such as a git commit pin, | |
| // comes before the releases. | |
| function newestFirst(a, b) { | |
| const release = (v) => v.match(/^\d+(?:\.\d+)+/)?.[0].split(".").map(Number); | |
| const [ra, rb] = [release(a), release(b)]; | |
| if (!ra || !rb) return Boolean(ra) - Boolean(rb) || a.localeCompare(b); | |
| for (let i = 0; i < Math.max(ra.length, rb.length); i++) { | |
| const d = (rb[i] ?? 0) - (ra[i] ?? 0); | |
| if (d) return d; | |
| } | |
| // A pre-release, such as 5.21.0rc1, is older than its release. | |
| const pre = (v) => /^\d+(?:\.\d+)+(?:a|b|rc|\.?dev)/.test(v); | |
| return pre(a) - pre(b); | |
| } | |
| const badge = (result) => `${result === "PASS" ? "✅" : "❌"} ${result}`; | |
| const memory = (run) => run.hbm_peak_gb == null ? "" | |
| : `${run.hbm_peak_gb.toFixed(2)} / ${Number(run.hbm_capacity_gb.toFixed(1))}`; | |
| const day = (date) => new Date(date).toISOString().slice(0, 10); | |
| const tabs = document.getElementById("tabs"); | |
| const panel = document.getElementById("panel"); | |
| const dialog = document.getElementById("run"); | |
| const state = new Map(LIBRARIES.map((library) => | |
| [library, { view: "selected", target: null, sdk: null, version: null, tasks: {}, names: {}, page: 1 }])); | |
| let active = LIBRARIES[0]; | |
| let rendering = 0; | |
| // The pending list render of the name being typed. | |
| let typing; | |
| function renderTabs() { | |
| tabs.replaceChildren(...[...LIBRARIES, STATUS_TAB].map((tab) => h("button", { | |
| role: "tab", | |
| "aria-selected": String(tab === active), | |
| onclick: () => { active = tab; renderTabs(); renderPanel(); }, | |
| }, tab))); | |
| } | |
| async function renderPanel() { | |
| const render = ++rendering; | |
| clearTimeout(typing); | |
| if (active === STATUS_TAB) { | |
| renderStatus(render); | |
| return; | |
| } | |
| if (index instanceof Error) { | |
| panel.replaceChildren(h("p", { class: "status" }, `Could not read the dataset: ${index.message}`)); | |
| return; | |
| } | |
| const all = index.pairs.filter((p) => p.library === active); | |
| if (!all.length) { | |
| panel.replaceChildren(h("p", { class: "status" }, "No records yet.")); | |
| return; | |
| } | |
| const s = state.get(active); | |
| // Each target has its own sweeps, so its own selection, compilers and library versions. | |
| const targets = [...new Set(all.map((p) => p.target))].sort(); | |
| if (!targets.includes(s.target)) s.target = targets[0]; | |
| const pairs = all.filter((p) => p.target === s.target); | |
| const sdks = [...new Set(pairs.map((p) => p.sdk))].sort(newestFirst); | |
| const versionLabel = (p) => p.transformers ? `${p.version} · transformers ${p.transformers}` : p.version; | |
| const versionsOf = (sdk) => pairs.filter((p) => p.sdk === sdk) | |
| .sort((a, b) => newestFirst(a.version, b.version) || newestFirst(a.transformers ?? "", b.transformers ?? "")) | |
| .map(versionLabel); | |
| // The latest selection was swept with the newest library version of the newest compiler. | |
| const latest = { sdk: sdks[0], version: versionsOf(sdks[0])[0] }; | |
| if (!sdks.includes(s.sdk)) s.sdk = latest.sdk; | |
| if (!versionsOf(s.sdk).includes(s.version)) s.version = versionsOf(s.sdk)[0]; | |
| const selected = s.view === "selected"; | |
| const shown = selected ? latest : { sdk: s.sdk, version: s.version }; | |
| const pathOf = ({ sdk, version }) => pairs.find((p) => p.sdk === sdk && versionLabel(p) === version).path; | |
| const select = (label, key, options, onchange) => h("label", {}, label, h("select", { | |
| onchange: (e) => { s[key] = e.target.value; s.page = 1; onchange?.(); renderPanel(); }, | |
| }, options.map((o) => h("option", { value: o, selected: o === s[key] }, o)))); | |
| const tasks = h("div", { class: "tasks", role: "group", "aria-label": "Task" }, h("span", {}, "Task")); | |
| const results = h("div", { class: "results" }, h("p", { class: "status" }, "Loading…")); | |
| // Typing renders the list again, not the panel, which would take the focus away. | |
| let renderResults; | |
| const nameField = h("label", {}, "Name", h("input", { | |
| type: "search", | |
| placeholder: "Filter by name", | |
| value: s.names[s.view] ?? "", | |
| oninput: (e) => { | |
| s.names[s.view] = e.target.value.trim(); | |
| s.page = 1; | |
| clearTimeout(typing); | |
| typing = setTimeout(() => renderResults?.(), 300); | |
| }, | |
| })); | |
| const instance = select("Instance", "target", targets, () => { s.sdk = null; s.version = null; }); | |
| panel.replaceChildren( | |
| h("div", { class: "views", role: "tablist" }, Object.entries(VIEWS).map(([view, label]) => h("button", { | |
| role: "tab", | |
| "aria-selected": String(view === s.view), | |
| onclick: () => { s.view = view; s.page = 1; renderPanel(); }, | |
| }, label))), | |
| selected | |
| ? h("div", { class: "controls" }, instance) | |
| : h("div", { class: "controls" }, | |
| instance, | |
| select("SDK (neuronx-cc)", "sdk", sdks, () => { s.version = null; }), | |
| select(active, "version", versionsOf(s.sdk)), | |
| nameField), | |
| ...(selected ? [h("p", { class: "pair" }, `neuronx-cc ${latest.sdk} · ${active} ${latest.version}`)] : [tasks]), | |
| results); | |
| let runs, rank, exclusions, taskList; | |
| try { | |
| let latestRows; | |
| [{ runs, exclusions }, latestRows] = await Promise.all([loadRows(pathOf(shown)), loadRows(pathOf(latest))]); | |
| rank = latestRows.selection; | |
| if (!selected) { | |
| // The tasks the sweep covers: those of the latest pair's and the selection's models. | |
| const covered = new Set([...latestRows.runs.map((run) => run.model_id), ...rank.keys()]); | |
| taskList = [...new Set(await Promise.all([...covered].map(loadTask)))].sort(); | |
| } | |
| } catch (e) { | |
| if (render === rendering) results.replaceChildren(h("p", { class: "status" }, `Could not load the results: ${e.message}`)); | |
| return; | |
| } | |
| if (render !== rendering) return; | |
| const runsOf = new Map(); | |
| for (const run of runs) runsOf.set(run.model_id, [...(runsOf.get(run.model_id) ?? []), run]); | |
| // The task Trending or Downloads shows, or null for all of them. | |
| if (!selected && !(s.view in s.tasks)) { | |
| s.tasks[s.view] = taskList.includes(DEFAULT_TASKS[active]) ? DEFAULT_TASKS[active] : null; | |
| } | |
| const task = s.tasks[s.view] ?? null; | |
| // The current page of the selection, or of the Hub's list of the chosen task or | |
| // of all tasks: its models, each with its runs on the shown pair, the position | |
| // of the first, and whether more follow. | |
| async function listed() { | |
| const start = (s.page - 1) * PAGE; | |
| const end = start + PAGE; | |
| let models, more; | |
| if (selected) { | |
| const ids = [...rank.keys()]; | |
| models = ids.slice(start, end).map((id) => ({ id })); | |
| more = ids.length > end; | |
| } else { | |
| const list = await hubList(active, task, s.names[s.view] ?? "", s.view, end); | |
| models = list.models.slice(start, end); | |
| more = list.models.length > end || Boolean(list.next); | |
| } | |
| return { start, more, models: models.map((model) => ({ ...model, runs: runsOf.get(model.id) ?? [] })) }; | |
| } | |
| // Why a model was not tested: weights larger than the test instance's HBM, or | |
| // the reason the sweep's selection left it out. | |
| function untestedReason({ id, params }) { | |
| const device = TARGETS[s.target]; | |
| if (device && params * 2 > DEVICES * device.deviceHbm) return `Requires more than ${DEVICES} ${device.name} devices`; | |
| return exclusions.get(id)?.notes ?? ""; | |
| } | |
| renderResults = async () => { | |
| const render = ++rendering; | |
| let page; | |
| try { | |
| page = await listed(); | |
| } catch (e) { | |
| if (render === rendering) results.replaceChildren(h("p", { class: "status" }, `Could not load the Hub's list: ${e.message}`)); | |
| return; | |
| } | |
| if (render !== rendering) return; | |
| if (!page.models.length) { | |
| const name = s.names[s.view]; | |
| results.replaceChildren(h("p", { class: "status" }, selected ? "No selection yet." | |
| : `No model of ${task ?? "any task"}${name ? ` matching "${name}"` : ""} is listed.`)); | |
| return; | |
| } | |
| // A model passes if one of its runs passed. | |
| const passed = page.models.filter((m) => m.runs.some((run) => run.result === "PASS")).length; | |
| const untested = page.models.filter((m) => !m.runs.length).length; | |
| const go = async (pages) => { | |
| s.page += pages; | |
| await renderResults(); | |
| if (results.getBoundingClientRect().top < 0) results.scrollIntoView(); | |
| }; | |
| const pager = () => h("div", { class: "pager" }, | |
| h("button", { disabled: s.page === 1, onclick: () => go(-1) }, "‹ Previous"), | |
| h("button", { disabled: !page.more, onclick: () => go(1) }, "Next ›")); | |
| results.replaceChildren( | |
| h("div", { class: "summary" }, | |
| h("p", {}, h("strong", {}, `${page.start + 1}-${page.start + page.models.length}`), | |
| ` · ✅ Pass ${passed} · ❌ Fail ${page.models.length - passed - untested} · Untested ${untested}`), | |
| pager()), | |
| h("div", { class: "scroll" }, h("table", {}, | |
| h("thead", {}, h("tr", {}, COLUMNS.map((c) => h("th", { title: TOOLTIPS[c] }, c)))), | |
| h("tbody", {}, page.models.map((model) => model.runs.length ? model.runs.map((run) => h("tr", { | |
| tabindex: 0, | |
| onclick: () => showRun(run), | |
| onkeydown: (e) => { if (e.key === "Enter") showRun(run); }, | |
| }, | |
| h("td", {}, h("code", {}, model.id)), | |
| h("td", { class: "num" }, run.neuron_cores), | |
| h("td", { class: "result" }, badge(run.result)), | |
| h("td", { class: "num" }, memory(run)), | |
| h("td", { class: "notes" }, thumbnail(run), run.notes ?? ""))) | |
| : h("tr", { class: "untested" }, | |
| h("td", {}, h("code", {}, model.id)), h("td"), h("td", { class: "result" }, "not tested"), | |
| h("td"), h("td", { class: "notes" }, untestedReason(model))))))), | |
| pager()); | |
| }; | |
| // One task at a time, as on the Hub: clicking the chosen task again shows all of them. | |
| if (!selected) { | |
| tasks.append(...[null, ...taskList].map((t) => h("button", { | |
| "aria-pressed": String(task === t), | |
| onclick: () => { s.tasks[s.view] = task === t ? null : t; s.page = 1; renderPanel(); }, | |
| }, t ?? "All"))); | |
| } | |
| renderResults(); | |
| } | |
| // The URLs of what a pipeline generated on Neuron and on CPU, made once per run: | |
| // the rows of a file stay cached. | |
| const imageUrls = new WeakMap(); | |
| function images(run) { | |
| if (!run.image) return null; | |
| if (!imageUrls.has(run)) { | |
| const url = (image) => image && URL.createObjectURL(new Blob([image.bytes], { type: "image/webp" })); | |
| imageUrls.set(run, { neuron: url(run.image), cpu: url(run.cpu_image) }); | |
| } | |
| return imageUrls.get(run); | |
| } | |
| // The Neuron and CPU outputs side by side, next to the thumbnail under the | |
| // pointer. Outside the table, which would clip it. | |
| const preview = h("div", { class: "preview", hidden: true }); | |
| document.body.append(preview); | |
| function showPreview(thumb, urls) { | |
| preview.replaceChildren(...[["Neuron", urls.neuron], ["CPU", urls.cpu]].filter(([, url]) => url) | |
| .map(([label, url]) => h("figure", {}, h("img", { src: url, alt: `${label} output` }), h("figcaption", {}, label)))); | |
| preview.hidden = false; | |
| const box = thumb.getBoundingClientRect(); | |
| const { width, height } = preview.getBoundingClientRect(); | |
| preview.style.left = `${Math.max(8, box.left - width - 8)}px`; | |
| preview.style.top = `${Math.max(8, Math.min(box.top + (box.height - height) / 2, innerHeight - height - 8))}px`; | |
| } | |
| // A thumbnail of what a pipeline generated on Neuron, or null for other models. | |
| function thumbnail(run) { | |
| const urls = images(run); | |
| return urls && h("img", { | |
| class: "thumb", | |
| src: urls.neuron, | |
| alt: "Neuron output", | |
| onmouseenter: (e) => showPreview(e.currentTarget, urls), | |
| onmouseleave: () => { preview.hidden = true; }, | |
| }); | |
| } | |
| let scriptUrl; | |
| function showRun(run) { | |
| URL.revokeObjectURL(scriptUrl); | |
| scriptUrl = URL.createObjectURL(new Blob([run.run_py], { type: "text/x-python" })); | |
| const pip = run.run_py.match(/^# (pip install .*)$/m)?.[1]; | |
| // The rows of the files from before the target level ran on trn2. | |
| const target = run.target ?? "trn2"; | |
| const stack = [ | |
| ["neuronx-cc", run.neuronx_cc], ["torch-neuronx", run.torch_neuronx], ["torch", run.torch], | |
| ["nki", run.nki], ["Python", run.python], ["Neuron driver", run.neuron_driver], | |
| ].filter(([, version]) => version); | |
| dialog.replaceChildren(h("div", { class: "dialog" }, | |
| h("form", { method: "dialog" }, h("button", { class: "close", "aria-label": "Close" }, "×")), | |
| h("h2", {}, h("a", { href: `${HUB}/${run.model_id}`, target: "_blank", rel: "noopener" }, run.model_id)), | |
| h("p", {}, `${badge(run.result)} · ${run.neuron_cores} NeuronCore${run.neuron_cores > 1 ? "s" : ""}` | |
| + ` · ${run.runner} · ${run.library} ${run.library_version}` | |
| + (run.library === "transformers" ? "" : ` · transformers ${run.transformers}`) | |
| + ` · tested ${day(run.tested_at)}`), | |
| h("h3", {}, "Run it"), | |
| h("p", {}, `On a ${TARGETS[target]?.name ?? target} (${target}) instance with this Neuron stack,` | |
| + " for example in the AWS Neuron Deep Learning Container:"), | |
| h("dl", {}, stack.map(([name, version]) => [h("dt", {}, name), h("dd", {}, h("code", {}, version))])), | |
| h("ol", {}, | |
| pip && h("li", {}, "Install the packages the script adds:", h("pre", {}, pip)), | |
| h("li", {}, "Optionally, skip compilation with the graphs this compiler already built:", | |
| h("pre", {}, `hf buckets sync ${NEFF_CACHE}/${target}/neuronxcc-${run.neuronx_cc} /tmp/neff_cache`)), | |
| h("li", {}, "Download ", h("a", { href: scriptUrl, download: "run.py" }, "run.py"), " and run it", | |
| run.neuron_cores > 1 ? ". It launches its own torch.distributed ranks:" : ":", | |
| h("pre", {}, "python3 run.py"))), | |
| run.error && [h("h3", {}, "Error"), h("pre", { class: "error" }, run.error)], | |
| h("details", {}, h("summary", {}, "run.py"), h("pre", {}, run.run_py)))); | |
| dialog.showModal(); | |
| } | |
| dialog.addEventListener("click", (e) => { if (e.target === dialog) dialog.close(); }); | |
| // The visitor's sign-in, until its token expires, or null. | |
| function signedIn() { | |
| try { | |
| const saved = JSON.parse(localStorage.getItem(SIGN_IN)); | |
| if (saved && new Date(saved.expires) > new Date()) return saved; | |
| } catch { | |
| // Without storage, such as in some private windows, the visitor is signed out. | |
| } | |
| return null; | |
| } | |
| let signInError; | |
| async function signIn() { | |
| try { | |
| const { oauthLoginUrl } = await import(HUB_JS); | |
| // The token reads the private bucket of aws-neuron only if the visitor grants it access to the organization. | |
| location.href = `${await oauthLoginUrl()}&orgIds=${AWS_NEURON_ID}`; | |
| } catch (e) { | |
| signInError = e.message; | |
| renderPanel(); | |
| } | |
| } | |
| function signOut() { | |
| try { | |
| localStorage.removeItem(SIGN_IN); | |
| } catch { | |
| // Nothing was saved. | |
| } | |
| renderPanel(); | |
| } | |
| // Back from the sign-in, the page's URL holds its code or its error, which a reload must not use again. | |
| async function finishSignIn() { | |
| const query = new URLSearchParams(location.search); | |
| if (!query.has("code") && !query.has("error")) return; | |
| active = STATUS_TAB; | |
| try { | |
| const { oauthHandleRedirectIfPresent } = await import(HUB_JS); | |
| const result = await oauthHandleRedirectIfPresent(); | |
| if (result) { | |
| localStorage.setItem(SIGN_IN, JSON.stringify({ | |
| token: result.accessToken, expires: result.accessTokenExpiresAt, name: result.userInfo.preferred_username, | |
| })); | |
| } | |
| } catch (e) { | |
| signInError = e.message; | |
| } | |
| for (const key of ["code", "state", "error", "error_description"]) query.delete(key); | |
| const rest = query.toString(); | |
| history.replaceState(null, "", `${location.pathname}${rest ? `?${rest}` : ""}`); | |
| } | |
| // The status of each pod that wrote one in the last day, with its host, by target and host. | |
| async function loadStatus(token) { | |
| const options = { headers: { Authorization: `Bearer ${token}` }, cache: "no-store" }; | |
| const files = await (await fetchOk(`${HUB}/api/buckets/${STATUS_BUCKET}/tree`, options)).json(); | |
| const pods = await Promise.all(files | |
| .filter((file) => file.type === "file" && file.path.endsWith(".json") && Date.now() - new Date(file.uploadedAt) < GONE) | |
| .map(async (file) => ({ | |
| host: file.path.slice(0, -".json".length), | |
| ...await (await fetchOk(`${HUB}/buckets/${STATUS_BUCKET}/resolve/${encodePath(file.path)}`, options)).json(), | |
| }))); | |
| return pods.sort((a, b) => a.target.localeCompare(b.target) || a.host.localeCompare(b.host)); | |
| } | |
| // A time as the logs of the sweep write it, in UTC. | |
| const clock = (iso) => `${iso.slice(0, 16).replace("T", " ")} UTC`; | |
| function duration(ms) { | |
| const minutes = Math.floor(ms / 60000); | |
| if (minutes < 1) return `${Math.round(ms / 1000)} s`; | |
| if (minutes < 60) return `${minutes} min`; | |
| const hours = Math.floor(minutes / 60); | |
| if (hours < 24) return `${hours} h ${minutes % 60} min`; | |
| return `${Math.floor(hours / 24)} d ${hours % 24} h`; | |
| } | |
| const since = (iso) => duration(Date.now() - new Date(iso)); | |
| // A run directory's version of its library, and of the transformers its runs pin: a release or a commit. | |
| const short = (version) => /^[0-9a-f]{40}$/.test(version) ? version.slice(0, 7) : version; | |
| const versions = ({ library, pins }) => library === "transformers" ? short(pins.transformers) | |
| : `${short(pins[library])} · transformers ${short(pins.transformers)}`; | |
| const table = (columns, rows) => h("div", { class: "scroll" }, h("table", {}, | |
| h("thead", {}, h("tr", {}, columns.map((column) => h("th", {}, column)))), | |
| h("tbody", {}, rows.map((cells) => h("tr", {}, cells.map((cell) => h("td", {}, cell))))))); | |
| function renderPod(pod) { | |
| const stale = pod.scheduled && Date.now() - new Date(pod.updated) > STALE; | |
| const runs = (key) => pod.libraries.flatMap((l) => l[key].map((run) => ({ ...run, library: l.library }))); | |
| const running = runs("running").sort((a, b) => a.started.localeCompare(b.started)); | |
| const latest = runs("latest").sort((a, b) => b.ended.localeCompare(a.ended)); | |
| return h("section", { class: "pod" }, | |
| h("h2", {}, `${TARGETS[pod.target]?.name ?? pod.target} (${pod.target}) · ${pod.host}`), | |
| h("p", { class: stale ? "pair stale" : "pair" }, | |
| `${pod.deployed} · ${pod.scheduled ? "scheduled" : "paused"} · updated ${clock(pod.updated)}, ${since(pod.updated)} ago`, | |
| stale ? ": the pod stopped writing its status" : ""), | |
| table(["Library", "Version", "neuronx-cc", "Position in its list", "Pipeline"], pod.libraries.map((l) => [ | |
| l.library, | |
| versions(l), | |
| l.neuronx_cc ?? "", | |
| l.position && [h("progress", { value: l.position[0], max: l.position[1] }), ` ${l.position[0]} / ${l.position[1]}`], | |
| l.pipeline_started ? `running for ${since(l.pipeline_started)}` : "", | |
| ])), | |
| running.length > 0 && [h("h3", {}, "Running"), table(["Model", "Library", "Cores", "Runner", "Started", "For"], | |
| running.map((run) => [h("code", {}, run.model_id), run.library, run.neuron_cores, run.runner, | |
| clock(run.started), since(run.started)]))], | |
| latest.length > 0 && [h("h3", {}, "Latest results"), | |
| table(["Ended", "Model", "Library", "Cores", "Result", "Wall", "Notes"], | |
| latest.map((run) => [clock(run.ended), h("code", {}, run.model_id), run.library, run.neuron_cores, | |
| badge(run.result), run.wall_s == null ? "" : duration(run.wall_s * 1000), run.notes]))], | |
| h("details", {}, h("summary", {}, "scheduler.log"), h("pre", {}, pod.log.join("\n")))); | |
| } | |
| // The status of each pod, which refreshes every minute while its tab shows. | |
| async function renderStatus(render) { | |
| const auth = signedIn(); | |
| const signInButton = (label) => h("button", { onclick: signIn }, label); | |
| if (!auth) { | |
| panel.replaceChildren(h("div", { class: "signin" }, | |
| h("p", {}, "Members of the aws-neuron organization can sign in to see the status of the sweep of each pod:" | |
| + " where it is in the list of each library, the models it runs and its latest results."), | |
| signInError && h("p", { class: "error" }, `Could not sign in: ${signInError}`), | |
| signInButton("Sign in with Hugging Face"))); | |
| return; | |
| } | |
| if (!panel.querySelector(".pod")) panel.replaceChildren(h("p", { class: "status" }, "Loading…")); | |
| let pods; | |
| try { | |
| pods = await loadStatus(auth.token); | |
| } catch (e) { | |
| if (render === rendering) { | |
| panel.replaceChildren(h("div", { class: "signin" }, | |
| h("p", { class: "error" }, `Could not read the status: ${e.message}`), | |
| h("p", {}, "Only the members of aws-neuron who give this Space access to the organization when they sign in" | |
| + " can read it."), | |
| signInButton("Sign in again"), " ", h("button", { onclick: signOut }, "Sign out"))); | |
| } | |
| return; | |
| } | |
| if (render !== rendering) return; | |
| panel.replaceChildren( | |
| h("p", { class: "pair" }, `Signed in as ${auth.name} · `, h("button", { class: "link", onclick: signOut }, "Sign out")), | |
| pods.length ? pods.map(renderPod) : h("p", { class: "status" }, "No pod has written its status in the last day.")); | |
| setTimeout(() => { if (render === rendering) renderPanel(); }, STATUS_REFRESH); | |
| } | |
| await finishSignIn(); | |
| renderTabs(); | |
| renderPanel(); | |