ArGrigorov commited on
Commit
6f7c86f
·
verified ·
1 Parent(s): f620380

AGIWSVoice: project scaffolding, roadmap, compute job harness

Browse files
.gitignore ADDED
@@ -0,0 +1,13 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ .venv/
2
+ __pycache__/
3
+ *.pyc
4
+ temp/*
5
+ !temp/.gitkeep
6
+ data/*.gguf
7
+ data/*.safetensors
8
+ data/*.wav
9
+ data/*.mp3
10
+ data/fixtures/*.wav
11
+ data/fixtures/*.mp3
12
+ logs/
13
+ .pytest_cache/
README.md ADDED
@@ -0,0 +1,52 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # AGIWSVoice
2
+
3
+ Исследование и построение TTS/VC-движка без языковой модели: только дифференцируемый
4
+ декодер OmniVoice (латент `[T, 256]` 25 fps → аудио 24 кГц) и управление просодией
5
+ automation-curves.
6
+
7
+ ## Идея
8
+
9
+ OmniVoice = Qwen3-ствол + дискретная голова на 8 кодбуков + DAC-декодер. Ствол учит
10
+ `текст → латент`, но он нестриминговый (двунаправленный, 32 полных прогона MaskGIT на
11
+ чанк), поэтому в реальном времени непригоден. В этом проекте ствол и кодбуки не
12
+ используются: остаётся только декодер, а латент порождается и правится нами.
13
+
14
+ ```
15
+ фонемы + длительности + curves (F0/энергия) -> латент [T,256] -> DAC-декодер -> 24 кГц
16
+ ^
17
+ инверсия реального аудио
18
+ ```
19
+
20
+ Декодер берётся из `omnivoice-tokenizer-Q8_0.gguf` (те же Q8_0-веса, что в проде) и
21
+ переносится в PyTorch через NeuralQuant, чтобы по латенту можно было считать градиент.
22
+
23
+ ## Что даёт инверсия декодера
24
+
25
+ - **детектор артефактов** — остаток `audio - decode(latent)`; щелчки, клиппинг, наводка,
26
+ обрывы, потери сжатия не объясняются декодером и садятся в остаток (метки не нужны);
27
+ - **клон голоса** — тембр из усреднённого латента референса, без энкодера;
28
+ - **speech-to-speech** — контент и кривые из исходника + тембр целевого;
29
+ - **просодия** — направления `d(F0, энергия)/d(латент)` и counterfactual-правка ударений;
30
+ - **ASR-надстройки** — распознавание эмоции по координатам кривых, расстановка ударений,
31
+ ре-скоринг гипотез ASR по остатку.
32
+
33
+ ## Структура
34
+
35
+ - `docs/tasks/roadmap.md` — пошаговый план (фазы 0-7);
36
+ - `docs/tasks/worklog.md` — подробный журнал работ (append-only);
37
+ - `docs/tasks/worklog_summary.md` — выжимка;
38
+ - `src/agiws_voice/` — код проекта;
39
+ - `scripts/` — запускаемые скрипты (экстракция весов, инверсия, замеры);
40
+ - `tests/` — тесты;
41
+ - `data/fixtures/` — короткие аудиофикстуры;
42
+ - `temp/` — разовые скрипты и диагностика.
43
+
44
+ ## Внешние зависимости
45
+
46
+ - `C:\dev\AGIWSNeuralQuant\src\agiws_neural_quant` — квантованные модули (Q8_0, `QuantizedModule`),
47
+ GGUF-ридеры;
48
+ - `C:\dev\llama-cpp\tools\omnivoice\src` — эталонная реализация декодера (C++/ggml);
49
+ - `C:\dev\OmniVoiceGoogleDriveWorker\google-drive\OmniVoiceWorker\models\omnivoice-tokenizer-Q8_0.gguf` —
50
+ источник весов (Q8_0, 288 889 600 байт);
51
+ - Гейтвей `https://aigateway.agiws.ru` + compute-воркер `colab-1` (T4) — тяжёлые вычисления
52
+ (локально GPU нет).
docs/tasks/roadmap.md ADDED
@@ -0,0 +1,110 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Роадмап AGIWSVoice
2
+
3
+ Движение от простого к сложному. Цель — TTS/VC-движок без языковой модели: латент
4
+ `[T, 256]` (25 fps) → DAC-декодер OmniVoice, управление просодией через automation-curves,
5
+ клон голоса, speech-to-speech, детектор артефактов.
6
+
7
+ Ограничения, принятые на старте:
8
+ - ствол OmniVoice (Qwen3, MaskGIT) НЕ используется: двунаправленный, без KV-кеша,
9
+ 32 полных прогона на чанк (142-199 мс/шаг, ~5-6 с на чанк) — рилтайм невозможен;
10
+ - кодбуки и HuBERT в рабочем пайплайне отсутствуют;
11
+ - веса декодера — ровно те Q8_0, что в проде (`omnivoice-tokenizer-Q8_0.gguf`);
12
+ - **все работы выполняются на compute-воркере** `colab-1` (T4, Гейтвей `https://aigateway.agiws.ru`):
13
+ локально только правка кода, ревью и запуск джоб. Веса берутся из HF
14
+ `agiws/OmniVoice-0.6B-Q8-GGUF-llama.cpp`, артефакты складываются на Google Drive воркера;
15
+ worker_id в submit пинится, перед каждой джобой — проверка живости воркера.
16
+
17
+ ## Фаза 0 — каркас `[v]`
18
+
19
+ - [v] Структура проекта: `docs/tasks/`, `src/agiws_voice/`, `scripts/`, `tests/`, `data/fixtures/`, `temp/`
20
+ - [v] `README.md` со схемой пайплайна, `.gitignore`
21
+ - [v] Роадмап, ворклог, ворклог-саммари
22
+ - Критерий: проект описывает архитектуру и план, ничего не считается готовым без артефакта.
23
+
24
+ ## Фаза 1 — дифференцируемый декодер из Q8_0 GGUF `[~]`
25
+
26
+ Цель: получить в PyTorch весь тракт, куда подаётся латент `[T, 256]`, с весами ровно
27
+ из прода, чтобы по латенту считался градиент (`d(audio)/d(latent)`), веса — константы.
28
+
29
+ - [v] **1.1 Инвентаризация GGUF** (джоба `7ff1c203`): префикс декодера — `acoustic_decoder.*`,
30
+ 110 тензоров (37 `weight` F16, 37 `bias` F32, 36 `snake*.alpha` F32). **Q8_0 в декодере нет**
31
+ (74 `Q8_0` в GGUF — это семантический энкодер, он нам не нужен). Контейнер: GGUF v3, 486
32
+ тензоров, 27 KV, align 32, байтовый учёт сходится. KV: `sample_rate=24000`, `hop_length=960`,
33
+ `acoustic.hidden_size=256` (вход декодера), `acoustic.decoder_hidden_size=1024`,
34
+ `n_codebooks=9`, `codebook_size=1024`, `codebook_dim=64`, `semantic_sample_rate=16000`,
35
+ `downsample_factor=320`.
36
+ - [~] **1.1a Экстрактор**: вытащить все `acoustic_decoder.*` из `omnivoice-tokenizer-Q8_0.gguf`
37
+ в safetensors (float, без де-квантования) + манифест с sha256; джоба `518a0647`.
38
+ - [ ] **1.2 Трансформации загрузки**: повторить три преобразования из `dac-decoder.h`:
39
+ `alpha → 1/(alpha + 1e-9)` для snake, пре-пермьют ConvTranspose1d `(IC, OC, K) → [IC, K*OC]`,
40
+ `fc2` bias грузится как `F32`. Без них веса «похожи», но не те.
41
+ - [ ] **1.3 Модуль декодера в PyTorch**: `Snake` (`y = x + (1/(alpha+1e-9))·sin(alpha·x)^2`),
42
+ residual unit (`snake → conv k=7 dil=d → snake → conv k=1` + skip), decoder block
43
+ (`snake → conv_t → 3 res_units`), финальный блок и выход на 24 кГц; `hop_length = 960`.
44
+ - [ ] **1.4 Сверка с `.so`**: один и тот же латент `[T, 256]` → PyTorch vs `libomnivoice.so`
45
+ (через `ov_*` или отладочный путь C++); метрика SNR по сэмплам.
46
+ - Критерий фазы: `SNR ≥ 60 дБ` PyTorch относительно `.so` на 2-3 разных латентах
47
+ (в т.ч. случайном и взятом из реального синтеза). Иначе — разбор расхождения, а не «почти совпало».
48
+
49
+ ## Фаза 2 — инверсия и детектор артефактов `[ ]`
50
+
51
+ - [ ] **2.1 Инверсия** `audio → латент`: оптимизация латента по многомасштабному
52
+ спектральному лоссу (+ фаза), инициализация нулём/средним.
53
+ Критерий: на своём TTS-выходе остаток близок к шумовому полу; на реальной речи сходимость
54
+ за фиксированное число итераций.
55
+ - [ ] **2.2 Калибровка шумового пола**: источник 1 — самогенераци�� (латент свой, значит
56
+ `decode(invert(x))` обязан вернуться), источник 2 — записи, в чистоте которых уверены
57
+ (`data/fixtures/`, голоса из `agiws/TTSVoiceSamples`). Статистика по трактам отдельно,
58
+ порог по квантилю остатка.
59
+ - [ ] **2.3 Детектор артефактов**: остаток `audio − decode(latent)` по кадрам + спектральная
60
+ плоскостность остатка (отличить щелчок от шума).
61
+ Критерий: ROC-AUC на синтетически испорченных файлах (клиппинг, белый шум, дропауты, склейки).
62
+ - [ ] **2.4 Карта остатков** по кадрам — диагностика: большой остаток на чистой речи означает,
63
+ что инверсия не сошлась и строить управление рано.
64
+
65
+ ## Фаза 3 — просодия: curves → латент `[ ]`
66
+
67
+ - [ ] **3.1 Измерение** F0 / энергии / длительностей (питч-трекер + энергия на кадрах).
68
+ - [ ] **3.2 Чувствительность**: якобиан `d(F0, энергия)/d(латент)` через декодер → базис
69
+ просодических направлений.
70
+ - [ ] **3.3 Контрфакт ударения**: правка латента вдоль базиса и/или оптимизация под целевой
71
+ F0-контур; слушаем, перескочило ли ударение.
72
+ - [ ] **3.4 Адаптер** `curves → латент` (маленький, обучается на синтетике: свои латенты +
73
+ целенаправленные кривые).
74
+ - Критерий: заданный F0-контур воспроизводится с ошибкой в центах (порог фиксируется по замеру),
75
+ ударение переносится слышимо и устойчиво.
76
+
77
+ ## Фаза 4 — клон голоса и speech-to-speech (офлайн) `[ ]`
78
+
79
+ - [ ] **4.1 Тембровый вектор** из инверсии референса (средний латент), базис тембров
80
+ (PCA по набору референсов). Без энкодера.
81
+ - [ ] **4.2 Синтез** «контент + тембр»; сравнение с прямым синтезом по латенту.
82
+ - [ ] **4.3 S2S**: контент и кривые исходника + целевой тембр.
83
+ - Критерий: сходство голоса (ECAPA-cosine), сохранение F0-контура исходника, разборчивость
84
+ (WER внешним ASR). Запасной путь при смазывании контента: фонемы + длительности из
85
+ исходника (ASR/выравнивание) и синтез заново.
86
+
87
+ ## Фаза 5 — автоматизация из текста `[ ]`
88
+
89
+ - [ ] **5.1 G2P** (русский: словарь + правила) → фонемы, длительности.
90
+ - [ ] **5.2 Акустическая модель** `фонемы + curves → латент` (feed-forward по кадрам,
91
+ без авторегрессии и без диффузии), декодер — критик (спектральный + перцептивный лосс).
92
+ - [ ] **5.3 Данные**: записи с разметкой либо офлайн-учитель (медленный OmniVoice генерирует
93
+ корпус `текст → латент`); в проде учителя нет.
94
+ - Критерий: разборчивость и естественность не хуже эталона учителя на отложенной выборке.
95
+
96
+ ## Фаза 6 — рилтайм `[ ]`
97
+
98
+ - [ ] **6.1 Дистилляция каузального энкодера** `audio → латент` из инверсий (свой, не HuBERT).
99
+ - [ ] **6.2 Стриминговый декодер**: кадр за кадром, кэш активаций свёрточных слоёв,
100
+ конечный lookahead по рецептивному полю.
101
+ - [ ] **6.3 Замер TTFB** и бюджета задержки на кадр.
102
+ - Критерий: TTFB и стабильность под потоковым входом; отчёт с числами.
103
+
104
+ ## Фаза 7 — ASR-надстройки `[ ]`
105
+
106
+ - [ ] **7.1 Эмоция**: регрессия по координатам кривых (arousal/valence); при необходимости
107
+ добавить DSP-признаки.
108
+ - [ ] **7.2 Ударения**: выравнивание + проекция измеренных кривых на базис чувствительности.
109
+ - [ ] **7.3 Ре-скоринг ASR**: гипотезы внешнего ASR переранжируются по остатку (инверсия
110
+ только на неоднозначных участках).
docs/tasks/worklog.md ADDED
@@ -0,0 +1,71 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Ворклог AGIWSVoice
2
+
3
+ Журнал работ, append-only. Новые записи — в конец.
4
+
5
+ ## 2026-11-14 — Старт проекта: договорённости и постановка
6
+
7
+ - **Папка проекта:** `C:\dev\AGIWSVoice` (создана пользователем, изначально пустая).
8
+ - **Цель:** TTS/VC-движок, управляемый automation-curves, без языковой модели OmniVoice.
9
+ - **Ключевые решения (согласованы с пользователем):**
10
+ - работаем в рамке «есть только декодер»: вход — латент `[T, 256]` 25 fps, выход — 24 кГц;
11
+ - ствол OmniVoice (Qwen3 + MaskGIT) НЕ используется: диффузный, двунаправленный, без KV-кеша,
12
+ 32 полных прогона на чанк (замеры воркера: 142-199 мс/шаг ⇒ 5-6 с на чанк) — рилтайм невозможен;
13
+ - кодбуки и HuBERT из рабочего пайплайна исключены; веса — ровно Q8_0 из прода;
14
+ - вход — фонемы (G2P прикручивается позже, пайплайн заканчивается на «фонемы + длительности»);
15
+ - клонирование голоса — обязательная фича, реализуется через инверсию референса (без энкодера);
16
+ - speech-to-speech — контент и кривые исходника + тембр целевого;
17
+ - детектор артефактов — по остатку `audio − decode(latent)`, метки не нужны;
18
+ - ASR-надстройки (эмоция, ударения, ре-скоринг) — производные от тех же кривых/остатка;
19
+ - полноценный ASR через инверсию не делаем (поиск × итеративная оптимизация = астрономия),
20
+ только ре-скоринг гипотез внешнего ASR.
21
+ - **Снятые возражения:** «25 fps смазывает тонкие признаки» — снято: 40 мс на кадр при слоге
22
+ 150-250 мс с запасом для интонации/ударений/эмоции; артефакты считаются по остатку в сэмплах.
23
+ - **Калибровка «чистого датасета»:** корпус OmniVoice не нужен. Источник 1 — самогенерация
24
+ (свой латент ⇒ `decode(invert(x))` должен вернуться в ноль ⇒ шумовой пол инверсии);
25
+ источник 2 — записи, в чистоте которых уверены (`data/fixtures/`, голоса `agiws/TTSVoiceSamples`).
26
+ - **Окружение:** локально GPU нет (`nvidia-smi` отсутствует); torch в `C:\agiws.ru\aigateway\.venv`
27
+ отсутствует; `.venv` у `AGIWSNeuralQuant` нет. Тяжёлые прогоны — джобами на compute-воркер
28
+ `colab-1` (T4, Гейтвей `https://aigateway.agiws.ru`), лёгкое (тесты, короткие инверсии) — CPU.
29
+ - **Источники:** веса `C:\dev\OmniVoiceGoogleDriveWorker\google-drive\OmniVoiceWorker\models\omnivoice-tokenizer-Q8_0.gguf`
30
+ (Q8_0, 288 889 600 Б); эталон декодера `C:\dev\llama-cpp\tools\omnivoice\src\dac-decoder.h`;
31
+ квантованные модули `C:\dev\AGIWSNeuralQuant\src\agiws_neural_quant` (`base.py`, `converters/gguf_reader.py`,
32
+ `converters/gguf_to_quantmodule.py`, `kquant/gguf_packed.py`, `training/ste.py`).
33
+ - **План:** фазы 0-7 в `docs/tasks/roadmap.md`, подтверждён пользователем.
34
+ - **Текущий шаг:** фаза 1.1 — вытащить весь тракт декодера (всё, куда подаётся латент `[T,256]`)
35
+ из GGUF с сохранением Q8_0-блоков.
36
+
37
+ ### Все работы на compute-воркере (уточнение, 2026-11-14)
38
+
39
+ - Пользователь: «Все работы производим на компьют-воркере». Локально — только написание кода,
40
+ ревью и запуск джоб; всё исполнение (экстракция, сверка, инверсия, обучение, замеры) — джобы
41
+ на `colab-1`. Роадмап обновлён в разделе ограничений.
42
+ - Следствия: код джобы передаётся в payload submit; веса качаются из HF-репо воркера; артефакты
43
+ (safetensors, отчёты) — на Google Drive воркера, в `result` возвращаются только метрики и пути;
44
+ перед каждой отправкой — проверка живости воркера, `worker_id: colab-1` пинится явно.
45
+
46
+ ### Дж��ба 01 — инвентаризация tokenizer-GGUF (`7ff1c203`, 2026-11-14)
47
+
48
+ - Первый submit упал 500: баг Гейтвея (colorama в logstore-sink → RecursionError) — починен,
49
+ записан в ворклог Гейтвея. Второй submit отбили валидатором воркера: `raise SystemExit`
50
+ в job-коде запрещён (`CODE REJECTED`) → заменил на `RuntimeError`.
51
+ - **Результат:** GGUF v3, 486 тензоров, 27 KV, align 32; `accounting_ok=True`
52
+ (288 845 892 Б тензоров против 288 889 600 Б файла, разница — data_start+паддинг).
53
+ Типы: F32 320, F16 92, Q8_0 74.
54
+ - **Декодер:** префикс `acoustic_decoder.*`, 110 тензоров = 37 weight (F16) + 37 bias (F32)
55
+ + 36 snake alpha (F32). **Q8_0 в декодере отсутствует** — квантованы только 74 тензора
56
+ семантического энкодера (HuBERT), которые нам не нужны. Значит план «сохранять Q8_0-блоки»
57
+ для декодера снимается: извлекаем float как есть, де-квантование не применяется.
58
+ - **KV токенизатора:** `sample_rate=24000`, `semantic_sample_rate=16000`, `downsample_factor=320`,
59
+ `codebook_size=1024`, `codebook_dim=64`, `acoustic.encoder_hidden_size=64`,
60
+ `acoustic.decoder_hidden_size=1024`, `acoustic.hidden_size=256` (вход декодера, `[T,256]`),
61
+ `acoustic.n_codebooks=9`, `acoustic.hop_length=960`, `semantic.hidden_size=768`,
62
+ `semantic.num_hidden_layers=12`, `semantic.num_feat_extract_layers=7`,
63
+ `semantic.num_conv_pos_embeddings=128`, `general.quantization_version=2`.
64
+ - **Грабли:** `print` из job-кода = отдельный HTTP-POST на строку (`GatewayStream` → `/jobs/{id}/log`),
65
+ ~1-2 с на строку: вывод 300 тензоров растянул джобу на ~10 минут. В следующих джобах — один
66
+ блок текста на всю выдачу.
67
+ - **Процесс:** вторая джоба была ошибочно поставлена в очередь при живой первой (воркер один) —
68
+ отменена по просьбе пользователя. Правильный порядок: джоба → `submit_job.py --no-wait` →
69
+ остановка, без фоновых `wait_job.py`.
70
+ - NeuralQuant в sandbox не установлен; теперь джобы ставят его из приватного HF `agiws/NeuralQuant`
71
+ (`list_repo_files` → пофайловый `hf_hub_download` → `sys.path` на `src`, без pip).
docs/tasks/worklog_summary.md ADDED
@@ -0,0 +1,32 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Ворклог-саммари AGIWSVoice
2
+
3
+ ## Суть проекта
4
+
5
+ TTS/VC-движок на одном декодере OmniVoice: латент `[T, 256]` (25 fps) → аудио 24 кГц.
6
+ Языковая модель OmniVoice не используется (диффузная, двунаправленная, без KV-кеша, 32 прогона
7
+ на чанк ⇒ нестриминговая). Кодбуки и HuBERT из рабочего пайплайна исключены.
8
+
9
+ ## Что даёт инверсия декодера
10
+
11
+ Остаток `audio − decode(latent)` = детектор артефактов без меток; усреднённый латент референса
12
+ = тембр для клона; разложение «контент + тембр + кривые» = speech-to-speech; якобиан по латенту
13
+ = направления F0/энергии = управление ударениями и интонацией; координаты кривых = эмоция.
14
+
15
+ ## Ключевые решения
16
+
17
+ - веса декодера — те же Q8_0 из `omnivoice-tokenizer-Q8_0.gguf`, вытаскиваются с сохранением
18
+ блоков (34 Б: f16 scale + 32 int8) и трёх загрузочных трансформаций (snake reciprocal,
19
+ conv_t permute `(IC,OC,K)→[IC,K*OC]`, `fc2` bias f32);
20
+ - вход синтеза — фонемы + длительности + curves; G2P подключается позже;
21
+ - клон голоса обязателен, через инверсию референса (без энкодера);
22
+ - рилтайм (фаза 6) требует своего каузального энкодера `audio → латент`, дистиллированного
23
+ из инверсий — это отдельная ветка, не офлайн-качество;
24
+ - «чистый датасет» для калибровки артефактов = самогенерация (эталон нуля) + доверенные записи,
25
+ корпус OmniVoice не нужен;
26
+ - локально GPU нет: тяжёлое — джобами на compute-воркер `colab-1`, лёгкое — CPU.
27
+
28
+ ## Статус
29
+
30
+ Фаза 0 закрыта (каркас, роадмап, ворклог). Фаза 1 в работе: экстракция декодера из GGUF
31
+ с Q8_0-блоками, затем три трансформации, модуль в PyTorch (NeuralQuant `QuantizedModule`),
32
+ сверка с `libomnivoice.so` по SNR.
scripts/hf_publish.py ADDED
@@ -0,0 +1,58 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Publish the AGIWSVoice project tree to the public HF repo agiws/AGIWSVoice.
2
+
3
+ Usage:
4
+ $env:HF_TOKEN = "hf_..."; python scripts/hf_publish.py
5
+
6
+ Creates the repo if missing, verifies the returned id, then uploads the project
7
+ folder as a single commit. Local scratch and cached artefacts are excluded.
8
+ """
9
+
10
+ import os
11
+ import sys
12
+ from pathlib import Path
13
+
14
+ from huggingface_hub import HfApi
15
+
16
+ REPO_ID = "agiws/AGIWSVoice"
17
+ ROOT = Path(__file__).resolve().parents[1]
18
+
19
+ IGNORE = [
20
+ "temp/**",
21
+ "**/__pycache__/**",
22
+ "**/*.pyc",
23
+ ".venv/**",
24
+ "data/**",
25
+ ".git/**",
26
+ ]
27
+
28
+ COMMIT_MESSAGE = "AGIWSVoice: project scaffolding, roadmap, compute job harness"
29
+
30
+
31
+ def main():
32
+ token = os.environ.get("HF_TOKEN")
33
+ if not token:
34
+ raise SystemExit("HF_TOKEN is not set")
35
+ api = HfApi(token=token)
36
+
37
+ api.create_repo(repo_id=REPO_ID, repo_type="model", private=False, exist_ok=True)
38
+ info = api.model_info(REPO_ID, token=token)
39
+ if info.id != REPO_ID:
40
+ raise SystemExit(f"repo id mismatch: {info.id} != {REPO_ID}")
41
+
42
+ commit = api.upload_folder(
43
+ folder_path=str(ROOT),
44
+ repo_id=REPO_ID,
45
+ repo_type="model",
46
+ ignore_patterns=IGNORE,
47
+ commit_message=COMMIT_MESSAGE,
48
+ )
49
+ files = api.list_repo_files(REPO_ID, repo_type="model", token=token)
50
+ print(f"repo={info.id} private={info.private}")
51
+ print(f"commit={getattr(commit, 'oid', '?')}")
52
+ print(f"files={len(files)}")
53
+ for f in files:
54
+ print(f" {f}")
55
+
56
+
57
+ if __name__ == "__main__":
58
+ sys.exit(main())
scripts/jobs/job_01_gguf_inventory.py ADDED
@@ -0,0 +1,211 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Job 01: inventory the OmniVoice tokenizer GGUF.
2
+
3
+ Runs on the compute worker. Downloads the tokenizer GGUF (Q8_0) from HF, parses
4
+ the GGUF container, and reports every tensor with its shape/type/byte size,
5
+ plus a prefix histogram. Purpose: learn the exact decoder tensor names before
6
+ extracting them, and prove the parser is correct (byte accounting vs file size).
7
+
8
+ No writes outside /content and Drive; result is a JSON summary.
9
+ """
10
+
11
+ import json
12
+ import os
13
+ import shutil
14
+ import struct
15
+ import sys
16
+ import time
17
+ from pathlib import Path
18
+
19
+ t0 = time.time()
20
+ WORK = Path("/content/agiws_voice")
21
+ WORK.mkdir(parents=True, exist_ok=True)
22
+ DRIVE = Path("/content/drive/MyDrive/AGIWSVoice")
23
+ DRIVE_OK = Path("/content/drive/MyDrive").is_dir()
24
+ if DRIVE_OK:
25
+ DRIVE.mkdir(parents=True, exist_ok=True)
26
+
27
+ REPORT = {"stage": "init"}
28
+
29
+
30
+ def log(msg):
31
+ print(msg, flush=True)
32
+
33
+
34
+ # ---------------------------------------------------------------- env probe
35
+ try:
36
+ import torch
37
+ REPORT["torch"] = torch.__version__
38
+ REPORT["cuda"] = bool(torch.cuda.is_available())
39
+ REPORT["gpu"] = torch.cuda.get_device_name(0) if torch.cuda.is_available() else None
40
+ except Exception as e:
41
+ REPORT["torch_error"] = f"{type(e).__name__}: {e}"
42
+
43
+ REPORT["drive_mounted"] = DRIVE_OK
44
+ REPORT["disk_free_gb"] = round(shutil.disk_usage("/content").free / 1024 ** 3, 2)
45
+ REPORT["hf_token_present"] = bool(os.environ.get("HF_TOKEN"))
46
+ log(f"[env] torch={REPORT.get('torch')} cuda={REPORT.get('cuda')} gpu={REPORT.get('gpu')}")
47
+ log(f"[env] drive={DRIVE_OK} disk_free_gb={REPORT['disk_free_gb']} hf_token={REPORT['hf_token_present']}")
48
+
49
+ for mod in ("safetensors", "huggingface_hub", "numpy", "agiws_neural_quant"):
50
+ try:
51
+ __import__(mod)
52
+ REPORT.setdefault("modules", {})[mod] = True
53
+ except Exception as e:
54
+ REPORT.setdefault("modules", {})[mod] = f"{type(e).__name__}"
55
+ log(f"[env] modules={REPORT.get('modules')}")
56
+
57
+ # ---------------------------------------------------------------- weights
58
+ REPO = "agiws/OmniVoice-0.6B-Q8-GGUF-llama.cpp"
59
+ FNAME = "models/omnivoice-tokenizer-Q8_0.gguf"
60
+ candidates = [
61
+ Path("/content/omnivoice_q8") / FNAME,
62
+ WORK / "models" / "omnivoice-tokenizer-Q8_0.gguf",
63
+ ]
64
+ gguf_path = next((p for p in candidates if p.is_file()), None)
65
+ if gguf_path is None:
66
+ from huggingface_hub import hf_hub_download
67
+ started = time.time()
68
+ got = hf_hub_download(
69
+ repo_id=REPO, filename=FNAME, token=os.environ.get("HF_TOKEN"),
70
+ repo_type="model", local_dir=str(WORK),
71
+ )
72
+ gguf_path = Path(got)
73
+ log(f"[dl] {FNAME} in {time.time() - started:.1f}s")
74
+ else:
75
+ log(f"[dl] reuse {gguf_path}")
76
+ REPORT["gguf_path"] = str(gguf_path)
77
+ REPORT["gguf_bytes"] = gguf_path.stat().st_size
78
+ log(f"[gguf] {gguf_path} {REPORT['gguf_bytes']} bytes")
79
+
80
+ # ---------------------------------------------------------------- GGUF parse
81
+ GGML_TYPE = {
82
+ 0: ("F32", 1, 4), 1: ("F16", 1, 2), 2: ("Q4_0", 32, 18), 3: ("Q4_1", 32, 20),
83
+ 6: ("Q5_0", 32, 22), 7: ("Q5_1", 32, 24), 8: ("Q8_0", 32, 34), 9: ("Q8_1", 32, 40),
84
+ 10: ("Q2_K", 256, 84), 11: ("Q3_K", 256, 110), 12: ("Q4_K", 256, 144),
85
+ 13: ("Q5_K", 256, 176), 14: ("Q6_K", 256, 210), 15: ("IQ2_XXS", 256, 66),
86
+ 16: ("IQ2_XS", 256, 74), 17: ("IQ3_XXS", 256, 98), 18: ("IQ1_S", 256, 50),
87
+ 19: ("IQ4_NL", 32, 18), 20: ("IQ3_S", 256, 110), 21: ("IQ2_S", 256, 82),
88
+ 22: ("IQ4_XS", 256, 136), 23: ("IQ1_M", 256, 56), 24: ("BF16", 1, 2),
89
+ 28: ("TQ1_0", 256, 54), 29: ("TQ2_0", 256, 66),
90
+ }
91
+ SCALAR = {0: "<B", 1: "<b", 2: "<H", 3: "<h", 4: "<I", 5: "<i", 6: "<f", 7: "<?", 10: "<Q", 11: "<q", 12: "<d"}
92
+
93
+
94
+ def read_str(f):
95
+ n = struct.unpack("<Q", f.read(8))[0]
96
+ return f.read(n).decode("utf-8", "replace")
97
+
98
+
99
+ def skip_value(f, vtype):
100
+ if vtype == 8:
101
+ return read_str(f)
102
+ if vtype == 9:
103
+ etype = struct.unpack("<I", f.read(4))[0]
104
+ count = struct.unpack("<Q", f.read(8))[0]
105
+ if etype == 8:
106
+ for _ in range(count):
107
+ n = struct.unpack("<Q", f.read(8))[0]
108
+ f.seek(n, 1)
109
+ return {"array": "str", "count": count}
110
+ fmt = SCALAR.get(etype)
111
+ if fmt is None:
112
+ raise ValueError(f"bad array elem type {etype}")
113
+ size = struct.calcsize(fmt) * count
114
+ f.seek(size, 1)
115
+ return {"array": etype, "count": count}
116
+ fmt = SCALAR.get(vtype)
117
+ if fmt is None:
118
+ raise ValueError(f"bad kv type {vtype}")
119
+ return struct.unpack(fmt, f.read(struct.calcsize(fmt)))[0]
120
+
121
+
122
+ t_parse = time.time()
123
+ tensors = []
124
+ kv_keep = {}
125
+ with gguf_path.open("rb") as f:
126
+ magic = f.read(4)
127
+ if magic != b"GGUF":
128
+ raise RuntimeError(f"not a GGUF file: {magic!r}")
129
+ version = struct.unpack("<I", f.read(4))[0]
130
+ n_tensors = struct.unpack("<Q", f.read(8))[0]
131
+ n_kv = struct.unpack("<Q", f.read(8))[0]
132
+ for _ in range(n_kv):
133
+ key = read_str(f)
134
+ vtype = struct.unpack("<I", f.read(4))[0]
135
+ val = skip_value(f, vtype)
136
+ if any(k in key for k in ("audio", "omnivoice", "hop", "sample", "codebook", "align", "quant", "dac", "rvq")):
137
+ kv_keep[key] = val
138
+ alignment = int(kv_keep.get("general.alignment") or 32)
139
+ for _ in range(n_tensors):
140
+ name = read_str(f)
141
+ nd = struct.unpack("<I", f.read(4))[0]
142
+ dims = [struct.unpack("<Q", f.read(8))[0] for _ in range(nd)]
143
+ ttype = struct.unpack("<I", f.read(4))[0]
144
+ offset = struct.unpack("<Q", f.read(8))[0]
145
+ info = GGML_TYPE.get(ttype)
146
+ n_elem = 1
147
+ for d in dims:
148
+ n_elem *= int(d)
149
+ nbytes = (n_elem // info[1]) * info[2] if info else None
150
+ tensors.append({
151
+ "name": name, "dims": dims, "type": info[0] if info else f"unknown({ttype})",
152
+ "offset": offset, "bytes": nbytes,
153
+ })
154
+ data_start = f.tell()
155
+ data_start += (-data_start) % alignment
156
+
157
+ REPORT.update({
158
+ "gguf_version": version,
159
+ "n_kv": n_kv,
160
+ "n_tensors": n_tensors,
161
+ "alignment": alignment,
162
+ "data_start": data_start,
163
+ "parse_seconds": round(time.time() - t_parse, 2),
164
+ })
165
+ log(f"[gguf] v{version} kv={n_kv} tensors={n_tensors} align={alignment} data_start={data_start}")
166
+
167
+ known = [t for t in tensors if t["bytes"] is not None]
168
+ data_end = max(t["offset"] + t["bytes"] for t in known) + data_start
169
+ REPORT["tensor_bytes"] = sum(t["bytes"] for t in known)
170
+ REPORT["data_end_estimate"] = data_end
171
+ REPORT["file_bytes"] = REPORT["gguf_bytes"]
172
+ REPORT["accounting_ok"] = abs(data_end - REPORT["gguf_bytes"]) <= max(4096, alignment * 2)
173
+ log(f"[gguf] tensor_bytes={REPORT['tensor_bytes']} data_end={data_end} file={REPORT['file_bytes']} "
174
+ f"accounting_ok={REPORT['accounting_ok']}")
175
+
176
+ type_hist = {}
177
+ for t in tensors:
178
+ type_hist[t["type"]] = type_hist.get(t["type"], 0) + 1
179
+ REPORT["type_hist"] = type_hist
180
+ log(f"[gguf] types={type_hist}")
181
+
182
+ prefix_hist = {}
183
+ for t in tensors:
184
+ parts = t["name"].split(".")
185
+ prefix = parts[0] if len(parts) == 1 else ".".join(parts[:2])
186
+ prefix_hist[prefix] = prefix_hist.get(prefix, 0) + 1
187
+ REPORT["prefix_hist"] = prefix_hist
188
+ log("[gguf] prefixes:")
189
+ for k in sorted(prefix_hist, key=lambda x: -prefix_hist[x]):
190
+ log(f" {k:40s} {prefix_hist[k]}")
191
+
192
+ REPORT["kv_keep"] = {k: v for k, v in kv_keep.items() if not isinstance(v, dict)}
193
+ REPORT["names"] = [t["name"] for t in tensors]
194
+ REPORT["tensors"] = tensors
195
+
196
+ log("[gguf] decoder candidates:")
197
+ for t in tensors:
198
+ low = t["name"].lower()
199
+ if any(k in low for k in ("decoder", "vocoder", "dac", "fc2", "snake", "conv_t")):
200
+ log(f" {t['name']:60s} {t['type']:8s} {t['dims']}")
201
+
202
+ if DRIVE_OK:
203
+ out = DRIVE / "manifest_tokenizer_gguf.json"
204
+ with out.open("w", encoding="utf-8") as fh:
205
+ json.dump(REPORT, fh, ensure_ascii=False, indent=1)
206
+ log(f"[drive] manifest -> {out} ({out.stat().st_size} bytes)")
207
+ REPORT["manifest_path"] = str(out)
208
+
209
+ REPORT["stage"] = "done"
210
+ REPORT["seconds"] = round(time.time() - t0, 1)
211
+ result = REPORT
scripts/jobs/job_02_extract_decoder.py ADDED
@@ -0,0 +1,162 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Job 02: extract the whole decoder (acoustic_decoder.*) into safetensors.
2
+
3
+ Runs on the compute worker. Pulls NeuralQuant from the private HF repo
4
+ (agiws/NeuralQuant) into sys.path, downloads the tokenizer GGUF, and writes
5
+ every tensor under the decoder prefix as float arrays with a manifest.
6
+ Data is stored shape-reversed (ggml -> torch element order); per-tensor layout
7
+ fixes happen in the model module, verified against libomnivoice.so.
8
+ """
9
+
10
+ import hashlib
11
+ import json
12
+ import os
13
+ import subprocess
14
+ import sys
15
+ import time
16
+ from pathlib import Path
17
+
18
+ REPO_WORKERS = "agiws/OmniVoice-0.6B-Q8-GGUF-llama.cpp"
19
+ REPO_NQ = "agiws/NeuralQuant"
20
+ GGUF_REL = "models/omnivoice-tokenizer-Q8_0.gguf"
21
+ PREFIX = "acoustic_decoder."
22
+ WORK = Path("/content/agiws_voice")
23
+ DRIVE = Path("/content/drive/MyDrive/AGIWSVoice")
24
+ HF_TOKEN = os.environ.get("HF_TOKEN") or ""
25
+ WORK.mkdir(parents=True, exist_ok=True)
26
+ if Path("/content/drive/MyDrive").is_dir():
27
+ DRIVE.mkdir(parents=True, exist_ok=True)
28
+ DRIVE_OK = True
29
+ else:
30
+ DRIVE_OK = False
31
+
32
+ REPORT = {"stage": "init", "drive": DRIVE_OK}
33
+ t0 = time.time()
34
+
35
+
36
+ def log(msg):
37
+ print(msg, flush=True)
38
+
39
+
40
+ def pip(*pkgs):
41
+ subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", *pkgs])
42
+
43
+
44
+ # ---------------------------------------------------------------- NeuralQuant
45
+ def install_neural_quant():
46
+ from huggingface_hub import hf_hub_download, list_repo_files
47
+
48
+ root = WORK / "neuralquant"
49
+ files = list_repo_files(REPO_NQ, repo_type="model", token=HF_TOKEN)
50
+ want = [
51
+ f for f in files
52
+ if f.startswith("src/agiws_neural_quant/") and f.endswith(".py")
53
+ ] + ["pyproject.toml"]
54
+ missing = [w for w in want if not (root / w).is_file()]
55
+ log(f"[nq] repo files={len(files)} needed={len(want)} missing={len(missing)}")
56
+ for i, rel in enumerate(missing, 1):
57
+ hf_hub_download(repo_id=REPO_NQ, filename=rel, token=HF_TOKEN,
58
+ repo_type="model", local_dir=str(root))
59
+ if i % 20 == 0 or i == len(missing):
60
+ log(f"[nq] downloaded {i}/{len(missing)}")
61
+ src = str(root / "src")
62
+ if src not in sys.path:
63
+ sys.path.insert(0, src)
64
+ import agiws_neural_quant as nq
65
+ REPORT["nq_version"] = getattr(nq, "__version__", "unknown")
66
+ REPORT["nq_path"] = getattr(nq, "__file__", src)
67
+ log(f"[nq] imported from {REPORT['nq_path']} version={REPORT['nq_version']}")
68
+
69
+
70
+ try:
71
+ install_neural_quant()
72
+ except Exception as e:
73
+ REPORT["nq_error"] = f"{type(e).__name__}: {e}"
74
+ log(f"[nq] install failed: {REPORT['nq_error']}")
75
+
76
+ pip("gguf")
77
+
78
+ # ---------------------------------------------------------------- GGUF
79
+ from huggingface_hub import hf_hub_download # noqa: E402
80
+
81
+ candidates = [
82
+ Path("/content/omnivoice_q8") / GGUF_REL,
83
+ WORK / "models" / Path(GGUF_REL).name,
84
+ ]
85
+ gguf_path = next((p for p in candidates if p.is_file()), None)
86
+ if gguf_path is None:
87
+ got = hf_hub_download(repo_id=REPO_WORKERS, filename=GGUF_REL, token=HF_TOKEN,
88
+ repo_type="model", local_dir=str(WORK))
89
+ gguf_path = Path(got)
90
+ log(f"[gguf] {gguf_path} {gguf_path.stat().st_size} bytes")
91
+
92
+ import numpy as np # noqa: E402
93
+ from gguf import GGUFReader # noqa: E402
94
+ from safetensors.numpy import save_file # noqa: E402
95
+
96
+ reader = GGUFReader(str(gguf_path))
97
+ log(f"[gguf] reader tensors={len(reader.tensors)} fields={len(reader.fields)}")
98
+
99
+ arrays = {}
100
+ manifest = []
101
+ skipped = []
102
+ for t in reader.tensors:
103
+ name = t.name
104
+ if not name.startswith(PREFIX):
105
+ continue
106
+ data = np.asarray(t.data)
107
+ if data.dtype == np.float16:
108
+ out = data.astype(np.float16)
109
+ elif data.dtype in (np.float32, np.float64):
110
+ out = data.astype(np.float32)
111
+ else:
112
+ skipped.append({"name": name, "dtype": str(data.dtype), "shape": list(data.shape)})
113
+ continue
114
+ out = np.ascontiguousarray(out.reshape(data.shape))
115
+ arrays[name] = out
116
+ manifest.append({
117
+ "name": name,
118
+ "torch_shape": list(out.shape),
119
+ "dtype": str(out.dtype),
120
+ "nbytes": int(out.nbytes),
121
+ "digest": hashlib.sha256(out.tobytes()).hexdigest()[:16],
122
+ })
123
+
124
+ log(f"[extract] tensors={len(arrays)} bytes={sum(m['nbytes'] for m in manifest)}")
125
+ log(f"[extract] skipped(non-float)={len(skipped)}")
126
+ for s in skipped[:10]:
127
+ log(f" skip {s['name']} {s['dtype']} {s['shape']}")
128
+
129
+ if not arrays:
130
+ raise RuntimeError("no decoder tensors matched prefix " + PREFIX)
131
+
132
+ blocks = sorted({name.split(".")[1] for name in arrays})
133
+ REPORT.update({
134
+ "prefix": PREFIX,
135
+ "n_tensors": len(arrays),
136
+ "bytes": sum(m["nbytes"] for m in manifest),
137
+ "groups": blocks,
138
+ "skipped": skipped,
139
+ "manifest": manifest,
140
+ })
141
+
142
+ target_dir = DRIVE if DRIVE_OK else (WORK / "out")
143
+ target_dir.mkdir(parents=True, exist_ok=True)
144
+ st_path = target_dir / "decoder_raw.safetensors"
145
+ save_file(arrays, str(st_path))
146
+ mf_path = target_dir / "decoder_raw_manifest.json"
147
+ with mf_path.open("w", encoding="utf-8") as fh:
148
+ json.dump({"prefix": PREFIX, "tensors": manifest, "n": len(manifest)}, fh, indent=1)
149
+
150
+ st_sha = hashlib.sha256(st_path.read_bytes()).hexdigest()
151
+ REPORT.update({
152
+ "safetensors": str(st_path),
153
+ "safetensors_bytes": st_path.stat().st_size,
154
+ "safetensors_sha256": st_sha,
155
+ "manifest_path": str(mf_path),
156
+ "seconds": round(time.time() - t0, 1),
157
+ })
158
+ log(f"[save] {st_path} {st_path.stat().st_size} bytes sha256={st_sha[:16]}")
159
+ log(f"[save] manifest {mf_path}")
160
+ log(f"[done] {REPORT['seconds']}s")
161
+
162
+ result = REPORT
scripts/submit_job.py ADDED
@@ -0,0 +1,160 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """Submit a compute job to the Gateway and wait for the terminal status.
2
+
3
+ Job code is sent as text (the worker execs it). The canonical waiter
4
+ `C:\\agiws.ru\\aigateway\\scripts\\wait_job.py` is reused for polling.
5
+
6
+ Usage:
7
+ python scripts/submit_job.py scripts/jobs/job_01_gguf_inventory.py --name gguf-inventory
8
+ python scripts/submit_job.py ... --worker colab-1 --mode direct --timeout 3600
9
+ """
10
+
11
+ import argparse
12
+ import json
13
+ import os
14
+ import subprocess
15
+ import sys
16
+ import time
17
+ from pathlib import Path
18
+
19
+ import requests
20
+
21
+ ROOT = Path(__file__).resolve().parents[1]
22
+ GATEWAY = "https://aigateway.agiws.ru"
23
+ API_KEY = "sk-agi-workshop-test"
24
+ WAITER = Path(r"C:\agiws.ru\aigateway\scripts\wait_job.py")
25
+ AUTH = {"Authorization": f"Bearer {API_KEY}"}
26
+ CLIENT_FILE = ROOT / "temp" / "client.json"
27
+ LAST_JOB = ROOT / "temp" / "last_job.json"
28
+ LAST_RESULT = ROOT / "temp" / "last_result.json"
29
+
30
+
31
+ def _session():
32
+ s = requests.Session()
33
+ s.headers.update(AUTH)
34
+ return s
35
+
36
+
37
+ def register_client():
38
+ """Register a fresh compute client for this run.
39
+
40
+ The registry keeps clients in memory only, so a Gateway restart drops every
41
+ client_id. Registering per run costs one POST and removes that failure mode.
42
+ """
43
+ r = _session().post(f"{GATEWAY}/api/v1/compute/clients/register", timeout=20)
44
+ r.raise_for_status()
45
+ client_id = r.json()["client_id"]
46
+ CLIENT_FILE.parent.mkdir(parents=True, exist_ok=True)
47
+ CLIENT_FILE.write_text(json.dumps({"client_id": client_id}), encoding="utf-8")
48
+ return client_id
49
+
50
+
51
+ def worker_alive(worker_id):
52
+ r = _session().get(f"{GATEWAY}/api/v1/compute/workers", timeout=20)
53
+ r.raise_for_status()
54
+ data = r.json()
55
+ items = data if isinstance(data, list) else data.get("workers", [])
56
+ if isinstance(items, dict):
57
+ items = [items]
58
+ for w in items:
59
+ if w.get("worker_id") == worker_id:
60
+ return True, w
61
+ return False, items
62
+
63
+
64
+ def submit(code, name, client_id, worker_id, mode, timeout_seconds):
65
+ body = {
66
+ "code": code,
67
+ "mode": mode,
68
+ "name": name,
69
+ "client_id": client_id,
70
+ "worker_id": worker_id,
71
+ }
72
+ if timeout_seconds:
73
+ body["timeout_seconds"] = timeout_seconds
74
+ r = _session().post(f"{GATEWAY}/api/v1/compute/submit", json=body, timeout=30)
75
+ if r.status_code not in (200, 202):
76
+ raise SystemExit(f"submit failed {r.status_code}: {r.text[:400]}")
77
+ return r.json()
78
+
79
+
80
+ def fetch_job(job_id, client_id, worker_id):
81
+ r = _session().get(
82
+ f"{GATEWAY}/api/v1/compute/jobs/{job_id}",
83
+ params={"client_id": client_id, "worker_id": worker_id},
84
+ timeout=20,
85
+ )
86
+ r.raise_for_status()
87
+ return r.json()
88
+
89
+
90
+ def main():
91
+ ap = argparse.ArgumentParser()
92
+ ap.add_argument("code_file")
93
+ ap.add_argument("--name", default=None)
94
+ ap.add_argument("--worker", default="colab-1")
95
+ ap.add_argument("--mode", default="direct", choices=["direct", "tree"])
96
+ ap.add_argument("--timeout", type=int, default=0, help="job timeout_seconds on the Gateway")
97
+ ap.add_argument("--wait", type=int, default=3600, help="max seconds to wait locally")
98
+ ap.add_argument("--no-wait", action="store_true", help="submit only, do not poll")
99
+ ap.add_argument("--interval", type=float, default=5.0)
100
+ args = ap.parse_args()
101
+
102
+ try:
103
+ sys.stdout.reconfigure(encoding="utf-8")
104
+ except Exception:
105
+ pass
106
+
107
+ code_path = Path(args.code_file)
108
+ code = code_path.read_text(encoding="utf-8")
109
+ name = args.name or code_path.stem
110
+
111
+ alive, info = worker_alive(args.worker)
112
+ if not alive:
113
+ raise SystemExit(f"worker {args.worker} is not alive; workers={info}")
114
+ print(f"[submit] worker {args.worker} alive: status={info.get('status')} "
115
+ f"job={info.get('current_job_id')}", flush=True)
116
+
117
+ client_id = register_client()
118
+ print(f"[submit] client_id={client_id}", flush=True)
119
+
120
+ resp = submit(code, name, client_id, args.worker, args.mode, args.timeout)
121
+ job_id = resp.get("job_id") or resp.get("id")
122
+ print(f"[submit] job_id={job_id} name={name} mode={args.mode}", flush=True)
123
+ LAST_JOB.write_text(
124
+ json.dumps({"job_id": job_id, "client_id": client_id, "worker_id": args.worker,
125
+ "name": name, "submitted_at": time.time()}, indent=2),
126
+ encoding="utf-8",
127
+ )
128
+
129
+ if args.no_wait:
130
+ print(f"[submit] no-wait: job {job_id} left running on worker {args.worker}", flush=True)
131
+ return 0
132
+
133
+ env = dict(os.environ)
134
+ env.update({
135
+ "GATEWAY_URL": GATEWAY,
136
+ "GATEWAY_API_KEY": API_KEY,
137
+ "GATEWAY_CLIENT_ID": client_id,
138
+ "GATEWAY_WORKER_ID": args.worker,
139
+ "PYTHONIOENCODING": "utf-8",
140
+ })
141
+ rc = subprocess.call(
142
+ [sys.executable, str(WAITER), job_id, "--timeout", str(args.wait),
143
+ "--interval", str(args.interval)],
144
+ env=env,
145
+ )
146
+ print(f"[submit] waiter exit={rc}", flush=True)
147
+
148
+ job = fetch_job(job_id, client_id, args.worker)
149
+ LAST_RESULT.write_text(json.dumps(job, ensure_ascii=False, indent=2), encoding="utf-8")
150
+ print(f"[submit] status={job.get('status')} result_saved={LAST_RESULT}", flush=True)
151
+ payload = job.get("result")
152
+ if payload is not None:
153
+ print(json.dumps(payload, ensure_ascii=False, indent=2)[:20000], flush=True)
154
+ if job.get("error"):
155
+ print(f"[submit] ERROR: {job['error'][:800]}", flush=True)
156
+ return 0 if job.get("status") == "done" else 1
157
+
158
+
159
+ if __name__ == "__main__":
160
+ raise SystemExit(main())