| --- |
| 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 (открыто для свободного использования и исследований) |
