- Регистрация
- 23 Август 2023
- Сообщения
- 3 132
- Лучшие ответы
- 0
- Реакции
- 0
- Баллы
- 51
Offline
Не так давно я писал про наш проект SemantML и про нейродинамическую архитектуру (https://habr.com/ru/articles/964834). Хочется поделиться последними результатами развития архитектуры и показателями нашей модели на основе синтеза классических трансформеров и нейродинамики в проведенных бенчрмарках в сравнении с классическим Трансформером.
Что такое Transformer рассказывать не буду, кто не знает, вики в помощь, зато подробно расскажу про свою модель. При создании архитектуры DynamicTSCO я вдохновлялся понятиями из единой теории информации, в частности, Обобщенным уравнением информационного поля и интересной штукой под названием TSCO - Temporal Self-Constistent Objects. Очень кратко об этих сущностях. Обобщенное уравнение информационного поля это удобный формализм для описания поведения любой информационной системы, задаваемый по следующей формуле (в общем виде):
Те, кто знает физику, наверняка узнали в нем что-то похожее на формулу Шредингера. В общем случае оно включает постоянную планка (для физических систем). Другие параметры: Н - Гамильтониан (энергия системы), Γ - нелинейность (нелинейность в чистом виде, хаос и эмерджентность и прочее), Ω - топологический член, M - память системы (для нелокальных эффектов), Θ - оператор самореференции, Φ - контекст (семантическое сжатие входных потоков, получение информации из внешней среды), Λ - (межсистемные или межмасштабные корреляции, ξ - стохастический (неустранимый) шум любой природы. D - диссипация (энтропийные потери). Разумеется, в модели уравнение (а точнее, его компоненты) использованы не в прямом, физическом контексте, а чисто концептуально, архитектурно. TSCO, же если кратко, это оператор самосогласования системы во времени, некий собирательный термин для обозначения класса процессов, протекающих по принципу самосогласованности Новикова. Используется аналогично, не в физическом смысле, а в вычислительно-архитектурном. Теперь - конкретно к реализации адаптивной динамической модели на основе TSCO.
Код DynamicTSCOModel:
class DynamicTSCOModel(nn.Module):
"""
адаптивная DynamicTSCOModel-модель
"""
def __init__(self, vocab_size: int, d_model: int = 256, n_heads: int = 4, n_scales: int = 3):
super().__init__()
self.d_model = d_model
self.vocab_size = vocab_size
self.n_heads = n_heads
self.n_scales = n_scales
# АДАПТИВНЫЕ ПАРАМЕТРЫ
self.alpha_H = nn.Parameter(torch.tensor(0.3))
self.alpha_Γ = nn.Parameter(torch.tensor(0.1))
self.alpha_Ω = nn.Parameter(torch.tensor(0.05))
self.alpha_Λ = nn.Parameter(torch.tensor(0.005))
self.alpha_ξ = nn.Parameter(torch.tensor(0.003))
self.alpha_D = nn.Parameter(torch.tensor(0.3))
self.alpha_M = nn.Parameter(torch.tensor(0.3))
self.alpha_Θ = nn.Parameter(torch.tensor(0.005))
self.alpha_Φ = nn.Parameter(torch.tensor(0.05))
self.alpha_tsco = nn.Parameter(torch.tensor(0.01)) # коэффициент TSCO-loss
# СЧЁТЧИКИ
self.register_buffer("_step_count", torch.tensor(0))
self.register_buffer("_epoch_count", torch.tensor(0))
self.register_buffer("tsco_loss", torch.tensor(0.0))
# АРХИТЕКТУРА
self.embedding = nn.Embedding(vocab_size, d_model)
# Temporal Attention
self.phase_amp = nn.Parameter(torch.ones(n_heads, 1) * 0.1)
self.phase_offset = nn.Parameter(torch.zeros(n_heads, 1))
self.q_linear = nn.Linear(d_model, d_model)
self.k_linear = nn.Linear(d_model, d_model)
self.v_linear = nn.Linear(d_model, d_model)
# Multi-scale Wave
self.scale_convs = nn.ModuleList([
nn.Conv1d(d_model, d_model, kernel_size=3, padding=1, dilation=2 ** i)
for i in range(n_scales)
])
# Observer Θ
self.teta_linear = nn.Linear(d_model, d_model)
self.teta_gate = nn.Linear(d_model * 2, d_model)
# Correlation Λ (динамическая)
self.lambda_mixer = nn.Linear(d_model, d_model)
# TSCO predictor (для внутреннего лосса)
self.tsco_predictor = nn.Linear(d_model, d_model)
# Fusion
self.fusion_linear = nn.Linear(d_model * 3, d_model)
self.norm = nn.LayerNorm(d_model)
self.final_norm = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(0.1)
self.fc = nn.Linear(d_model, vocab_size)
print(f"DynamicTSCOModel создана: {sum(p.numel() for p in self.parameters()):,} параметров")
# Adaptive coefficients
def get_adaptive_alphas(self):
epoch = self._epoch_count.item()
prog = min(epoch / 50.0, 1.0)
α = {
"H": torch.sigmoid(self.alpha_H) * 0.5,
"Γ": torch.sigmoid(self.alpha_Γ) * 0.3,
"Ω": torch.sigmoid(self.alpha_Ω) * 0.2,
"Λ": torch.sigmoid(self.alpha_Λ) * 0.4,
"ξ": torch.sigmoid(self.alpha_ξ) * 0.01,
"D": torch.sigmoid(self.alpha_D) * 0.6,
"M": torch.sigmoid(self.alpha_M) * 0.5,
"Θ": torch.sigmoid(self.alpha_Θ) * 0.3,
"Φ": torch.sigmoid(self.alpha_Φ) * 0.2,
"tsco": torch.sigmoid(self.alpha_tsco) * 0.01,
}
# динамическая адаптация
if prog > 0.3:
α["Θ"] *= (prog * 2.0)
α["Λ"] *= (prog * 2.0)
if prog < 0.2:
α["ξ"] *= 1.8
α["D"] *= 0.6
α["H"] *= 1.2
elif prog > 0.6:
α["ξ"] *= 0.4
α["M"] *= 1.3
α["Λ"] *= 1.1
return α
def temporal_attention(self, x, α):
seq_len, batch, _ = x.size()
Q = self.q_linear(x).view(seq_len, batch, self.n_heads, -1).transpose(0, 1)
K = self.k_linear(x).view(seq_len, batch, self.n_heads, -1).transpose(0, 1)
V = self.v_linear(x).view(seq_len, batch, self.n_heads, -1).transpose(0, 1)
attn = torch.einsum("bqhd,bkhd->bhqk", Q, K) / math.sqrt(Q.size(-1))
positions = torch.arange(seq_len, device=x.device).float().unsqueeze(0)
phase = self.phase_amp.unsqueeze(2) * torch.sin(positions * α["Ω"] + self.phase_offset.unsqueeze(2))
attn = attn + phase * α["H"]
weights = F.softmax(attn, dim=-1)
out = torch.einsum("bhqk,bkhd->bqhd", weights, V)
out = out.transpose(0, 1).contiguous().view(seq_len, batch, self.d_model)
return out
# Multi-scale Wave
def multi_scale_wave(self, x, α):
seq_len, batch, d_model = x.shape
x_perm = x.transpose(0, 1).transpose(1, 2)
feats = []
for i, conv in enumerate(self.scale_convs):
h = conv(x_perm)
if h.size(-1) != seq_len:
h = F.interpolate(h, size=seq_len, mode="linear", align_corners=False)
time = torch.arange(seq_len, device=x.device).float().view(1, 1, -1)
resonance = α["Γ"] * torch.sin(h * (i + 1) * 0.1 + time * 0.1)
feats.append(h + resonance)
stacked = torch.stack(feats, dim=-1)
wave_out = stacked.mean(-1).transpose(1, 2).transpose(0, 1)
return wave_out
# Correlation operator Λ
def correlation_operator(self, x, α):
λ = torch.sigmoid(self.lambda_mixer(x)) # [s,b,d]
corr = torch.tanh(x * λ)
return x + α["Λ"] * corr
# Observer operator Θ
def observer_operator(self, x, α):
proj = self.teta_linear(x)
gate = torch.sigmoid(self.teta_gate(torch.cat([x, proj], dim=-1)))
return x + α["Θ"] * gate * (proj - x)
# TSCO-loss (самосогласованность)
def compute_tsco_loss(self, x, α):
x_pred = self.tsco_predictor(x)
tsco_loss = F.mse_loss(x_pred, x)
self.tsco_loss = tsco_loss.detach()
return α["tsco"] * tsco_loss
# Forward
def forward(self, x):
if self.training:
self._step_count += 1
α = self.get_adaptive_alphas()
x_emb = self.embedding(x) * math.sqrt(self.d_model)
temp_out = self.temporal_attention(x_emb, α)
wave_out = self.multi_scale_wave(x_emb, α)
fused = torch.cat([x_emb, temp_out, wave_out], dim=-1)
fused = self.fusion_linear(fused)
fused = self.norm(fused + x_emb)
fused = self.correlation_operator(fused, α)
fused = self.observer_operator(fused, α)
fused = self.final_norm(fused)
fused = self.dropout(fused)
if self.training:
_ = self.compute_tsco_loss(fused, α)
noise = α["ξ"] * math.log(self._step_count.item() + 1)
fused = fused + noise * torch.randn_like(fused)
logits = self.fc(fused)
return logits.view(-1, logits.size(-1))
def update_epoch(self):
if self.training:
self._epoch_count += 1
def get_alpha_status(self):
α = self.get_adaptive_alphas()
α["tsco_loss"] = float(self.tsco_loss)
return {k: float(v) for k, v in α.items()}
Говоря кратко, TSCO - это гибрид между "трансформером", рекуррентной системой и самоорганизующимся процессом, то есть - "динамическая сеть, у которой память и внимание управляются внутренними законами". В самом конце еще будут рассмотрены детально несколько блоков кода, а для особо любознательных - ссылка на гитхаб, а пока же непосредственно результаты бенчмарков.
Сравнение результатов бенчмарка моделей
Бенчмарк #1 (eeg_benchmark.py) Сравнение на обучении в датасете EEG (использовался реальный файл с записью ЭЭГ - приложен в репозитории в папке datasets)
Метрики DynamicTSCO модели
Метрики обычного Transformer
Обсуждение результатов
TSCO в 5 раз эффективнее по perplexity (1.06 vs 5.68) и в 3.3 раза точнее по валидационной точности (98.2% vs 29.3%), при этом имеет на 35% меньше параметров, почти не увеличивает задержку, потребляет меньше памяти и работает в реальном времени (1236 seq/s при ~6.5 мс задержки).
Это фактически означает, что TSCO лучше моделирует структуру EEG-сигнала, стабильно обучается и использует меньше ресурсов, чем Transformer. Почему TSCO "взлетел" на EEG?
ЭЭГ - это временной биосигнал, обладающий сложной периодичностью (альфа-, бета-, дельта-ритмы), взаимными корреляциями между каналами, а также шумом и нелинейными компонентами. Трансформер на таких данных теряет эффективность - его attention не знает, что фаза сигнала имеет значение, positional encoding не подходит для волновой динамики, и модель неустойчива к шуму и фазовым сдвигам.
Почему TSCO справился?
Temporal Attention с фазовым сдвигом (Ω, H) позволяет "синхронизироваться" с ритмическими компонентами EEG, не теряя временной структуры. фактически делает "временную фазовую привязку".
Multi-scale Wave улавливает частоты на разных масштабах (дельта, альфа, гамма).
Это аналог био-фильтрации по диапазонам. Адаптивные α-параметры:
динамически регулируют вклад внимания, корреляций и шума - это как "нейронная самонастройка под частотный контекст". Шум ξ действует как мягкая регуляризация,
повышая устойчивость к артефактам и шуму от электродов. Fusion block + normalization -
объединяет фазовые и амплитудные компоненты сигнала в единую репрезентацию,
что трансформер просто не делает.
Это один из редких случаев, когда архитектура, созданная для языковых данных,
демонстрирует превосходство в биосигналах, что указывает на универсальность механизмов TSCO как динамической модели адаптивных систем, а не просто архитектуры для текстов. TSCO в этом эксперименте фактически действует как нейронный наблюдатель временной динамики, улавливающий фазовую структуру EEG, как физический осциллограф, но через обучаемые внутренние параметры.
Бенчмарк #2 (text_benchmark.py) Сравнение на обучении в датасете wiki_text (использовался обработанный текст в русскоязычными статьями вики 250мб весом - аналогично приложен в репозитории в папке datasets). Результат бенчмарка
сравнение метрик DynamicTSCO и Transformer - обучение на текстовом корпусе Wiki-text
Сравнение результатов показывает ощутимый выигрыш модели DynamicTSCOModel над классическим трансформером.
Параметры запуска:
Всего слов - 141106.
Словарь - 38,542 уникальных слов.
Обучающие данные - 3,968 последовательностей.
Валидационные данные - 441 последовательностей.
DynamicTSCOModel - 16,258,360 параметров (из-за архитектурных особенностей чуть больше параметров чем в Transformer)
Transformer - 15,939,342 параметров
Результаты. DynamicTSCOModel почти в 10 раз точнее предсказывает следующие токены (PPL в 27 против 245), несмотря на то что обе модели имеют сопоставимое число параметров. Вот разбор причин такого разрыва:
Архитектурные преимущества TSCO
Руки не дошли до полноценного сравнения с более крупными современными моделями, в том числе и по причину отсутствия полноценного GPU и лени на развертывание остальных моделей типа mamba или vanilla. Но, попросив сhatGPT сделать теоретическое сравнение при тех же параметрах неоптимизированных вышеперечисленных моделей (аналогичный датасет, аналогичные параметры обучения, CPU), получил вот такую табличку:
да, это умозрительно и приблизительно, но порядок величины по Perplexity оценить можно в сравнении. Известно, что современные трансформеры на малых данных часто переобучаются или недообучаются, потому что их архитектуры рассчитаны на огромные датасеты. На малом датасете с ~16M параметров, TSCO показывает весьма приятный PPL (~27). Vanilla трансформеры и современные LLM при тех же данных выдают PPL 100-300, из-за недостатка адаптивных механизмов, отсутствия встроенной самосогласованности и плохой работы на маленьких датасетах. Именно поэтому TSCO на маленьком датасете с 16M параметров может обходить даже большие трансформеры, обучаемые на том же объеме данных.
Немножко кода
Хотелось бы также детально рассмотреть отдельные архитектурные решения и что они дают в общий вклад эффективности.
positions = torch.arange(seq_len, device=x.device).float().unsqueeze(0)
phase = self.phase_amp.unsqueeze(2) torch.sin(positions α["Ω"] + self.phase_offset.unsqueeze(2))
attn = attn + phase * α["H"]
2. Адаптивный шум. В обучении добавляется обучаемый стохастический шум, зависящий от итерации (log(step)). Как работает: На ранних шагах выдает слабый шум, который усиливается при стабилизации. Это не просто регуляризация, а управляемая стохастическая динамика. Некое подобие "адаптивного стохастического охлаждения" -
аналог simulated annealing внутри нейросети. Модель исследует пространство параметров активно в начале, а затем стабилизируется.
if self.training:
noise = α["ξ"] * math.log(self._step_count.item() + 1.0) * torch.randn_like(x)
return x + noise
3. Мультимасштабные волновые свертки. Каждый Conv с разной последовательностью (1, 2, 4, …) извлекает паттерны разной временной длины. Затем поверх фильтра добавляется резонансная волна, зависящая от α[Γ]. Как работает: dilation=2^i - разные временные масштабы; sin(h (i + 1) 0.1 + time * 0.1) - добавление ритмической фазы в фильтр; усреднение по масштабам (stacked.mean) даёт баланс между короткими и длинными зависимостями. Это гибрид между dilated CNN и осцилляторной системой, которая не только извлекает признаки, но и адаптирует частотный диапазон фильтрации во времени. Иными словами, что-то близкое к спектральному анализу внутрь архитектуры, без FFT.
for i, conv in enumerate(self.scale_convs):
h = conv(x_perm)
resonance = α["Γ"] * torch.sin(h * (i + 1) * 0.1 + time * 0.1)
feats.append(h + resonance)
wave_out = stacked.mean(-1).transpose(1, 2).transpose(0, 1)
Возможные области применения архитектуры Dynamic TSCO
Где же уместно в наше время применение TSCO?
TSCO хорошо подходит для малых языковых моделей (TinyLM), где данных немного, а нужно добиться хорошего PPL. Подходит для кодовых автодополнителей, где важна консистентность внутренних представлений (пример: кросс-слойная логика в коде) - TSCO-loss и Θ/Λ стабилизируют скрытые представления, предотвращая “дрейф контекста”, который бывает у малых трансформеров. TSCO изначально идеально ложится в задачи в духе прогнозирования временных рядов (финансы, метео, сенсоры), анализ биоритмов (ЭЭГ, ЭКГ) - что собственно продемонстировано бенчмарком, отслеживание паттернов в IoT-сетях и потоках данных. Почему? Temporal attention с фазовыми параметрами (phase_amp, phase_offset) позволяет учить периодичность и фазу сигналов напрямую, Multi-scale wave ловит длинные и короткие колебания, Θ/Λ действуют как адаптивная фильтрация, сглаживая шум и усиливая коррелированные паттерны. В целом архиектуру TSCO можно рассматривать как "обобщённый WaveNet+Transformer" с самоорганизующимся вниманием.
Подходит и для следующих задач:
TSCO создаёт самосогласованные временные представления, которые устойчивы к разрывам и пропускам. Это критически важно для аудио и видео, где контекст часто неполон.
Еще одна потенциальная сфера применения - моделирование систем и процессов, TSCO можно применять как нейро-аппроксиматор динамических систем (для уравнений (ODE/PDE), симуляции физических процессов, предсказания поведения сложных систем (рынков, экосистем, сетей). Почему? Observer и Correlation фактически имитируют измерение состояния и обратную связь - TSCO можно рассматривать как обобщённый цифровой наблюдатель, который учится динамике системы во времени. А это открывает путь к применению в инженерии управления, робототехнике.
https://github.com/homoastricus/TSCO_ML - репа с бенчмарками
Что такое Transformer рассказывать не буду, кто не знает, вики в помощь, зато подробно расскажу про свою модель. При создании архитектуры DynamicTSCO я вдохновлялся понятиями из единой теории информации, в частности, Обобщенным уравнением информационного поля и интересной штукой под названием TSCO - Temporal Self-Constistent Objects. Очень кратко об этих сущностях. Обобщенное уравнение информационного поля это удобный формализм для описания поведения любой информационной системы, задаваемый по следующей формуле (в общем виде):
Те, кто знает физику, наверняка узнали в нем что-то похожее на формулу Шредингера. В общем случае оно включает постоянную планка (для физических систем). Другие параметры: Н - Гамильтониан (энергия системы), Γ - нелинейность (нелинейность в чистом виде, хаос и эмерджентность и прочее), Ω - топологический член, M - память системы (для нелокальных эффектов), Θ - оператор самореференции, Φ - контекст (семантическое сжатие входных потоков, получение информации из внешней среды), Λ - (межсистемные или межмасштабные корреляции, ξ - стохастический (неустранимый) шум любой природы. D - диссипация (энтропийные потери). Разумеется, в модели уравнение (а точнее, его компоненты) использованы не в прямом, физическом контексте, а чисто концептуально, архитектурно. TSCO, же если кратко, это оператор самосогласования системы во времени, некий собирательный термин для обозначения класса процессов, протекающих по принципу самосогласованности Новикова. Используется аналогично, не в физическом смысле, а в вычислительно-архитектурном. Теперь - конкретно к реализации адаптивной динамической модели на основе TSCO.
Код DynamicTSCOModel:
class DynamicTSCOModel(nn.Module):
"""
адаптивная DynamicTSCOModel-модель
"""
def __init__(self, vocab_size: int, d_model: int = 256, n_heads: int = 4, n_scales: int = 3):
super().__init__()
self.d_model = d_model
self.vocab_size = vocab_size
self.n_heads = n_heads
self.n_scales = n_scales
# АДАПТИВНЫЕ ПАРАМЕТРЫ
self.alpha_H = nn.Parameter(torch.tensor(0.3))
self.alpha_Γ = nn.Parameter(torch.tensor(0.1))
self.alpha_Ω = nn.Parameter(torch.tensor(0.05))
self.alpha_Λ = nn.Parameter(torch.tensor(0.005))
self.alpha_ξ = nn.Parameter(torch.tensor(0.003))
self.alpha_D = nn.Parameter(torch.tensor(0.3))
self.alpha_M = nn.Parameter(torch.tensor(0.3))
self.alpha_Θ = nn.Parameter(torch.tensor(0.005))
self.alpha_Φ = nn.Parameter(torch.tensor(0.05))
self.alpha_tsco = nn.Parameter(torch.tensor(0.01)) # коэффициент TSCO-loss
# СЧЁТЧИКИ
self.register_buffer("_step_count", torch.tensor(0))
self.register_buffer("_epoch_count", torch.tensor(0))
self.register_buffer("tsco_loss", torch.tensor(0.0))
# АРХИТЕКТУРА
self.embedding = nn.Embedding(vocab_size, d_model)
# Temporal Attention
self.phase_amp = nn.Parameter(torch.ones(n_heads, 1) * 0.1)
self.phase_offset = nn.Parameter(torch.zeros(n_heads, 1))
self.q_linear = nn.Linear(d_model, d_model)
self.k_linear = nn.Linear(d_model, d_model)
self.v_linear = nn.Linear(d_model, d_model)
# Multi-scale Wave
self.scale_convs = nn.ModuleList([
nn.Conv1d(d_model, d_model, kernel_size=3, padding=1, dilation=2 ** i)
for i in range(n_scales)
])
# Observer Θ
self.teta_linear = nn.Linear(d_model, d_model)
self.teta_gate = nn.Linear(d_model * 2, d_model)
# Correlation Λ (динамическая)
self.lambda_mixer = nn.Linear(d_model, d_model)
# TSCO predictor (для внутреннего лосса)
self.tsco_predictor = nn.Linear(d_model, d_model)
# Fusion
self.fusion_linear = nn.Linear(d_model * 3, d_model)
self.norm = nn.LayerNorm(d_model)
self.final_norm = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(0.1)
self.fc = nn.Linear(d_model, vocab_size)
print(f"DynamicTSCOModel создана: {sum(p.numel() for p in self.parameters()):,} параметров")
# Adaptive coefficients
def get_adaptive_alphas(self):
epoch = self._epoch_count.item()
prog = min(epoch / 50.0, 1.0)
α = {
"H": torch.sigmoid(self.alpha_H) * 0.5,
"Γ": torch.sigmoid(self.alpha_Γ) * 0.3,
"Ω": torch.sigmoid(self.alpha_Ω) * 0.2,
"Λ": torch.sigmoid(self.alpha_Λ) * 0.4,
"ξ": torch.sigmoid(self.alpha_ξ) * 0.01,
"D": torch.sigmoid(self.alpha_D) * 0.6,
"M": torch.sigmoid(self.alpha_M) * 0.5,
"Θ": torch.sigmoid(self.alpha_Θ) * 0.3,
"Φ": torch.sigmoid(self.alpha_Φ) * 0.2,
"tsco": torch.sigmoid(self.alpha_tsco) * 0.01,
}
# динамическая адаптация
if prog > 0.3:
α["Θ"] *= (prog * 2.0)
α["Λ"] *= (prog * 2.0)
if prog < 0.2:
α["ξ"] *= 1.8
α["D"] *= 0.6
α["H"] *= 1.2
elif prog > 0.6:
α["ξ"] *= 0.4
α["M"] *= 1.3
α["Λ"] *= 1.1
return α
def temporal_attention(self, x, α):
seq_len, batch, _ = x.size()
Q = self.q_linear(x).view(seq_len, batch, self.n_heads, -1).transpose(0, 1)
K = self.k_linear(x).view(seq_len, batch, self.n_heads, -1).transpose(0, 1)
V = self.v_linear(x).view(seq_len, batch, self.n_heads, -1).transpose(0, 1)
attn = torch.einsum("bqhd,bkhd->bhqk", Q, K) / math.sqrt(Q.size(-1))
positions = torch.arange(seq_len, device=x.device).float().unsqueeze(0)
phase = self.phase_amp.unsqueeze(2) * torch.sin(positions * α["Ω"] + self.phase_offset.unsqueeze(2))
attn = attn + phase * α["H"]
weights = F.softmax(attn, dim=-1)
out = torch.einsum("bhqk,bkhd->bqhd", weights, V)
out = out.transpose(0, 1).contiguous().view(seq_len, batch, self.d_model)
return out
# Multi-scale Wave
def multi_scale_wave(self, x, α):
seq_len, batch, d_model = x.shape
x_perm = x.transpose(0, 1).transpose(1, 2)
feats = []
for i, conv in enumerate(self.scale_convs):
h = conv(x_perm)
if h.size(-1) != seq_len:
h = F.interpolate(h, size=seq_len, mode="linear", align_corners=False)
time = torch.arange(seq_len, device=x.device).float().view(1, 1, -1)
resonance = α["Γ"] * torch.sin(h * (i + 1) * 0.1 + time * 0.1)
feats.append(h + resonance)
stacked = torch.stack(feats, dim=-1)
wave_out = stacked.mean(-1).transpose(1, 2).transpose(0, 1)
return wave_out
# Correlation operator Λ
def correlation_operator(self, x, α):
λ = torch.sigmoid(self.lambda_mixer(x)) # [s,b,d]
corr = torch.tanh(x * λ)
return x + α["Λ"] * corr
# Observer operator Θ
def observer_operator(self, x, α):
proj = self.teta_linear(x)
gate = torch.sigmoid(self.teta_gate(torch.cat([x, proj], dim=-1)))
return x + α["Θ"] * gate * (proj - x)
# TSCO-loss (самосогласованность)
def compute_tsco_loss(self, x, α):
x_pred = self.tsco_predictor(x)
tsco_loss = F.mse_loss(x_pred, x)
self.tsco_loss = tsco_loss.detach()
return α["tsco"] * tsco_loss
# Forward
def forward(self, x):
if self.training:
self._step_count += 1
α = self.get_adaptive_alphas()
x_emb = self.embedding(x) * math.sqrt(self.d_model)
temp_out = self.temporal_attention(x_emb, α)
wave_out = self.multi_scale_wave(x_emb, α)
fused = torch.cat([x_emb, temp_out, wave_out], dim=-1)
fused = self.fusion_linear(fused)
fused = self.norm(fused + x_emb)
fused = self.correlation_operator(fused, α)
fused = self.observer_operator(fused, α)
fused = self.final_norm(fused)
fused = self.dropout(fused)
if self.training:
_ = self.compute_tsco_loss(fused, α)
noise = α["ξ"] * math.log(self._step_count.item() + 1)
fused = fused + noise * torch.randn_like(fused)
logits = self.fc(fused)
return logits.view(-1, logits.size(-1))
def update_epoch(self):
if self.training:
self._epoch_count += 1
def get_alpha_status(self):
α = self.get_adaptive_alphas()
α["tsco_loss"] = float(self.tsco_loss)
return {k: float(v) for k, v in α.items()}
Говоря кратко, TSCO - это гибрид между "трансформером", рекуррентной системой и самоорганизующимся процессом, то есть - "динамическая сеть, у которой память и внимание управляются внутренними законами". В самом конце еще будут рассмотрены детально несколько блоков кода, а для особо любознательных - ссылка на гитхаб, а пока же непосредственно результаты бенчмарков.
Сравнение результатов бенчмарка моделей
Бенчмарк #1 (eeg_benchmark.py) Сравнение на обучении в датасете EEG (использовался реальный файл с записью ЭЭГ - приложен в репозитории в папке datasets)
Метрики DynamicTSCO модели
Метрики обычного Transformer
Модель | Параметры | Latency | Throughput | ΔПамять | PPL | ValAcc |
|---|---|---|---|---|---|---|
DynamicTSCOModel | 272,886 | 0.0065s | 1236.85 seq/s | +0.00 MB | 1.06 | 0.982 |
SimpleTransformer | 422,501 | 0.0055s | 1443.64 seq/s | +1.18 MB | 5.68 | 0.293 |
Обсуждение результатов
TSCO в 5 раз эффективнее по perplexity (1.06 vs 5.68) и в 3.3 раза точнее по валидационной точности (98.2% vs 29.3%), при этом имеет на 35% меньше параметров, почти не увеличивает задержку, потребляет меньше памяти и работает в реальном времени (1236 seq/s при ~6.5 мс задержки).
Это фактически означает, что TSCO лучше моделирует структуру EEG-сигнала, стабильно обучается и использует меньше ресурсов, чем Transformer. Почему TSCO "взлетел" на EEG?
ЭЭГ - это временной биосигнал, обладающий сложной периодичностью (альфа-, бета-, дельта-ритмы), взаимными корреляциями между каналами, а также шумом и нелинейными компонентами. Трансформер на таких данных теряет эффективность - его attention не знает, что фаза сигнала имеет значение, positional encoding не подходит для волновой динамики, и модель неустойчива к шуму и фазовым сдвигам.
Почему TSCO справился?
Temporal Attention с фазовым сдвигом (Ω, H) позволяет "синхронизироваться" с ритмическими компонентами EEG, не теряя временной структуры. фактически делает "временную фазовую привязку".
Multi-scale Wave улавливает частоты на разных масштабах (дельта, альфа, гамма).
Это аналог био-фильтрации по диапазонам. Адаптивные α-параметры:
динамически регулируют вклад внимания, корреляций и шума - это как "нейронная самонастройка под частотный контекст". Шум ξ действует как мягкая регуляризация,
повышая устойчивость к артефактам и шуму от электродов. Fusion block + normalization -
объединяет фазовые и амплитудные компоненты сигнала в единую репрезентацию,
что трансформер просто не делает.
Это один из редких случаев, когда архитектура, созданная для языковых данных,
демонстрирует превосходство в биосигналах, что указывает на универсальность механизмов TSCO как динамической модели адаптивных систем, а не просто архитектуры для текстов. TSCO в этом эксперименте фактически действует как нейронный наблюдатель временной динамики, улавливающий фазовую структуру EEG, как физический осциллограф, но через обучаемые внутренние параметры.
Бенчмарк #2 (text_benchmark.py) Сравнение на обучении в датасете wiki_text (использовался обработанный текст в русскоязычными статьями вики 250мб весом - аналогично приложен в репозитории в папке datasets). Результат бенчмарка
сравнение метрик DynamicTSCO и Transformer - обучение на текстовом корпусе Wiki-text
Сравнение результатов показывает ощутимый выигрыш модели DynamicTSCOModel над классическим трансформером.
Параметры запуска:
Всего слов - 141106.
Словарь - 38,542 уникальных слов.
Обучающие данные - 3,968 последовательностей.
Валидационные данные - 441 последовательностей.
DynamicTSCOModel - 16,258,360 параметров (из-за архитектурных особенностей чуть больше параметров чем в Transformer)
Transformer - 15,939,342 параметров
Результаты. DynamicTSCOModel почти в 10 раз точнее предсказывает следующие токены (PPL в 27 против 245), несмотря на то что обе модели имеют сопоставимое число параметров. Вот разбор причин такого разрыва:
Архитектурные преимущества TSCO
Temporal Attention с фазовым сдвигом и амплитудой (phase_amp, phase_offset).
Модель учитывает периодические и временные паттерны в последовательностях напрямую, что стандартный трансформер не делает. Это помогает лучше моделировать повторяющиеся структуры текста.
Multi-scale Wave (свёртки с разными длинами) позволяет охватывать контексты разной длины. Трансформер с 2 слоями и 4 головами ограничен в объёме контекста и слабее улавливает длинные зависимости.
Observer operator Θ и Correlation operator Λ добавляют динамическую адаптацию внутренних представлений и межсостояний токенов. Это фактически "самокоррекция" скрытых состояний, чего нет у обычного трансформера.
TSCO-предсказатель и самосогласованность (TSCO-loss) - встроенный внутренний лосс заставляет модель учиться согласованным внутренним представлениям. Это улучшает стабильность градиентов и снижает переобучение, что особенно важно на небольших датасетах.
TSCO вводит аддитивный шум и адаптивные коэффициенты (ξ, H, D, M, Θ, Λ и др.), что эффективно выполняет регуляризацию и стабилизирует обучение.
Классический трансформер обучается стандартной CrossEntropy без внутренних механизмов регуляризации и адаптации, что делает его очень чувствительным к небольшому датасету.
В TSCO слияние эмбеддингов, временной и многомасштабной волны через fusion_linear позволяет модели комбинировать локальные и глобальные признаки.
Трансформер с 2 слоями не имеет такой гибкой агрегации, поэтому теряет большую часть информации при сравнении PPL.
Малое количество слоёв (NLAYERS=2) и голов (NHEAD=4) не позволяет трансформеру достаточно моделировать сложные зависимости текста.
При этом TSCO компенсирует недостаток параметров за счёт умной архитектурной индукции и встроенных адаптивных механизмов.
В целом TSCO выигрывает за счёт специальных механизмов для моделирования временных, многомасштабных и корреляционных зависимостей, встроенной самосогласованности и адаптивного шумового регуляризатора.
Трансформер же на маленьком датасете и с небольшой архитектурой страдает от ограниченной способности захватывать контекст и отсутствия встроенной адаптивной регуляризации.
Руки не дошли до полноценного сравнения с более крупными современными моделями, в том числе и по причину отсутствия полноценного GPU и лени на развертывание остальных моделей типа mamba или vanilla. Но, попросив сhatGPT сделать теоретическое сравнение при тех же параметрах неоптимизированных вышеперечисленных моделей (аналогичный датасет, аналогичные параметры обучения, CPU), получил вот такую табличку:
Модель | Параметры | Датасет ~140k слов | Ожидаемый PPL (теоретически) | Причины |
|---|---|---|---|---|
Vanilla Transformer (2 слоя, 4 головы) | 16M | Да | ~200–300 | Ограниченные слои и головы → слабое моделирование длинных зависимостей; без адаптивной регуляризации → PPL высок |
GPT-2 small (124M) | 124M | Да | ~100–200 | Большая модель, но переобучение на маленьком датасете → высокая PPL без регуляризации |
Mamba / MPT-7B/Small (70M) | 70M | Да | ~80–150 | Современные архитектуры + нормализация помогают, но маленький датасет → переобучение и недообучение одновременно |
DynamicTSCOModel | 16M | Да | 26–27 | Temporal + Multi-scale + TSCO-loss → эффективная адаптация к маленькому датасету; внутренний консистентный лосс ускоряет обучение; шум и адаптивные коэффициенты предотвращают переобучение |
да, это умозрительно и приблизительно, но порядок величины по Perplexity оценить можно в сравнении. Известно, что современные трансформеры на малых данных часто переобучаются или недообучаются, потому что их архитектуры рассчитаны на огромные датасеты. На малом датасете с ~16M параметров, TSCO показывает весьма приятный PPL (~27). Vanilla трансформеры и современные LLM при тех же данных выдают PPL 100-300, из-за недостатка адаптивных механизмов, отсутствия встроенной самосогласованности и плохой работы на маленьких датасетах. Именно поэтому TSCO на маленьком датасете с 16M параметров может обходить даже большие трансформеры, обучаемые на том же объеме данных.
Немножко кода
Хотелось бы также детально рассмотреть отдельные архитектурные решения и что они дают в общий вклад эффективности.
Добавление осцилляторной (волновой) компоненты к обычной attention-матрице, основанную на фазе (Ω) и амплитуде (H). Как работает: phase_amp и phase_offset создают синусоидальную модуляцию внимания; это моделирует ритмическую природу данных (временные ряды, EEG, речь и т.д.); результат - "осциллирующее внимание", которое улавливает фазовые зависимости, а не только амплитудные корреляции.
Фактически это нейроосциллятор внутри attention-механизма - нечто, что не делает ни GPT, ни Mamba. Такой attention синхронизируется с периодикой данных и как следствие повышает чувствительность к ритму и фазовым сдвигам.
positions = torch.arange(seq_len, device=x.device).float().unsqueeze(0)
phase = self.phase_amp.unsqueeze(2) torch.sin(positions α["Ω"] + self.phase_offset.unsqueeze(2))
attn = attn + phase * α["H"]
2. Адаптивный шум. В обучении добавляется обучаемый стохастический шум, зависящий от итерации (log(step)). Как работает: На ранних шагах выдает слабый шум, который усиливается при стабилизации. Это не просто регуляризация, а управляемая стохастическая динамика. Некое подобие "адаптивного стохастического охлаждения" -
аналог simulated annealing внутри нейросети. Модель исследует пространство параметров активно в начале, а затем стабилизируется.
if self.training:
noise = α["ξ"] * math.log(self._step_count.item() + 1.0) * torch.randn_like(x)
return x + noise
3. Мультимасштабные волновые свертки. Каждый Conv с разной последовательностью (1, 2, 4, …) извлекает паттерны разной временной длины. Затем поверх фильтра добавляется резонансная волна, зависящая от α[Γ]. Как работает: dilation=2^i - разные временные масштабы; sin(h (i + 1) 0.1 + time * 0.1) - добавление ритмической фазы в фильтр; усреднение по масштабам (stacked.mean) даёт баланс между короткими и длинными зависимостями. Это гибрид между dilated CNN и осцилляторной системой, которая не только извлекает признаки, но и адаптирует частотный диапазон фильтрации во времени. Иными словами, что-то близкое к спектральному анализу внутрь архитектуры, без FFT.
for i, conv in enumerate(self.scale_convs):
h = conv(x_perm)
resonance = α["Γ"] * torch.sin(h * (i + 1) * 0.1 + time * 0.1)
feats.append(h + resonance)
wave_out = stacked.mean(-1).transpose(1, 2).transpose(0, 1)
Возможные области применения архитектуры Dynamic TSCO
Где же уместно в наше время применение TSCO?
TSCO хорошо подходит для малых языковых моделей (TinyLM), где данных немного, а нужно добиться хорошего PPL. Подходит для кодовых автодополнителей, где важна консистентность внутренних представлений (пример: кросс-слойная логика в коде) - TSCO-loss и Θ/Λ стабилизируют скрытые представления, предотвращая “дрейф контекста”, который бывает у малых трансформеров. TSCO изначально идеально ложится в задачи в духе прогнозирования временных рядов (финансы, метео, сенсоры), анализ биоритмов (ЭЭГ, ЭКГ) - что собственно продемонстировано бенчмарком, отслеживание паттернов в IoT-сетях и потоках данных. Почему? Temporal attention с фазовыми параметрами (phase_amp, phase_offset) позволяет учить периодичность и фазу сигналов напрямую, Multi-scale wave ловит длинные и короткие колебания, Θ/Λ действуют как адаптивная фильтрация, сглаживая шум и усиливая коррелированные паттерны. В целом архиектуру TSCO можно рассматривать как "обобщённый WaveNet+Transformer" с самоорганизующимся вниманием.
Подходит и для следующих задач:
аудио-синтез и генерация речи (text-to-speech),
детекция событий во времени (video segmentation, motion prediction),
восстановление звука и видео из фрагментов.
TSCO создаёт самосогласованные временные представления, которые устойчивы к разрывам и пропускам. Это критически важно для аудио и видео, где контекст часто неполон.
Еще одна потенциальная сфера применения - моделирование систем и процессов, TSCO можно применять как нейро-аппроксиматор динамических систем (для уравнений (ODE/PDE), симуляции физических процессов, предсказания поведения сложных систем (рынков, экосистем, сетей). Почему? Observer и Correlation фактически имитируют измерение состояния и обратную связь - TSCO можно рассматривать как обобщённый цифровой наблюдатель, который учится динамике системы во времени. А это открывает путь к применению в инженерии управления, робототехнике.
https://github.com/homoastricus/TSCO_ML - репа с бенчмарками
