Alexey Bolshakov

Posted on Jun 9

Forth заставил страдать нейросети

#ai #programming #forth #toochain

... и мой Cursor-счёт

Fail недели

Вдохновившись тем, что с помощью ИИ мне удалось написать буквально за вечер пакетный менеджер для Forth, а так-же несколько модерновых утилит я задумался. Получается, конечно, хорошо. Но как-то дорого. А что, если попробовать обучить нейросеть и запускать ее локально? И денег сэкономлю и опыт получу!

Для большинства современных языков программирования, нейросети вполне готовы. Их обучали на килотоннах примеров. Но вот Forth каким-то образом обошли. Я поискал coder сети на предмет списка языков, на которые обучали, и не смог найти сеть, где есть Forth в списке поддерживаемых. Если говорить о вариантах использования моделей в cursor, то самый доступный агент=Auto вообще не справляется с программированием на Forth. Тут я опять "психанул" и говорю - "а давай на все деньги" (Opus 4.7) - решай! В таком режиме у компьютерных мозгов начало даже что-то получаться. Иногда не с первого раза. Иногда прям очень не с первого раза, но все же успешно.

Вообще, Forth оказался крепким орешком для нейросетей: топовые модели что-то выдают, но долго, мучительно, десятки раз переписывая, переставляя слова, запуская тесты и накапливая контекст. Forth заставил как следует поскрипеть железные шестерёнки — и мой кошелёк тоже. Это не история о том, как «Forth победил AI». Это история о том, как я постепенно начал приходить к пониманию того, как работают нейронные сети и экосистема вокруг них, решая нетипичную для ИИ задачу и как всегда, собрав все возможные грабли. История о том, как я начал приходить к пониманию того, как сделать "AI, который победит Forth". История о том, как это сделать эффективнее, не оставшись без денег.

Что такое frules

Ответ прост - объясняешь ИИ, как писать на Forth и ... Profit? А вот и нет!

frules — это не «ещё один prompt для ChatGPT»

У меня появилась гипотеза, что ИИ просто не знает, что такое Forth и надо ему просто дать всю информацию. Подумал я так, конечно же, не на ровном месте, а после длительных диалогов в чате с ИИ. После чего мы пришли к тому, что нужно собрать датасет со знаниями, и уж тогда модель сможет программировать!

Из того, что я знаю, я попросил ИИ скачать весь GForth мануал и примеры работы с ним. Написать тезисы по программированию на Forth. Так же добавил в датасет источники книгу Brodie попутно преобразовав ее в формат MD (ура! теперь ее можно читать онлайн). После этого многие обобщенные тезисы, что ИИ уже сформировала, переписались почти полностью. Плюс к этому, мы попытались сделать блок из типичных программерских задач, как это происходит на Codewars. Сложнее всего оказалось то, что решений задач нет, и я спустил кучу времени и денег на то, чтобы ИИ мне решила все 98 задач таким образом, чтобы решения проходили тесты. Местами было прям больно. Потому что под конец осталось порядка 10ти задач уровня 7 из 10 по шкале сложности. И на решение каждой уходило минимум по часу времени.

Из предыдущих диалогов с ИИ стало ясно, что этот этап придется решать на самых умных моделях. Ставим правильные задачи, правильно решаем и получаем рабочие примеры. Слабая сеть и задачу не решит, и даже тест правильный не напишет. Решая задачи и получая правильный ответ, мы, по сути, "вытаскиваем" из большой модели то, как она научена решать задачи. Вообще, на одной задаче, которую за 2-3 захода ни одна ИИ не могла решить, я просто взял и проверил тесты, уже сам. И выяснилось, что в принципе сам тест составлен не правильно - были не верные ответы указаны (галлюцинации нейросети), и вышло так, что одна сеть обманула другую, а другая тщетно пыталась решить правильное задание, и проверить его неправильным тестом. Пострадавшим, как всегда, оказалась третья сторона (я).

Потом, пройдя эту контрольную точку, я добавил просто код библиотек с theForthNet и задачи из Rosettа с решениями (чооорд, можно было не решать, там все есть!). Но анализ электронными мозгами показал, что не всё так просто. Во-первых, изначальный датасет у нас был логически разбит по разным областям знаний, чтоб по кажому было несколько решений. И задачи из Rosetta оказались в основном дублирующими. Поэтому из них взято всего порядка 10 штук, а не 500+. Другие задачи там были игровые и никак (по мнению ИИ) не помогли бы научиться программировать. Но можно было всё же, расширить датасет. Еще выяснилось, что решения то есть, но на gforth они не проходят тесты. С этого момента ИИ решила начать исправлять эти тесты, но я этот процесс остановил, поняв, что еще раз спринт по починке неработающих задач я уже ни эмоционально ни экономически не перенесу, а мы ведь еще и до обучения не дошли.

Итак, самое сложное позади, подумал я. Датасет готов. Но в чистом виде весь материал не нужен ИИ! Ему нужно взять только какие-то конкретные выжимки. На этом этапе ИИ прям обработав все это сделала то, что она называет "дистилляция" и сформировала набор .mdc файлов о том, как же надо программировать. Попутно сгруппировав эту информацию по темам.

Что в итоге вышло

rules (.mdc) — дистилляция Gforth manual, Brodie, Rosetta, theForthNet;
eval — 151 challenge (98 train / 53 hold-out blind);
gforth — судья: каждый gold solution помечен как TESTS OK.

Получилась библиотека - база знаний, которую можно установить (с помощью скрипта) в свой проект на Форте, и если работать с ИИ, то он все эти файлы с правилами будет использовать в работе.

Cursor подхватывает rules из .cursor/rules/

Но в принципе, я думаю, что можно и самому почитать и что-то понять. Тут сложно всё это оценить. Валидировать всё это одному — долго.

Обучение своей модели - Track A

Предпосылки. Перед тем, как начать "по настоящему" обучать модель, именно данными, именно на GPU - мной на работе был для себя открыт RAG как источник данных для модели. То есть, мы берем модель общего назначения и в качестве внешнего источника - подключаем доступ к векторной базе. Мы там получили модель данных о том, как организовано наше производство, и могли задавать вопросы и получать ответы. Создание векторной БД оказалось отдельным видом искусства. Я со стороны наблюдал, как ИИ само пишет скрипты для того, чтобы "правильно" разложить данные в векторы. Потом я задавал какие-то вопросы и ИИ отвечала не так, как я хочу. И далее программирующая ИИ исправляла индексы. На тот момент вообще было слабое понимание, как это все происходит "под капотом". Но я пришел к пониманию того, что по некоторым моим рабочим вопросам мне ИИ вообще не нужно. Мне нужно просто сформировать некий инструментарий, который данные добудет, обработает и выдаст. Это знание мне пригодится немного позже...

Предположив, что RAG это не совсем то, что я хочу - я захотел освоить пайплайн дообучения модели своими данными. Тот самый случай, когда каким-то образом готовятся датасеты. Потом ими обучают нейросеть и на ней вырастает дополнительный слой знаний и у нас модель "бац" и научилась программировать на Forth! Круто (думал я). В моем понимании на тот момент было то, что Модель+RAG это когда у нас постоянно меняющиеся знания. Мы легко и непринужденно меняем векторную БД и нам не надо переобучать модель. А вот если нам нужно "запечь" знания в модель - вот тогда мы ее и обучаем.

Чтобы не состариться раньше, чем будет получен результат, я попросил ИИ создать мне как раз этот Track A, где мы возьмем самую маленькую модель 0.5B дообучим ее, увидим то, что она научилась, поймем пайплайн сбора датасета, запуска обучения и выходной результат. И уже после этого пойдем дальше на большие модели, которые будем обучать дольше по времени.

Чтож. На моем ноутбуке используется 4070 на 8 Гб и в принципе обучение происходит достаточно быстро: буквально несколько минут. Ведь модель небольшая. Что я в итоге получил? Получил сеть, которая вместо Forth кода выдает какую-то многократно повторяющуюся ерунду. После чего мы обучили сеть подольше - добавили повторения, я начал всматриваться в цифры и мне показалось, что я начал что-то понимать: эпохи, процент ошибок. Этот процент начинал снижаться. Но итоговая модель все равно вместо Forth выдала смесь кода на Python и слов Forth.

Дальше мы пошли обсуждать с ИИ полученный результат и как его улучшить. Мне захотелось, чтобы сеть выдавала что-то более полезное. Дать ей больше данных. Но тут мне напомнили, что я, в общем-то, и не должен был получить нормальный результат, потому что целью было - освоить инструментальный пайплайн! Блин. Однако, увидеть, что модель чему-то научилась - у меня вышло. В этот момент надо было закрывать Track A, выкидывать первый блин комом и идти дальше (не пытаясь получить от малой модели что-то осмысленное). Но... Мой ИИ мне сказал, что в моих скриптах нашлась ошибка: данные были обрезаны и модель обучалась не тем, чем нужно. Хорошо - исправляем! Обучили модель уже нормальными данными. И о чудо: модель ... не научилась программировать на Forth, но прогресс был! Она уже начала оформлять результат в виде синтаксически верных определений Forth : forth-word commands ; и я даже немного обрадовался.

Сам этап Track А решено было закрыть и дальше не дообучать модель на 0.5B. Почему? Потому что цель - "песочница" выполнена, а мечта «модель 0.5B выучит Forth» — нет. Оставалось понять почему — это не мало эпох, повторений или данных. Это что-то фундаментальное, чего я еще не понял.

Время собирать камни

Накопилось много вопросов, и без ответов на эти вопросы двигаться дальше было никак нельзя. Начались дикие душевные порывы: купить свой мощный компьютер и видеоплату (а какую?), а может в институт сходить, там кластер из 4хA100, или может арендовать облако. Но для чего?

В процессе решения задач, ИИ выдает очень много терминов из области ML. Я их собрал и начал обсуждения. Кроме этого, проведя эксперименты и замеры, нужно ведь правильно трактовать результат, уметь делать выводы, а я их делать не умею. Поэтому у нас начался длительный этап общения с целью понять, а что же мы сделали, какой из этого сделать вывод и что делать дальше. И вот мы с ней общались и общались, у меня появлялись новые вопросы, появлялись новые термины. Я по ним задавал дополнительные вопросы. Это хороший механизм узнать то, что ты сам не знаешь (мы не можем знать то, чего не знаем). Постепенно раскрутили диалог.

Некоторые вопросы я задавал неоднократно, возвращаясь по много раз. Видимо, мне просто не хотелось верить в некоторые свои заблуждения.

Маленькую модель с самого начала планировалось использовать только для отладки пайплайна обучения и освоения инструментария. Но увидев первые результаты, я все забыл и захотел улучшить работу сети, чтобы получить верный результат - код на Forth. И я упорно пытался найти варианты решений этого вопроса.

Стадии принятия тщетности идеи созать свою сеть, программирующую на Forth

ИИ: Модель 0.5B Слишком мала и ее не обучить. С таким объемом она вообще не может практически ничего. И результат на Forth она не выдаст и выдать не может. Даже топовые облачные модели работают с трудом.

Пока я дошел до приниятия этой мысли, произошла еще целая цепочка познаний и осознаний. Наверняка не все из них верные.

Осознание +1: RAG - это просто текст в промпт. То есть, нету никакой прямой связи нейросети и векторной БД. Сеть никуда через отдельную дырку не ходит. Все данные из RAG просто текстом вставляются вместе с моим изначальным вопросом в промпт. Всё это попадает в контекст. Модель это понимает и начинает в соответствии с этим отвечать.

Знание +1: А вот дообучение LoRA - это уже привычки в весах. Но база-сеть та же, но над ней адаптер. Можно выполнить операцию merge и будет новая модель. Но как оказалось, на моем ПК это нереально долго. Я могу быть не прав, но merge упирается в процессор и диск, и GPU тут вообще никак не помогает. В общем, это два разных метода добавить знаний сети. Но в случае с RAG - тратится контекст, а в случае с LoRA нет.

Осознание +1: LoRA не заменяет RAG/rules в контексте. А контекст - это только то, что существует - факты, тезисы. Но в целом, ответ от наличия RAG может быть лучше, чем от обучения.

Дискутируя с ИИ про то, как обучать модель и зачем - появилось частичное понимание, почему не стоит долго обучать модель одними данными, максимально снижая ошибку. Если обучать долго, то ответ будет "зазубриваться", а нужно получить ответ через рассуждение. Именно поэтому не на все задачи в датасете есть ответы. Это как раз для того, чтобы мы научили сеть через задача-ответ, а потом уже даем новую задачу, и ожидаем ответ через рассуждения. Но решение от сети ждем самостоятельное. Далее, имея её рассуждение - ответ, мы можем его валидировать, потому что у нас имеется правильный ответ на задачу. Но увы. Похоже, что размера сети 0.5В не хватит даже на то чтобы зазубрить ответы.

Знание +1: Hold-out («оставлено не решенным») — задачи, которые не попадали в обучение (ни в challenge-train.jsonl, ни в train-merged для этого slug). Их используют только чтобы проверить модель вслепую, а не «насколько она зазубрила учебник».

А что вообще можно ждать от 0.5B сети? И что вообще в целом ждать от сети? как она работает? Мы же пользуемся сетями и это какая то магия. А понимание, как они работают - высшая магия. Но хотя бы понять, что и как она отвечает.

Знание +1: сеть - это вообще предсказатель следующего правильного токена исходя из текущего контекста.

Что? В смысле?

Осознание +1: осознание того, как думает ИИ и что она может выдавать в ответ, какую задачу она может решить, а какую нет - один из ключевых моментов для получения инструмента разработчика.

И вот тут я начинаю догадываться, что иду вообще не туда. Я то хочу получить от нейронки прямую генерацию кода на Forth! Но требовать от сети генерацию обратной польской нотации (RPN (1 2 +)) - напрямую это ошибка. Она ни в силу малого объема обучающих данных, ни в силу своей природы - последовательно генерировать слова - вообще не может отменить свои слова и переставить их (без применения внешнего инструмента).

Осознание +1: сервисы типа cursor - просто создают набор инструментов вокруг думающей модели. Причем текстовых, потому что другого способа связи нет. У модели один примитив: вопрос → ответ. То, что в UI выглядит как Agent с «размышлениями», — Cursor под капотом: это просто несколько скиллов и инструментов mcp.

Но мне по прежнему не дает покоя мысль. А зачем тогда существуют такие модели по 0.5B?

Нужно помнить, что никакая сеть не запускает forth в голове, не представляет себе стек и не имеет его в памяти. Она может пользоваться контекстом как блокнотом, в общем, как и человек. Но нужно на много больший объем сети. Маленькие модели могут делать какие-то очень простые вещи, типа автодополнения.

Попутно выяснилось, что еще и размер модели фиксирован. LoRA не «вырастит» 0.5B до других размеров, если добавлять данных. Сеть всегда остается такого же размера.

Дальше я пытался понять, а чему же мы тогда учили сеть? Например, я учил сеть определению слов: факториал, фибоначи итд. Видел как меняется loss. Он снижается, казалось бы, можно поучить подольше и все будет хорошо. Задавал вопросы, на что это влияет. Но в итоге мне рассказали, что при снижении loss до 1 - это нормальное обучение, а меньше уже зазубривание. Да и вообще нет правильного ответа на вопрос - при каком loss надо заканчивать. Если обучить до очень низкой ошибки, то просто на запрос fib придет ответ точный, зазубренный. Как если бы у школьника был объем знаний 10 лет русского языка, но ему еще дали зазубрить какие-то слова на английском. Ну он их зазубрит, и только их сможет сказать. Но другого ничего сделать не сможет.

Вообще я попробовал понять, а чем нейросеть, как дерево, отличается от дерева слов и понятий Forth? Модель же может понимать и классифицировать любую часть Forth выражения. Каждое отдельное слово - это отдельное понятие. Может стоит сначала обучить простым стековым операциям, сложение там итд. А то получается, что я базовым вещам модель не обучил, а сразу прошу решать сложные задачи на форте. Может она поэтому не решает?

Знание +1: из модели обученной под Python миллионами примеров не сделать модель, которая будет писать на Forth на базе 100 примеров.

Знание +1: вообще, просить и ожидать от сети точные формулировки - это ошибка. Сама природа сети в том, что она ошибается в мелких деталях и синтаксисе и прям точно ошибется в синтаксисе форта. Чтобы модели генерили json их очень долго и упорно учат. Научить модель с нуля - у домашнего пользователя нету таких ресурсов (ни технических, на научно-датасетовых)

Но чего же удалось добиться? Я сначала получил вообще очень странный ответ на малой модели. Потом стал дообучать. Увидел выше указанные снижения loss, но лучше не стало. А потом вообще выяснилось, что был рассинхрон промптов. То есть ошибка в скриптах данных на обучении. После исправления, в итоге получились ответы похожие на правду что-то. Но только именно что похожие:

Слово	Модель	Эталон (tests/ans/)
gcd	begin dup 0= … while dup 0= … dup 1 swap gcd	begin dup while tuck mod repeat drop
factorial	0= if drop exit then 1* factorial	dup 1<= if drop 1 exit then dup 1- recurse *
divisible?	1 div 0= if 1 else 0	mod 0=

Само пределение слова было обернуто в правильный формат : word ( … ) … ; есть — это уже не markdown/return формат ответа, как было. Но логика неверна на всех трёх. При проверке gforth справедливо падает на тестах.

Модель не копирует строки из jsonl (gcd в train есть) — 0.5B не удерживает алгоритм даже при корректном SFT.

Но smoke тест писал «OK», потому что он проверял наличие ":" в начале определения слова и ";" в конце. Он не сравнивает с эталоном и не требует TESTS OK.

В train не было базовых основ по возрастанию сложности (curriculum), а сразу шли определения сложных задач (gcd/factorial). Таблица выше и есть итог: даже честный SFT не спас. По факту Track A закрыли окончательно.

Но в голове всё же крутилась идея о том, что логически дерево форта и дерево мышления нейросети очень похожи и генерировать Форт код для нейросети - как будто бы просто записать путь классификации того, что ты осознал. Но я не могу объяснить, как это выразить. И не понимаю, можно ли это понимание применить к результату.

Раз за разом мы обсуждали эту идею и каждый раз ИИ мне объясняла, что мне так не сделать. И что лучше получить от ИИ - нормально описанный алгоритм, в виде кода на известном ИИ языке программирования, или псевдокоде и уже с помощью внешнего преобразования утилитой - получить Форт код! Потому что утилита сделает эту операцию, быстро, дешево и точно. В отличие от нейросети, которая будет делать это путем обработки огромных массивов данных и при этом будет иметь ненулевой шанс ошибиться в какой-нибудь букве. Это все равно, что забивать гвозди микроскопом.

После этого я сдался. И признал, что надо делать именно так. Тем более, я уже начал догадываться, что прямая работа с синтаксисом и нотацией - это еще не программирование. Нужно ведь еще алгоритмы понимать, структуры данных и иметь опыт к решению задач используя алгоритмы и структуры. На решение алгоритмических задач! И Coder модели как раз на это и обучены и надо использовать результат их работы. И этот результат уже преобразовывать в Forth не нейронным способом.

А каким способом? Я начал спрашивать, а может быть модели могут выдать AST? Это почти Forth. Прямого ответа на то, что какая-то модель умеет отдавать AST не нашлось, но по мнению ИИ, при обучении, модели видели миллионы деревьев из учебников по компиляторам. Но чтобы получит AST утверждается, что программисты просят показать ответ в виде List - S-выражений.

Задача: 1 + (2 * 3)

AST (в формате Lisp, который отлично генерируют модели): (+ 1 (* 2 3))

Результат скрипта преобразования в Forth: 1 2 3 * +

Вообще Форт и Лисп - зеркальны. Их можно выражать один из другого.

Какие еще варианты? Ассемблер? Не совсем то. Ассемблер для стековой виртуальной машины? Да!

Вот стековые языки, которые LLM знают на 10 из 10:
WebAssembly (WASM): В текстовом виде (.wat) WASM — это чистая стековая машина.
Байт-код Java (JVM): Вычисления в JVM происходят строго на стеке операндов.
PostScript (PS): Язык принтеров PDF. А теперь шок-контент: PostScript — это диалект Форта! Он использует ту же Обратную Польскую Запись, те же слова dup, pop (аналог drop), exch (аналог swap).
CIL (Байт-код .NET) и Байт-код Python (dis) — тоже стековые.

Далее я прихожу к выводу о том, что итоговый Forth результат можно получить вообще другим путем - через внешний инструмент преобразования. В составе набора инструментов вокруг ИИ модели - так называемого "завода".

Остановиться решил на WASM

Смотри, как поразительно WASM похож на Форт:
Код на WASM (модель пишет его без ошибок):

get_local $a
get_local $b
i32.add

Далее мы тупо заменяем и получаем Forth.

Чтож, подобьем еще раз:

Мой тезис: «Forth должен быть простым для дерева/нейросети»

Ответ ИИ: Forth прост для компилятора, не для autoregressive LLM:

LLM генерирует слева направо; RPN требует «держать операцию в голове», пока кладёшь операнды. Forth смешивает данные и метапрограммирование (immediate, ['], create/does>) — трансформер этого не «исполняет», только имитирует текст. Поэтому ваша цепочка «разобрать задачу → записать токенами» правильная — но середина (разбор → RPN) должна быть алгоритмом, а сетью, и тем более не сетью на 0.5B.

После этого мне захотелось четко разграничить "инструмент-задача" и какие из моих задач надо решать нейросетями, а какие - инструментами экосистемы "завода".

Чего не стоит ждать от ИИ (архитектурные ограничения):

Исполнять код, держать стек в «голове», откаты при ошибке — нет внутренней VM; только текст.
Гарантированная корректность — никогда; только вероятность.

Потом мы немного поговорили про то, что кроме дообучения модели, есть еще и обучение модели вообще с нуля (не переучивать с Python на Forth, а учить на Forth с нуля). И что этот процесс для домашней разработки вообще нежизнеспособен. Нужно научить делать все уровни программирования. Но даже если иметь много денег и специалистов - ошибочна сама по себе идея делать текст на Forth. Нейросеть все равно будет ошибаться, а если нет, то это забивание гвоздей микроскопом.

Но что мы можем сделать? Мы можем сделать "Завод" из тулчейна!

Ну и далее, выходит, что мы можем получить от большой модели саму суть алгоритма и код в удобной для трансляции в Форт нотации. Инструментально преобразовать. Инструментально проверить. Дать ответ. Тем самым мы избавим большую модель через боль, страдания и большие затраты токенов, программировать на Forth.

Так что задача сильно поменялась с точки зрения философии решения: ИИ не должен писать на Forth сам, а должен с помощью внешних инструментов получить форт и проверить результат. И для валидации преобразования как раз пригодятся написанные за несколько дней инструменты для Forth экосистемы: fmix + test, lint flint, fcov coverage.

Если все получится, то мы сможем получать Forth код, но обходиться это будет дешевле. Если cursor+Opus запускать над этим tools функционалом, то результат должен получаться дешевле.

Таким образом, мы пришли к пониманию и изобрели (велосипед) такое понятие, которое все называют skills/tools.

Осознание: монолитных ИИ нейронок, которые умеют программировать - нет. Мы ими не пользуемся. Мы пользуемся ИИ экосистемами, которые умеют в итоге получить программный код. А дома мы запускаем одну моно модель. И потом удивляемся - я че она такая тупая. Но мы сравниваем одну маленькую модель с большим набором больших моделей и инструментов вокруг них.

Терминология ИИ

Термины, которые ИИ активно использовала, объясняя мне принципы своей работы. Вообще в этом есть забавный момент: мы с ИИ обсуждаем ИИ )) Я их дам прямо так, как их мне объяснила ИИ. В рамках контекста нашего с ней диалога. Я думаю, лучше по каждому слову искать в интернете более корректное объяснение. Тут ценен именно сам перечень слов.

Термин	По-простому	Что происходит технически	Для Forth / frules
Параметр (parameter)	«Ячейка памяти» сети	Одно обучаемое число в матрице	0.5B = 500 млн таких чисел
0.5B / 7B	Размер / ёмкость модели	Число параметров; больше → больше паттернов	0.5B — мало для алгоритмов на стеке
Pretrain (претрейн)	«Школа жизни» на интернете	Predict next token на огромном корпусе	Forth там ≈ 0%; зато Python, C, «код вообще» в достатке
Token (токен)	Кусок текста (~слово/часть)	Единица входа/выхода LLM	`: gcd` может быть 2–3 токена
Transformer	Архитектура LLM	Attention: каждый токен «смотрит» на предыдущие	Нет стека, нет VM — только текст
SFT	Supervised fine-tuning	Учебник: prompt → эталонный ответ	Ваш `train-merged.jsonl`
Instruct / instruction-tuned	Модель «ассистент»	SFT на диалогах «вопрос → ответ»	`Qwen2.5-Coder-0.5B-Instruct`
LoRA	Тонкая «накладка»	Мало новых весов; база заморожена (QLoRA: в 4-bit)	~17 MB поверх 0.5B
QLoRA	LoRA + сжатая база	База в 4-bit, учится только adapter	Track A на RTX 4070
Loss (потери)	Ошибка угадывания	Cross-entropy: насколько модель промахнулась по следующему токену	Низкий loss ≠ рабочий Forth
Epoch (эпоха)	Один проход по всему jsonl	Сколько раз модель видела каждую строку	3 ep на 139 строк — мало для обобщения
Overfit / зазубривание	Запомнила train, не переносит	Отлично на тех же промптах, плохо на новых	Старый run: зазубрила rules, не gcd
Generalization (обобщение)	Перенос на новое	Работает на промптах/задачах вне train	0.5B + Forth: practically нет
Memorization	Копирование train-пар	Ответ ≈ строка из jsonl	Даже этого 0.5B не сделала для gcd
Curriculum	От простого к сложному	Сначала `1 2 +`, потом `: square`, потом gcd	В frules не было; нужно для маленьких моделей
Hold-out	Задачи не из train	Только для проверки	`eval_holdout` в `tests/challenges/`
System prompt	Роль / правила в чате	Первое сообщение `role: system`	SFT: short (~50 tok); Ollama: full rules
Reasoning (рассуждение)	Цепочка шагов к ответу	Модель генерирует промежуточные шаги (CoT)	Forth-стек = нужен «scratchpad» или алгоритм
CoT (chain-of-thought)	«Думай вслух» в тексте	В ответе: стек, разбор, потом код	Помогает большим моделям; 0.5B ломается на длинной цепочке
Rules (frules)	Текст в промпте, не в весах	`.mdc` в SYSTEM; веса не меняются	Cursor / Ollama — сильнее LoRA 0.5B
Merge LoRA	Влить adapter в базу	Полные веса для Ollama/GGUF	Отдельно от качества Forth
GGUF / Ollama	Формат локального inference	Квантованная модель для чата	Rules в Modelfile ≠ train jsonl

Побочные продукты этой увлекательной недели

Пока я всем этим занимался, попутно создавались некоторые инструменты. В итоге, мне захотелось попробовать оценить объемы того, что получилось: по периоду времени, объему функционалу и объему кода.

Repo	Период	Версии	Одной строкой	Код*
fmix	2024 → 24.05	0.7.x	Пакетный менеджер	~1.2k LOC `.4th`
fsemver	24.05, 1 день	0.1.x	Semver-библиотека (для fmix/flint)	~360 LOC
fcov	24.05, 1 день	0.1→0.3	Инструмент Coverage: console/JSON/LCOV/HTML	~2.8k LOC
flint	24.05, 1 день	0.1→0.2.2	Lint дубликатов `: word`	~825 LOC
fenum	22.05	0.1.x	Библиотека для `ulist` и `enum` (используется в flint/fcov)	~750 LOC
fhdlgen	20–24.05	0.3.1	Преобразователь DSL→Verilog (расскажу в следующий раз)	~2k LOC
frules	25–31.05	0.1.x	151/98/53, Track A closed, docs hub	gold ~6.5k; rules ~2.1k md

*LOC без forth-packages/ — просто чтоб оценить объемы.

24 мая — flint, fcov, fsemver были написаны всего за один день с помощью Opus 4.8. frules — ещё шесть дней: challenge bank, gold, первые проверки (Track A), hub с документацией по Forth.

Обычно меня душит жаба, за бесцельно потраченные деньги. Но здесь — нет: ни денег, ни бессонных ночей не жалею. Слишком много узнал и осознал за эти дни. Многие навыки пригодились и на основной работе