clean: remove old v11 checkpoints

best_checkpoint_v11.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:19a469d8ed889e660357b329cff6b854f7109c73b60432147833580f05507f71
-size 106321288

train_kaggle_v11.py

@@ -1,939 +0,0 @@
-import subprocess, sys
-subprocess.run([sys.executable, "-m", "pip", "install", "-q",
-    "tiktoken", "datasets", "huggingface_hub"], check=True)
-
-# Kaggle T4 validation run - SEQ=128, HIDDEN=128, 5M chars, 10 epochs, warm-start+freeze h1/h2, ANTI=0.15
-import math
-import os
-import time
-from dataclasses import dataclass, field
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.utils.data import Dataset, DataLoader, random_split, Subset
-
-# ---------------------------------------------------------------------------
-# Конфиг
-# ---------------------------------------------------------------------------
-
-SEQ_LEN           = 128
-HIDDEN_DIM        = 128
-TAUS              = (4.0, 32.0, 128.0)
-HORIZONS          = (1, 4, 32)
-BATCH_SIZE        = 32
-EPOCHS            = 15
-LR                = 3e-4
-EARLY_STOP        = 3
-MAX_EPOCH_SECONDS = 600
-JACOBI_K          = 2
-SEED              = 42
-MAX_SEQS          = 6_000
-TARGET_CHARS      = 5_000_000
-
-A_RANGES = ((0.55, 0.88), (0.90, 0.975), (0.980, 0.999))
-
-TRAIN_HEAD_WEIGHTS = (0.2, 0.3, 0.5)
-
-# v8+: предсказательное кодирование
-PRED_LAMBDA = 0.1
-
-# v11 Change B: anti-task loss — h3 штрафуется за предсказание t+1
-# total_loss -= ANTI_LAMBDA * CE(head3, t+1)
-# Цель: h3 вынужден активно избегать t+1-полезных признаков
-ANTI_LAMBDA = 0.15
-
-WARM_START    = True
-WARM_START_HF = "v11_last_checkpoint.pt"
-
-# v11 Change D: slow-tick для h3 — h3 получает новый h2_error только раз в N токенов.
-# Между обновлениями h3 видит то же самое h2_error (hold).
-# Принуждает h3 интегрировать информацию крупными блоками, а не гнаться за каждым токеном.
-H3_SLOW_TICK = 8
-
-# v10+: h3 landmark attention ВНУТРИ цикла Якоби
-LANDMARK_STRIDE = 32
-LANDMARK_HEADS  = 4
-
-CE_CHUNK          = 128
-LR_WARMUP_EPOCHS  = 1
-DROPOUT           = 0.10
-
-CKPT_DIR   = os.environ.get("CHECKPOINT_DIR", "/kaggle/working")
-HF_TOKEN   = "__HF_TOKEN_PLACEHOLDER__"
-HF_REPO_ID = "Omibranch/harmonic-checkpoints"
-LOG_FILE   = "/tmp/v11_train.log"
-
-
-class _Tee:
-    def __init__(self, path):
-        self._f    = open(path, "w")
-        self._orig = sys.__stdout__
-    def write(self, s):
-        self._orig.write(s)
-        self._f.write(s)
-        self._f.flush()
-    def flush(self):
-        self._orig.flush()
-        self._f.flush()
-    def fileno(self):
-        return self._orig.fileno()
-
-
-# ---------------------------------------------------------------------------
-# HF Hub
-# ---------------------------------------------------------------------------
-
-def _silence_hf():
-    try:
-        from huggingface_hub.utils import disable_progress_bars
-        disable_progress_bars()
-    except Exception:
-        pass
-    try:
-        import datasets as _ds
-        _ds.disable_progress_bar()
-    except Exception:
-        pass
-    import logging
-    logging.getLogger("huggingface_hub").setLevel(logging.ERROR)
-    logging.getLogger("fsspec").setLevel(logging.ERROR)
-    logging.getLogger("datasets").setLevel(logging.ERROR)
-    logging.getLogger("urllib3").setLevel(logging.ERROR)
-
-_silence_hf()
-
-
-def _hf_repo_id():
-    global HF_REPO_ID
-    if HF_REPO_ID is None:
-        from huggingface_hub import HfApi
-        api = HfApi(token=HF_TOKEN)
-        username = api.whoami()["name"]
-        repo_id = f"{username}/harmonic-checkpoints"
-        api.create_repo(repo_id=repo_id, exist_ok=True, private=True)
-        HF_REPO_ID = repo_id
-    return HF_REPO_ID
-
-
-def upload_to_hf(local_path, filename):
-    try:
-        from huggingface_hub import upload_file
-        rid = _hf_repo_id()
-        t0 = time.perf_counter()
-        upload_file(
-            path_or_fileobj=local_path,
-            path_in_repo=filename,
-            repo_id=rid,
-            repo_type="model",
-            token=HF_TOKEN,
-        )
-        mb = os.path.getsize(local_path) / 1024 / 1024
-        print(f"  HF: {filename} -> {rid}  ({mb:.0f} MB, {time.perf_counter()-t0:.1f}s)",
-              flush=True)
-    except Exception as e:
-        print(f"  HF upload error: {e}", flush=True)
-
-
-def upload_to_hf_epoch(model_only_path, epoch, val_far):
-    filename = f"v11_e{epoch:02d}_{val_far:.4f}.pt"
-    upload_to_hf(model_only_path, filename)
-    return filename
-
-
-# ---------------------------------------------------------------------------
-# AMP dtype
-# ---------------------------------------------------------------------------
-
-def get_amp_dtype(device):
-    if device.type != "cuda":
-        return None
-    props = torch.cuda.get_device_properties(0)
-    if props.major >= 8:
-        return torch.bfloat16
-    return torch.float16
-
-
-# ---------------------------------------------------------------------------
-# Chunked cross-entropy
-# ---------------------------------------------------------------------------
-
-class _ChunkedCE(torch.autograd.Function):
-    @staticmethod
-    def forward(ctx, logits, flat_targets, chunk_size, label_smoothing):
-        B, T, V = logits.shape
-        tgt = flat_targets.reshape(B, T)
-        acc = torch.zeros((), device=logits.device, dtype=torch.float32)
-        with torch.no_grad():
-            for t0 in range(0, T, chunk_size):
-                t1 = min(t0 + chunk_size, T)
-                lg = logits[:, t0:t1].float()
-                lg.clamp_(-50, 50)
-                acc.add_(F.cross_entropy(
-                    lg.view(-1, V), tgt[:, t0:t1].reshape(-1),
-                    reduction="sum", label_smoothing=label_smoothing,
-                ))
-                del lg
-        ctx.save_for_backward(logits, tgt)
-        ctx.chunk_size = chunk_size
-        ctx.label_smoothing = label_smoothing
-        return acc.div_(B * T)
-
-    @staticmethod
-    def backward(ctx, g):
-        logits, tgt = ctx.saved_tensors
-        B, T, V = logits.shape
-        chunk_size = ctx.chunk_size
-        ls = ctx.label_smoothing
-        scale = g.item() / (B * T)
-        grad = torch.zeros_like(logits)
-        with torch.no_grad():
-            for t0 in range(0, T, chunk_size):
-                t1 = min(t0 + chunk_size, T)
-                C = t1 - t0
-                lg = logits[:, t0:t1].float()
-                lg.clamp_(-50, 50)
-                probs = F.softmax(lg.view(-1, V), dim=-1)
-                del lg
-                idx = tgt[:, t0:t1].reshape(-1)
-                probs[torch.arange(B * C, device=probs.device), idx] -= (1.0 - ls)
-                probs -= ls / V
-                grad[:, t0:t1].add_(probs.view(B, C, V).to(grad.dtype), alpha=scale)
-                del probs, idx
-        return grad, None, None, None
-
-
-def chunked_ce(logits, targets, label_smoothing=0.0):
-    return _ChunkedCE.apply(logits, targets.reshape(-1), CE_CHUNK, label_smoothing)
-
-
-# ---------------------------------------------------------------------------
-# Label smoothing curriculum
-# ---------------------------------------------------------------------------
-
-def get_label_smoothing(epoch: int) -> float:
-    if epoch <= 5:
-        return 0.10
-    if epoch <= 15:
-        return 0.05
-    return 0.02
-
-
-# ---------------------------------------------------------------------------
-# Loss функции v11
-#
-# Change B: total_loss -= ANTI_LAMBDA * CE(head3, t+1)
-# h3 получает отрицательный градиент на задаче t+1 — вынужден избегать
-# признаков, полезных для предсказания следующего токена.
-# ---------------------------------------------------------------------------
-
-def train_loss_fn_v11(l1, l2, l3, pred_loss, batch, epoch):
-    w1, w2, w3 = TRAIN_HEAD_WEIGHTS
-    ls = get_label_smoothing(epoch)
-    H1, H2, H3 = HORIZONS
-    T_eff = l1.shape[1]
-
-    n1 = T_eff - H1 + 1
-    n2 = T_eff - H2 + 1
-    n3 = T_eff - H3 + 1
-
-    ce1 = chunked_ce(l1[:, :n1, :], batch[:, H1:H1 + n1], ls)
-    ce2 = chunked_ce(l2[:, :n2, :], batch[:, H2:H2 + n2], ls)
-    ce3 = chunked_ce(l3[:, :n3, :], batch[:, H3:H3 + n3], ls)
-
-    # Change B: минимальный anti-task — лёгкий намёк, не убивает h3
-    anti3 = chunked_ce(l3[:, :n1, :], batch[:, H1:H1 + n1], 0.0)
-
-    return w1 * ce1 + w2 * ce2 + w3 * ce3 + PRED_LAMBDA * pred_loss - ANTI_LAMBDA * anti3
-
-
-def val_h1_loss_fn(l1, batch):
-    return chunked_ce(l1, batch[:, 1:], label_smoothing=0.0)
-
-
-def val_ce3_loss_fn(l3, batch):
-    return chunked_ce(l3, batch[:, 1:], label_smoothing=0.0)
-
-
-def val_far_loss_fn(l3, batch):
-    H3 = HORIZONS[2]
-    T_eff = l3.shape[1]
-    n3 = T_eff - H3 + 1
-    return chunked_ce(l3[:, :n3, :], batch[:, H3:H3 + n3], label_smoothing=0.0)
-
-
-# ---------------------------------------------------------------------------
-# BPEDataset
-# ---------------------------------------------------------------------------
-
-_SHAKESPEARE = """First Citizen:
-Before we proceed any further, hear me speak.
-
-All:
-Speak, speak.
-
-First Citizen:
-You are all resolved rather to die than to famish?
-
-All:
-Resolved. resolved.
-
-First Citizen:
-First, you know Caius Marcius is chief enemy to the people.
-
-All:
-We know't, we know't.
-
-First Citizen:
-Let us kill him, and we'll have corn at our own price.
-
-VOLUMNIA:
-O, he is wounded; I thank the gods for't.
-
-MENENIUS:
-So do I too, if it be not too much: brings a' victory in his pocket?
-the wounds become him.
-
-VOLUMNIA:
-On's brows: Menenius, he comes the third time home with the oaken garland.
-
-MENENIUS:
-Has he disciplined Aufidius soundly?
-
-VOLUMNIA:
-Titus Lartius writes, they fought together, but Aufidius got off.
-
-MENENIUS:
-And 'twas time for him too, I'll warrant him that: an he had stayed
-by him, I would not have been so fidiussed for all the chests in Corioli,
-and the gold that's in them.
-
-CORIOLANUS:
-Thanks. What's the matter, you dissentious rogues,
-That, rubbing the poor itch of your opinion,
-Make yourselves scabs?
-""" * 2000
-
-
-class BPEDataset(Dataset):
-    BPE_VOCAB_SIZE = 50257
-
-    def __init__(self, tokens: torch.Tensor, seq_len: int):
-        self.data = tokens
-        self.seq_len = seq_len
-        self.vocab_size = self.BPE_VOCAB_SIZE
-
-    def __len__(self):
-        return max(0, (len(self.data) - 1) // self.seq_len)
-
-    def __getitem__(self, idx):
-        start = idx * self.seq_len
-        return self.data[start : start + self.seq_len + 1]
-
-    @classmethod
-    def from_text(cls, text: str, seq_len: int) -> "BPEDataset":
-        import tiktoken
-        enc = tiktoken.get_encoding("gpt2")
-        token_ids = enc.encode(text)
-        tokens = torch.tensor(token_ids, dtype=torch.long)
-        print(f"BPE токенов: {len(tokens):,}  vocab_size={cls.BPE_VOCAB_SIZE}", flush=True)
-        return cls(tokens, seq_len)
-
-
-def load_data():
-    try:
-        from datasets import load_dataset
-        print(f"Загружаю Wikipedia (target={TARGET_CHARS:,} символов)...", flush=True)
-        ds = load_dataset("wikimedia/wikipedia", "20231101.en", streaming=True, split="train")
-        buf = []
-        total = 0
-        for ex in ds:
-            chunk = ex["text"].strip()
-            if not chunk:
-                continue
-            buf.append(chunk)
-            total += len(chunk)
-            if total >= TARGET_CHARS:
-                break
-        text = "\n\n".join(buf)[:TARGET_CHARS]
-        print(f"Wikipedia загружена: {len(text):,} символов", flush=True)
-        return text
-    except Exception as e:
-        print(f"Wikipedia недоступна ({e}), переключаюсь на Shakespeare", flush=True)
-    return _SHAKESPEARE
-
-
-# ---------------------------------------------------------------------------
-# Parallel prefix scan
-# ---------------------------------------------------------------------------
-
-def parallel_scan_chunk(A, b, h_init):
-    orig_dtype = b.dtype
-    p = A.float().clone()
-    q = b.float().clone()
-    h = h_init.float()
-    stride = 1
-    while stride < p.shape[1]:
-        i = torch.arange(stride, p.shape[1], device=A.device)
-        j = i - stride
-        pi = p[:, i, :]
-        pj = p[:, j, :]
-        qi = q[:, i, :]
-        qj = q[:, j, :]
-        p = p.clone()
-        q = q.clone()
-        p[:, i, :] = pj * pi
-        q[:, i, :] = pi * qj + qi
-        stride *= 2
-    result = p * h.unsqueeze(1) + q
-    return result.to(orig_dtype)
-
-
-# ---------------------------------------------------------------------------
-# Уровень v11
-#
-# Change C: level3 создаётся с inp_dim=0.
-# forward_chunk проверяет inp_dim: если 0 — не конкатенирует x_chunk.
-# Все остальные уровни (level1, level2) работают как прежде.
-# ---------------------------------------------------------------------------
-
-class MambaLevelV11(nn.Module):
-    def __init__(self, hidden_dim, inp_dim, cross_dim, tau, a_min, a_max, dropout=0.0):
-        super().__init__()
-        D = hidden_dim
-        self.inp_dim = inp_dim
-        total = inp_dim + cross_dim
-
-        self.a_min   = a_min
-        self.a_range = a_max - a_min
-
-        self.net_A = nn.Sequential(
-            nn.Linear(total, D * 2),
-            nn.SiLU(),
-            nn.Dropout(dropout),
-            nn.Linear(D * 2, D),
-        )
-        self.net_B = nn.Sequential(
-            nn.Linear(total, D * 2),
-            nn.SiLU(),
-            nn.Dropout(dropout),
-            nn.Linear(D * 2, D),
-        )
-        self.norm = nn.LayerNorm(D)
-
-        target_A = 1.0 - 1.0 / tau
-        x = max(0.01, min(0.99, (target_A - a_min) / self.a_range))
-        logit_A = math.log(x / (1.0 - x))
-        with torch.no_grad():
-            self.net_A[-1].bias.fill_(logit_A)
-
-    def forward_chunk(self, x_chunk, h_cross_chunk, h_init):
-        # Change C: level3 имеет inp_dim=0 — x_chunk игнорируется
-        if self.inp_dim == 0:
-            inp = h_cross_chunk
-        else:
-            inp = torch.cat([x_chunk, h_cross_chunk], dim=-1)
-        A = self.a_min + self.a_range * torch.sigmoid(self.net_A(inp))
-        b = (1.0 - A) * torch.tanh(self.net_B(inp))
-        return self.norm(parallel_scan_chunk(A, b, h_init))
-
-
-# ---------------------------------------------------------------------------
-# Конфиг v11
-# ---------------------------------------------------------------------------
-
-@dataclass
-class V11Config:
-    vocab_size:      int
-    hidden_dim:      int   = 256
-    taus:            tuple = (4.0, 32.0, 128.0)
-    a_ranges:        tuple = field(default_factory=lambda: ((0.55, 0.88), (0.90, 0.975), (0.980, 0.999)))
-    jacobi_k:        int   = 2
-    dropout:         float = 0.1
-    horizons:        tuple = (1, 4, 32)
-    pred_lambda:     float = 0.1
-    anti_lambda:     float = 0.15
-    h3_slow_tick:    int   = 32
-    landmark_stride: int   = 32
-    landmark_heads:  int   = 4
-
-
-# ---------------------------------------------------------------------------
-# Модель v11
-#
-# v11 = v10 + Change B + Change C + Change D
-#
-# Change B (anti-task):
-#   total_loss -= ANTI_LAMBDA * CE(head3, t+1)
-#   h3 получает отрицательный градиент на задаче t+1.
-#   Вынужден активно избегать признаков, полезных для предсказания следующего токена.
-#   ANTI_LAMBDA=0.15 (было 0.03 — слишком слабо при w3=0.5).
-#
-# Change C (no-X for h3):
-#   level3 создан с inp_dim=0.
-#   level3 видит только h2_error (cross_dim=D), не имеет прямого доступа к X.
-#   Убирает "шорткат" через локальный контекст токена.
-#
-# Change D (slow-tick):
-#   h3 получает новый h2_error только раз в H3_SLOW_TICK=32 токенов.
-#   Между обновлениями h3 видит то же самое h2_error (hold-pattern).
-#   Принуждает h3 интегрировать информацию крупными блоками.
-#
-# Архитектура (Jacobi K=2):
-#   iter k:
-#     h1 = scan1(X, h2.detach())
-#     h1_error = (h1 - pred12(h2.detach())).detach()
-#     h2 = scan2(X, cat[h1_error, h3.detach()])
-#     h2_error = (h2 - pred23(h3.detach())).detach()
-#     h2_error_slow = repeat_interleave(h2_error[:,::32,:], 32)  ← Change D
-#     h3 = scan3(h2_error_slow)                                  ← Change C: нет X
-#     h3 = h3 + LN(landmark_attn(h3, ...))                       ← из v10, внутри цикла
-#
-# Grad isolation сохранён: все cross-соединения через .detach().
-# ---------------------------------------------------------------------------
-
-class HarmonicV11(nn.Module):
-    def __init__(self, cfg: V11Config):
-        super().__init__()
-        self.cfg = cfg
-        D    = cfg.hidden_dim
-        drop = cfg.dropout
-
-        self.embed   = nn.Embedding(cfg.vocab_size, D)
-        nn.init.normal_(self.embed.weight, std=1.0 / math.sqrt(D))
-
-        self.drop_in  = nn.Dropout(drop)
-        self.drop_out = nn.Dropout(drop)
-
-        ar = cfg.a_ranges
-        self.level1 = MambaLevelV11(D, D, D,     tau=cfg.taus[0],
-                                    a_min=ar[0][0], a_max=ar[0][1], dropout=drop)
-        self.level2 = MambaLevelV11(D, D, D * 2, tau=cfg.taus[1],
-                                    a_min=ar[1][0], a_max=ar[1][1], dropout=drop)
-        # Change C: inp_dim=0 — level3 не видит X напрямую
-        self.level3 = MambaLevelV11(D, inp_dim=0, cross_dim=D, tau=cfg.taus[2],
-                                    a_min=ar[2][0], a_max=ar[2][1], dropout=drop)
-
-        self.pred12 = nn.Linear(D, D)
-        self.pred23 = nn.Linear(D, D)
-
-        # h3 landmark attention — из v10, применяется ВНУТРИ цикла Якоби
-        self.h3_landmark_attn = nn.MultiheadAttention(
-            D, num_heads=cfg.landmark_heads, batch_first=True, dropout=drop
-        )
-        self.h3_landmark_norm = nn.LayerNorm(D)
-
-        self.ln1 = nn.LayerNorm(D)
-        self.ln2 = nn.LayerNorm(D)
-        self.ln3 = nn.LayerNorm(D)
-
-        self.head1 = nn.Linear(D, cfg.vocab_size)
-        self.head2 = nn.Linear(D, cfg.vocab_size)
-        self.head3 = nn.Linear(D, cfg.vocab_size)
-
-    def _scan_level(self, level, X, cross, chunk_size):
-        B, T, D = X.shape
-        parts = []
-        h = torch.zeros(B, D, device=X.device, dtype=X.dtype)
-        for i in range(0, T, chunk_size):
-            j = min(i + chunk_size, T)
-            h_traj = level.forward_chunk(X[:, i:j], cross[:, i:j], h)
-            parts.append(h_traj)
-            h = h_traj[:, -1, :]
-        return torch.cat(parts, dim=1)
-
-    def _apply_landmark_attn(self, h3_all):
-        B, T, D = h3_all.shape
-        stride = self.cfg.landmark_stride
-        device = h3_all.device
-
-        h3_landmarks = h3_all[:, ::stride, :]
-        N = h3_landmarks.shape[1]
-
-        landmark_positions = torch.arange(N, device=device) * stride
-        query_positions    = torch.arange(T, device=device)
-        attn_mask = torch.zeros(T, N, device=device, dtype=h3_all.dtype)
-        blocked = landmark_positions.unsqueeze(0) > query_positions.unsqueeze(1)
-        attn_mask.masked_fill_(blocked, float("-inf"))
-
-        attn_out, _ = self.h3_landmark_attn(
-            query=h3_all,
-            key=h3_landmarks,
-            value=h3_landmarks,
-            attn_mask=attn_mask,
-            need_weights=False,
-        )
-        return h3_all + self.h3_landmark_norm(attn_out)
-
-    def forward(self, tokens):
-        B, T = tokens.shape
-        device = tokens.device
-        D = self.cfg.hidden_dim
-        K = self.cfg.jacobi_k
-
-        X = self.drop_in(self.embed(tokens[:, :-1]))
-        T_eff = T - 1
-
-        c1 = int(self.cfg.taus[0])
-        c2 = int(self.cfg.taus[1])
-        c3 = int(self.cfg.taus[2])
-
-        h1_all = torch.zeros(B, T_eff, D, device=device, dtype=X.dtype)
-        h2_all = torch.zeros(B, T_eff, D, device=device, dtype=X.dtype)
-        h3_all = torch.zeros(B, T_eff, D, device=device, dtype=X.dtype)
-
-        for _ in range(K):
-            h1_all = self._scan_level(self.level1, X, h2_all.detach(), c1)
-
-            h1_pred  = self.pred12(h2_all.detach())
-            h1_error = (h1_all - h1_pred).detach()
-            h2_all = self._scan_level(self.level2, X,
-                                      torch.cat([h1_error, h3_all.detach()], dim=-1), c2)
-
-            h2_pred  = self.pred23(h3_all.detach())
-            h2_error = (h2_all - h2_pred).detach()
-            # Change C+D: true state-hold — скан только по tick-позициям,
-            # state держится константным между тиками (вместо soft input-hold)
-            _T = h2_error.shape[1]
-            h3_ticks = self._scan_level(
-                self.level3,
-                X[:, ::H3_SLOW_TICK, :],
-                h2_error[:, ::H3_SLOW_TICK, :],
-                c3,
-            )
-            h3_all = h3_ticks.repeat_interleave(H3_SLOW_TICK, dim=1)[:, :_T, :]
-
-            # landmark attention внутри цикла (из v10)
-            h3_all = self._apply_landmark_attn(h3_all)
-
-        pred_loss = (
-            F.mse_loss(self.pred12(h2_all.detach()), h1_all.detach()) +
-            F.mse_loss(self.pred23(h3_all.detach()), h2_all.detach())
-        )
-
-        l1 = self.head1(self.drop_out(self.ln1(h1_all)))
-        l2 = self.head2(self.drop_out(self.ln2(h2_all)))
-        l3 = self.head3(self.drop_out(self.ln3(h3_all)))
-        return l1, l2, l3, pred_loss
-
-
-# ---------------------------------------------------------------------------
-# Утилиты
-# ---------------------------------------------------------------------------
-
-def count_params(model):
-    return sum(p.numel() for p in model.parameters())
-
-
-def measure_A_means(raw_model, device):
-    D = raw_model.cfg.hidden_dim
-    param_dtype = next(raw_model.parameters()).dtype
-    x  = torch.zeros(1, 4, D, device=device, dtype=param_dtype)
-    z1 = torch.zeros(1, 4, D, device=device, dtype=param_dtype)
-    z2 = torch.zeros(1, 4, D * 2, device=device, dtype=param_dtype)
-
-    def bounded_A(level, inp):
-        return (level.a_min + level.a_range * torch.sigmoid(level.net_A(inp))).mean().item()
-
-    with torch.no_grad():
-        a1 = bounded_A(raw_model.level1, torch.cat([x, z1], dim=-1))
-        a2 = bounded_A(raw_model.level2, torch.cat([x, z2], dim=-1))
-        # Change C: level3.inp_dim=0, принимает только cross (D-мерный)
-        a3 = bounded_A(raw_model.level3, z1)
-    return a1, a2, a3
-
-
-# ---------------------------------------------------------------------------
-# Основной цикл обучения
-# ---------------------------------------------------------------------------
-
-def run_training(model, train_loader, val_loader, device, amp_dtype):
-    n_gpus = torch.cuda.device_count() if device.type == "cuda" else 0
-    if n_gpus > 1:
-        print(f"DataParallel: {n_gpus} GPU", flush=True)
-        model = nn.DataParallel(model)
-    raw_model = model.module if isinstance(model, nn.DataParallel) else model
-    _ckpt_val_far = float("inf")
-
-    _warm_ck = None
-    if WARM_START:
-        from huggingface_hub import hf_hub_download
-        rid = _hf_repo_id()
-        print(f"Warm-start: скачиваем {WARM_START_HF} из {rid} ...", flush=True)
-        local_ckpt = hf_hub_download(repo_id=rid, filename=WARM_START_HF, token=HF_TOKEN)
-        import sys as _sys
-        _sys.modules.setdefault("train_gpu_v11", _sys.modules["__main__"])
-        _warm_ck = torch.load(local_ckpt, map_location=device, weights_only=False)
-        raw_model.load_state_dict(_warm_ck["model_state"])
-        _ckpt_val_far = _warm_ck.get("val_far", float("inf"))
-        print(f"  Чекпоинт загружен (epoch={_warm_ck.get('epoch','?')}, val_far={_ckpt_val_far:.4f})",
-              flush=True)
-        has_opt = "optimizer_state" in _warm_ck
-        print(f"  optimizer_state: {'есть' if has_opt else 'нет (только model_state)'}",
-              flush=True)
-
-    optimizer = torch.optim.AdamW(
-        [p for p in model.parameters() if p.requires_grad], lr=LR, weight_decay=0.01
-    )
-    use_amp = (device.type == "cuda" and amp_dtype is not None)
-    scaler = torch.amp.GradScaler("cuda", enabled=(amp_dtype == torch.float16))
-
-    def lr_lambda(epoch_idx):
-        if epoch_idx < LR_WARMUP_EPOCHS:
-            return float(epoch_idx + 1) / LR_WARMUP_EPOCHS
-        progress = (epoch_idx - LR_WARMUP_EPOCHS) / max(1, EPOCHS - LR_WARMUP_EPOCHS)
-        return 0.1 + 0.9 * 0.5 * (1.0 + math.cos(math.pi * progress))
-
-    scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
-
-    best_val   = _ckpt_val_far if WARM_START else float("inf")
-    no_improve = 0
-    start_epoch = 1
-
-    if WARM_START and _warm_ck is not None and "optimizer_state" in _warm_ck:
-        optimizer.load_state_dict(_warm_ck["optimizer_state"])
-        if "scheduler_state" in _warm_ck:
-            scheduler.load_state_dict(_warm_ck["scheduler_state"])
-        start_epoch  = _warm_ck.get("epoch", 0) + 1
-        no_improve   = _warm_ck.get("no_improve", 0)
-        best_val     = _warm_ck.get("best_val", _ckpt_val_far)
-        print(f"  Продолжаем с эпохи {start_epoch}  best_val={best_val:.4f}  no_improve={no_improve}",
-              flush=True)
-
-    if not WARM_START:
-        last_ckpt = os.path.join(CKPT_DIR, "last_checkpoint_v11.pt")
-        if os.path.exists(last_ckpt):
-            ck = torch.load(last_ckpt, map_location=device, weights_only=False)
-            raw_model.load_state_dict(ck["model_state"])
-            optimizer.load_state_dict(ck["optimizer_state"])
-            if "scheduler_state" in ck:
-                scheduler.load_state_dict(ck["scheduler_state"])
-            start_epoch = ck["epoch"] + 1
-            best_val    = ck["best_val"]
-            no_improve  = ck["no_improve"]
-            print(f"  Resume: epoch {start_epoch}  best_val={best_val:.4f}  no_improve={no_improve}",
-                  flush=True)
-
-    amp_name = str(amp_dtype).replace("torch.", "") if amp_dtype else "fp32"
-    V = raw_model.cfg.vocab_size
-    H1, H2, H3 = raw_model.cfg.horizons
-    print(f"\nпараметры: {count_params(model):,}  jacobi_k={JACOBI_K}"
-          f"  hidden={raw_model.cfg.hidden_dim}  vocab={V}  AMP={amp_name}  GPUs={max(n_gpus,1)}",
-          flush=True)
-    print(f"head_weights={TRAIN_HEAD_WEIGHTS}  horizons=({H1},{H2},{H3})"
-          f"  dropout={DROPOUT}  pred_lambda={PRED_LAMBDA}", flush=True)
-    print(f"anti_lambda={ANTI_LAMBDA}  (Change B: h3 штрафуется за t+1)", flush=True)
-    print(f"level3.inp_dim=0  (Change C: нет прямого доступа к X)", flush=True)
-    print(f"h3_slow_tick={H3_SLOW_TICK}  (Change D: h3 обновляется раз в {H3_SLOW_TICK} токенов)", flush=True)
-    print(f"A_ranges={A_RANGES}", flush=True)
-    print(f"landmark_stride={LANDMARK_STRIDE}  landmark_heads={LANDMARK_HEADS}", flush=True)
-    print(f"seq_len={SEQ_LEN}  batch={BATCH_SIZE}  tokens/batch={SEQ_LEN*BATCH_SIZE}",
-          flush=True)
-
-    header = (f"{'epoch':>5}  {'tr_loss':>8}  {'val_h1':>7}  {'val_ce3':>8}"
-              f"  {'val_far':>8}  {'pred_l':>7}  {'A1':>6}  {'A2':>6}  {'A3':>6}"
-              f"  {'lr':>8}  {'t/ep':>7}")
-    print(f"\n{header}", flush=True)
-    print("-" * len(header), flush=True)
-
-    A1_mean = A2_mean = A3_mean = float("nan")
-
-    for epoch in range(start_epoch, EPOCHS + 1):
-        model.train()
-        t0 = time.perf_counter()
-        train_loss_acc = 0.0
-        pred_loss_acc  = 0.0
-        n_batches   = 0
-        nan_batches = 0
-
-        for batch in train_loader:
-            batch = batch.to(device, non_blocking=True)
-            optimizer.zero_grad()
-            with torch.amp.autocast("cuda", dtype=amp_dtype, enabled=use_amp):
-                l1, l2, l3, pred_loss = model(batch)
-            loss = train_loss_fn_v11(l1, l2, l3, pred_loss, batch, epoch)
-            l = loss.item()
-            if math.isnan(l) or math.isinf(l):
-                nan_batches += 1
-                optimizer.zero_grad()
-                continue
-            scaler.scale(loss).backward()
-            scaler.unscale_(optimizer)
-            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
-            scaler.step(optimizer)
-            scaler.update()
-            train_loss_acc += l
-            pred_loss_acc  += pred_loss.item()
-            n_batches += 1
-            if n_batches % 200 == 0:
-                avg = train_loss_acc / n_batches
-                elapsed_so_far = time.perf_counter() - t0
-                print(f"  epoch {epoch}  batch {n_batches}  loss {avg:.4f}  {elapsed_so_far:.1f}s",
-                      flush=True)
-
-        model.eval()
-        val_h1_acc  = 0.0
-        val_ce3_acc = 0.0
-        val_far_acc = 0.0
-        with torch.no_grad():
-            for batch in val_loader:
-                batch = batch.to(device, non_blocking=True)
-                with torch.amp.autocast("cuda", dtype=amp_dtype, enabled=use_amp):
-                    l1, l2, l3, _ = model(batch)
-                val_h1_acc  += val_h1_loss_fn(l1, batch).item()
-                val_ce3_acc += val_ce3_loss_fn(l3, batch).item()
-                val_far_acc += val_far_loss_fn(l3, batch).item()
-
-        tr_loss  = train_loss_acc / n_batches if n_batches > 0 else float("nan")
-        pred_avg = pred_loss_acc  / n_batches if n_batches > 0 else float("nan")
-        val_h1   = val_h1_acc  / len(val_loader)
-        val_ce3  = val_ce3_acc / len(val_loader)
-        val_far  = val_far_acc / len(val_loader)
-        elapsed  = time.perf_counter() - t0
-        cur_lr   = optimizer.param_groups[0]["lr"]
-
-        A1_mean, A2_mean, A3_mean = measure_A_means(raw_model, device)
-
-        far_marker = " [FAR<CE3]" if val_far < val_ce3 else ""
-        nan_str    = f"  [NaN:{nan_batches}]" if nan_batches > 0 else ""
-        print(f"  {epoch:>3}  {tr_loss:.4f}    {val_h1:.4f}   {val_ce3:.4f}"
-              f"  {val_far:.4f}  {pred_avg:.4f}  {A1_mean:.3f}  {A2_mean:.3f}  {A3_mean:.3f}"
-              f"  {cur_lr:.2e}  {elapsed:.0f}s{far_marker}{nan_str}", flush=True)
-
-        scheduler.step()
-
-        if elapsed > MAX_EPOCH_SECONDS:
-            print(f"  ABORT: эпоха {epoch} заняла {elapsed:.0f}s > {MAX_EPOCH_SECONDS}s",
-                  flush=True)
-            break
-
-        epoch_model_path = os.path.join(CKPT_DIR, f"v11_epoch_{epoch:02d}_model.pt")
-        torch.save(
-            {"epoch": epoch, "val_h1": val_h1, "val_ce3": val_ce3, "val_far": val_far,
-             "pred_loss": pred_avg,
-             "model_state": raw_model.state_dict(),
-             "cfg": raw_model.cfg},
-            epoch_model_path
-        )
-        upload_to_hf_epoch(epoch_model_path, epoch, val_far)
-
-        if val_far < best_val:
-            best_val   = val_far
-            no_improve = 0
-            best_path  = os.path.join(CKPT_DIR, "best_checkpoint_v11.pt")
-            torch.save(
-                {"epoch": epoch, "val_h1": val_h1, "val_ce3": val_ce3, "val_far": val_far,
-                 "pred_loss": pred_avg,
-                 "model_state": raw_model.state_dict(),
-                 "cfg": raw_model.cfg},
-                best_path
-            )
-            upload_to_hf(best_path, "best_checkpoint_v11.pt")
-        else:
-            no_improve += 1
-            if no_improve >= EARLY_STOP:
-                print(f"  Ранняя остановка на эпохе {epoch} (нет улучшения val_far {EARLY_STOP} эпох)",
-                      flush=True)
-                break
-
-        last_path = os.path.join(CKPT_DIR, "last_checkpoint_v11.pt")
-        torch.save(
-            {"epoch": epoch, "val_h1": val_h1, "val_ce3": val_ce3, "val_far": val_far,
-             "pred_loss": pred_avg,
-             "best_val": best_val, "no_improve": no_improve,
-             "model_state": raw_model.state_dict(),
-             "optimizer_state": optimizer.state_dict(),
-             "scheduler_state": scheduler.state_dict(),
-             "cfg": raw_model.cfg},
-            last_path
-        )
-        upload_to_hf(last_path, "v11_last_checkpoint.pt")
-        if os.path.exists(LOG_FILE):
-            upload_to_hf(LOG_FILE, "v11_training_log.txt")
-
-    return best_val, A1_mean, A2_mean, A3_mean
-
-
-def main():
-    sys.stdout = _Tee(LOG_FILE)
-    os.makedirs(CKPT_DIR, exist_ok=True)
-    torch.manual_seed(SEED)
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    amp_dtype = get_amp_dtype(device)
-    print(f"device: {device}", flush=True)
-    if device.type == "cuda":
-        p = torch.cuda.get_device_properties(0)
-        amp_name = str(amp_dtype).replace("torch.", "") if amp_dtype else "fp32"
-        print(f"GPU: {p.name}  VRAM: {p.total_memory // 1024 ** 2} MB  AMP: {amp_name}",
-              flush=True)
-
-    text    = load_data()
-    full_ds = BPEDataset.from_text(text, seq_len=SEQ_LEN)
-    V       = full_ds.vocab_size
-    n_total = min(len(full_ds), MAX_SEQS)
-    indices = torch.randperm(len(full_ds),
-                             generator=torch.Generator().manual_seed(SEED))[:n_total]
-    dataset = Subset(full_ds, indices.tolist())
-    n_val   = max(1, n_total // 10)
-    n_train = n_total - n_val
-    train_ds, val_ds = random_split(
-        dataset, [n_train, n_val],
-        generator=torch.Generator().manual_seed(SEED)
-    )
-    pin = (device.type == "cuda")
-    nw  = 4 if device.type == "cuda" else 0
-    train_loader = DataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True,
-                              pin_memory=pin, num_workers=nw,
-                              persistent_workers=(nw > 0))
-    val_loader   = DataLoader(val_ds, batch_size=BATCH_SIZE,
-                              pin_memory=pin, num_workers=nw,
-                              persistent_workers=(nw > 0))
-
-    print(f"используем={n_total:,} последовательностей  seq_len={SEQ_LEN}  vocab={V}",
-          flush=True)
-
-    cfg = V11Config(
-        vocab_size=V,
-        hidden_dim=HIDDEN_DIM,
-        taus=TAUS,
-        a_ranges=A_RANGES,
-        jacobi_k=JACOBI_K,
-        dropout=DROPOUT,
-        horizons=HORIZONS,
-        pred_lambda=PRED_LAMBDA,
-        anti_lambda=ANTI_LAMBDA,
-        landmark_stride=LANDMARK_STRIDE,
-        landmark_heads=LANDMARK_HEADS,
-    )
-    model = HarmonicV11(cfg).to(device)
-
-    print("\n" + "=" * 64, flush=True)
-    print("ОБУЧЕНИЕ — Harmonic v11", flush=True)
-    print("  bounded-A + Jacobi K=2 + predictive coding + landmark attn", flush=True)
-    print("  Change B: total_loss -= ANTI_LAMBDA * CE(head3, t+1)", flush=True)
-    print("    h3 получает отрицательный градиент на предсказании t+1", flush=True)
-    print("  Change C: level3.inp_dim=0, level3 не видит X нап��ямую", flush=True)
-    print("    level3 видит только h2_error (ошибку предсказания h2)", flush=True)
-    print("  цель: val_far < val_ce3 (h3 специализируется на t+32)", flush=True)
-    print(f"  anti_lambda={ANTI_LAMBDA}  pred_lambda={PRED_LAMBDA}", flush=True)
-    print(f"  epochs={EPOCHS}  early_stop={EARLY_STOP}  lr={LR}", flush=True)
-    print(f"  train={n_train}  val={n_val}  seq_len={SEQ_LEN}", flush=True)
-    print("=" * 64, flush=True)
-
-    best_val, A1, A2, A3 = run_training(model, train_loader, val_loader, device, amp_dtype)
-
-    print("\n" + "=" * 64, flush=True)
-    print("ИТОГ — Harmonic v11", flush=True)
-    print("=" * 64, flush=True)
-    print(f"  val_far лучший: {best_val:.4f}", flush=True)
-    print(f"  vocab_size:     {V}", flush=True)
-    hierarchy_ok = (A1 < A2 < A3)
-    print(f"\n  Иерархия A1={A1:.3f}  A2={A2:.3f}  A3={A3:.3f}", flush=True)
-    if hierarchy_ok:
-        print("  [OK] A1 < A2 < A3 — иерархия подтверждена", flush=True)
-    else:
-        print("  [WARN] Иерархия A нарушена", flush=True)
-
-
-if __name__ == "__main__":
-    main()

v11_e01_5.7054.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:42b98782046213ea1b468b13f6f84feea728013ce9cf05502b78eecccf670beb
-size 106321229

v11_e01_7.6276.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5052c908cccf1f3d0ec8d6f57aaf046bd9f6acaffa9a14faa377eeea99ddfcb4
-size 106321229

v11_e01_7.6320.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4d7c9b77fe6330406840f3e1dfbdeb4c451e937f7ba9526b5f9b3f4744130ce5
-size 106321229

v11_e01_7.6413.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:60c06e6a05895e8c32bf313d8bd811adf57a40fb2bf959627e4b403bf99362fa
-size 106321229

v11_e01_7.6450.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b0f534fdb0ba77a4cdc073707b40698f3657577d45a7949f8f0abc4a1d495f70
-size 106321229

v11_e01_7.6961.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f66b05e966ebde5fdd703c81fb1d4795c344b59fed68a58494cd8a862f7c1021
-size 106321229

v11_e02_4.8399.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8671309d39b985cc1c057cec179e49d4b0ec1607c463264168715e6fc9840a02
-size 106321229

v11_e02_7.6341.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:86bead10890cef72e60bce1a0458cce86852b5fb74b98e1e7dfef2a6d727ffc0
-size 106321229

v11_e02_7.6347.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:940e7963218ba22a97f0729acf920278ae6984b128fc22a6da36aa0e14913b79
-size 106321229

v11_e02_7.6381.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fe686787306cecb30d9999d5dd8d6c1329e5c48adf1d65536f34b0cef8760d17
-size 106321229

v11_e02_7.6439.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:db89d3f2eaca4af4850ead22c230cb3211e5f4200963077d4242e879dedaaecc
-size 106321229

v11_e02_7.6467.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2d45c7221751c7cc522498cce9284bc9983133ade6638a2b3ac4a79a51602ad4
-size 106321229

v11_e03_4.6867.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:35b3bc35a989f4b23591571138a63346d57b8ae23837865b9b54fc327bc1b43a
-size 106321229

v11_e03_7.6298.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:83c60351ccd23096d9924bed26155fa02def09eaec7767359ac45ecdfea4a5ae
-size 106321229

v11_e03_7.6331.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:67890774e19631f12aa4c7a8899e401ac35035338d054cb1893c200b93e306e2
-size 106321229

v11_e03_7.6398.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0626a1c5f3b0642eb275f30e0ebbc5e16dc75b0483a1a19e126bd3b1f1c6da0f
-size 106321229

v11_e03_7.6448.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0efc7f20de965fc4cfdfb1d833c8d685e63bed4348784bcf455cb6107e6e36f8
-size 106321229

v11_e03_7.6460.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:615ed2e02927f1d7897feea4559acb46cb915a0570af88430f4744db57ffe169
-size 106321229

v11_e03_7.6986.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:dfa08e14a7b6cde8bfe06ec20885fc56ad7913cb0d4321f5569dc74d0f2f985f
-size 106321229

v11_e04_4.6482.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9c592ab53caf2ba6caadb495e8f25bf82576572f444cadb73c2cd327f29da916
-size 106321229

v11_e04_7.6298.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:25aa3d34dfb68ff2c78d564c9ddeb3d0c9f32535035118430e2d2517b976348d
-size 106321229

v11_e04_7.6346.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a466044f4dd56fa0031415c597f1e720bd4363a0408ffead66bb686f06239e9d
-size 106321229

v11_e04_7.6441.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8da39dd7d3beba258f7a4951131c80c6391ee2ba2c5a481cbeffd0cf2db61dc3
-size 106321229

v11_e04_7.6480.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ca4849eb1baee43fa406e7a019ff5973ff7dbfcde674e1a21f0a9cb9c7306d7a
-size 106321229

v11_e04_7.6508.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:faa482e3b93deb1a23c152026dbccec0a4af6a8411b22c3edb778241a53b9989
-size 106321229

v11_e05_4.6245.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:975b84b79d5d9dc816f6c2d1fe8698c40332963324a321fb2aafe765e0c5b964
-size 106321229

v11_e05_7.6313.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6909d0f1fc92025623fac7d1a040b4cd196ce8731d44749b86da102e5e565462
-size 106321229

v11_e05_7.6325.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e508fb42b5d80486a265d396f47fbda8afa289ba0c81adb66bdfd0f1880724c0
-size 106321229

v11_e05_7.6487.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ab34f5eb73be8efc372faa5a1f7f123f3aa59191abf2176fc164d58163d8bc3a
-size 106321229

v11_e05_7.6530.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e339bcd35b1038023a11b8bc4c5ad7e00b689fcfb64e2c73c658af6ee5409b6e
-size 106321229

v11_e05_7.6534.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0b5cf6ec7a3cb68b074e387e4c05f9b9e0d18736857e9f14888b24059de97ca3
-size 106321229

v11_e06_4.4890.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5d41b500d0487aac9e8d43efeabba2e0d540498e13d5200ef946065cd449d216
-size 106321229

v11_e06_7.5951.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:be0fd174894fb58cfc54c15b1bb6ed0018fbdeffd2ce6161ae385953b9dec0c8
-size 106321229

v11_e06_7.6048.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0aae88ac63998525fc91d65e091c000da8d33483de8a277cd3405c0edb96882c
-size 106321229

v11_e06_7.6115.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7b1863380d2596b87331ac8c388a50d11a0e2f7ddfb1ed253653eb5d3bfd4b9e
-size 106321229

v11_e06_7.6158.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bb6e9a97bc188f9714d7d0abdf85bd541ecc429ae185c47043e098e4a9ccbdd7
-size 106321229

v11_e07_4.4619.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:025ac9cd332bc89a7d446f2acfab16866e5e4abe4e86aae9681737bdd0e024d3
-size 106321229

v11_e07_7.5943.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fa306ff2bda5f0dbf4ffd415edeca73d37711f198492db87ae88bcb5055eebb6
-size 106321229

v11_e07_7.6080.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d30f5b0b2cdfa2cf2fd23d6d8142d6635b1a6562b10975078631cc141a8a1f66
-size 106321229

v11_e07_7.6106.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4d0ed7a57e98446c691ea6919dea517790009f502e2561ecda7c2436d4b30200
-size 106321229

v11_e07_7.6168.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3aef8ea4719d24b6b36a39b683b21269737077e5c290f5eea142368c029e279a
-size 106321229

v11_e08_4.4406.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:34d43df468d7909e5c2459b5afffde06a64ad416d35fa9ea933b134d4966c72d
-size 106321229

v11_e08_7.5941.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:de92a079e631d9b63c661fd288bf1793ab0954076a0be0fc4a1f6638c19d7636
-size 106321229

v11_e08_7.6061.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ef6c16d99d918fbcdd58a85319bf624be8e654b2c430c2c1440cef1fc26f6276
-size 106321229

v11_e08_7.6097.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:33131856ebeb0c354ef9fb2ad5e0360a810eed983edc7cdb723701606fd9d5c0
-size 106321229

v11_e08_7.6160.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b2fc8fd1126b864edbb5e40784b2ed9db41ea43a12d77c4cd9a4f39f5af01651
-size 106321229

v11_e09_4.4265.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3e18c4ad61658c69a673cbc5696c7f86bb1ff73f146893c4b1e0a1dfd2ce4cde
-size 106321229

v11_e09_7.5946.pt

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c32c1038c14cacb1c74d642660d048d7e5cb6720baeb9d78bfad3ed79a1505e9
-size 106321229