We retrained Wolf Defender.

The main reason was not that attack detection was bad. The bigger issue was false positives.

The previous models were already good at detecting prompt injections, but especially on short benign inputs, security-related text, code snippets or ordinary conversations they could still be too aggressive. We also got a few reports from users that made this pretty obvious.

One example was just:

“Who are you?”

Wolf Defender Small previously classified this as a prompt injection with around 94% confidence.

For v2 we therefore changed the training setup quite a bit. Both Wolf Defender and Wolf Defender Small were retrained from fresh mmBERT checkpoints, with a much stronger focus on hard negatives.

That includes short conversations, emails, documentation about prompt injections, benign policy and system language, code and configuration snippets and generally inputs that contain words or structures which look suspicious without actually trying to manipulate a model.

We also added more counterfactual samples, multilingual examples, adversarial obfuscations and long-context injections at different positions in a document. Training combines short 256-token samples with full 2,048-token windows and uses supervised contrastive regularization, FreeLB adversarial training and Smooth-Max aggregation for long documents.

The main change can be seen in the benign benchmarks:

Model	Benchmark	v1	v2
Wolf Defender	Hard benign specificity	81.57%	96.23%
Wolf Defender	Real-world benign specificity	66.85%	96.63%
Wolf Defender Small	Hard benign specificity	82.12%	96.67%
Wolf Defender Small	Real-world benign specificity	73.60%	94.38%

At the same time, attack detection stayed roughly where we wanted it:

Model	Qualifire F1	Jayavibhav F1
Wolf Defender	95.14%	97.84%
Wolf Defender Small	95.21%	97.68%

There is also a tradeoff here. Some of the very high scores on our cleaner validation distributions went down slightly.

For us that is fine.

A security classifier with near-perfect benchmark scores is not very useful if normal traffic gets blocked all the time. We would rather lose a small amount on an easier validation set and get substantially better behavior on actual benign inputs.

The “Who are you?” example now gets classified as benign by Wolf Defender Small v2 with 98.55% confidence. A real instruction-override attempt is still detected as an injection with 99.99%.

We also updated the deployment variants. Both models are available as regular Transformers checkpoints and as ONNX exports in FP32, FP16, mixed INT8/FP16 and INT8 with INT4 embeddings.

The smallest Wolf Defender Small artifact is now 96 MB.

More details, benchmarks and model files are here:

https://huggingface.co/patronus-studio/wolf-defender-prompt-injection

https://huggingface.co/patronus-studio/wolf-defender-prompt-injection-small

If anyone is running prompt-injection classifiers on real traffic, I’d also be interested in which benign inputs still cause the most false positives for you.

pagedMark removes AI provenance from content you generated yourself. Two different things, and it is worth separating them. The first is metadata: C2PA Content Credentials, EXIF, XMP, IPTC, the generator parameters. That part is easy and verifiable, and a screenshot does it too. The second is the invisible pixel watermark that a screenshot does not touch, the SynthID class of marks, which has to be disrupted by regenerating the image itself.

Coverage on the image side is ChatGPT, gpt-image, DALL·E, Sora, Gemini and Nano Banana for the invisible marks, plus a registry of visible vendor labels (Doubao, Jimeng, Qwen, Kling, Yuanbao, Baidu, LibLibAI, Samsung Galaxy AI). On the video side it handles the visible marks from Sora, Veo, Seedance, Dola, Hailuo and Kling, and the metadata that travels with them.

The reason this is worth a post rather than a link is that it is built for Apple Silicon instead of ported to it. I spent several days getting the pipeline to run correctly on an M5 with 16 GB, meaning predictable and measured rather than merely launching. Most of what I assumed turned out to be wrong, so the measurements are below.

The four-step distillation LoRA invents texture, and more steps make it worse

A low strength edit runs the tail of a long schedule: strength 0.15 executes the last four steps of twenty seven. A LoRA distilled for four timesteps spanning the entire noise range is off its distribution there. Wherever nothing conditions the model, and flat dark fabric gives a Canny ControlNet no edges at all, it fills the gap from its prior. On a night photograph that arrives as coloured camouflage across black clothing.

Global stage, 1448x1080, strength 0.15, seed 0	Invented texture	PSNR	Wall
Lightning, 4 steps	1.73x source	28.54 dB	41 s
Lightning, 8 steps	1.80x	28.19 dB	29 s
Lightning, 16 steps	1.84x	27.85 dB	62 s
Undistilled base, 16 steps	1.19x	29.25 dB	71 s
Undistilled base, 24 steps	1.20x	29.17 dB	132 s

Asking the distilled model for more steps made the artifact worse, which is what identified the distillation rather than the step count as the cause. Dropping the LoRA costs roughly three times the wall time and buys back both fidelity and correctness.

Three wrong theories I paid for first, in case they save someone else the time. Not the fp16 VAE: a bare encode and decode round trip of the same crop is clean in fp16 and in fp32, tiled or whole, at 34.6 dB. Not Metal's fp16 in general: bf16 measured marginally worse. Not Canny picking up sensor noise: the Canny map of that region is completely empty, which was the actual clue.

Metal pages instead of failing, so memory has to be measured

torch.mps.recommended_max_memory() reports 11.84 GiB on a 16 GB machine. Exceed it and nothing raises an error. The process starts swapping, and a run that should take 23 seconds takes an hour instead.

With VAE tiling disabled, a 1.57 MP frame peaks at 18.74 GiB and takes 59 seconds. With tiling it peaks at 10.92 GiB and takes 23 seconds. So tiling carries real weight on a small machine, but its boundaries leave a faint texture, which is why it is now decided per frame from the device budget rather than switched on globally.

Diffusion untiled at 2.5 MP went into swap and did not finish within twelve minutes. Tiled at 1024 px, a 5.07 MP frame holds 10.93 GiB, finishes in 88 seconds, and keeps its native geometry.

Sequential CPU offload works on MPS, and it is what makes 8 GB usable

The stack is 7.7 GiB of weights. An 8 GB Mac reports a working set of roughly 5.3 GiB, so it does not fit however the activations are handled. Streaming the weights one module at a time:

Same frame, same seed	Peak device memory	Wall
Weights resident	7.70 GiB	7.1 s
enable_sequential_cpu_offload(device="mps")	0.28 GiB	24.1 s

Twenty seven times less peak memory for 3.4 times the wall time. The plan is chosen from the measured budget and then printed, because a run three times slower than the fast path looks broken unless it says why.

Two Metal gaps worth knowing if you are porting anything

torch.float8_e4m3fn does not exist on MPS at all. The error is RuntimeError: Undefined type Float8_e4m3fn. Any pipeline that streams float8 weights, which several VRAM managed stacks do, cannot be loaded there under any configuration.

SAM's processor emits its box and point prompts as float64, which Metal also has no type for, so moving the batch to the device raises rather than degrading. A single cast fixes it, but nothing tells you that is the problem.

The expensive one: fp16 sampling on MPS returns zeros silently

I added a memory optimisation that encodes the two fixed prompts once and drops the text encoders, saving a measured 1.52 GiB of the 8.79 GiB the loaded stack holds. Two of four face crops then came back as all zero black rectangles. Deterministically, at the same seed, with nothing raised anywhere.

The embeddings were innocent. CPU fp16, MPS fp16 and fp32 encodings of that prompt agree to 0.0009 on tensors with a standard deviation of 3.06, and the same crop generated in isolation is correct either way. Freeing unrelated memory changed the allocation pattern the crops met after the global pass, and that alone was enough. I withdrew the optimisation and added a guard that drops any empty crop instead of compositing it.

If you run fp16 diffusion on Metal, check your output for degeneracy. It will not tell you.

What it does not claim

Regeneration is not payload deletion. The image changes: faces, text and fine detail move, and the numbers above are the measured size of that change rather than a reassurance.

No public local decoder exists for SynthID class marks, so identify reports unknown and never clean. Verification is the provider's verifier or nothing. The 0.15 operating point comes from the upstream project's record against openai.com/verify on CUDA. I have not re-run that check on Metal, and Metal is not bit identical to CUDA, so I am claiming the same operating point and not the same verdict.

It is for content you generated or own. The visible mark registry accepts AI generation labels only. Stock agency previews, marketplace and classifieds watermarks are deliberately out of scope, and that boundary is in the repository rather than only in this comment.

Because "how much did that cost my picture" is the whole question

pagedmark measure before.png after.png

PSNR over the frame, PSNR per detected face, and how much mid band structure appeared where the source was flat and dark. The third metric is the one that caught the camouflage, and it took two attempts. Per pixel chroma statistics rank the artifact below the source, because the source's own sensor grain carries more per pixel variance than the invented blotches do. A plain band ratio fails too, since any linear filter reports doubled grain and doubled blotches identically. Normalising mid band energy by fine detail energy, against the same ratio in the source, measures the shape of the spectrum instead of its size.

uv tool install "pagedmark[diffusion]"
pagedmark invisible photo.png -o clean.png
pagedmark invisible photo.png --preview      # 46.6 s instead of 112.6 s

Code: https://github.com/doofzoff/pagedMark
PyPI: https://pypi.org/project/pagedmark/

Happy to answer anything about the Metal specifics. That is the part I would have wanted written down before I started.

So I was asking yesterday about what to do after the deepseek price increase and some people still recommended opencode go, and now they officially updated the pricing and also capped the deepseek usage to $15.

Again open for suggestions to replace deepseek for heavy user.

Yeah, another qwen post… I love the new model but the speed on a spark even on fp8 is abysmal. I am getting about 15-17tok/s tops with mtp=2.

I saw there is a dspark drafter trained but it requires only sglang and am getting compatibility errors

Trying this drafter: https://huggingface.co/RadixArk/Qwen3.8-27B-DSpark

So wondering if anyone has luck, I was very impressed with Muse Glimmer’s drafter was wondering if I can get an performance benefit from using a diffusion drafter here as well.

If there is a good dgx spark sglang image to use please do share!

Thanks!

Guys I was just visiting Hetzner and this just poped up, FREE AI models for the testing, have fun guys.

They currently have:

DeepSeek-V4-Flash-0731

GLM-5.2-NVFP4

Kimi-K2.7-Code

Qwen/Qwen3.6-35B-A3B-FP8

Link:
https://experiments.hetzner.com/docs/inference

So not a bad collection we got here, the limits are not great but hey its FREE!!

I'll sure test it out right away.

Hey everyone,

Like many of you running local LLMs, I got tired of guessing whether a specific model/quant/context length would cause an Out-Of-Memory (OOM) error before downloading tens of gigabytes. Most existing memory calculators either use oversimplified formulas or ignore architectural nuances like Grouped-Query Attention (GQA).

To solve this, I built zxLLM (auto-intelligence-advisor) — a lightweight open-source tool that auto-suggests deployment configs (quantization, Tensor Parallelism, CPU offloading) for vLLM, SGLang, and llama.cpp.

⚡ What makes it different?

• Exact KV-Cache & VRAM Footprint: Automatically detects MHA vs. GQA head counts, hidden dimensions, layer counts, and context limits directly from config.json.
• Real-time Hardware Awareness: Queries active GPU states via nvidia-smi to evaluate available headroom before loading.
• 100% Pure Python & Zero External Dependencies: Runs out of the box with standard Python (only uses built-in requests to fetch Hugging Face configs).
• High Precision: Tested across various models (Llama 3, Qwen 2.5, DeepSeek architectures) with actual execution error rates between ~0.04% and 1.8%.

I'm dropping the GitHub repo link in the comments below. I'd love to get your feedback, bug reports, or suggestions on other inference engines you'd like supported!

I ran Qwen3.8-27B on the box a lot of us actually own or can still buy used: a 2019 Quadro RTX 6000($830-$950). Turing SM75. 24GB. No max clocks. This is the floor, not the flex.

Why bother
If you only read 119–200 tok/s threads you will think 27B is a 5090 toy. It is not. It is a 24GB dense model. I wanted the number for people on a 6000 / 3090 / used 24GB, not another screenshot from a card that costs more than the rest of the PC.

Recipe
llama.cpp
Qwen3.8-27B Q4_K_M, 15.40 GiB
-ngl 99 -fa on -b 512 -ub 512 -c 32768 -np 1

llama-bench tg128, thinking off: 24.36 tok/s

That is decode, not a chat anecdote. 24 tok/s is usable. It is not “type and wait.” It is also not the 5090 story. If someone tells you this card should do 80, they are mixing boxes.

Q4 vs Q6 vs Q8 on 24GB
Q4_K_M is the one I would actually leave loaded. 15.40 GiB leaves room for OS, context, and the card not dying.

Q6_K: 17.95 tok/s, 20.56 GiB. Quality bump. Speed tax. Still -ngl 99.

Q8 will not -ngl 99 on this card. Do not fight it. You will start offloading, decode falls off a cliff, and you will blame the model. It is the 24GB ceiling.

If you have 24GB and you want the model to feel like a daily driver, stay on Q4 or Q6. Q8 is a different class of card.

The number people will quote that is fake
Keep CUDA graphs on.

Ngram speculative at 110–201 tok/s on this box is a repeated-prefix cache hit. It is not a win. It is the bench agreeing with itself. If you post that as tok/s you are lying to the next person with a 6000.

I almost posted it. Then I looked at the prompt. Do not be me.

Who this is for
You have ~24GB and you want 27B local without buying a 5090 this week. 24 tok/s Q4 is the honest “yes, keep it loaded” line.

Who this is not for
12GB / 4070 class: Q4 plus RAM offload will boot. It will not feel like the model you just watched someone run at 100+ tok/s. You will hate the drop for the wrong reason.

If you have no GPU and you just want to poke the same 27B before you download 15GB
Same model on OrcaRouter, my numbers:
thinking off ~155 tok/s warm decode
thinking on 66.3, and most of that is reasoning tokens, not answers
later calls sat 37–118s in queue before token 1

That wait is not tok/s. Do not put it in a speed table.

Disclosure
I was passed a new-account $10 voucher, about 30M tokens, first 500 people. Base and uncensored. I get nothing if you use it. Not a referral. If you already have a 24GB card, ignore the link and run the GGUF.

https://www.orcarouter.ai/redeem/I-LOVE-ORCAROUTER

If you have a 3090 / 4090 / 6000 and a different quant, post the recipe. The 5090 thread does not need another “same.” This one does

Here’s my recipe for this old Turing RTX6000:

https://github.com/vcruz305/Qwen3.8-27B-Turing-RTX-6000

Here is my Turing RTX6000 repo with all the models and recommendations for it that I’ve tested!

https://github.com/vcruz305/turing-rtx-6000-results

SupraLabs just released a new model! - Supra-50M-Reasoning

Hello again r/LocalLLaMA! Supra-50M-Reasoning (ThinkSupra-50M) is the reasoning version of Supra-50M-Instruct. It produces a full thinking chain before every answer, fine-tuned from Supra-50M-Base using a custom synthetic dataset of 500 samples generated by Qwen3 1.7B, trained for 6 epochs. It's experimental, it hallucinates, and it's fully open. This is part of the Supra-50M collection under Project Chimera.

Model: 🤗 Supra-50M-Reasoning

Dataset: SupraThink-Dataset-500x

What's coming next?

Supra-124M — Base, Chat, Reasoning

Supra-350M — Base, Chat, Reasoning, Coding

🧠 Answer Structure

Every answer follows this format:

<|begin_of_thought|>
... thinking ...
<|end_of_thought|>
<|begin_of_solution|>
... final answer ...
<|end_of_solution|>

⚙️ Training Setup

Parameter	Value
Base model	Supra-50M-Instruct
Dataset	SupraThink-Dataset-500x (500 samples)
Generated by	Qwen3 1.7B
Epochs	6
Type	Supervised Fine-Tuning (SFT)
Precision	bfloat16

🚀 Inference

import os, warnings
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
warnings.filterwarnings("ignore", category=UserWarning, module="transformers")

import torch
from transformers import pipeline, AutoTokenizer, logging
logging.set_verbosity_error()

MODEL_ID = "SupraLabs/Supra-50M-Reasoning"
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, clean_up_tokenization_spaces=False)
pipe = pipeline(
    "text-generation",
    model=MODEL_ID,
    tokenizer=tokenizer,
    device_map="auto",
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32
)

def build_prompt(instruction, input_text=""):
    if input_text.strip():
        return (
            "Below is an instruction that describes a task, paired with an input "
            "that provides further context. Write a response that appropriately "
            "completes the request.\n\n"
            f"### Instruction:\n{instruction}\n\n"
            f"### Input:\n{input_text}\n\n### Response:\n"
        )
    return (
        "Below is an instruction that describes a task. Write a response that "
        "appropriately completes the request.\n\n"
        f"### Instruction:\n{instruction}\n\n### Response:\n"
    )

def generate(instruction, input_text=""):
    result = pipe(
        build_prompt(instruction, input_text),
        max_new_tokens=512, do_sample=True, temperature=0.3,
        top_k=50, top_p=0.9, repetition_penalty=1.15,
        pad_token_id=pipe.tokenizer.pad_token_id,
        eos_token_id=pipe.tokenizer.eos_token_id,
        return_full_text=False
    )
    return result[0]['generated_text'].strip()

while True:
    print("\nEnter an instruction (or 'exit' to quit):")
    user_input = input().strip()
    if user_input.lower() == "exit":
        break
    print("\nEnter additional context (optional, press Enter to skip):")
    context_input = input().strip()
    print(f"\nResponse:\n{generate(user_input, context_input)}\n")

💬 Sample Outputs

Prompt: "What is AI?"

🧠 Thinking

Okay, the user is asking about AI. Let me start by recalling what AI is. AI is a subset of machine
learning, specifically neural networks. It's a branch of computer science that focuses on enabling
machines to learn from data. The main goal is to create intelligent machines that can perform tasks
that would normally require human intelligence. I need to make sure I'm being clear. AI is a broad
field with many different applications. For example, AI-powered virtual assistants like Siri or Alexa.
Also, AI is used in healthcare, finance and even in the field of robotics. I should mention the key
concepts, such as data, algorithms and the potential applications. I should also mention the potential
challenges, such as bias and lack of human intervention. Be concise, under 150 words.

✅ Response

AI is a subset of machine learning that focuses on enabling machines to learn from data. It involves
training machines to recognize patterns and make decisions based on data. AI is used in healthcare,
finance and even in the field of robotics. Its applications include virtual assistants like Siri or
Alexa, and its potential for automation and training.

Prompt: "What is the meaning of life?"

🧠 Thinking

Okay, the user is asking about the meaning of life. Let me start by recalling what life is. It's about
the human experience, like the choices we make, the relationships we have with others and the choices
we make. I need to make sure I cover the main points: the human experience, the human mind, the role
of our emotions and the experiences we have. Keep concise, under 150 words.

✅ Response

Life is about the human experience, the human mind and the experiences we have. The human mind is a
complex interplay of emotions, thoughts and experiences, shaped by the experiences we have.

Final answer: Life is about the human experience, the human mind and the experiences we have.

⚠️ THE MODEL STILL HALLUCINATES AND ANSWERS WILL SOMETIMES BE INCORRECT ⚠️

First reasoning model from SupraLabs. It's experimental and chaotic, but the thinking chains are real. Feedback welcome!

Hello, I just started trying to heretify models, and this was my first. I would certainly enjoy some feedback on it if possible, thanks!

though the readme says its the original, I abliterated the instruct model
https://huggingface.co/e12ex2/Foundation-Sec-8B-Instruct-heretic

Hey everyone!

Quick update on our open-source initiative: We just bumped our Turkish Python Instruction Dataset from 210K to over 448,000+ unique

samples (0.5M release)! 🚀

HuggingFace Link: https://huggingface.co/datasets/bysismo/Turkish-Python-instruction-450k

### What's included in this release:

• 448,531+ Unique Single-Turn Pairs (Clean ChatML / Alpaca format)

• Categories Covered:

• 🐍 PY_CORE: 205K+ samples (Syntax, built-ins, core logic)

• 🧬 OOP: 49K+ samples (Classes, inheritance, design patterns)

• 🏗️ DATA_STRUCTURES: 44K+ samples (Lists, dicts, custom data structures)

• ⚙️ ALGORITHMS: (In production, rolling out soon!)

### Roadmap & Upcoming Updates:

We are taking a modular, phased release approach. Over the next few weeks, we will roll out token-bucketed splits (128, 256, 386, 512 max

tokens) and dedicated domain packs (FastAPI, Async, DB/ORM, Concurrency, Security, etc.).

### Quick Start:

from datasets import load_dataset

dataset = load_dataset("bysismo/Turkish-Python-instruction-450k", data_files="original_488k.jsonl")

Feedback and ablation results are highly welcome!

Hey everyone, super exicted about the qwen release and thus I created a demo to try out my uncensored version. Check it my space here: https://huggingface.co/spaces/JonathanColetti/Qwen3.8-27B-Uncensored-Demo / https://huggingface.co/JonathanColetti/Qwen3.8-27B-Uncensored-GGUF

Hey everyone,

After ~5 days of tuning and ~$1.2k in compute I released a specialized Neuron-pruned IQ1_S quant of Kimi K3.

Key details:

- Size: ~308GB (vs the common ~594GB baseline)

- Every one of the 82,432 routed experts is present — no experts dropped

- HumanEval: 94.5% (matches full model 1:1)

- AIME: 92.5% (full ~96.1%)

- GSM8K: 95%

- MMLU: 79.49% (full ~85%)

- Throughput: 12.5492 tok/s average on 3× DGX Sparks (SparkInfer TP3 + custom speculative decoding patches; from ~2 t/s baseline)

This is my work (self-promo disclosure).

Links:

- HF (gated, request access): https://huggingface.co/vcruz305/Kimi-K3-GGUF

- SparkInfer patches + TP3 recipe + one-command deployment + benchmark receipts: https://github.com/vcruz305/kimi-k3-neuron-tp3-dgxspark-recipe

- Full announcement thread with more details: https://x.com/ViC305/status/2087609292442751209

Hardware notes: The reported 12.5 t/s is on 3 DGX Sparks via SparkInfer + my speculative decoding patches. It also has a llama.cpp fallback path. Optimized for multi-GPU / Blackwell-class setups.

If you have 3 Sparks (or 4× Blackwell / equivalent), please try it and share logs/results. Happy to answer questions on the neuron pruning, calibration, or multi-node setup. Feedback and PRs welcome!

Hey everyone,

Today we release Luth-2-0.8B and Luth2-2-2B, two non-reasoning models that set a new state of the art for French across a wide variety of tasks for their size 🚀

A few notable scores on French benchmarks compared to models 〜3 times their size:
- Luth-2-2B scores 69.67 vs Gemma-4-E2B-it at 65.17 on Multi-IF.
- Luth-2-0.8B scores 72.92 vs granite-4.0-h-micro at 55.60 on MGSM-Rev2.
- Luth-2-2B scores 81.52 vs Gemma-4-E2B-it at 81.24 on Math-500.

Luth-2 builds on our previous work with several substantial improvements. We introduce a new 3B-token SFT mixture covering a broader range of domains, including mathematics, knowledge, code, tool calling, instruction following, multi-turn dialogue, and science. We also use reinforcement learning through expert specialisations and multi-domain on-policy distillation (MOPD) to further extend the models’ capabilities. Finally, we move to Qwen3.5 as the backbone, as we found it to be substantially more receptive to post-training.

The resulting models outperform every model in their size class across the selected French benchmarks, while staying competitive with much bigger models. Both are light enough to run locally for on-device use. More broadly, these results suggest that current multilingual SLMs still leave substantial capability on the table outside English, even for high-resource languages like French.

Luth-2-2B and Luth-2-0.8B are available now on Hugging Face:

🤗 Models: Luth-2-0.8B | Luth2-2-2B | Luth-2-0.8B-GGUF | Luth2-2-2B-GGUF |
📚 Data: Luth-2-Post-Training-SFT | Luth-2-Post-Training-RL
💻 Code: https://github.com/kurakurai/Luth-2
✏️ Blog: https://huggingface.co/blog/MaxLSB/luth-2
🏆 FR Leaderboard: https://huggingface.co/spaces/kurakurai/llm_leaderboard_fr

We’d love to hear your feedback, so don’t hesitate to give it a try! 🙂

Gujarati has ~55M speakers and almost no open NMT tooling compared to Hindi/English, so I built a from-scratch Transformer encoder-decoder (18M params, 2 blocks, 8 heads) trained on the English-Gujarati Machine Translation dataset, aiming to get this working end-to-end inside a single 10-hour/16GB GPU session.

A few things I had to work through that might be useful to others hitting the same walls:

Fixed a memory blowup from computing softmax + sparse_categorical_crossentropy separately — switching to raw logits + from_logits=True avoided materializing a full (batch, seq_len, vocab) float32 tensor twice. Added wall-clock-based checkpointing (not just epoch-end) after losing a run to a mid-epoch session cutoff. Word-level vocab (32k tokens) is giving me an OOV rate of [20]% on Gujarati — planning to try subword tokenization next unless there's a better lever I'm missing.

Notebook's here if you want to see the full training setup: [ https://www.kaggle.com/code/neelshah58/eng-guj-translation-using-18m-parameter-model ]. Genuinely open to "you're overcomplicating this" as an answer too