Vi-LAB
/

KenT-300M-Base

@@ -22,41 +22,41 @@ tags:
 # KenT
-KenT là một mô hình ngôn ngữ hồi quy thuộc họ SSM. Thay vì chồng thêm tầng, KenT dồn dung lượng vào **chiều sâu của phép biến đổi bên trong một cell duy nhất**, và giữ phần ghi nhớ theo thời gian ở dạng đơn giản nhất có thể.
-> Repo này chứa mã `trust_remote_code`; trọng số được lưu ở **FP16**.
-## Triết lý kiến trúc
-- **Một cell, không chồng tầng.** KenT là một cell hồi quy duy nhất, không nhân bản cả mô hình thành nhiều tầng.
-  Chiều sâu không đến từ số tầng mà đến từ chuỗi khối biến đổi nối tiếp bên trong cell.
-- **Đầu tư vào lõi biến đổi.** Dung lượng được dồn vào phần "hidden", nơi đặc trưng thực sự được biến đổi,
-  thay vì vào bảng từ vựng hay số lần lặp lại kiến trúc. Độ rộng và độ sâu của lõi này được tăng cùng nhau để
-  giữ cân bằng, không đẩy riêng một chiều.
-- **Hai luồng, hai vai trò.** Một luồng biểu diễn mang thông tin của token hiện tại; một luồng bộ nhớ gom
-  lịch sử. Hai luồng chỉ gặp nhau qua các phép chiếu học được, không trộn trực tiếp.
-- **Tần số là nền cố định, học tập ở nơi cần.** Đặc trưng được xử lý trong không gian hệ số cosine bằng một
-  toán tử **cố định, không học**, xen kẽ với các khối phi tuyến. Phần cố định mang cấu trúc sẵn có; phần học
-  chỉ tập trung vào việc biến đổi đặc trưng.
-- **Ghi nhớ bằng phép tích lũy đơn giản.** Lịch sử được tổng hợp bằng trung bình tích lũy: không có tham số
-  riêng, không có cơ chế quên ẩn. Trạng thái giải mã có kích thước **không đổi** theo độ dài ngữ cảnh.
-- **Hai trục chiều sâu tách biệt.** Độ sâu biến đổi đặc trưng trong một bước và độ dài lịch sử được nhớ là hai
-  trục độc lập: tăng cái này không làm đổi cái kia.
-- **Song song hóa được theo chunk.** Vì bộ nhớ là phép tích lũy kết hợp, một tài liệu dài có thể được chia thành
-  nhiều chunk, xử lý đồng thời rồi ghép lại, cho cùng kết quả như xử lý tuần tự.
-Các điểm trên là **giả thuyết thiết kế** cần được kiểm chứng bằng thực nghiệm, không phải bảo đảm về hiệu năng.
-Chi tiết cấu hình và công thức đầy đủ không được mô tả ở đây.
-## Cấu trúc repo
-| File | Vai trò |
 |---|---|
-| `model.py` | Cài đặt mô hình (`KentConfig`, `KentModel`, `KentForCausalLM`, `KentCache`) |
-| `config.json` | Cấu hình chuẩn của mô hình |
-| `generate_config.json` | Cấu hình sinh mặc định |
-| `infer.py` | Nạp prefix theo chunk song song và vòng lặp sinh |
-| `model.safetensors` | Trọng số FP16 |
 ## Quickstart
@@ -64,20 +64,20 @@ Chi tiết cấu hình và công thức đầy đủ không được mô tả
 pip install torch transformers
 ```
-### Sinh văn bản chuẩn (`generate`)
 ```python
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
-repo = "Vi-LAB/KenT-100M-Base"  # thay bằng repo id hoặc thư mục cục bộ
 tok = AutoTokenizer.from_pretrained(repo)
 model = AutoModelForCausalLM.from_pretrained(
     repo, trust_remote_code=True, torch_dtype=torch.float16
 ).to("cuda").eval()
 gen_cfg = GenerationConfig.from_pretrained(repo, config_file_name="generate_config.json")
-inputs = tok("Xin chào, hôm nay", return_tensors="pt").to("cuda")
 out = model.generate(
     input_ids=inputs.input_ids,
     attention_mask=inputs.attention_mask,
@@ -86,42 +86,42 @@ out = model.generate(
 print(tok.decode(out[0], skip_special_tokens=True))
 ```
-Trạng thái hồi quy được trả về dưới dạng `cache_params` (tương tự các mô hình SSM khác trong `transformers`):
 ```python
 out = model(**inputs, use_cache=True)
-cache = out.cache_params                       # trạng thái hồi quy
 out = model(input_ids=next_token, cache_params=cache, use_cache=True)
 ```
-### Tài liệu dài: nạp prefix theo chunk song song
-Khi xử lý theo batch, mỗi hàng của batch là **một chunk của cùng một tài liệu**; các chunk được xử lý
-song song bằng cờ `chunked=True`, trạng thái cuối được trả về trong `cache_params`.
 ```python
 from infer import prefill, stream
 ids = tok(open("doc.txt", encoding="utf-8").read(), return_tensors="pt").input_ids[0]
-# 1) chỉ nạp prefix, lấy logits token cuối và trạng thái
 logits, cache = prefill(model, ids, chunk_size=1024, max_parallel_chunks=16)
-# 2) nạp prefix rồi sinh (streaming)
 for token_id in stream(model, ids, gen_cfg):
     print(tok.decode([token_id]), end="", flush=True)
 ```
-Dòng lệnh:
 ```bash
 python infer.py --model Vi-LAB/KenT-100M-Base --prompt-file doc.txt --chunk-size 1024
 ```
-`cache.clone()` cho phép dùng lại cùng một prefix để sinh nhiều nhánh khác nhau mà không phải nạp lại.
-## Lưu ý
-- Bộ nhớ là trung bình tích lũy đều theo mọi timestep đã thấy; mô hình không tự học cách quên hay chọn lọc.
-- Tokenizer và trọng số cần khớp `vocab_size` trong `config.json`.
-- Đây là mô hình nghiên cứu; hãy đánh giá trước khi dùng cho tác vụ thực tế.

 # KenT
+KenT is a recurrent language model from the SSM family. Rather than stacking more layers, KenT concentrates its capacity in the **depth of the transformation inside a single cell**, and keeps temporal memory as simple as possible.
+> This repo contains `trust_remote_code` code; weights are stored in **FP16**.
+## Architectural Philosophy
+- **One cell, no layer stacking.** KenT is a single recurrent cell; the model is not replicated into multiple layers.
+  Depth comes not from the number of layers but from a chain of transformation blocks applied in sequence inside the cell.
+- **Invest in the transformation core.** Capacity is concentrated in the "hidden" part, where features are actually transformed,
+  rather than in the vocabulary table or in repeating the architecture. The width and depth of this core are scaled together to
+  stay balanced, rather than pushing a single dimension.
+- **Two streams, two roles.** One stream is a representation carrying information about the current token; the other is a memory
+  stream that aggregates history. The two streams meet only through learned projections and are never mixed directly.
+- **Frequency as a fixed foundation, learning where it's needed.** Features are processed in the cosine-coefficient space using a
+  **fixed, non-learned** operator, interleaved with nonlinear blocks. The fixed part carries built-in structure; the learned part
+  focuses solely on transforming features.
+- **Memory via simple accumulation.** History is summarized with a cumulative average: no dedicated parameters and no implicit
+  forgetting mechanism. The decoding state has **constant** size regardless of context length.
+- **Two separate depth axes.** The depth of feature transformation within a single step and the length of history remembered are
+  two independent axes: increasing one does not change the other.
+- **Chunk-parallelizable.** Because memory is an associative accumulation, a long document can be split into multiple chunks,
+  processed concurrently, and then merged, yielding the same result as sequential processing.
+The points above are **design hypotheses** that need to be verified experimentally, not performance guarantees.
+Detailed configuration and full formulas are not described here.
+## Repo Structure
+| File | Role |
 |---|---|
+| `model.py` | Model implementation (`KentConfig`, `KentModel`, `KentForCausalLM`, `KentCache`) |
+| `config.json` | Standard model configuration |
+| `generate_config.json` | Default generation configuration |
+| `infer.py` | Parallel chunked prefix loading and the generation loop |
+| `model.safetensors` | FP16 weights |
 ## Quickstart
 pip install torch transformers
 ```
+### Standard text generation (`generate`)
 ```python
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
+repo = "Vi-LAB/KenT-100M-Base"  # replace with a repo id or a local directory
 tok = AutoTokenizer.from_pretrained(repo)
 model = AutoModelForCausalLM.from_pretrained(
     repo, trust_remote_code=True, torch_dtype=torch.float16
 ).to("cuda").eval()
 gen_cfg = GenerationConfig.from_pretrained(repo, config_file_name="generate_config.json")
+inputs = tok("Hello, today", return_tensors="pt").to("cuda")
 out = model.generate(
     input_ids=inputs.input_ids,
     attention_mask=inputs.attention_mask,
 print(tok.decode(out[0], skip_special_tokens=True))
 ```
+The recurrent state is returned as `cache_params` (similar to other SSM models in `transformers`):
 ```python
 out = model(**inputs, use_cache=True)
+cache = out.cache_params                       # recurrent state
 out = model(input_ids=next_token, cache_params=cache, use_cache=True)
 ```
+### Long documents: parallel chunked prefix loading
+When processing in batches, each row of the batch is **one chunk of the same document**; the chunks are processed
+in parallel with the `chunked=True` flag, and the final state is returned in `cache_params`.
 ```python
 from infer import prefill, stream
 ids = tok(open("doc.txt", encoding="utf-8").read(), return_tensors="pt").input_ids[0]
+# 1) load the prefix only, get the last token's logits and the state
 logits, cache = prefill(model, ids, chunk_size=1024, max_parallel_chunks=16)
+# 2) load the prefix, then generate (streaming)
 for token_id in stream(model, ids, gen_cfg):
     print(tok.decode([token_id]), end="", flush=True)
 ```
+Command line:
 ```bash
 python infer.py --model Vi-LAB/KenT-100M-Base --prompt-file doc.txt --chunk-size 1024
 ```
+`cache.clone()` lets you reuse the same prefix to generate multiple different branches without reloading it.
+## Notes
+- Memory is a uniform cumulative average over every timestep seen; the model does not learn to forget or to select on its own.
+- The tokenizer and weights must match `vocab_size` in `config.json`.
+- This is a research model; please evaluate it before using it for real-world tasks.