<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
  <title>Paweł Dubiel Tech Blog: Глоссарий</title>
  <link>https://paweldubiel.com/ru</link>
  <atom:link href="https://paweldubiel.com/ru/glossary.xml" rel="self" type="application/rss+xml" />
  <description>Заметки об ИИ, языковых моделях и разработке программного обеспечения.</description>
  <language>ru</language>
  <lastBuildDate>Sun, 11 Oct 2026 00:00:00 GMT</lastBuildDate>
<item>
  <title>Overfitting</title>
  <link>https://paweldubiel.com/ru/glossary/overfitting</link>
  <guid isPermaLink="true">https://paweldubiel.com/ru/glossary/overfitting</guid>
  <pubDate>Sun, 11 Oct 2026 15:59:40 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>У тебя киоск с мороженым. 10 дней ты записывал в тетрадь температуру в полдень и число проданных шариков.</description>
  <content:encoded><![CDATA[<p>У тебя киоск с мороженым. 10 дней ты записывал в тетрадь температуру в полдень и число проданных шариков. Из этих записей ты хочешь вывести правило: завтра обещают 24°C, сколько мороженого приготовить?</p>
<p>Самое простое правило — прямая линия: «каждый лишний градус — это несколько лишних шариков». В примере из этой заметки она ошибается на записанных днях обычно на 27,5 шарика, потому что не видит, что в самую сильную жару продажи падают. Значит, можно дать правилу больше свободы и позволить кривой изгибаться. Самая гибкая из опробованных кривых проходит точно через все 10 точек. Её ошибка на днях из тетради равна 0.</p>
<p>Выглядит это как идеальное правило. Только вот дни из тетради уже прошли, а правило должно работать завтра. На 400 новых днях из того же киоска «идеальная» кривая ошибается обычно на 236,5 шарика. Умеренно гибкая кривая, которая на тетради выглядела хуже (10,9), на новых днях ошибается на 16,8.</p>
<p><strong>Overfitting</strong> — это ситуация, когда у модели маленькая ошибка на данных, использованных для обучения, а ошибка на новых данных того же рода слишком велика по сравнению с ней (<a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio и Courville, <em>Deep Learning</em>, §5.2</a>). Модель подстроилась под особенности своего набора, которые за его пределами не повторяются. Обратная беда называется <strong>underfitting</strong>: правило слишком простое, чтобы хорошо описать даже те данные, которые оно видело. Так ведёт себя прямая линия из нашего примера.</p>
<p><img src="https://paweldubiel.com/assets/overfitting-smooth-rule-versus-tangled-line-through-every-point.webp" alt="Два киоска с мороженым рядом: над первым гладкая линия идёт плавной дугой между точками, над вторым запутанная линия проходит через каждую точку и вылетает далеко за пределы кадра." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="откуда-берётся-эта-разница">Откуда берётся эта разница</h2>
<p>Каждая запись в тетради состоит из двух вещей: закономерности (теплее — значит, больше мороженого) и случайности (как раз приехала экскурсия). Правило должно уловить первую и пропустить вторую. Но модель не знает, что есть что. Она видит только точки.</p>
<p>Сколько случайности модель впитает, зависит от её гибкости, которую в литературе называют <strong>capacity</strong>: способности подстроиться под множество разных форм. Кривую в примере описывают от 2 до 10 чисел, которые подбираются под данные; их количество — это степень кривой плюс один. У кривой степени 9 таких чисел 10 на 10 дней, поэтому она может попасть в каждую точку, вместе со всей случайностью. Авторы учебника описывают это так: очень гибкая модель может представить правильную зависимость, но также и множество других, столь же хорошо подходящих к обучающим данным, и мала вероятность, что она выберет именно ту, которая оправдает себя дальше (§5.2).</p>
<p>Типичный ход событий такой: когда гибкость растёт, ошибка на обучающих данных уменьшается, а ошибка на новых данных сначала уменьшается, потом начинает расти (§5.2, рисунок 5.3). Отсюда следует практическое правило. Модель не оценивают на данных, на которых она училась, а гибкость не подбирают по ошибке на этих данных, потому что та всегда укажет на наибольшую. Часть данных откладывают в сторону: <strong><a href="https://paweldubiel.com/glossary/validation-set" hreflang="pl">validation set [Polski]</a></strong> служит для выбора настроек, а отдельный <strong>test set</strong> — для итоговой оценки (§5.3).</p>
<h2 id="проверь-сам">Проверь сам</h2>
<p>Ниже — тот же киоск. Все числа из этой заметки можно воспроизвести: после нажатия «Сначала» видно 10 дней, а эксперименты 1–5 задают описанные случаи.</p>
<div id="overfitting-lab"></div>
<p>Стоит сделать две вещи, которых не показывает статичный график. Во-первых, включи «24 другие тетради» и меняй степень: при низкой серые линии держатся близко друг к другу, при высокой расходятся во все стороны, хотя каждая получена из того же киоска. Во-вторых, перетащи одну точку высоко вверх. Кривая степени 2 сдвинется лишь немного, а кривая степени 9 перестроится по всей длине, чтобы в неё попасть.</p>
<h2 id="что-помогает">Что помогает</h2>
<ul>
<li><strong>Больше данных.</strong> При 80 днях та же кривая степени 9 ошибается обычно на 14,8 шарика на тетради и на 15,9 на новых днях. Разница почти исчезает, потому что кривая уже не может попасть в каждую точку (§5.2).</li>
<li><strong>Меньшая гибкость.</strong> Кривая степени 3 на 10 днях: 10,9 на тетради, 16,8 на новых днях.</li>
<li><strong>Regularization</strong>, то есть изменение способа обучения, которое должно уменьшить ошибку на новых данных, а не на обучающих (§5.2.2). Пример — штраф за большие коэффициенты, родственный <a href="https://paweldubiel.com/glossary/weight-decay" hreflang="pl">Weight decay [Polski]</a>: кривая степени 9 со штрафом λ = 0,01 ошибается на 5,8 на тетради и на 21,2 на новых днях, а не на 236,5.</li>
</ul>
<p>Ни одну из этих настроек нельзя выбрать, глядя только на ошибку на обучающих данных.</p>
<h2 id="ограничения">Ограничения</h2>
<ul>
<li>Это собственный пример с одной входной величиной и смоделированными данными. Сама случайность даёт здесь обычно 15 шариков ошибки, и ни одно правило не опустится ниже на новых днях.</li>
<li>Форма «сначала лучше, потом хуже» типична, но не гарантирована. Авторы отмечают, что в глубоких сетях трудно даже установить фактическую гибкость модели, потому что она зависит ещё и от алгоритма обучения (§5.2). Поэтому число параметров LLM само по себе не говорит, переобучена ли модель.</li>
<li>Маленькая ошибка на новых данных относится к данным из того же источника. Если киоск переедет к морю, городская тетрадь ничего не обещает.</li>
</ul>
<h2 id="связанные-заметки">Связанные заметки</h2>
<ul>
<li><a href="https://paweldubiel.com/glossary/weight-decay" hreflang="pl">Weight decay [Polski]</a> ограничивает величину весов и является одним из способов уменьшить разницу между ошибкой на обучающих и на новых данных.</li>
<li><a href="https://paweldubiel.com/glossary/grokking" hreflang="pl">Grokking [Polski]</a> описывает случаи, когда модель, выглядящая переобученной, после долгого дальнейшего обучения начинает хорошо работать на новых данных.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> на маленьком наборе требует того же контроля: отдельных данных, которых модель не видела при обучении.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> — другая проблема: там модель теряет прежнее умение после нового обучения, а здесь с самого начала плохо переносится за пределы собственных обучающих данных.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Time horizon</title>
  <link>https://paweldubiel.com/ru/glossary/time-horizon</link>
  <guid isPermaLink="true">https://paweldubiel.com/ru/glossary/time-horizon</guid>
  <pubDate>Sun, 11 Oct 2026 15:02:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>Time horizon в оценке агентов описывает длину задач, при которой агент достигает выбранного уровня успешности. Длина измеряется временем, которое нужно человеку, а не временем работы ИИ.</description>
  <content:encoded><![CDATA[<p><strong>Time horizon</strong> в оценке агентов описывает длину задач, при которой агент достигает выбранного уровня успешности. Длина измеряется временем, которое нужно человеку, а не временем работы ИИ.</p>
<p>Для варианта 50% мы собираем удачные и неудачные попытки агента на задачах с разным временем человека. Подбираем кривую шансов на успех, а затем считываем время, при котором она пересекает 50%. Это предсказание для распределения задач с данным временем; оно не означает, что у каждой из них одинаковый шанс быть выполненной. <a href="https://metr.org/time-horizons/" rel="noopener noreferrer">METR: определение и методология</a>.</p>
<p>Учебный пример: если подобранная кривая достигает 50% на двух часах, то два часа и есть горизонт. Удачную задачу агент может выполнить гораздо быстрее. Сам по себе результат не говорит и о том, насколько успешно агент справится с задачей из другой области.</p>
<p>Чтобы такое считывание имело смысл, между временем человека и сложностью для ИИ должна быть осмысленная зависимость. Когда кривая плоская, небольшое изменение шансов может сильно сдвинуть точку её пересечения с порогом. <a href="https://paweldubiel.com/ru/articles/a-longer-metr-horizon-does-not-mean-proportionally-harder-tasks">Статья о пересчёте горизонта METR</a> показывает эту проблему на примере, который можно просчитать, и разбирает новую подгонку к данным METR. <a href="https://arxiv.org/html/2610.12466v1#S2" rel="noopener noreferrer">Nguyen и Fithian, §2–3</a>.</p>
<p>При сравнении горизонтов нужно сохранять сведения о наборе задач, среде агента, бюджете попыток и принятом пороге успешности.</p>]]></content:encoded>
</item>
<item>
  <title>Item response theory</title>
  <link>https://paweldubiel.com/ru/glossary/item-response-theory</link>
  <guid isPermaLink="true">https://paweldubiel.com/ru/glossary/item-response-theory</guid>
  <pubDate>Sun, 11 Oct 2026 15:01:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>Item response theory (IRT) — это семейство методов, которые по ответам на отдельные задания совместно оценивают способности исполнителей и сложность заданий.</description>
  <content:encoded><![CDATA[<p><strong>Item response theory (IRT)</strong> — это семейство методов, которые по ответам на отдельные задания совместно оценивают способности исполнителей и сложность заданий. В оценке ИИ исполнитель — это агент, а ответом может быть успех или неудача целой попытки.</p>
<p>Допустим, два агента решают одни и те же три задачи. Первый обычно справляется с A и B, второй — ещё и с C. Сам процент успехов даёт рейтинг. IRT пытается вдобавок оценить, насколько C сложнее остальных задач и какая разница в способностях объясняет картину ответов. Это учебный пример; такой маленькой таблицы недостаточно для надёжной подгонки.</p>
<p>В простой модели Раша шанс на успех растёт, когда способности агента больше по отношению к сложности задачи. Обе величины скрытые: мы делаем о них выводы по результатам, а не отождествляем сразу сложность с длиной инструкции или временем человека. Разные варианты IRT добавляют новые параметры и допущения.</p>
<p>В <a href="https://paweldubiel.com/ru/articles/a-longer-metr-horizon-does-not-mean-proportionally-harder-tasks">анализе горизонтов METR</a> авторы связывают скрытую сложность со временем работы человека с помощью обучаемой кривой. Они добавляют эффекты семейств задач и разброс результатов повторных попыток. Это позволяет проверить, в каком диапазоне время действительно различает задачи, трудные и лёгкие для ИИ. <a href="https://arxiv.org/html/2610.12466v1#S2.SS3" rel="noopener noreferrer">Nguyen и Fithian, §2.3 и §3.1</a>.</p>
<p>Хорошее предсказание ответов не доказывает, что выученный параметр охватывает все виды способностей агента. При интерпретации нужно проверять допущения модели и результаты на задачах, не использованных при подгонке.</p>]]></content:encoded>
</item>
<item>
  <title>Elastic Weight Consolidation</title>
  <link>https://paweldubiel.com/ru/glossary/elastic-weight-consolidation</link>
  <guid isPermaLink="true">https://paweldubiel.com/ru/glossary/elastic-weight-consolidation</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Модель направляет вопросы клиентов в отделы «доставка» и «возвраты». Теперь она должна научиться распознавать рекламации, но хранить старые сообщения больше нельзя.</description>
  <content:encoded><![CDATA[<p>Модель направляет вопросы клиентов в отделы «доставка» и «возвраты». Теперь она должна научиться распознавать рекламации, но хранить старые сообщения больше нельзя. Значит, повторять их во время обучения не получится. Единственное, что осталось от старой задачи, — сама модель: миллионы чисел, настроенных в ходе прежнего обучения, которые называют весами.</p>
<p>Можно учить модель рекламациям без всяких ограничений. Тогда веса сдвигаются туда, где это помогает новой задаче, — в том числе те, от которых зависело распознавание доставки и возвратов. Можно также штрафовать любое изменение одинаково, но тогда модель держится за старые настройки так крепко, что плохо учится новому. Нужен ответ на вопрос: <strong>какие веса можно трогать, а какие лучше не надо?</strong></p>
<p><strong>Elastic Weight Consolidation (EWC)</strong> добавляет к обучению новой задаче штраф за отдаление весов от значений после старой задачи, причём штраф тем больше, чем важнее был данный вес для старой задачи. Авторы сравнивают это с пружиной, прикреплённой к каждому весу: жёсткой у важных весов, слабой у остальных (<a href="https://arxiv.org/abs/1612.00796" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §2</a>).</p>
<p><img src="https://paweldubiel.com/assets/elastic-weight-consolidation-stiff-and-loose-springs.webp" alt="Ряд дисков, прикреплённых пружинами к столбикам: диски на толстых жёстких пружинах остаются на месте, а те, что на тонких и слабых, сдвигаются в сторону красного круга." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="два-веса-одна-новая-задача">Два веса, одна новая задача</h2>
<p>Возьмём всего два веса. После обучения доставке и возвратам оба равны 1. Первый для старых отделов очень важен (важность 10), второй почти безразличен (важность 0,1). Новая задача требует лишь, чтобы <strong>сумма обоих весов равнялась 4</strong>. Этому удовлетворяет много настроек: (2, 2), но также и (1, 3).</p>
<ul>
<li><strong>Без защиты</strong> обучение сдвигает оба веса поровну, до (2, 2). Новая задача освоена, но важный вес уехал на 1, и потери на старой задаче растут с 0 до 5,05.</li>
<li><strong>Одинаковый штраф</strong> для обоих весов останавливает их на полпути, на (1,67, 1,67). Старая задача страдает меньше, но сумма равна 3,33 вместо 4.</li>
<li><strong>EWC</strong> переносит почти всё движение на маловажный вес: (1,02, 2,80). Сумма равна 3,82, а потери на старой задаче — всего 0,16.</li>
</ul>
<p>Потери — это число, которое говорит, насколько сильно модель ошибается; чем оно меньше, тем лучше. В эксперименте ниже можно менять силу штрафа λ и способ защиты. Результат считается точно для этого примера с двумя весами; это не симуляция настоящей сети.</p>
<div id="ewc-spring-lab"></div>
<h2 id="как-узнать-какой-вес-важен">Как узнать, какой вес важен</h2>
<p>В настоящей сети никто не задаёт важность заранее. Её оценивают после завершения старой задачи, пока её данные ещё доступны: проверяют, насколько сильно небольшое изменение данного веса меняет ответы модели на старых примерах. Работа использует для этого диагональ <em>информационной матрицы Фишера</em>, то есть одно число важности на каждый вес. Потом данные можно удалить; остаются старые значения весов и их важности.</p>
<p>Во время нового обучения минимизируется сумма двух слагаемых (уравнение 3 в работе):</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>L</mi><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>L</mi><mi>B</mi></msub><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>+</mo><munder><mo>∑</mo><mi>i</mi></munder><mfrac><mi>λ</mi><mn>2</mn></mfrac><msub><mi>F</mi><mi>i</mi></msub><mtext> </mtext><mo stretchy="false">(</mo><msub><mi>θ</mi><mi>i</mi></msub><mo>−</mo><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup><msup><mo stretchy="false">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">L(\theta) = L_B(\theta) + \sum_i \frac{\lambda}{2} F_i \,(\theta_i - \theta^*_{A,i})^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">L</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.6491em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3714em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">2</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">λ</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.2472em;vertical-align:-0.3831em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7387em;"><span style="top:-2.453em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3831em;"><span></span></span></span></span></span></span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>L</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">L_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> — потери на новой задаче, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>θ</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">\theta_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> — текущее значение веса номер <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup></mrow><annotation encoding="application/x-tex">\theta^*_{A,i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1059em;vertical-align:-0.4114em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6887em;"><span style="top:-2.4247em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4114em;"><span></span></span></span></span></span></span></span></span></span> — его значение после старой задачи, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>F</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">F_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> — его важность, а <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi></mrow><annotation encoding="application/x-tex">\lambda</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span></span></span></span> говорит, насколько старая задача значима по сравнению с новой. В нашем примере <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mo stretchy="false">(</mo><mn>10</mn><mo separator="true">;</mo><mtext> </mtext><mn>0,1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F = (10;\ 0{,}1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">10</span><span class="mpunct">;</span><span class="mspace"> </span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> и <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\lambda = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>.</p>
<h2 id="границы-метода">Границы метода</h2>
<p>Важность — это приближение, которое считается в одной точке, отдельно для каждого веса. Сами авторы показывают, что их оценка бывает слишком уверенной в том, какие веса несущественны, и называют это главной слабостью метода (§2.2 и §3). В их экспериментах с играми Atari агент с EWC учился многим играм по очереди, но не сравнялся с отдельными сетями, обученными для каждой игры. Результаты относятся к распознаванию цифр и играм, а не к большим языковым моделям. Наши два веса и сообщения клиентов — собственное упрощение.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> — это значительное ухудшение прежних умений после нового обучения; EWC пытается ограничить его без доступа к старым данным.</li>
<li><a href="https://paweldubiel.com/ru/glossary/experience-replay">Experience Replay</a> решает ту же проблему иначе: хранит часть старых примеров вместо важностей весов.</li>
<li><a href="https://paweldubiel.com/ru/glossary/continual-learning">Continual Learning</a> задаёт цель, то есть обучение новым задачам с сохранением прежних; EWC — один из методов.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> — это дальнейшее обучение готовой модели; EWC меняет его цель, добавляя штраф за сдвиг важных весов.</li>
</ul>
<p><em>Текст и иллюстрация подготовлены с помощью ИИ. Два веса, их важности и демонстрация — собственный упрощённый учебный пример; иллюстрация — метафора, а не схема устройства модели.</em></p>]]></content:encoded>
</item>
<item>
  <title>Reservoir Sampling</title>
  <link>https://paweldubiel.com/ru/glossary/reservoir-sampling</link>
  <guid isPermaLink="true">https://paweldubiel.com/ru/glossary/reservoir-sampling</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Модель службы поддержки учится на сообщениях, которые приходят одно за другим. Ты хочешь сохранить несколько из них для повторения в будущем, но у тебя в памяти всего четыре места.</description>
  <content:encoded><![CDATA[<p>Модель службы поддержки учится на сообщениях, которые приходят одно за другим. Ты хочешь сохранить несколько из них для повторения в будущем, но у тебя в памяти всего четыре места. К тому же ты не знаешь, сколько сообщений ещё придёт: двадцать или два миллиона.</p>
<p>Оставить первые четыре? Тогда память знает только начало. Всегда держать четыре последних? Тогда она знает только конец. Честный случайный выбор «четырёх из всего» потребовал бы хранить всё или заранее знать число сообщений. Вопрос такой: <strong>как при постоянном числе мест и неизвестной длине потока дать каждому сообщению один и тот же шанс?</strong></p>
<p><strong>Reservoir Sampling</strong> — это способ поддерживать случайную выборку постоянного размера за один проход по данным, количество которых заранее неизвестно. После каждого очередного сообщения память, называемая здесь резервуаром, содержит честную случайную выборку из всего, что пришло до этого момента. Простейшую версию, Algorithm R, описывает <a href="https://doi.org/10.1145/3147.3165" rel="noopener noreferrer">Vitter, <em>Random Sampling with a Reservoir</em>, §2</a>, приписывая её Alan Waterman.</p>
<p><img src="https://paweldubiel.com/assets/reservoir-sampling-pebble-stream-four-slot-tray.webp" alt="Длинный поток камешков и ракушек течёт мимо маленького деревянного лотка с четырьмя углублениями; одна рука вынимает камешек из лотка, другая кладёт на его место камешек из потока." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="рецепт-в-два-шага">Рецепт в два шага</h2>
<ol>
<li>Первые четыре сообщения попадают в память без жребия.</li>
<li>Сообщение номер <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> (пятое, шестое и каждое следующее) попадает в память с шансом <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>. Если попало, оно заменяет одно из четырёх сохранённых, выбранное случайно.</li>
</ol>
<p>Пятое сообщение, таким образом, входит с шансом 4/5, сотое — с шансом 4/100. У новых сообщений шанс войти всё меньше, но старые уже много раз рисковали быть выброшенными, и эти два эффекта в точности уравновешиваются. Проверим это после пятого сообщения. Оно входит с шансом 4/5. Первое сообщение выпадает только тогда, когда пятое вошло (4/5) и попало как раз на его место (1/4), то есть с шансом 1/5. Оно остаётся с шансом 4/5: таким же, как у пятого. После <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> сообщений каждое из них находится в памяти с шансом <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span>.</p>
<h2 id="равный-шанс--не-гарантия">Равный шанс — не гарантия</h2>
<p>В эксперименте поток состоит из 20 сообщений. Восемнадцать касаются доставки, а два, девятое и пятнадцатое, — возвратов. Каждый запуск пропускает такой поток 2000 раз и считает, как часто данная позиция оставалась в памяти в конце. Случайный выбор настоящий, поэтому результаты каждый раз отличаются на долю процента.</p>
<div id="reservoir-sampling-lab"></div>
<p>При Reservoir Sampling каждый столбик составляет около 20%, то есть 4/20. При этом в большинстве прогонов ни один из двух возвратов не остаётся в памяти. Точное значение — 3060/4845, то есть около 63%: столько из всех четвёрок, выбранных из 20 сообщений, состоит исключительно из восемнадцати сообщений о доставке. Метод честен по отношению к отдельным сообщениям, но не следит за тем, чтобы у каждой категории был представитель.</p>
<h2 id="где-это-важно">Где это важно</h2>
<p>В обучении с повторением Reservoir Sampling служит способом записи в буфер: не нужно знать ни длину потока, ни границы между задачами. <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, алгоритм 2</a> используют его именно так. В их экспериментах на задачах с изображениями он работал хорошо, за исключением очень маленькой памяти, когда из буфера исчезали более ранние классы; лучше тогда показывали себя стратегии, заботящиеся о равном представительстве классов (§4.4). Это результат для классификации изображений, а не для LLM.</p>
<p>Сам алгоритм не относится к машинному обучению. Работа Vitter 1985 года описывает случайный выбор записей с магнитной ленты неизвестной длины и предлагает более быстрые варианты, которые, вместо того чтобы бросать жребий на каждой записи, вычисляют, сколько записей пропустить. Сообщения клиентов и поток из 20 позиций — собственный пример.</p>
<ul>
<li><a href="https://paweldubiel.com/ru/glossary/experience-replay">Experience Replay</a> нуждается в буфере со старыми примерами; Reservoir Sampling — один из способов решать, что в него попадает.</li>
<li><a href="https://paweldubiel.com/ru/glossary/continual-learning">Continual Learning</a> предполагает обучение на потоке данных при ограниченной памяти, то есть ситуацию, когда сохранить всё невозможно.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> может усилиться, когда из маленькой памяти выпадут все примеры старой категории.</li>
</ul>
<p><em>Текст и иллюстрация подготовлены с помощью ИИ. Поток сообщений и демонстрация — собственный упрощённый учебный пример; иллюстрация — метафора, а не схема алгоритма.</em></p>]]></content:encoded>
</item>
<item>
  <title>Experience Replay</title>
  <link>https://paweldubiel.com/ru/glossary/experience-replay</link>
  <guid isPermaLink="true">https://paweldubiel.com/ru/glossary/experience-replay</guid>
  <pubDate>Sun, 11 Oct 2026 08:22:26 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Модель научилась направлять вопросы клиентов в отделы «доставка» и «возвраты». Теперь ты дообучаешь её распознавать рекламации, например «Товар пришёл повреждённым».</description>
  <content:encoded><![CDATA[<p>Модель научилась направлять вопросы клиентов в отделы «доставка» и «возвраты». Теперь ты дообучаешь её распознавать рекламации, например «Товар пришёл повреждённым». Если в следующих упражнениях она видит одни только рекламации, она может хуже справляться с давно знакомым «Где посылка?». Полный старый архив недоступен. Можно ли возвращаться хотя бы к нескольким сохранённым сообщениям?</p>
<p><strong>Experience Replay (ER)</strong> состоит в том, чтобы хранить часть прежних примеров и повторно использовать их для обучения. В простом варианте к порции новых данных подмешиваются примеры из памяти, которую называют <em>replay buffer</em>. Это контейнер с данными для повторения, а не запись всех знаний модели. Такое совместное обучение описывают <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, алгоритм 1</a>.</p>
<p><img src="https://paweldubiel.com/assets/experience-replay-card-box-returning-examples.webp" alt="Сохранённые тёмно-синие и охристые карточки возвращаются из небольшой коробки в ряд новых красных карточек: метафора повторения во время дальнейшего обучения." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="что-попадает-в-следующее-упражнение">Что попадает в следующее упражнение</h2>
<p>Перед потерей архива мы сохранили четыре сообщения вместе с правильными отделами. Теперь у нас четыре новые рекламации. Без повторов модель учится на четырёх новых сообщениях. С повторами она упражняется ещё и на четырёх старых: снова получает сигнал, что «Где посылка?» относится к доставке. В этом маленьком примере мы используем весь буфер; большие буферы обычно выдают случайно выбранную порцию.</p>
<p>Однако посчитать места в памяти недостаточно. В четырёх сохранённых вопросах о доставке нет ни одного примера возврата. Если заменить два из них на «Как отправить покупку обратно?» и «Хочу вернуть рубашку», число повторов останется тем же, но они охватят оба прежних отдела. Эксперимент ниже <strong>считает примеры в порции данных; он не предсказывает точность модели</strong>.</p>
<div id="experience-replay-lab"></div>
<h2 id="повторы-помогают-только-на-доступных-данных">Повторы помогают только на доступных данных</h2>
<p>Модель получает возможность упражняться в прежних ответах, но не гарантию сохранения всех умений. Маленькая случайная выборка может полностью упустить редкую категорию; такую проблему исследователи наблюдали при очень маленьких буферах (§4.4 той же работы). Наши сообщения — собственный пример, а не результат этих экспериментов. Результат обучения нужно проверять на отдельных старых и новых сообщениях, не использованных для тренировки. Кроме того, буфер занимает память и требует хранить отобранные данные.</p>
<p>См. также: <a href="https://paweldubiel.com/ru/glossary/reservoir-sampling">Reservoir Sampling</a> — способ решать, какие примеры из потока попадают в буфер постоянного размера, дающий каждому равный шанс.</p>
<p>В играх, в <a href="https://paweldubiel.com/glossary/reinforcement-learning" hreflang="pl">Reinforcement Learning [Polski]</a> — обучении действиям на основе наград — сохраняют ситуацию, действие, награду и следующую ситуацию. Случайный выбор таких записей ослабляет зависимость от событий, следующих непосредственно друг за другом (<a href="https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf#page=7" rel="noopener noreferrer">Mnih et al., <em>Human-level control through deep reinforcement learning</em>, Methods, «Training algorithm for deep Q-networks»</a>). Это другие данные, чем сообщение с правильным отделом; результаты с Atari нельзя напрямую переносить на LLM.</p>
<ul>
<li><a href="https://paweldubiel.com/ru/glossary/continual-learning">Continual Learning</a> задаёт цель дальнейшего обучения с сохранением прежних способностей; ER — один из способов её достижения.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> описывает значительное ухудшение прежних умений, которое повторы могут ограничивать.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> — это дальнейшее обучение модели; replay меняет подбор его данных. Простая вставка старых сообщений в разговор не является таким обновлением модели.</li>
</ul>
<p><em>Текст и иллюстрация подготовлены с помощью ИИ. Сообщения и демонстрация — собственный упрощённый учебный пример; иллюстрация — метафора, а не схема устройства модели.</em></p>]]></content:encoded>
</item>
<item>
  <title>Continual Learning</title>
  <link>https://paweldubiel.com/ru/glossary/continual-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/ru/glossary/continual-learning</guid>
  <pubDate>Sat, 10 Oct 2026 20:03:52 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Модель направляет сообщения клиентов в отделы «заказы» и «возвраты». Она умеет распознать «Где моя посылка?». Теперь компания открывает отдел рекламаций.</description>
  <content:encoded><![CDATA[<p>Модель направляет сообщения клиентов в отделы «заказы» и «возвраты». Она умеет распознать «Где моя посылка?». Теперь компания открывает отдел рекламаций. Ты дообучаешь модель на сообщениях о повреждённых товарах. Рекламации попадают по адресу всё точнее, но часть вопросов о доставке тоже начинает оказываться в новом отделе. Проверка одних только рекламаций дала бы ложное ощущение прогресса.</p>
<p>Тебе нужно <strong>учить модель новому, сохраняя прежние умения</strong>. Это цель <strong>Continual Learning</strong>: обучения на данных или задачах, которые поступают последовательно, с учётом того, чему модель научилась раньше. Название обозначает проблему и семейство подходов; оно не гарантирует, что забывания не будет. Такую потребность описывают <a href="https://arxiv.org/html/1612.00796v2#S1" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §1</a>.</p>
<p><img src="https://paweldubiel.com/assets/continual-learning-embroidered-sampler-growing-repertoire.webp" alt="На одном куске ткани остаются вышитые круги и треугольники, а игла добавляет новый волнистый узор: метафора развития умений с сохранением прежних." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="что-мы-меняем-в-обучении-и-проверке">Что мы меняем в обучении и проверке</h2>
<p>Допустим, полный архив примеров, на которых модель училась раньше, уже недоступен. Перед его удалением мы сохранили небольшую выборку: 20 сообщений с известными правильными отделами. Один из возможных методов состоит в том, чтобы подмешать эту выборку к новым примерам рекламаций. Благодаря этому дальнейшее обучение получает ещё и сигнал по-прежнему правильно обрабатывать «Где моя посылка?». Повторное использование старых примеров — одна из стратегий, которые описывают <a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven и Tolias, <em>Three scenarios for continual learning</em>, §3.3</a>.</p>
<p>См. также: <a href="https://paweldubiel.com/ru/glossary/experience-replay">Experience Replay</a> — хранение небольшой выборки старых примеров и подмешивание её к новому обучению.</p>
<p>Команда, которая оценивает модель, держит отдельный тест из старых сообщений, который <strong>мы не используем для обучения</strong>. После каждого обновления мы проверяем и старые, и новые категории. Числа ниже — выдуманный пример, а не результат исследования; в каждом тесте 100 сообщений.</p>

























<table><thead><tr><th>Вариант модели</th><th>Правильные старые сообщения</th><th>Правильные рекламации</th></tr></thead><tbody><tr><td>До нового обучения</td><td>90/100</td><td>0/100 — такой категории нет</td></tr><tr><td>После обучения только на рекламациях</td><td>40/100</td><td>92/100</td></tr><tr><td>После обучения с выборкой старых сообщений</td><td>89/100</td><td>87/100</td></tr></tbody></table>
<p>Последний вариант лучше сохраняет прежнее умение, хотя распознаёт рекламации слабее, чем второй. Таблица показывает, <strong>что сравнивать</strong>; она не обещает такого результата после добавления 20 примеров.</p>
<h2 id="условия-меняют-сложность">Условия меняют сложность</h2>
<p>В нашем примере модель сама выбирает среди всех известных ей отделов. Подсказка «это сообщение из новой категории» облегчила бы тест. Доступность таких подсказок и границ между задачами важна при сравнении методов (<a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven и Tolias, §2–2.3</a>). Небольшая выборка может упустить редкие вопросы; хорошее среднее не доказывает, что сохранилось каждое умение.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> описывает значительное ухудшение старых умений; его демонстрация показывает, как новое обучение меняет общие настройки.</li>
<li><a href="https://paweldubiel.com/glossary/fine-tuning" hreflang="pl">Fine-tuning [Polski]</a> — это дальнейшее обучение модели на отобранных примерах. После очередных тренировок мы проверяем и прежние способности.</li>
<li><a href="https://paweldubiel.com/glossary/knowledge-distillation" hreflang="pl">Knowledge Distillation [Polski]</a> может передавать подсказки от старой модели к обновляемой; это другая стратегия, чем хранение исходных сообщений (§3.3 работы van de Ven и Tolias).</li>
</ul>
<p><em>Текст и иллюстрация подготовлены с помощью ИИ; сообщения, размер выборки и результаты в таблице — собственный учебный пример. Иллюстрация показывает цель — сохранение прежних умений, а не устройство модели.</em></p>]]></content:encoded>
</item>
</channel>
</rss>