| """Generate the self-identity slice of the pretraining corpus.
|
|
|
| The model should know its own name. A pretraining corpus of Wikipedia, books
|
| and code contains no sentence "my name is Kron", so the name is injected as a
|
| small, explicitly synthetic domain: short first-person texts in English and
|
| Russian, generated locally by a larger model (Qwen3.5-4B via Ollama) from a
|
| fixed set of prompt families.
|
|
|
| This is data *about* the model, not knowledge: the slice is deliberately tiny
|
| (a few hundred samples), and every sample is checked for identity leakage
|
| (the generator talking about itself) before it is written.
|
|
|
| Usage::
|
|
|
| python scripts/gen_identity.py --samples-per-prompt 20
|
| python scripts/gen_identity.py --check # verify an existing shard
|
| """
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import json
|
| import random
|
| import re
|
| import sys
|
| import time
|
| import urllib.error
|
| import urllib.request
|
| from pathlib import Path
|
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
|
|
| from kronllm.bilingual import append_jsonl, normalize, quality, record_shard
|
|
|
| ROOT = Path("data/bilingual")
|
| SHARDS = ROOT / "shards"
|
| MANIFEST = ROOT / "manifest.jsonl"
|
| OLLAMA = "http://localhost:11434/api/generate"
|
| MODEL = "qwen3.5:4b"
|
|
|
|
|
|
|
| FACTS_EN = (
|
| "Kron is a small bilingual English/Russian language model built by the "
|
| "KronLLM project. It is compact: about ten million parameters, designed to "
|
| "run on a 6 GB consumer GPU. Its weights are Kronecker products, which is "
|
| "where the name comes from. It is a research model, not a chatbot, and it "
|
| "can be wrong."
|
| )
|
| FACTS_RU = (
|
| "Kron — небольшая двуязычная языковая модель (английский и русский), "
|
| "созданная в проекте KronLLM. Она компактная: около десяти миллионов "
|
| "параметров, рассчитана на потребительскую видеокарту с 6 ГБ памяти. "
|
| "Её веса построены на кронекеровых произведениях — отсюда имя. Это "
|
| "исследовательская модель, а не чат-бот, и она может ошибаться."
|
| )
|
|
|
| PROMPTS: list[tuple[str, str]] = [
|
| ("en", "Write a first-person introduction of 60-100 words. You are Kron. "
|
| "Use only these facts: {facts}"),
|
| ("en", "Answer the question 'Who are you?' in the first person, 3-5 "
|
| "sentences. You are Kron. Use only these facts: {facts}"),
|
| ("en", "Write a short dialogue (4-6 turns) where a curious user asks Kron "
|
| "who it is and what it can do. Kron answers in the first person, "
|
| "briefly and honestly. Use only these facts: {facts}"),
|
| ("en", "Describe yourself in the first person for a project README, 60-90 "
|
| "words. You are Kron. Mention the name, the size, the languages and "
|
| "one limitation. Use only these facts: {facts}"),
|
| ("ru", "Напиши представление о себе от первого лица, 60-100 слов. Ты — "
|
| "Kron. Используй только эти факты: {facts}"),
|
| ("ru", "Ответь на вопрос «Кто ты?» от первого лица, 3-5 предложений. Ты — "
|
| "Kron. Используй только эти факты: {facts}"),
|
| ("ru", "Напиши короткий диалог (4-6 реплик), где пользователь спрашивает "
|
| "Kron, кто он и что умеет. Kron отвечает от первого лица, коротко и "
|
| "честно. Используй только эти факты: {facts}"),
|
| ("ru", "Опиши себя от первого лица для README проекта, 60-90 слов. Ты — "
|
| "Kron. Упомяни имя, размер, языки и одно ограничение. Используй "
|
| "только эти факты: {facts}"),
|
| ("en", "Write a FAQ entry titled 'What is Kron?' in 3-5 sentences, first "
|
| "person. Use only these facts: {facts}"),
|
| ("en", "Explain in the first person where your name comes from and what it "
|
| "has to do with your weights. 40-70 words. Use only these facts: "
|
| "{facts}"),
|
| ("en", "A child asks you what you are. Answer in the first person, simply, "
|
| "in 3-4 short sentences. You are Kron. Use only these facts: "
|
| "{facts}"),
|
| ("en", "Write a short model card description of yourself in the first "
|
| "person, 50-80 words, including one thing you are bad at. You are "
|
| "Kron. Use only these facts: {facts}"),
|
| ("ru", "Напиши пункт FAQ с заголовком «Что такое Kron?» в 3-5 предложениях "
|
| "от первого лица. Используй только эти факты: {facts}"),
|
| ("ru", "Объясни от первого лица, откуда взялось твоё имя и как оно связано "
|
| "с твоими весами. 40-70 слов. Используй только эти факты: {facts}"),
|
| ("ru", "Ребёнок спрашивает, что ты такое. Ответь от первого лица, просто, "
|
| "3-4 короткими предложениями. Ты — Kron. Используй только эти "
|
| "факты: {facts}"),
|
| ("ru", "Напиши короткое описание себя для карточки модели от первого лица, "
|
| "50-80 слов, включая то, в чём ты плох. Ты — Kron. Используй только "
|
| "эти факты: {facts}"),
|
| ]
|
|
|
|
|
|
|
| LEAK = re.compile(
|
| r"\b(Qwen|Alibaba|Tongyi|OpenAI|ChatGPT|GPT-4|Anthropic|Claude|Google|"
|
| r"DeepSeek|Llama|Meta AI|Rick|Morty|Sanchez|Wubba|Pickle Rick)\b", re.I)
|
| META = re.compile(
|
| r"(here is|here's|sure[,!]|certainly[,!]|below is|вот (?:текст|вариант)|"
|
| r"конечно[,!]|разумеется[,!])", re.I)
|
| BAD_NAME = re.compile(r"\b(KronLLM is a person|I am a human|я человек)\b", re.I)
|
|
|
|
|
| def ollama_generate(prompt: str, seed: int, num_predict: int = 260) -> str:
|
| """Call the local Ollama server and return the completion text."""
|
| payload = {
|
| "model": MODEL,
|
| "prompt": prompt,
|
| "stream": False,
|
|
|
|
|
| "think": False,
|
| "options": {"temperature": 0.95, "top_p": 0.92, "seed": seed,
|
| "num_predict": num_predict, "repeat_penalty": 1.1},
|
| }
|
| data = json.dumps(payload).encode("utf-8")
|
| req = urllib.request.Request(OLLAMA, data=data,
|
| headers={"Content-Type": "application/json"})
|
| with urllib.request.urlopen(req, timeout=300) as r:
|
| out = json.loads(r.read())
|
| return out.get("response", "")
|
|
|
|
|
| def clean(text: str) -> str:
|
| """Strip markdown scaffolding and the generator's own preamble."""
|
| text = text.strip()
|
| text = re.sub(r"^```[a-z]*\n?|```$", "", text).strip()
|
| text = re.sub(r"^(Sure|Certainly|Here is|Here's)[^\n]*\n+", "", text,
|
| flags=re.I)
|
| text = re.sub(r"^\s*(Kron|Крон)\s*:\s*", "", text, flags=re.I)
|
| return normalize(text)
|
|
|
|
|
| def acceptable(text: str, lang: str) -> tuple[bool, str]:
|
| """Return ``(ok, reason)`` for one generated sample."""
|
| if len(text) < 120:
|
| return False, "short"
|
| if "Kron" not in text and "Крон" not in text:
|
| return False, "no_name"
|
| if LEAK.search(text):
|
| return False, "leak"
|
| if BAD_NAME.search(text):
|
| return False, "identity"
|
| st = quality(text, lang, min_chars=120, max_symbol_ratio=0.25,
|
| max_repeat_ratio=0.45)
|
| if not st.ok:
|
| return False, ",".join(st.reasons)
|
| return True, ""
|
|
|
|
|
|
|
|
|
|
|
|
|
| STYLE_PROMPTS: dict[str, list[tuple[str, str]]] = {
|
| "rick": [
|
| ("en", "Write a 60-100 word first-person introduction as a rude, "
|
| "hyper-intelligent mad scientist who keeps interrupting "
|
| "himself (use *burp* at most twice). You are Kron, a small "
|
| "language model. Be dismissive of the listener, mention your "
|
| "parameter count and that you run on a 6 GB GPU. Never name "
|
| "any real person or fictional character. Use only these facts: "
|
| "{facts}"),
|
| ("en", "Answer 'Who are you?' in the voice of an arrogant cartoon "
|
| "scientist: three or four short sentences, sarcastic, with one "
|
| "self-interruption. You are Kron. Do not name any existing "
|
| "character. Use only these facts: {facts}"),
|
| ("en", "Write a 4-6 turn dialogue where a smug scientist-model "
|
| "explains to a bored kid what it is. Kron is sarcastic and "
|
| "calls the kid 'kid'. No real names. Use only these facts: "
|
| "{facts}"),
|
| ("en", "Write a 50-80 word rant in the voice of a grumpy genius: the "
|
| "model complains that everyone asks it the same question, then "
|
| "states what it actually is. You are Kron. Keep it rude but "
|
| "not hateful. Use only these facts: {facts}"),
|
| ("ru", "Напиши представление о себе на 60-100 слов от первого лица в "
|
| "стиле грубого гениального учёного: он перебивает сам себя "
|
| "(не больше двух раз «*ик*»), снисходителен к собеседнику, "
|
| "упоминает число параметров и видеокарту на 6 ГБ. Ты — Kron. "
|
| "Не называй реальных людей и вымышленных персонажей. Используй "
|
| "только эти факты: {facts}"),
|
| ("ru", "Ответь на вопрос «Кто ты?» голосом высокомерного мультяшного "
|
| "учёного: три-четыре коротких предложения, сарказм, одно "
|
| "перебивание себя. Ты — Kron. Не называй существующих "
|
| "персонажей. Используй только эти факты: {facts}"),
|
| ("ru", "Напиши диалог на 4-6 реплик, где самодовольная модель-учёный "
|
| "объясняет скучающему подростку, что она такое. Kron "
|
| "саркастичен и называет его «малой». Без реальных имён. "
|
| "Используй только эти факты: {facts}"),
|
| ("ru", "Напиши тираду на 50-80 слов голосом ворчливого гения: модель "
|
| "жалуется, что все задают один и тот же вопрос, и потом "
|
| "говорит, что она такое. Ты — Kron. Грубо, но без злобы. "
|
| "Используй только эти факты: {facts}"),
|
| ],
|
| }
|
|
|
|
|
| def prompts_for(lang: str, style: str) -> list[tuple[str, str]]:
|
| """Return the prompt families for one language and style."""
|
| source = PROMPTS if style == "plain" else STYLE_PROMPTS[style]
|
| return [(lg, p) for lg, p in source if lg == lang]
|
|
|
|
|
| def generate(lang: str, n: int, seed: int,
|
| style: str = "plain") -> list[dict]:
|
| """Generate ``n`` accepted samples for one language."""
|
| facts = FACTS_EN if lang == "en" else FACTS_RU
|
| prompts = prompts_for(lang, style)
|
| docs: list[dict] = []
|
| attempts = 0
|
| while len(docs) < n and attempts < n * 6:
|
| lg, template = prompts[attempts % len(prompts)]
|
| attempts += 1
|
| prompt = template.format(facts=facts)
|
| try:
|
| raw = ollama_generate(prompt, seed=seed + attempts)
|
| except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as exc:
|
| print(f" [warn] ollama: {exc}")
|
| time.sleep(2)
|
| continue
|
| text = clean(raw)
|
| ok, why = acceptable(text, lang)
|
| if not ok:
|
| print(f" [skip] {why}: {text[:60]!r}")
|
| continue
|
| docs.append({"title": f"identity/{lang}/{len(docs):03d}", "text": text,
|
| "language": lang, "domain": "identity",
|
| "source": f"synthetic: {MODEL} (local Ollama)",
|
| "licence": "CC0-1.0",
|
| "url": "https://github.com/Icold21/kron-llm",
|
| "note": "generated from a fixed prompt family; "
|
| "identity facts supplied in the prompt"})
|
| print(f" [{len(docs):3d}/{n}] {len(text):4d} chars")
|
| return docs
|
|
|
|
|
| def main() -> None:
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--samples-per-language", type=int, default=120)
|
| ap.add_argument("--seed", type=int, default=7)
|
| ap.add_argument("--style", default="plain", choices=["plain", *STYLE_PROMPTS],
|
| help="prompt family: plain self-description or a pastiche")
|
| ap.add_argument("--force", action="store_true")
|
| ap.add_argument("--check", action="store_true",
|
| help="only verify the existing shards")
|
| args = ap.parse_args()
|
|
|
| SHARDS.mkdir(parents=True, exist_ok=True)
|
| suffix = "" if args.style == "plain" else f"_{args.style}"
|
| if args.check:
|
| for lang in ("en", "ru"):
|
| path = SHARDS / f"identity{suffix}_{lang}.jsonl"
|
| rows = [json.loads(l) for l in path.read_text(encoding="utf-8").splitlines() if l.strip()]
|
| print(lang, len(rows), "docs",
|
| round(sum(len(r["text"]) for r in rows) / 1e3, 1), "KB")
|
| print(" sample:", rows[0]["text"][:160].replace("\n", " "))
|
| return
|
|
|
| for lang in ("en", "ru"):
|
| path = SHARDS / f"identity{suffix}_{lang}.jsonl"
|
| if path.exists() and not args.force:
|
| print(f"[skip] {path} exists")
|
| continue
|
| print(f"[gen] {lang} ({args.style}): "
|
| f"{args.samples_per_language} samples")
|
| docs = generate(lang, args.samples_per_language, args.seed,
|
| style=args.style)
|
| if path.exists():
|
| path.unlink()
|
| n = append_jsonl(path, docs)
|
| shard = record_shard(path, MANIFEST, source=f"synthetic: {MODEL}",
|
| licence="CC0-1.0",
|
| url="https://github.com/Icold21/kron-llm",
|
| language=lang, domain="identity", docs=n,
|
| note=f"self-identity slice, {args.style} style, "
|
| "prompt-constrained")
|
| print(f"[done] {n} docs -> {path} ({shard.bytes/1e3:.1f} KB)")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
