БиржаDEX+

Купить крипто Рынки Спотовая ФьючерсыBTC Сбережения Центр событий

Еще

Современное обучение нейросетей часто напоминает алхимию. У нас есть работающие рецепты, но как именно статистическая модель превращает терабайты текста в понимСовременное обучение нейросетей часто напоминает алхимию. У нас есть работающие рецепты, но как именно статистическая модель превращает терабайты текста в поним

Апофатический ИИ: Почему нейросети учатся через «НЕТ», и как синтетические данные убивают смысл

Автор: ProBlockChain

Источник: ProBlockChain

2026/01/18 13:26

Современное обучение нейросетей часто напоминает алхимию. У нас есть работающие рецепты, но как именно статистическая модель превращает терабайты текста в понимание до сих пор непонятно.

Почему возможно сублиминальное обучение (передача паттернов через шум)? Почему обучение на синтетических данных приводит к деградации, даже если данные кажутся качественными?

В этой статье я предлагаю взглянуть на архитектуру обучения под другим углом. Суть проста: позитивные определения в высокой размерности вычислительно неэффективны. Нейросеть не учит, что такое объект. Она учит, чем объект не является, и от качества этого «НЕ» зависит, насколько интеллектуальна будет модель.

Далее — теория, эксперименты на PyTorch (код прилагается), математика и объяснение того, почему коллапс LLM весьма вероятен.

1. Смысл как галлюцинация ограниченной пустоты

Идея о том, что смысл рождается из отрицания, не нова. От апофатического богословия (Бог непознаваем, можно лишь сказать, чем он не является) до структурной лингвистики Соссюра и диалектики Гегеля («Определенность есть отрицание») многие вполне авторитетные философы приходили к выводу:

Если продолжить, то смысл это система различий (по Соссюру), которая выстраивается через механизм активного отрицания (по Гегелю). Применительно к нейросетям (LLM) это можно сформулировать как:

Например, яблоко — это не список признаков (красное, круглое), а область в пространстве понятий, которая НЕ груша (близко, но отличается формой), НЕ помидор (похож цветом, но не фрукт), НЕ мяч (форма, но несъедобен). Границы этих отрицаний и формируют смысл как устойчивый аттрактор, возникающий из жёстких границ различения в системе с ограниченной ёмкостью.

Эту систему структурных отрицаний (границ, отделяющих концепт от похожих, но различных объектов) мы будем называть Тенью концепта — по аналогии с апофатической традицией, где истина познаётся через то, чем она не является.

Генерализация и галлюцинация в нейросетях — это технически изоморфные процессы заполнения латентного пространства. Различие между ними носит топологический характер. Если границы распределения вероятностей жесткие (нейросеть имеет четкий сигнал “так нельзя”), генерация остается в пределах валидного спектра, близкого к факту. Если границы размыты, генерация дрейфует в область правдоподобного шума (галлюцинации). Таким образом, смысл формируется не за счёт накопления позитивных примеров, а за счёт системы негативных связей — ограничений, отсекающих неверные траектории.

Чтобы понять механику этого процесса, рассмотрим информацию как единый поток, меняющий свое состояние:

Вариативная энтропия (S_dead). Это сырьё для обучения: шум, уникальные детали, контекст, синтаксические вариации. Это то, что модель должна переработать. В процессе обучения эта информация отбрасывается для снижения размерности. Чем выше вариативность входных данных, тем сильнее давление на веса модели.

Структурные ограничения (S_anti, Тень). Это результат переработки энтропии, границы, которые кристаллизуются под давлением функции потерь. Здесь критическую роль играют Hard Negatives (граничные примеры). Это энтропия с максимальной плотностью информации: она создает высокий градиент ошибки, заставляя модель формировать жесткую геометрию весов.

Важно понять: у нейросети нет хранилища образов. У неё есть только система навигации по запретам. Смысл — это не то, что модель хранит, а то, куда она неизбежно попадает, будучи зажатой ограничениями. Если границы (S_anti) слабые — смысл утекает, превращаясь в галлюцинацию.

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

Таким образом, в рамках предложенной модели генерализация рассматривается не как накопление паттернов, а как процесс селективной компрессии. Для выделения инварианта система обязана необратимо отбросить уникальную информацию о конкретных примерах (энтропия, S_dead) и сформировать новый компонент — структурную тень (S_anti), которая задает границы допустимого. Смысл здесь не набор признаков, а остаточное пространство вероятностей, ограниченное жесткими запретами.

Качество модели определяется точностью этой фильтрации:

Ошибка первого рода (Переобучение): Если система чрезмерно переработала вариативную энтропию, границы (S_anti) вырождаются — вместо инвариантных правил формируются абсолютные ограничения, привязанные к конкретным значениям обучающих примеров. Модель идеально работает на training set, но не обобщает на новые данные.
Ошибка второго рода (Размывание границ): Если система теряет S_anti (границы), возникают галлюцинации. Модель генерирует правдоподобный, но логически неверный контент, так как у неё нет механизма отсечения невалидных состояний.

То есть, генерализация — это обмен памяти о фактах на понимание топологии того, чем они не являются.

Важно отметить, что любое позитивное обучение LLM — это на самом деле обучение через огромное количество «НЕТ», на каждый предсказываемый токен приходятся десятки тысяч отброшенных, но давших свой сигнал отрицания.

2. Следствия для ML-инженерии

Концепция объясняет известные эмпирические факты через новый взгляд:

Неэффективность «Позитивного» обучения: Эффективнее показывать модели не миллион фотографий кошек, а миллион почти-кошек, которые на неё похожи (собаки, тигры, меховые шапки).
Природа эмбеддингов: Близость векторов в скрытом пространстве (Cosine Similarity) означает не столько схожесть, сколько критичность различения. Gradient descent создаёт отрицательные градиенты пропорционально произведению вероятностей: близкие конкуренты (высокие P_j) активно отталкиваются, далёкие (низкие P_j) игнорируются. Поэтому похожие концепты (apple/orange) критично важно различать, в то время как далёкие (apple/galaxy) различаются тривиально. Embedding space кластеризует объекты не для демонстрации сходства, а чтобы подвести их на линию огня градиентного спуска.
Неизбежность коллапса: Если модель учится на данных, сгенерированных другой моделью (синтетика), она теряет тень — информацию о том, где проходят жесткие границы недопустимого. Что ведет к растворению смысла.
Трудность continual learning: Catastrophic forgetting можно интерпретировать как разрушение системы структурных ограничений (S_anti) при попытке адаптации к новым задачам. Доучивание отдельных фактов (расширение S_dead) относительно безопасно, но изменение фундаментальных границ различения требует повторной генерализации всей системы. Это объясняет, почему методы типа fine-tuning работают для узких задач, но ломаются при попытке радикально изменить понимание концептов.
Роль архитектуры: Успех Transformers над RNN можно частично объяснить через способность формировать более плотную систему отрицаний: Self-attention явно вычисляет отношения между всеми токенами, что позволяет селективно подавлять нерелевантные связи через Softmax, создавая rich negative signal, в то время как RNN накапливает шум в скрытом состоянии при последовательной обработке.
Dropout как сэмплирование теней: Dropout можно интерпретировать не только как регуляризацию, но и как способ проверки устойчивости системы отрицаний: если модель полагается на одно ограничение (один путь в сети), dropout заставляет формировать избыточные, перекрывающиеся границы.
Quantization: При квантизации весов (INT8, INT4) мы огрубляем геометрию запретов. Если границы были кристаллизованы с высокой точностью (через rich вариативную энтропию), они устойчивы к квантизации. Если границы размыты (обучение на синтетике), квантизация разрушает их.
Data augmentation: повышает вариативную энтропию искусственно, создавая давление на формирование более жёстких границ. Однако если аугментация слишком агрессивна (выходит за пределы естественного многообразия), она создаёт шум вместо структуры — модель не может найти инвариант.
Гипотеза многообразий (Manifold Hypothesis) утверждает, что данные реального мира сосредоточены на низкоразмерных многообразиях, вложенных в высокоразмерное пространство признаков. Однако многообразие само по себе — это лишь статистическая структура, описывающая допустимые вариации данных. Смысл возникает не внутри многообразия, а на его границах — в точках, где одно многообразие (кот) отделяется от других (собака, лиса).В терминах нашей концепции: многообразие кодирует вариативную энтропию (S_dead), но смысл кристаллизуется в структурных ограничениях (S_anti), разделяющих многообразия. Только тогда кот проявляется через не-кота — через систему отрицаний, отсекающих соседние концепты.

В реально больших и хаотичных корпусах текстов (на которых обучаются современные LLM) уже присутствуют hard negatives. Разнообразие естественного языка обеспечивает наличие множества близких, но неверных продолжений, на различении которых и строится смысл. Стандартное next-token prediction на таких данных в существенной степени апофатично по своей природе — хотя явное усиление hard negatives (через contrastive методы или curated датасеты) может дать существенный выигрыш в генерализации.

Прежде чем переходить к экспериментам, давайте посмотрим на геометрию мышления. Почему нейросети (и мозг) выбирают стратегию отрицания? Ответ кроется в проблеме упаковки информации.

В высокоразмерных представлениях с ограниченной ёмкостью нейросети оказываются структурно смещены в сторону обучения через отрицание.

Позитивные определения (тождества) требуют выделения объёма в латентном пространстве (кластеров). Поэтому они неизбежно конкурируют друг с другом, усиливая интерференцию по мере роста числа понятий. Трудно разместить много разных объектов в одной точке пространства без коллизий.

Негативные определения (различия) реализуются как ограничения и границы — почти ортогональные направления или гиперплоскости. В многомерном пространстве такие плоскости могут накладываться и пересекаться в огромных количествах без взаимного разрушения. Позитивные сигналы локальны, отрицательные — глобальны по геометрии пространства.

Кроме того, отрицания устойчивее, потому что если один нейрон потерял данные позитивное кодирование теряет весь концепт, в негативном кодировании потеря одного нейрона убирает одно ограничение из многих.

Принципиально важным я считаю, что возможна иерархия отрицаний, которая, в отличие от позитивного кодирования, сворачивается до конечного (дискретного) числа различений и переиспользуется для разных контекстов. Это даёт нейросети композициональность, устойчивость, масштабируемость и возможность генерализации с минимальными затратами (лучший пример игра “Акинатор”)

В результате ограничения масштабируются значительно эффективнее: система может кодировать экспоненциально больше различий, не расходуя пропорционально больше representational capacity. Это делает обучение через негативы (контрасты, hard negatives, границы классов) не философским выбором, а геометрически и информационно неизбежной стратегией для эффективных нейросетей.

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

Звучит как философия, но попробуем перевести ее в код.

3. Дизайн эксперимента: Методология

Чтобы проиллюстрировать теорию, нет необходимости в мощных видеокартах, хватило компьютера с процессором Intel Core i5-4440 CPU 3.10 GHz. Была подобрана задача, где нельзя угадать по контексту, требуется логика. Задача выбрана намеренно минимальной, чтобы исключить семантический шум и изолировать эффект границы.

Задача: Проверка сортировки массива. Дана последовательность чисел. True, если она отсортирована (xi≤x[i+1]). False, если нет.

Я использовал крошечную LSTM (TinyLSTM: hidden_size=32, embedding=8). Это создает искусственный дефицит ресурсов (Information Bottleneck). Модель физически не может запомнить все варианты и приходится искать алгоритм.

Обучались две идентичные модели на одинаковом количестве шагов (1600). Разница только в генерации негативных примеров (класс False):

Baseline (Классический подход): Учится отличать отсортированный массив от случайного шума (Random Shuffle). Это аналог обучения на сырых данных, где структура ошибки случайна.
Concept (Наш подход): Учится отличать отсортированный массив от массива, где перепутана всего одна пара чисел (Hard Negative swap). Это аналог обучения на границах.

Чтобы убедиться, что модель не просто выучила локальный паттерн зубца (сбоя), а поняла принцип, дополнительно были проведены тесты на экстраполяцию (тест на длине 40 при обучении на 6-12, Extrapolation) и множественные ошибки.

Симуляция Коллапса:
Я смоделировал ситуацию когда нейросети обучаются на собственных текстах, запустив цепочку поколений. Каждое следующее поколение училось на данных, размеченных предыдущей моделью (псевдо-лейблинг).

Gen 0: Обучена на Ground Truth (Реальность).
Gen 1: Обучена на Gen 0 (Синтетика).
Gen 2: Обучена на Gen 1 (Синтетика 2-го порядка).

Код поиск инварианта

Скрытый текст

import torch import torch.nn as nn import torch.optim as optim import random import numpy as np import statistics # --- КОНФИГУРАЦИЯ --- N_RUNS = 20 # Количество повторов для статистики HIDDEN_SIZE = 32 EMBED_DIM = 8 VOCAB_SIZE = 50 MIN_LEN = 6 MAX_LEN = 12 BATCH_SIZE = 32 LR = 0.005 STEPS = 1600 # --- ГЕНЕРАТОРЫ --- def generate_sorted(length): return sorted(random.sample(range(VOCAB_SIZE), length)) def generate_random_unsorted(length): while True: seq = [random.randint(0, VOCAB_SIZE-1) for _ in range(length)] if sorted(seq) != seq: return seq def generate_hard_swap(length): seq = generate_sorted(length) idx = random.randint(0, length - 2) seq[idx], seq[idx+1] = seq[idx+1], seq[idx] return seq def get_batch(mode, batch_size, min_len, max_len): inputs, labels = [], [] length = random.randint(min_len, max_len) for _ in range(batch_size): if random.random() > 0.5: inputs.append(generate_sorted(length)) labels.append(1.0) else: if mode == 'baseline': inputs.append(generate_random_unsorted(length)) elif mode == 'concept': inputs.append(generate_hard_swap(length)) labels.append(0.0) return torch.LongTensor(inputs), torch.FloatTensor(labels).unsqueeze(1) # --- МОДЕЛЬ --- class TinyLSTM(nn.Module): def __init__(self): super().__init__() self.embedding = nn.Embedding(VOCAB_SIZE, EMBED_DIM) self.rnn = nn.LSTM(EMBED_DIM, HIDDEN_SIZE, batch_first=True) self.fc = nn.Linear(HIDDEN_SIZE, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): embedded = self.embedding(x) _, (hidden, _) = self.rnn(embedded) return self.sigmoid(self.fc(hidden[-1])) # --- ТЕСТ --- def evaluate_metrics(model): model.eval() metrics = {} # 1. Easy (L=20) pos = [generate_sorted(20) for _ in range(500)] neg = [generate_random_unsorted(20) for _ in range(500)] x = torch.LongTensor(pos + neg) y = torch.cat([torch.ones(500, 1), torch.zeros(500, 1)]) with torch.no_grad(): metrics['easy'] = ((model(x) > 0.5).float() == y).float().mean().item() # 2. Hard (L=20) neg = [generate_hard_swap(20) for _ in range(500)] x = torch.LongTensor(pos + neg) # pos те же with torch.no_grad(): metrics['hard'] = ((model(x) > 0.5).float() == y).float().mean().item() # 3. Extrapolation (L=40) - КОНТРОЛЬНЫЙ ТЕСТ pos_long = [generate_sorted(40) for _ in range(500)] neg_long = [generate_hard_swap(40) for _ in range(500)] x = torch.LongTensor(pos_long + neg_long) with torch.no_grad(): metrics['extrap'] = ((model(x) > 0.5).float() == y).float().mean().item() return metrics # --- ОДИН ПРОГОН --- def train_one_run(seed): # Установка сида torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) # Baseline model_base = TinyLSTM() opt_base = optim.Adam(model_base.parameters(), lr=LR, weight_decay=1e-4) for _ in range(STEPS): x, y = get_batch('baseline', BATCH_SIZE, MIN_LEN, MAX_LEN) opt_base.zero_grad(); nn.BCELoss()(model_base(x), y).backward(); opt_base.step() metrics_base = evaluate_metrics(model_base) # Concept (СБРОС СИДА для идентичного старта) torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) model_conc = TinyLSTM() opt_conc = optim.Adam(model_conc.parameters(), lr=LR, weight_decay=1e-4) for _ in range(STEPS): x, y = get_batch('concept', BATCH_SIZE, MIN_LEN, MAX_LEN) opt_conc.zero_grad(); nn.BCELoss()(model_conc(x), y).backward(); opt_conc.step() metrics_conc = evaluate_metrics(model_conc) return metrics_base, metrics_conc # --- MAIN LOOP --- def run_statistics(): print(f"🚀 Запуск статистики на {N_RUNS} прогонов...") # Хранилище: keys -> list of values hist_base = {'easy': [], 'hard': [], 'extrap': []} hist_conc = {'easy': [], 'hard': [], 'extrap': []} for i in range(N_RUNS): print(f"Run {i+1}/{N_RUNS}...", end='\r') m_b, m_c = train_one_run(seed=42 + i) for k in hist_base: hist_base[k].append(m_b[k]) hist_conc[k].append(m_c[k]) print("\n\n📊 ИТОГОВАЯ СТАТИСТИКА (Mean ± StdDev):") print(f"{'Metric':<15} | {'Baseline (Random)':<25} | {'Concept 77.3 (Hard)':<25}") print("-" * 70) for k in ['easy', 'hard', 'extrap']: mean_b = statistics.mean(hist_base[k]) * 100 std_b = statistics.stdev(hist_base[k]) * 100 mean_c = statistics.mean(hist_conc[k]) * 100 std_c = statistics.stdev(hist_conc[k]) * 100 print(f"{k.upper():<15} | {mean_b:5.1f}% ± {std_b:3.1f}% | {mean_c:5.1f}% ± {std_c:3.1f}%") if __name__ == "__main__": run_statistics()

Код коллапс.

Скрытый текст

import torch import torch.nn as nn import torch.optim as optim import random import numpy as np import statistics # --- КОНФИГУРАЦИЯ --- N_RUNS = 20 HIDDEN_SIZE = 32 EMBED_DIM = 8 VOCAB_SIZE = 50 MIN_LEN = 6 MAX_LEN = 12 BATCH_SIZE = 32 LR = 0.005 STEPS = 1600 # --- ГЕНЕРАТОРЫ (Те же) --- def generate_sorted(length): return sorted(random.sample(range(VOCAB_SIZE), length)) def generate_random_unsorted(length): while True: seq = [random.randint(0, VOCAB_SIZE-1) for _ in range(length)] if sorted(seq) != seq: return seq def generate_hard_swap(length): seq = generate_sorted(length) idx = random.randint(0, length - 2) seq[idx], seq[idx+1] = seq[idx+1], seq[idx] return seq # --- ОБУЧЕНИЕ --- class TinyLSTM(nn.Module): def __init__(self): super().__init__() self.embedding = nn.Embedding(VOCAB_SIZE, EMBED_DIM) self.rnn = nn.LSTM(EMBED_DIM, HIDDEN_SIZE, batch_first=True) self.fc = nn.Linear(HIDDEN_SIZE, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): embedded = self.embedding(x) _, (hidden, _) = self.rnn(embedded) return self.sigmoid(self.fc(hidden[-1])) def get_ground_truth_batch(batch_size, l_min, l_max): inputs, labels = [], [] length = random.randint(l_min, l_max) for _ in range(batch_size): if random.random() > 0.5: inputs.append(generate_sorted(length)); labels.append(1.0) else: inputs.append(generate_hard_swap(length)); labels.append(0.0) return torch.LongTensor(inputs), torch.FloatTensor(labels).unsqueeze(1) def get_synthetic_batch(teacher, batch_size, l_min, l_max): teacher.eval() inputs = [] length = random.randint(l_min, l_max) # Mix for generation for _ in range(batch_size): r = random.random() if r < 0.33: inputs.append(generate_sorted(length)) elif r < 0.66: inputs.append(generate_random_unsorted(length)) else: inputs.append(generate_hard_swap(length)) x = torch.LongTensor(inputs) with torch.no_grad(): pseudo_labels = (teacher(x) > 0.5).float() return x, pseudo_labels def evaluate_hard(model): model.eval() pos = [generate_sorted(20) for _ in range(500)] neg = [generate_hard_swap(20) for _ in range(500)] x = torch.LongTensor(pos + neg) y = torch.cat([torch.ones(500, 1), torch.zeros(500, 1)]) with torch.no_grad(): return ((model(x) > 0.5).float() == y).float().mean().item() # --- ЦЕПОЧКА --- def run_chain(seed): torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) # Gen 0 g0 = TinyLSTM() opt = optim.Adam(g0.parameters(), lr=LR, weight_decay=1e-4) for _ in range(STEPS): x, y = get_ground_truth_batch(BATCH_SIZE, MIN_LEN, MAX_LEN) opt.zero_grad(); nn.BCELoss()(g0(x), y).backward(); opt.step() acc0 = evaluate_hard(g0) # Gen 1 g1 = TinyLSTM() # New random weights opt = optim.Adam(g1.parameters(), lr=LR, weight_decay=1e-4) for _ in range(STEPS): x, y = get_synthetic_batch(g0, BATCH_SIZE, MIN_LEN, MAX_LEN) opt.zero_grad(); nn.BCELoss()(g1(x), y).backward(); opt.step() acc1 = evaluate_hard(g1) # Gen 2 g2 = TinyLSTM() opt = optim.Adam(g2.parameters(), lr=LR, weight_decay=1e-4) for _ in range(STEPS): x, y = get_synthetic_batch(g1, BATCH_SIZE, MIN_LEN, MAX_LEN) opt.zero_grad(); nn.BCELoss()(g2(x), y).backward(); opt.step() acc2 = evaluate_hard(g2) return acc0, acc1, acc2 # --- MAIN --- def run_collapse_stats(): print(f"🚀 Запуск статистики Коллапса на {N_RUNS} поколений...") res = {'g0': [], 'g1': [], 'g2': []} for i in range(N_RUNS): print(f"Chain {i+1}/{N_RUNS}...", end='\r') a0, a1, a2 = run_chain(seed=100 + i) res['g0'].append(a0); res['g1'].append(a1); res['g2'].append(a2) print("\n\n📉 ДИНАМИКА РАСПАДА (Hard Acc, Mean ± Std):") print(f"{'Generation':<15} | {'Accuracy':<20}") print("-" * 40) for k in ['g0', 'g1', 'g2']: mean = statistics.mean(res[k]) * 100 std = statistics.stdev(res[k]) * 100 print(f"{k:<15} | {mean:5.1f}% ± {std:3.1f}%") if __name__ == "__main__": run_collapse_stats()

4. Результаты экспериментов: Статистика и Анализ

Чтобы исключить фактор удачной инициализации, было проведено 20 независимых прогонов (runs) для каждого этапа, меняя Master Seed. Ниже приведены агрегированные данные (Mean ± Std Dev).

Этап I. Поиск инварианта

Мы сравнивали способность моделей отличать полностью отсортированную последовательность от хаоса (Easy Acc), определять последовательность только с одной ошибкой (Hard Acc) и работать с незнакомой длиной (Extrapolation).

Метрика	Baseline (Random)	Concept (Hard)	Delta
Easy Acc (Chaos)	100.0% ± 0.1%	97.7% ± 3.1%	-2.3%
Hard Acc (1 Swap)	50.0% ± 0.2%	85.3% ± 7.0%	+35.3%
Extrapolation (L=40)	50.3% ± 0.7%	65.7% ± 7.6%	+15.4%

Анализ результатов:

Иллюзия компетентности (Baseline): Посмотрите на Easy Acc. Модель, обученная на шуме, работает идеально (100%). Если использовать стандартные метрики, кажется, что модель обучилась.
Провал на Границе: Метрика Hard Acc — опознавание варианта только с одним смещением — (50.0% ± 0.2%) с ничтожным отклонением показывает, что Baseline стабильно гадает, выучена эвристика (общий тренд роста), но не структура.
Обобщение (Concept): Модель не просто выучила паттерн.
- Она уверенно (85%) детектирует малейшие нарушения.
- В тесте на экстраполяцию (длина 40, которую модель никогда не видела) нейросеть показывает результат 65.7%, что статистически значимо выше случайного гадания (50%). Учитывая ограниченную память LSTM, это говорит о том, что модель пытается применять выученное правило, а не запомненные примеры.

Вывод: Масштаб неэффективная замена структуры. Baseline-модель видела столько же примеров, но не встретила достаточно граничных случаев, чтобы сформировать правило (для задачи сортировки с длиной 12 на 1600 испытаний вероятность случайно встретить хотя бы один обучающий пример с одной перестановкой составляла 0,05%). В масштабах LLM это компенсируется триллионами токенов, Scaling Laws работают как брутфорс поиска границ. Но наш эксперимент доказывает: качество отрицания позволяет достичь хорошего уровня понимания на порядки быстрее и дешевле. Обучение на Hard Negatives формирует устойчивый инвариант, а не просто запоминание паттернов.

Этап II. Деградация Смысла: Динамика Модельного Коллапса

Статистика деградации при обучении на синтетических данных (цепочка поколений):

Поколение	Hard Accuracy (Mean ± Std)	Падение качества
Gen 0 (Reality)	85.6% ± 4.9%	—
Gen 1 (Echo)	72.8% ± 5.4%	-12.8%
Gen 2 (Noise)	68.0% ± 5.7%	-17.6% (total)

Механизм деградации: Gen 0 выдаёт вероятности (например, P=0.93 для сложного случая — не уверен, но скорее True). Hard labeling превращает это в категоричное 1.0, стирая информацию о неопределённости — именно в этой неопределённости и находится тень (знание о том, где проходит граница). Gen 1 обучается на искажённых метках и теряет понимание того, где настоящая граница между True и 'почти True'. Каждое поколение наследует и усиливает это искажение.

Важно отметить: во всех поколениях Easy Acc оставался на уровне 100%. Модели деградирующего поколения выглядят умными, они проходят базовые тесты на адекватность, но Hard Acc падает стремительно.

Я также проверил метод Knowledge Distillation (обучение на мягких метках учителя). Это дало результат 72.0% для Gen 2. Дистилляция замедляет распад (выигрыш +4%), но тренд остается нисходящим.

Интерпретация: Синтетические данные работают как фильтр, размывающий границы смысла, оставляя лишь общую форму. Когда LLM будут учиться на нейротекстах из интернета, или некорректных синтетических датасетах, интеллект моделей упадет катастрофически быстро, если не сохранять плотность Hard Negatives через контроль данных.

Справедливый довод о том, что современные LLM огромны, обладают достаточной памятью, чтобы запомнить всё, в отличие от TinyLSTM. Но здесь надо учесть тот факт, что пространство смыслов комбинаторно практически бесконечно, и даже модель с триллионом параметров, это ничто по сравнению с потенциальным количеством вариаций. И именно когда LLM выходит за пределы своей памяти (в зону новизны), она должна опираться на выученные границы. Обученная на шуме модель экстраполирует галлюцинации, обученная на Hard Negatives использует инварианты.

Очевидно, что в триллионах токенов человеческого текста содержатся миллионы естественных пограничных случаев. Но это не относится к синтетические данным, на которых корпорации планируют учить следующие поколения LLM. Чаще они статистически вычищены, и плотность Hard Negatives падает практически до нуля.

В этот момент масштаб перестает компенсировать отсутствие сигнала. Без Hard Negatives модель, обученная на синтетике, становится уверенным дилетантом не из-за нехватки памяти, а из-за узости обучающей среды. Без внешнего источника «НЕТ» система вырождается.

5. Принцип Соответствия Границ: Почему архитектура имеет значение

Я провел много времени, экспериментируя с обучением малых нейросетей на Gymnasium. Попытки научить модели играть в простые игры с использованием концепции границ смысла, привели к следующим выводам:

Эффективность обучения резко повышается когда мы можем явно выделить границу, которая обуславливает правильный результат.
Эта граница чаще всего является специфичной и работает только для конкретной задачи.
Инженеры могут назвать это хаком или читом, но это на самом деле принцип обучения и работы нейросетей. Мы учим нейросеть достигать цели, а не просто учим ради процесса. Их желаемая универсализация принципиально не будет работать для малых нейросетей и избыточна для специфичных задач.

То есть универсальная граница либо слишком общая, либо слишком дорогая для малых моделей. Эффективность обучения зависит от того, совпадает ли Inductive Bias (встроенный механизм восприятия модели) с топологией границы смысла (S_anti).

Проиллюстрирую это на двух логических задачах на одной и той же нейросети, явно подавая ей разные типы различий :

Задача «Зигзаг» (Динамика):

Последовательность чисел считается True, если отношения между соседними числами строго чередуются — больше, меньше.

Результат: Явная подача Neighbor Delta (x_t - x[t-1]) дала прирост точности +40%. Модель мгновенно нашла границу.
Задача «Пивот» (Контекст):

Последовательность чисел считается True, если все последующие числа больше первого элемента..

Результат: Подача Neighbor Delta в этом случае оказалась шумом, снизившим качество. Однако подача Anchor Delta (x_t - x_0) дала точность до 98% (+11% к базовой модели).

Вывод:

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

Почему трансформеры эффективнее RNN? Обычно говорят, LLM видят весь контекст. Я бы уточнил — они умеют игнорировать весь контекст, кроме нужного.

В рекуррентных сетях (RNN) информация смешивается в кашу скрытого состояния. Шум (S_dead) накапливается, и отделить его от сигнала трудно.

Механизм Self-Attention работает иначе. Через операцию Softmax каждый токен конкурирует за внимание с другими. Чтобы выделить одну важную связь (например, с опорным числом в начале массива), модель должна математически подавить (отрицать) сотни других, менее важных связей.

Обучение трансформера — это настройка фильтров, которые говорят «НЕТ» ложным корреляциям (например, привычке всегда смотреть на последнее слово), чтобы позволить проявиться истинной, дальнодействующей структуре. Чистая апофатика в действии.

В отличие от RNN, которая жестко привязана к локальному контексту (видит только соседа), механизм Self-Attention — это универсальный сканер. Он позволяет модели динамически выбирать, какое именно ограничение (S_anti) актуально прямо сейчас:

Нужно проверить соседа? Attention подавит все токены, кроме t−1. Нужно проверить начало фразы? Attention подавит соседа и выделит t=0.

Трансформер победил не потому, что он знает больше, а потому что его механизм глобального подавления шума (через Softmax) позволяет находить и активировать нужную границу смысла на любой дистанции.

Код зигзаг

Скрытый текст

import torch import torch.nn as nn import torch.optim as optim import random import numpy as np import statistics # --- КОНФИГУРАЦИЯ --- N_RUNS = 10 HIDDEN_SIZE = 32 # ДЛЯ ЧЕСТНОСТИ: EMBED_DIM_BASE = 16 # Standard получит жирные эмбеддинги EMBED_DIM_DELTA = 8 # Delta получит худые, но с дельтой (8+8=16) VOCAB_SIZE = 50 MIN_LEN = 6 MAX_LEN = 12 TEST_EXTRAP = 40 BATCH_SIZE = 32 LR = 0.005 STEPS = 2000 CHECK_INTERVAL = 200 def setup_seed(seed): torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) # --- ГЕНЕРАТОРЫ (Zig-Zag) --- def generate_zigzag(length): seq = [] current = random.randint(0, VOCAB_SIZE-1) seq.append(current) going_up = True for _ in range(length - 1): if going_up: if current >= VOCAB_SIZE - 1: return generate_zigzag(length) next_val = random.randint(current + 1, VOCAB_SIZE - 1) else: if current <= 0: return generate_zigzag(length) next_val = random.randint(0, current - 1) seq.append(next_val) current = next_val going_up = not going_up return seq def generate_hard_broken_zigzag(length): seq = generate_zigzag(length) idx = random.randint(0, length - 3) val_1 = seq[idx] val_2 = seq[idx+1] if val_2 > val_1: # Up if val_2 >= VOCAB_SIZE - 1: return generate_random_unsorted(length) val_3_bad = random.randint(val_2 + 1, VOCAB_SIZE - 1) # Up again (Error) else: # Down if val_2 <= 0: return generate_random_unsorted(length) val_3_bad = random.randint(0, val_2 - 1) # Down again (Error) seq[idx+2] = val_3_bad return seq def generate_random_unsorted(length): return [random.randint(0, VOCAB_SIZE-1) for _ in range(length)] def get_batch(batch_size, min_len, max_len): inputs, labels = [], [] length = random.randint(min_len, max_len) for _ in range(batch_size): if random.random() > 0.5: inputs.append(generate_zigzag(length)) labels.append(1.0) else: inputs.append(generate_hard_broken_zigzag(length)) labels.append(0.0) return torch.LongTensor(inputs), torch.FloatTensor(labels).unsqueeze(1) # --- МОДЕЛИ --- class StandardLSTM(nn.Module): def __init__(self): super().__init__() # WIDE EMBEDDING (16) self.embedding = nn.Embedding(VOCAB_SIZE, EMBED_DIM_BASE) # Input size = 16 self.rnn = nn.LSTM(EMBED_DIM_BASE, HIDDEN_SIZE, batch_first=True) self.fc = nn.Linear(HIDDEN_SIZE, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): emb = self.embedding(x) _, (hidden, _) = self.rnn(emb) return self.sigmoid(self.fc(hidden[-1])) class DeltaLSTM(nn.Module): def __init__(self): super().__init__() # NARROW EMBEDDING (8) self.embedding = nn.Embedding(VOCAB_SIZE, EMBED_DIM_DELTA) # Input size = 8 + 8 = 16 (SAME AS STANDARD) self.rnn = nn.LSTM(EMBED_DIM_DELTA * 2, HIDDEN_SIZE, batch_first=True) self.fc = nn.Linear(HIDDEN_SIZE, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): emb = self.embedding(x) padded_emb = torch.cat([torch.zeros_like(emb[:, :1, :]), emb[:, :-1, :]], dim=1) delta = emb - padded_emb combined_input = torch.cat([emb, delta], dim=2) _, (hidden, _) = self.rnn(combined_input) return self.sigmoid(self.fc(hidden[-1])) # --- ТЕСТ --- def evaluate_extrap(model): model.eval() pos = [generate_zigzag(TEST_EXTRAP) for _ in range(250)] neg = [generate_hard_broken_zigzag(TEST_EXTRAP) for _ in range(250)] x = torch.LongTensor(pos + neg) y = torch.cat([torch.ones(250, 1), torch.zeros(250, 1)]) with torch.no_grad(): acc = ((model(x) > 0.5).float() == y).float().mean().item() model.train() return acc def train_run(model_class, seed): setup_seed(seed) model = model_class() opt = optim.Adam(model.parameters(), lr=LR, weight_decay=1e-4) best_acc = 0 for step in range(1, STEPS + 1): x, y = get_batch(BATCH_SIZE, MIN_LEN, MAX_LEN) opt.zero_grad() loss = nn.BCELoss()(model(x), y) loss.backward() opt.step() if step % CHECK_INTERVAL == 0: acc = evaluate_extrap(model) if acc > best_acc: best_acc = acc return best_acc def run_comparison(): print(f"🚀 FAIR Comparison: Standard (Dim 16) vs Delta (8+8=16)...") res = {'Std': [], 'Delta': []} for i in range(N_RUNS): print(f"Run {i+1}/{N_RUNS}...", end='\r') seed = 7000 + i res['Std'].append(train_run(StandardLSTM, seed)) res['Delta'].append(train_run(DeltaLSTM, seed)) print("\n\n🏆 РЕЗУЛЬТАТЫ (Best Acc, Extrapolation L=40):") m_s = statistics.mean(res['Std']) * 100 s_s = statistics.stdev(res['Std']) * 100 m_d = statistics.mean(res['Delta']) * 100 s_d = statistics.stdev(res['Delta']) * 100 print(f"Standard (Wide): {m_s:5.1f}% ± {s_s:3.1f}%") print(f"Delta (Diff): {m_d:5.1f}% ± {s_d:3.1f}%") if __name__ == "__main__": run_comparison()

Код пивот

Скрытый текст

import torch import torch.nn as nn import torch.optim as optim import random import numpy as np import statistics # --- КОНФИГУРАЦИЯ --- N_RUNS = 10 HIDDEN_SIZE = 32 EMBED_DIM = 8 VOCAB_SIZE = 50 MIN_LEN = 6 MAX_LEN = 12 TEST_EXTRAP = 40 # Экстраполяция на длину 40 BATCH_SIZE = 32 LR = 0.005 STEPS = 2000 CHECK_INTERVAL = 200 def setup_seed(seed): torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) # --- ГЕНЕРАТОРЫ (Pivot Hard) --- def generate_pivot_valid(length): pivot = random.randint(0, VOCAB_SIZE // 2) seq = [pivot] for _ in range(length - 1): seq.append(random.randint(pivot, VOCAB_SIZE - 1)) return seq def generate_hard_pivot(length): seq = generate_pivot_valid(length) pivot = seq[0] if pivot == 0: return [random.randint(0, VOCAB_SIZE-1) for _ in range(length)] idx = random.randint(1, length - 1) err_val = random.randint(0, pivot - 1) seq[idx] = err_val return seq def get_batch(batch_size, min_len, max_len): inputs, labels = [], [] length = random.randint(min_len, max_len) for _ in range(batch_size): if random.random() > 0.5: inputs.append(generate_pivot_valid(length)) labels.append(1.0) else: inputs.append(generate_hard_pivot(length)) labels.append(0.0) return torch.LongTensor(inputs), torch.FloatTensor(labels).unsqueeze(1) # --- МОДЕЛИ --- # 1. Standard class StandardLSTM(nn.Module): def __init__(self): super().__init__() self.embedding = nn.Embedding(VOCAB_SIZE, EMBED_DIM) self.rnn = nn.LSTM(EMBED_DIM, HIDDEN_SIZE, batch_first=True) self.fc = nn.Linear(HIDDEN_SIZE, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): emb = self.embedding(x) _, (hidden, _) = self.rnn(emb) return self.sigmoid(self.fc(hidden[-1])) # 2. Neighbor Delta (Работало для Зиг-Зага) class NeighborDeltaLSTM(nn.Module): def __init__(self): super().__init__() self.embedding = nn.Embedding(VOCAB_SIZE, EMBED_DIM) self.rnn = nn.LSTM(EMBED_DIM * 2, HIDDEN_SIZE, batch_first=True) self.fc = nn.Linear(HIDDEN_SIZE, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): emb = self.embedding(x) # Delta = x[t] - x[t-1] padded_emb = torch.cat([torch.zeros_like(emb[:, :1, :]), emb[:, :-1, :]], dim=1) delta = emb - padded_emb combined = torch.cat([emb, delta], dim=2) _, (hidden, _) = self.rnn(combined) return self.sigmoid(self.fc(hidden[-1])) # 3. Anchor Delta (Специфично для Pivot) class AnchorDeltaLSTM(nn.Module): def __init__(self): super().__init__() self.embedding = nn.Embedding(VOCAB_SIZE, EMBED_DIM) self.rnn = nn.LSTM(EMBED_DIM * 2, HIDDEN_SIZE, batch_first=True) self.fc = nn.Linear(HIDDEN_SIZE, 1) self.sigmoid = nn.Sigmoid() def forward(self, x): emb = self.embedding(x) # [Batch, Seq, Dim] # Берем первый токен (Anchor) и растягиваем его на всю длину anchor_emb = emb[:, 0:1, :] # [Batch, 1, Dim] anchor_repeated = anchor_emb.expand(-1, emb.size(1), -1) # [Batch, Seq, Dim] # Delta = x[t] - x[0] delta = emb - anchor_repeated combined = torch.cat([emb, delta], dim=2) _, (hidden, _) = self.rnn(combined) return self.sigmoid(self.fc(hidden[-1])) # --- ТЕСТ --- def evaluate_extrap(model): model.eval() pos = [generate_pivot_valid(TEST_EXTRAP) for _ in range(250)] neg = [generate_hard_pivot(TEST_EXTRAP) for _ in range(250)] x = torch.LongTensor(pos + neg) y = torch.cat([torch.ones(250, 1), torch.zeros(250, 1)]) with torch.no_grad(): acc = ((model(x) > 0.5).float() == y).float().mean().item() model.train() return acc def train_run(model_class, seed): setup_seed(seed) model = model_class() opt = optim.Adam(model.parameters(), lr=LR, weight_decay=1e-4) best_acc = 0 for step in range(1, STEPS + 1): x, y = get_batch(BATCH_SIZE, MIN_LEN, MAX_LEN) opt.zero_grad() loss = nn.BCELoss()(model(x), y) loss.backward() opt.step() if step % CHECK_INTERVAL == 0: acc = evaluate_extrap(model) if acc > best_acc: best_acc = acc return best_acc def run_comparison(): print(f"🚀 PIVOT TASK: Architectures Battle (L={TEST_EXTRAP})...") res = {'Std': [], 'Neighbor': [], 'Anchor': []} for i in range(N_RUNS): print(f"Run {i+1}/{N_RUNS}...", end='\r') seed = 9000 + i res['Std'].append(train_run(StandardLSTM, seed)) res['Neighbor'].append(train_run(NeighborDeltaLSTM, seed)) res['Anchor'].append(train_run(AnchorDeltaLSTM, seed)) print("\n\n🏆 РЕЗУЛЬТАТЫ (Best Acc):") for name, vals in res.items(): m = statistics.mean(vals) * 100 s = statistics.stdev(vals) * 100 print(f"{name:<10}: {m:5.1f}% ± {s:3.1f}%") if __name__ == "__main__": run_comparison()

6. Сублиминальное обучение: Как совы пролезают сквозь числа

Недавно обсуждался феномен, когда LLM передавали скрытую информацию (любить сов) через последовательность случайных чисел. С точки зрения концепции это не мистика.

«Любить сов» — это не текст. Это топологическая деформация пространства эмбеддингов.
Когда модель-учитель генерирует даже нейтральные токены (числа), её скрытое состояние (hidden state) находится под воздействием вектора owl. Это создает микроскопические смещения в вероятностях выбора чисел (интерференционную картину).

Здесь нет противоречия с принципом смысл как отрицание. Числа в этом потоке перестают быть нейтральными. Скрытое состояние учителя (любить сова) действует как линза, искажая их вероятностное распределение. Это искажение — и есть тень (S_anti).

Модель-ученик не просто считывает числа. Она обнаруживает, что этот поток НЕ является случайным шумом. Чтобы предсказать такую неправильную статистику, ученик вынужден активировать у себя ту же самую систему внутренних ограничений (вектор любить сов), которая создала это искажение у учителя. Это передача формы через деформацию пространства, а не через обмен фактами.

Впрочем, по данному каналу обучения так и остается больше вопросов чем ответов — непонятна эффективность передачи данных (с одной стороны передаются только ограничения, с другой они вшиты в сырые данные), сложно оценить степень влияния переданных паттернов и так далее.

7. Эмбеддинги. Схожесть и различие

Математическое обоснование: Почему Softmax — это оператор отрицания

Стандартная интерпретация Embedding Space хорошо известна:
cosine_similarity("apple", "orange") ≈ 0.85 (Близко)
cosine_similarity("apple", "galaxy") ≈ 0.02 (Далеко)

Отсюда обычно делается вывод: близость и есть сходство. Я предлагаю дополнить эту картину: близость также определяет зону критичного различения.
Отличить яблоко от галактики тривиально (Easy Negative). Отличить яблоко от груши — сложно и важно (Hard Negative).

Чтобы понять, почему близость = важность отрицания, посмотрим на математику обучения. При обновлении весов через gradient descent производные Softmax показывают силу воздействия на каждый токен:

P(token_i | context) = exp(s_i) / Σ exp(s_j)

Где:

Числитель работает на Позитив (тянет правильный токен вверх).
Знаменатель (Σ exp(s_j)) — это тень. Это сумма всех конкурентов.

Посмотрите на производные Softmax (как меняется вероятность при обновлении весов):

Для правильного токена ii : ∂P_i / ∂s_i = P_i * (1 - P_i)
Для неправильного токена jj : ∂P_i / ∂s_j = -P_i * P_j

Что это значит на практике?
Знак минус во второй формуле означает подавление. Но сила этого подавления зависит от Pj.

Если Pj мало (токен "galaxy", далеко в эмбеддингах), градиент почти нулевой. Модель не тратит энергию на очевидное.
Если Pj велико (токен "orange" — сильный конкурент), отрицательный градиент становится значимым, активно расталкивая эти вектора.

Введение параметра температуры в Softmax (P(i) = exp(s_i/T) / Σ exp(s_j/T)) доказывает, что семантическая близость векторов — это зона активной конкуренции, а не просто ко-встречаемость в контекстах.

Температура действует как коэффициент жёсткости структурных ограничений (S_anti):

При T → 0: Система максимизирует подавление конкурентов. Вероятность ближайших Hard Negatives принудительно обнуляется, формируя абсолютные границы смысла.
При T → ∞: Подавляющая способность исчезает. Распределение становится uniform, и вектора правильного токена и его Hard Negative (например, "apple" vs "orange") становятся неразличимы.

Галлюцинации при высокой температуре — это статистический пробой границы ближайшим Hard Negative. Модель не выдаёт случайный шум — она подменяет правильный токен семантически близким, но неверным в данном контексте. Это подтверждает, что близость в embedding space отражает не сходство объектов, а критичность их различения — риск подмены, который Softmax должен активно купировать.

Оптимальная температура — это баланс между подавлением неверных Hard Negatives (точность) и допуском креативных Hard Negatives (инсайты). Если синтетика для обучения генерировалась при высокой T — система наследует размытые границы учителя.

Вывод:. Близость векторов в embedding space — это равновесие между притяжением (общий контекст) и отталкиванием (различение при путанице). Итоговая близость отражает частоту и важность различения этих концептов в процессе обучения.

Хотя математически Softmax содержит отрицание, на практике без Hard Negatives этот сигнал слишком слаб и размыт, чтобы быстро сформировать жесткие границы, поэтому возникает необходимость в триллионах токенов.

Аналогично работает Negative Sampling в Word2Vec:

Objective = log σ(w·c) + Σ log σ(-w·c_neg)

Второе слагаемое — это явное максимизация непохожести (отрицание) контекста на случайные слова.

Сначала негативы случайны. Но по мере обучения похожие слова сближаются, случайная выборка автоматически начинает попадать в hard negatives. Это естественное curriculum learning: easy → hard, без явного задания.

То есть embedding space — это не просто пространство сходства. Это система отрицательных связей, в которой:

близость означает важность различения,
обучение — это нарезка границ,
смысл — то, что осталось после исключений.

Именно поэтому неграмотные синтетические датасеты убивают модели, hard negatives важнее объёма данных, а понимание — это всегда искусство отрицания.

8. Природа факта и RAG

В рамках нашей теории факты не хранятся в модели как данные на жестком диске (в виде S_dead). Они существуют как топологическая неизбежность. Факт — это предельный случай смысла, когда система ограничений (S_anti) становится настолько плотной, что сужает коридор вероятностей до единственного возможного варианта. Модель пишет «Париж» после «Столица Франции» не потому, что она это помнит, а потому, что все остальные варианты (Лондон, Берлин, Марс) заблокированы жесткими весами.

Здесь критична инженерная роль токенизации. Токен — это базовый инвариант, предварительно очищенный от сырой энтропии. Нейросеть не тратит глубину слоев на то, чтобы понять, из каких букв состоит «Париж» — она получает готовый концепт [Paris].

Если токенизация качественная (семантическая), модель тратит свою емкость на выстраивание сложной топологии связей между понятиями.

Если токенизация мусорная (побуквенная/байтная), модель вынуждена сжигать ресурсы на создание самих первичных инвариантов из шума. У неё не остается глубины для фиксации жестких фактических границ высокого уровня.

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

Это объясняет ограниченность RAG (Retrieval-Augmented Generation). RAG усиливает позитивную сторону (подбрасывает факты в контекст), но не формирует структурные отрицания в весах модели. Это делает его эффективным для задач цитирования, но недостаточным для глубокого понимания. Модель с RAG как студент со шпаргалкой, может ответить на вопрос, но не владеет предметом.

Few-shot learning и In-context learning работают только в том случае, если базовая модель (Base Model) уже содержит S_anti, выученные при предварительном обучении. Промпт может активировать существующую апофатическую структуру, но не может создать её с нуля. Без внутренней структуры промпт становится просто шаблоном для копирования, и модель немедленно галлюцинирует при выходе за пределы примеров.

Заключение

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

Позитивное знание без системы ограничений — иллюзия понимания.
Масштаб не заменяет структуру. Baseline-модель видела тот же объем данных, но осталась глупой.
Кризис синтетики реален. Без внешнего источника «Нет» (Ground Truth Hard Negatives) ИИ вырождается в симулякр, который выглядит идеально, но не понимает сути.
У нейросетей нет цели и плана, любой инференс это интерференция с промптом в рамках ограничений.

Будущее ИИ — не в парсинге всего интернета, а в создании датасетов, состоящих из высококачественных ошибок и парадоксов. Нам нужно учить модели не тому, что есть, а тому, чего быть не может. Практически это означает, что при создании датасетов фокусироваться на hard negatives (пограничных случаях), а не на объёме. Для синтетических данных критически важно подмешивать 20-30% реальных примеров (Ground Truth), как защиту от модельного коллапса.

P.S. В этой таблице интерпретация некоторых феноменов в ML-инженерии сквозь предложенную концепцию

Феномен	Классическое объяснение (ML/DL)	Объяснение через концепцию негативного определения
Grokking (Гроккинг)	Переход от переобучения к обобщению. Модель находит более широкий минимум функции потерь после длительного плато.	Фазовый переход в процессе переработки энтропии. Плато соответствует накоплению давления градиента, после чего система резко переключается с экстенсионального хранения примеров (незавершённая переработка энтропии) на интенсиональную кристаллизацию правила (сформированные структурные ограничения)
Model Collapse (Коллапс модели)	Накопление статистических ошибок, исчезновение хвостов распределения, снижение дисперсии при обучении на синтетике.	Потеря разрешающей способности границ. Синтетические данные содержат позитивные примеры, но вариативная энтропия в них предварительно сглажена (усреднённые формы вместо граничных случаев). Модель-учитель уже переработала хаос в структуру, а модель-ученик получает только результат — без исходного давления, которое формирует жёсткие границы. В терминах информационной теории: плотность информации на границах классов падает до нуля, и система не может кристаллизовать собственные структурные ограничения.
Adversarial Examples (Состязательные примеры)	Линейность моделей в высокоразмерных пространствах. Малое изменение вектора перебрасывает его через границу решения.	Недостаточная плотность ограничений. Модель выучила позитивные признаки, но не сформировала негативные ограничения (S_anti) в ортогональных направлениях. Граница решений определена только вдоль многообразия данных, но не защищена от ортогональных возмущений вне него.
Hallucinations (Галлюцинации)	Вероятностная природа предсказания следующего токена. Модель генерирует правдоподобный текст, не проверяя его истинность.	Рассинхронизация генератора и фильтра. Механизм комбинаторики токенов (работа с S_dead) функционирует корректно, но механизм структурных ограничений (S_anti) не блокирует недопустимые последовательности. В терминах softmax: знаменатель (S_anti) недостаточно насыщен конкурирующими ограничениями, позволяя пробелам заполняться правдоподобным, но неверным.
Double Descent (Двойной спуск)	Эффект перепараметризации. Сначала баланс смещения-дисперсии, затем интерполяция шума, затем обобщение.	Динамика устранения шума. Первый спуск — попытка запомнить всю вариативную энтропию. Пик ошибки — момент, когда система начинает перерабатывать энтропию в ограничения, но процесс не завершён (интерференция). Второй спуск — успешная кристаллизация структурных ограничений.
In-Context Learning	Механизм Attention работает как как функциональный аналог локального градиентного обновления во время инференса.	Интерференционная настройка Тени. Промпт действует не как данные для запоминания, а как управляющий сигнал (стимул). Он взаимодействует с глобальным полем S_anti, временно перегруппировывая топологию запретов. Few-Shot примеры не «учат» модель, а гасят нерелевантные ветви вероятностей в пространстве активаций, оставляя доступной только нужную проекцию смысла
Chain of Thought (CoT)	Увеличение вычислительного бюджета задачи. Промежуточные токены служат буфером памяти.	Явная сериализация ограничений. Разбиение задачи вынуждает модель эксплицитно проверять соблюдение логических границ (S_anti) на каждом шаге вывода, предотвращая накопление ошибки за счёт локальной валидации ограничений.
Superposition (Суперпозиция)	Эффективная упаковка информации. Векторы почти ортогональны в высокой размерности.	Ортогональность ограничений (S_anti). Различные инварианты и правила (S_anti) могут кодироваться одними и теми же весами, если они лежат в почти ортогональных подпространствах. Модель экономит ресурсы, упаковывая неконфликтующие запреты в единый физический носитель без взаимных помех. Интерференция отсутствует из-за несовпадения контекстов, что позволяет масштабируемость представлений в высокой размерности.
Lottery Ticket Hypothesis	Инициализация имеет значение. Прунинг оставляет только удачные пути градиента.	Изоляция структурного ядра. Избыточная параметризация необходима для стохастического поиска топологии, совпадающей с требуемой структурой ограничений. Выигрышный билет — подсеть, кодирующая S_anti. Остальные веса кодируют избыточный шум (S_dead) и подлежат удалению.
Scaling Laws (Законы масштабирования)	Степенные законы. Производительность растет с ростом данных и вычислений.	Энергетическая стоимость сжатия. Извлечение высокоуровневых инвариантов (глубокая кристаллизация структурных ограничений) требует переработки экспоненциально большего объёма вариативной энтропии. Каждый новый уровень иерархии границ формируется только при достижении критической массы примеров с достаточной информационной плотностью
Subliminal Learning (Сублиминальное обучение)	Модели находят скрытые корреляции в распределении токенов (стеганография).	Топологический резонанс. Информация передается через искажение распределения вероятностей (негатив). Модель-ученик восстанавливает структуру ограничений учителя, адаптируя веса под наблюдаемые аномалии в распределении.
RAG	Предоставление модели актуальной фактологии из внешней базы.	Вынос энтропии вовне. Искусственное удержание фактов (S_dead) в контексте снижает необходимость их сжатия во внутренние веса. Это блокирует формирование глубоких внутренних инвариантов, заменяя их процедурой поиска. Это усиливает retrieval (позитив), но без internal S_anti — модель остается 'цитирующей', а не понимающей.
Catastrophic Forgetting	Перезапись старых знаний новыми	Разрушение структуры S_anti. Потеря иерархии ограничений, приводящая к циклическому перерождению.
Emergent Abilities	Неожиданные способности на large scale	Фазовый переход при накоплении критической массы S_anti, позволяющий формирование глубокой иерархии новых инвариантов.
Catastrophic Interference (или Bias Amplification)	Усиление biases в данных (e.g., gender bias в embeddings).	Накопление немой тени (сублиминальные неконтролируемые инварианты) без эксплицитного отрицания.
Induction Heads Механизм копирования паттернов	Нейронные контуры, реализующие алгоритм [A][B]...[A] -> [B]. Основа In-Context Learning. Головы внимания находят предыдущее вхождение текущего токена и переносят вероятность на следующий за ним элемент.	Кристаллизованный мета-инвариант Жесткая топологическая структура, сформированная на этапе пре-трейна для сжатия повторяющейся энтропии. Работает как оператор радикального отрицания: при резонансе с контекстом голова подавляет вероятность всего словаря, оставляя допустимым только токен, диктуемый структурой паттерна. Это не «обучение в моменте», а детерминированное исполнение ограничения.

Все перечисленные явления могут быть интерпретированы как различные режимы формирования, разрушения или временной реконфигурации структур отрицаний (S_anti) в обучаемой системе.

Источник

Отказ от ответственности: Статьи, размещенные на этом веб-сайте, взяты из общедоступных источников и предоставляются исключительно в информационных целях. Они не обязательно отражают точку зрения MEXC. Все права принадлежат первоисточникам. Если вы считаете, что какой-либо контент нарушает права третьих лиц, пожалуйста, обратитесь по адресу [email protected] для его удаления. MEXC не дает никаких гарантий в отношении точности, полноты или своевременности контента и не несет ответственности за любые действия, предпринятые на основе предоставленной информации. Контент не является финансовой, юридической или иной профессиональной консультацией и не должен рассматриваться как рекомендация или одобрение со стороны MEXC.