Дискретни представяния в RL: защо това трябва да интересува инженерите

Една AI система никога не вижда "света". Тя вижда представянето, което ние ѝ даваме.

Това звучи като изследователска подробност, докато не те ухапе в production. Агентът ти получава screenshot от браузър, но policy-то не действа директно върху пиксели. LLM-ът ти получава текст, но моделът не чете думи по начина, по който ти го правиш. Роботът ти записва непрекъснати стойности от сензори, но planner-ът му има нужда от нещо достатъчно стабилно, за да сравнява, помни, предвижда и се подобрява.

Инженерният въпрос е груб:

Оставяш ли модела да живее в непрекъсната супа от десетични числа, или принуждаваш части от света му да влязат в крайно множество от символи, buckets, токени, категории или codebook entries?

Това е практическата форма на въпроса за дискретните представяния.

Темата първоначално привлече вниманието ми чрез работата на Edan Meyer върху reinforcement learning, особено статията Harnessing Discrete Representations for Continual Reinforcement Learning, публикувана по-късно в Reinforcement Learning Journal. Статията е техническа, но урокът е чудесно приложим: понякога един модел учи по-бързо, адаптира се по-добре и изгражда по-добър world model, когато трябва да описва наблюденията с малък речник от възможни състояния.

Тази идея не е затворена в RL. Тя римува с tokenization в LLM-и, vector quantization в генеративни модели, learned codebooks в компресията и начина, по който agent systems все по-често се нуждаят от компактно вътрешно състояние вместо безкраен суров context.

За работещия инженер смисълът е този: representation не е просто preprocessing стъпка. Там решаваш какъв вид грешки е позволено да прави системата ти.

Версията на прост език

Непрекъснатото представяне казва: "Това нещо е точка в гладко пространство."

Дискретното представяне казва: "Това нещо принадлежи към един или повече именувани избора от крайно множество."

Нито едното не е автоматично по-добро. Непрекъснатият вектор е изразителен. Той може да носи gradients, нюанси, интерполации и фин детайл. Затова embeddings са толкова полезни. Но непрекъснатите пространства могат да бъдат и кашави. Миниатюрни числови промени може да значат нещо, а може и да не значат. Вектори, които изглеждат сходни, могат да крият различни причинни ситуации. Следващият модел трябва да научи не само кое има значение, а и къде са границите.

Дискретното представяне чертае граници.

То превръща въпроса от "кой точно реалностоен вектор идва след това?" в нещо по-близко до "кое състояние, token или code идва след това?" Това променя learning problem-а. Предсказанието може да стане classification вместо regression. Паметта може да стане достатъчно symbolic, за да се използва отново. Компресията става явна. Planner може да разсъждава върху по-малко множество от възможности.

Затова language model не работи върху сурови Unicode есета като неразличим поток. Той работи върху token IDs. Затова SentencePiece и byte-pair-style tokenizers имат значение. Затова VQ-VAE беше интересен: показа, че learned discrete codes могат да бъдат мощен bottleneck за изображения, аудио и реч. И затова world-model RL постоянно се връща към categorical latents и codebooks.

Моделът не учи само задача. Той учи речник за задачата.

Конкретен пример

Представи си агент, който се учи да играе проста игра от screen observations.

Едно непрекъснато латентно състояние може да кодира екрана като вектор като:

[0.13, -0.72, 1.84, 0.04, ...]

Този вектор може да представи много неща. Но ако агентът се опитва да научи transitions, моделът трябва да предскаже как всички тези floating-point стойности се променят след действие. Лесно е capacity да се похаби върху детайли без значение: трепкащ пиксел, малко по-различен animation frame, промяна в цвят, малко визуален шум.

Едно дискретно латентно състояние може вместо това да кодира същата ситуация така:

room=3, enemy_state=alert, key_status=missing, health_bucket=low

Или, в learned system, може да е по-малко четимо за човек:

[code_18, code_4, code_4, code_71]

Научените codes може да нямат хубави имена, но ограничението е полезно. Агентът не може да измисля безкрайно много едва различими вътрешни състояния. Той трябва да използва отново краен речник. Ако речникът е добър, моделът получава по-чиста дръжка за dynamics: когато съм в такъв тип ситуация и предприема такъв тип действие, това са вероятните следващи типове ситуации.

Това е компресия, но не просто за размера на файла. Това е компресия за учене.

Какво добавя статията на Edan Meyer

Meyer, Adam White и Marlos Machado изследват дискретните представяния в RL през world-model learning, model-free RL и continual RL. Резултатът, който е най-важен за мен, не е лозунгът "discrete beats continuous". Това би било прекалено спретнато, а реалността рядко е толкова учтива.

Полезното твърдение е по-тясно и по-интересно:

Когато моделът има ограничен capacity, дискретните представяния могат да му помогнат да моделира повече от полезния свят. В техните експерименти агентите, използващи тези представяния, учат по-добри policies с по-малко data, а в continual settings се адаптират по-бързо след промени.

Това е точно средата, за която инженерите трябва да се грижат. Почти винаги сме capacity-limited някъде. Може моделът да е малък. Може data да е тънка. Може environment-ът да се променя. Може latency budgets да налагат по-малки компоненти. Може context window на агент да е пълен с irrelevant history. Може светът да е твърде голям, за да бъде моделиран честно, така че системата се нуждае от lossy abstraction, която може постоянно да поправя.

Статията съдържа и полезно предупреждение: ползата може да не идва от discreteness като магическо свойство. Авторите сочат към sparsity и binarity като вероятни contributors. С други думи, "finite choices" помагат отчасти защото налагат structure. Те правят representation-а по-чист, по-селективен и по-лесен за използване от downstream learner.

Тази разлика има значение. Урокът не е да quantize-нем всичко, защото звучи умно. Урокът е да питаш дали твоето representation налага правилния вид опростяване.

Защо това отново изглежда модерно

Дискретните представяния преди звучаха като нишов RL въпрос. Сега изглеждат централни за половината системи, които изграждаме.

LLM-ите са очевидният пример. Моделът вижда token IDs, не prose. Tokenizer-ът решава кои парчета текст стават atomic units. Този избор влияе на cost, context length, multilingual behavior, странни edge cases и понякога reasoning behavior. GPT-2 paper вече е стар според днешните стандарти, но още тогава правеше практическата точка: language modeling е върху sequences of symbols. Modern systems са много по-големи, но symbolic bottleneck-ът още е там.

Agent systems имат същия проблем в по-разхвърляна форма. Един агент може да пази raw transcripts завинаги, но това обикновено е ужасна памет. Полезните агенти се нуждаят от distilled state: open tasks, known constraints, tool results, current plan, unresolved risks, user preferences, environment facts. Това е discrete-ish representation на много по-голяма continuous mess. То казва: това са малкото states, които си струва да се носят напред.

World models правят връзката още по-явна. World model се опитва да научи компактен вътрешен simulator: ако предприема това action от това state, какво става после? DreamerV3 е един съвременен ориентир тук, който показва колко мощно може да бъде да учиш behavior, като си представяш future trajectories вътре в learned model. По-нова работа като Discrete Codebook World Models for Continuous Control продължава да изследва как discrete codebooks могат да помагат дори когато външният control problem е continuous.

Компресията е тихият четвърти sibling. Когато компресираш, избираш кои разлики да игнорираш. Codebook е договор: много raw inputs се мапват към един и същ internal code, защото за текущата цел са достатъчно близки. Това е и което правят добрите abstractions в software. Те collapse-ват irrelevant variation, за да може останалата част от системата да разсъждава.

Шаблонът е навсякъде:

Затова темата се появява отново и отново под различни имена. Tokenization, quantization, bucketing, classification, learned codebooks, symbolic state, sparse binary features: те не са идентични, но всички задават един и същ инженерeн въпрос.

Кои са единиците на мисълта?

Trade-Off-ът

Дискретните представяния са мощни, защото изхвърлят информация.

Точно затова са и опасни.

Лош tokenizer осакатява език. Лоша bucketing схема изтрива сигнала, който ти трябва. Лош learned codebook мапва две смислено различни states към един и същ code и учи policy-то на грешния урок. Дискретната agent memory може да стане уверено lossy, като пази спретнат summary и изпуска единствения неудобен detail, който е имал значение.

Непрекъснатите представяния се провалят различно. Те често пазят твърде много. Позволяват на модела да носи subtle information напред, но downstream learner-ът трябва да открие кои dimensions имат значение. Могат да бъдат гъвкави, но хлъзгави.

Така че практичният избор не е "discrete or continuous?" Той е:

• Къде ми трябва smoothness?
• Къде ми трябват stable categories?
• Къде noise се преструва на information?
• Къде моделът хаби capacity върху irrelevant variation?
• Къде finite vocabulary би направил prediction, planning или debugging по-лесни?

Ако не можеш да отговориш на тези въпроси, discreteness може да стане decoration. Ако можеш, тя става design tool.

Работна рамка

Ето decision framework-а, който наистина бих използвал.

Използвай дискретно представяне, когато системата трябва многократно да разпознава един и същ тип ситуация под шумна surface variation. Game states, UI states, workflow statuses, failure classes, customer intents, document chunks, tool outcomes и environment modes всички пасват на този pattern.

Използвай дискретно представяне, когато следващият модел е по-добре framing-нат като classification, отколкото като regression. Да предскажеш "кой mode идва след това?" може да е по-лесно и по-robust от предсказването на точно floating-point state, особено когато future е multimodal.

Използвай дискретно представяне, когато ти трябва durable memory. Агентите нямат нужда да помнят всеки token от всяко observation. Те имат нужда от compact state, което оцелява достатъчно дълго, за да води следващото действие.

Внимавай с дискретните представяния, когато границата е произволна. Ако две states са разделени само защото implementation-ът ти е имал нужда от bucket, моделът може да наследи това фалшиво distinction. Същият проблем се появява постоянно в analytics dashboards: metric threshold се превръща в reality-distortion field.

Бъди особено внимателен, когато rare case има значение. Discrete compression е чудесна в пазенето на common structure. Тя може да бъде безмилостна към exceptions. В safety, fraud, medical, legal, financial или security systems "tiny detail" може да е целият point.

Инженерната миризма

Има една миризма, която вече забелязвам по-често:

Моделът технически вижда всичко, но не може да използва това, което вижда.

Виждаш го, когато агент има massive context window, но пак губи нишката. Виждаш го, когато policy има high-dimensional observations, но не може да се адаптира след малка environment change. Виждаш го, когато classifier получава richer embeddings, но се проваля върху прости out-of-distribution variants. Виждаш го, когато world model предсказва plausible-looking mush вместо useful next states.

В тези моменти adding capacity може да помогне. More data може да помогне. Bigger model може да помогне.

Но понякога липсващото парче е по-добър bottleneck.

Системата трябва да бъде принудена да каже: това принадлежи с онова, тази разлика няма значение, това състояние вече се е случвало, това действие промени категорията, това е частта, която си струва да се помни.

Това е истинската стойност на дискретните представяния. Те правят reuse възможен.

Какво харесвам в тази линия на изследване

Харесвам работата на Meyer, защото не третира representation като философска гарнитура. Тя поставя избора под experimental pressure. Колко добре учи world model-ът? Колко data трябва на policy-то? Какво става, когато environment-ът се промени? Оцелява ли advantage-ът, когато минем от чист setup към continual learning?

Това са правилните въпроси.

Харесва ми и че отговорът не е карикатурно прост. Статията не доказва, че всички discrete latents са добри. Тя подсказва, че полезните discrete representations правят няколко неща едновременно: намаляват capacity demands, структурират prediction, насърчават sparsity и дават на learner-а по-чисти handles за adaptation.

Това звучи вярно и в обикновеното engineering.

Добрите системи не са raw reality all the way down. Те имат внимателно избрани interfaces. Имат enums. Имат states. Имат event types. Имат schemas. Имат IDs. Имат summaries. Имат lossy, useful names за повтарящи се ситуации.

Machine learning systems се нуждаят от същата discipline. Разликата е, че някои от interfaces са learned вместо handwritten.

Изводът

Дискретните представяния имат значение, защото intelligence не е само да имаш powerful model. То е и да дадеш на модела useful units, с които да мисли.

За RL това може да означава world models, които учат по-полезни transitions с по-малко capacity, и agents, които се адаптират по-бързо, когато светът се промени. За LLM-и се появява в tokenization и context management. За agents се появява в memory, planning state и tool-use traces. За compression и generative models се появява в codebooks, които пазят structure worth keeping.

Практичният урок е прост:

Когато една система се затруднява, не питай само дали моделът е достатъчно голям. Питай дали representation-ът му е достатъчно мил.

Collapse-ва ли noise-а? Пази ли distinctions, които имат значение? Прави ли следващото prediction по-лесно? Дава ли на агента reusable vocabulary за света?

Ако да, discreteness не е ограничение. Тя е handle.