--- language: - ru - en - zh - de - uk tags: - causal-lm - pytorch - safetensors - timegpt - 0.5b - text-generation license: apache-2.0 pipeline_tag: text-generation inference: false model_name: TimeGPT-Base --- # ⏳ TimeGPT-Base (0.5B) **TimeGPT-Base** — это мультиязычная авторегрессионная языковая модель (Causal LM) класса **0.5B**, разработанная и обученная **полностью с нуля (from scratch)** без использования сторонних весов или дистилляции. Модель создана независимой командой **LongTime Devs** и обучена на одном потребительском ускорителе **NVIDIA GeForce RTX 5060 Ti 16GB**. Основной язык обучения — **русский**, с интеграцией английского, китайского, немецкого и украинского корпусов. > ⚠️ **Важное замечание:** это **базовая фундаментальная модель (Base)**. Она обучена задаче продолжения текста (next-token prediction / text completion) и не проходила стадию выравнивания инструкций. > > Диалоговая инструктивная версия — **TimeGPT-Instruct (0.5B)** — в настоящее время находится на финальной стадии дообучения и **в скором времени будет опубликована** в репозитории команды LongTime Devs. --- ## 🏛 Архитектурные особенности TimeGPT построена на современной архитектуре трансформера (уровня Llama 3 и Qwen 2.5), оптимизированной для высокой скорости инференса и экономии видеопамяти: - **Grouped-Query Attention (GQA)**: 20 голов Query и 4 головы Key/Value (соотношение 5:1), что кратно снижает размер KV-кеша при работе с контекстом. - **SwiGLU Activation**: нелинейная функция активации в блоках MLP. - **RMSNorm**: быстрая среднеквадратичная нормализация вместо классического LayerNorm. - **Rotary Position Embeddings (RoPE)**: векторное позиционное кодирование с базовой частотой $\theta = 500\,000$ для стабильности контекста. - **Weight Tying**: совмещение матриц эмбеддингов токенов и выходной языковой головы для компактности и регуляризации весов. - **FlashAttention / SDPA**: поддержка нативного аппаратного ускорения Scaled Dot-Product Attention в режиме `bfloat16`. ### Спецификация модели | Параметр | Значение | | :--- | :--- | | **Класс параметров** | **0.5B** | | **Размер файла весов** | **1.02 GB** (`model.safetensors`) | | **Размерность скрытого слоя (`dim`)** | 1280 | | **Количество слоев (`n_layers`)** | 24 | | **Голов внимания (`n_heads`)** | 20 | | **Голов Key/Value (`n_kv_heads`)** | 4 (GQA) | | **Размерность промежуточного слоя MLP** | 3456 (SwiGLU) | | **Контекстное окно (`max_seq_len`)** | 1024 токена | | **Размер словаря (`vocab_size`)** | 32 000 | | **Формат весов** | SafeTensors (`bfloat16`) | --- ## 🔤 Токенизатор Модель использует собственный мультиязычный **Byte-Level BPE** токенизатор: - **Размер словаря**: 32 000 токенов. - **Byte-fallback**: байтовое резервирование исключает появление токенов неизвестных символов (`<|unk|>`) при обработке редких знаков, иероглифов и эмодзи. - **Служебные токены стандарта ChatML**: - `<|pad|>` - `<|unk|>` - `<|im_start|>` - `<|im_end|>` --- ## 📚 Данные и процесс предобучения Модель обучалась фундаментальному чтению в непрерывном мультиязычном потоке данных: - **Русский язык (основной массив, ~55%)**: русскоязычный срез Википедии + новостные корпуса (`IlyaGusev/gazeta`). - **Английский язык (~20%)**: статьи англоязычной Википедии. - **Китайский язык (~10%)**: срез китайской Википедии. - **Немецкий язык (~8%)**: срез немецкой Википедии. - **Украинский язык (~7%)**: статьи украинской Википедии. ### Детали тренировочного цикла: - **Оборудование**: 1× NVIDIA GeForce RTX 5060 Ti 16GB. - **Шаги обучения**: 50 000 шагов (эффективный размер батча = 16 последовательностей по 1024 токена). - **Суммарный объем прочитанных данных**: ~820 млн токенов. - **Время непрерывного обучения**: ~27 часов. - **Оптимизатор**: AdamW ($\beta_1 = 0.9$, $\beta_2 = 0.95$, weight decay = 0.01). - **График Learning Rate**: Cosine Annealing с плавным разогревом (Warmup: 1500 шагов, Peak LR: `1.8e-4`). - **Динамика Loss**: стартовый лосс **10.64** $\rightarrow$ финальный лосс **3.02–3.36** (перплексия снизилась с бесконечности до ~20). --- ## 💻 Быстрый запуск (Inference) Установите необходимые зависимости: ```bash pip install torch tokenizers safetensors huggingface_hub ``` Скрипт автоматически скачивает веса (`model.safetensors` — 1.02 GB) и токенизатор напрямую из репозитория `longtimedevs/TimeGPT-Base`: ```python # WARNING: DO NOT USE THIS SCRIPT IN PRODUCTION ENVIRONMENTS! // ВНИМАНИЕ: НЕ ИСПОЛЬЗУЙТЕ ДАННЫЙ КОД В ПРОДАКШЕНЕ! # FOR RESEARCH, TESTING AND EXPERIMENTAL PURPOSES ONLY! // ТОЛЬКО ДЛЯ ИССЛЕДОВАТЕЛЬСКИХ ЦЕЛЕЙ, ТЕСТИРОВАНИЯ И ЭКСПЕРИМЕНТОВ! import os import torch import torch.nn as nn import torch.nn.functional as F from dataclasses import dataclass from tokenizers import Tokenizer from safetensors.torch import load_file from huggingface_hub import hf_hub_download # --- 1. Автоматическое скачивание с Hugging Face --- REPO_ID = "longtimedevs/TimeGPT-Base" print(f"[*] Проверка и скачивание файлов из {REPO_ID}...") weights_path = hf_hub_download(repo_id=REPO_ID, filename="model.safetensors") tokenizer_path = hf_hub_download(repo_id=REPO_ID, filename="tokenizer.json") # --- 2. Конфигурация модели --- @dataclass class TimeGPTConfig: vocab_size: int = 32000 dim: int = 1280 n_layers: int = 24 n_heads: int = 20 n_kv_heads: int = 4 multiple_of: int = 256 max_seq_len: int = 1024 norm_eps: float = 1e-5 rope_theta: float = 500000.0 # --- 3. Архитектура TimeGPT --- class RMSNorm(nn.Module): def __init__(self, dim: int, eps: float = 1e-5): super().__init__() self.eps = eps self.weight = nn.Parameter(torch.ones(dim)) def forward(self, x): return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight def precompute_rope_sincos(dim: int, max_seq_len: int, theta: float = 500000.0): freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim)) t = torch.arange(max_seq_len, dtype=torch.float32) freqs = torch.outer(t, freqs) freqs = torch.cat([freqs, freqs], dim=-1) return torch.cos(freqs), torch.sin(freqs) def rotate_half(x: torch.Tensor): x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :] return torch.cat((-x2, x1), dim=-1) def apply_rope(xq, xk, cos, sin): cos = cos[:xq.shape[2]].unsqueeze(0).unsqueeze(1) sin = sin[:xq.shape[2]].unsqueeze(0).unsqueeze(1) return (xq * cos) + (rotate_half(xq) * sin), (xk * cos) + (rotate_half(xk) * sin) class Attention(nn.Module): def __init__(self, cfg): super().__init__() self.n_heads, self.n_kv_heads = cfg.n_heads, cfg.n_kv_heads self.head_dim = cfg.dim // cfg.n_heads self.n_rep = self.n_heads // self.n_kv_heads self.wq = nn.Linear(cfg.dim, cfg.n_heads * self.head_dim, bias=False) self.wk = nn.Linear(cfg.dim, cfg.n_kv_heads * self.head_dim, bias=False) self.wv = nn.Linear(cfg.dim, cfg.n_kv_heads * self.head_dim, bias=False) self.wo = nn.Linear(cfg.n_heads * self.head_dim, cfg.dim, bias=False) def forward(self, x, cos, sin): B, S, _ = x.shape xq = self.wq(x).view(B, S, self.n_heads, self.head_dim).transpose(1, 2) xk = self.wk(x).view(B, S, self.n_kv_heads, self.head_dim).transpose(1, 2) xv = self.wv(x).view(B, S, self.n_kv_heads, self.head_dim).transpose(1, 2) xq, xk = apply_rope(xq, xk, cos, sin) if self.n_rep > 1: xk = xk.repeat_interleave(self.n_rep, dim=1) xv = xv.repeat_interleave(self.n_rep, dim=1) out = F.scaled_dot_product_attention(xq, xk, xv, is_causal=True) return self.wo(out.transpose(1, 2).contiguous().view(B, S, -1)) class SwiGLUMLP(nn.Module): def __init__(self, cfg): super().__init__() hidden_dim = int(2 * (4 * cfg.dim) / 3) hidden_dim = cfg.multiple_of * ((hidden_dim + cfg.multiple_of - 1) // cfg.multiple_of) self.w1 = nn.Linear(cfg.dim, hidden_dim, bias=False) self.w2 = nn.Linear(hidden_dim, cfg.dim, bias=False) self.w3 = nn.Linear(cfg.dim, hidden_dim, bias=False) def forward(self, x): return self.w2(F.silu(self.w1(x)) * self.w3(x)) class TransformerBlock(nn.Module): def __init__(self, cfg): super().__init__() self.attn_norm, self.attn = RMSNorm(cfg.dim, cfg.norm_eps), Attention(cfg) self.ffn_norm, self.ffn = RMSNorm(cfg.dim, cfg.norm_eps), SwiGLUMLP(cfg) def forward(self, x, cos, sin): return x + self.ffn(self.ffn_norm(x + self.attn(self.attn_norm(x), cos, sin))) class TimeGPT(nn.Module): def __init__(self, cfg): super().__init__() self.cfg = cfg self.tok_embeddings = nn.Embedding(cfg.vocab_size, cfg.dim) self.layers = nn.ModuleList([TransformerBlock(cfg) for _ in range(cfg.n_layers)]) self.norm = RMSNorm(cfg.dim, cfg.norm_eps) self.output = nn.Linear(cfg.dim, cfg.vocab_size, bias=False) self.output.weight = self.tok_embeddings.weight cos, sin = precompute_rope_sincos(cfg.dim // cfg.n_heads, cfg.max_seq_len, cfg.rope_theta) self.register_buffer("rope_cos", cos, persistent=False) self.register_buffer("rope_sin", sin, persistent=False) def forward(self, idx): B, S = idx.shape h = self.tok_embeddings(idx) cos, sin = self.rope_cos[:S], self.rope_sin[:S] for layer in self.layers: h = layer(h, cos, sin) return self.output(self.norm(h)) # --- 4. Загрузка весов и инференс со стримингом --- device = "cuda" if torch.cuda.is_available() else "cpu" cfg = TimeGPTConfig() model = TimeGPT(cfg).to(device, dtype=torch.bfloat16) # Чтение скачанных весов SafeTensors weights = load_file(weights_path, device=device) model.load_state_dict(weights, strict=False) model.eval() tokenizer = Tokenizer.from_file(tokenizer_path) prompt = "Искусственный интеллект — это" input_ids = torch.tensor([tokenizer.encode(prompt).ids], device=device) print(prompt, end="", flush=True) with torch.inference_mode(): for _ in range(80): logits = model(input_ids[:, -cfg.max_seq_len:]) next_token = torch.multinomial(F.softmax(logits[0, -1, :] / 0.7, dim=-1), num_samples=1) if next_token.item() == tokenizer.token_to_id("<|im_end|>"): break input_ids = torch.cat([input_ids, next_token.unsqueeze(0)], dim=1) print(tokenizer.decode([next_token.item()]), end="", flush=True) print() ``` --- ## 👥 Разработчики - **Команда**: LongTime Devs - **Архитектура**: TimeGPT - **Лицензия**: Apache 2.0 (открыто для свободного использования и исследований)