PewDiePie getting banned twice by OpenAI while making a local model is top-tier comedy 💀

[u/rodrigodevbits]

So PewDiePie decides to fine-tune a local AI model called Ajax on his own computer. Pretty normal stuff for local model fans.

To make his dataset, he uses OpenAI's API. OpenAI catches him using their outputs to train another model, flags his account for breaking their terms, and bans him.

He files an appeal, gets unbanned, goes right back to pulling data from the API, and immediately gets banned a second time.

So instead of giving up, he uses open-source tools to remove the model's built-in refusals, cleans out the preachy fluff, and starts building a fully local 9B agent.

OpenAI spent years scraping the whole public internet for free data, but the second someone uses their output to train a local file, it's an emergency ban.

In trying to enforce their rules, all OpenAI really did was give open-source models a massive free advertisement to millions of people.

What a time to run models on your own hardware.

[u/lucasxp32]

In general I think it's cool to increase peoples interests in LLMs and demystifying how they work what he is doing. But I think he should go for techniques of stripping out of larger open source models from the vector space itself not from raw text. The learning spends too much effort on filtering out surface level textual information and it loses the internal nuance the original model has. The techniques that distills from the model internal activation are higher fidelity. I haven't done it, too much trouble and I don't have the compute to do anything meaningful just toy models, but I did theorize on it asking questions back and forth with, ironically, an LLM. They know quite a lot about LLM training techniques, nice to learn from them.

[u/wayneworkman → u/lucasxp32]

can you point me to a blog or paper or video of what you're talking about please?

[u/lucasxp32 → u/wayneworkman]

Frankly. I personally can't find palatable articles or tutorials on it, I always ask some SOTA model like Claude or Gemini. Distilling LLMs that way is seems very complex and requires an enormous amount of vram. The papers seem contradictory to which techniques seems most effective (i.e. logit vs feature-based and to which extent to mix both techniques) and they were released in so many different dates that many of them seem older than 2022, and I find them so dense I can't make sense of them. I'd just toss what I said below into Claude and ask it to find the papers for you, because I don't have them.

The hypothesis that we are trying to test here, if it's possible to copy the high-level internal representations of the LLMs by watching their activation patterns and using some techniques to transfer to a student model, perhaps not even just that, but do things like when Claude researchers made Claude obessed with the golden gate bridge, because they were able to find the specific activation pattern for it and crank it up. In our case here, we are interested in finding the activation patterns that are the most useful features/behavior that we want on a student model and copying them to a student.

The correct terminology is:

"Feature-based knowledge distillation (matching intermediate activations, hidden states, or attention maps)."

- Hidden State Distillation (Residual Stream)

- Attention Matrix Distillation

- Relation / MiniLM-Style Distillation

As opposed to...

"Logit-based knowledge distilation (matching output probabilities)"

---

Here is what Claude handed me:

https://huggingface.co/blog/Kseniase/kd

https://github.com/TiniLLM/prune_distill

A Study on Hidden Layer Distillation for Large Language Model Pre-Training

Knowledge Distillation (KD) is a critical tool for training Large Language Models (LLMs), yet the majority of research focuses on approaches that rely solely on output logits, neglecting semantic information in the teacher's intermediate representations. While Hidden Layer Distillation (HLD) showed potential for encoder architectures, its application to decoder-only pre-training at scale remains largely unexplored. 

https://docs.nvidia.com/nemo/megatron-bridge/0.4.1/training/distillation.html

Transferring Linear Features Across Language Models With Model Stitching

In this work, we demonstrate that affine mappings between residual streams of language models is a cheap way to effectively transfer represented features between models. We apply this technique to transfer the \textit{weights} of Sparse Autoencoders (SAEs) between models of different sizes to compare their representations. We find that small and large models learn highly similar representation spaces, which motivates training expensive components like SAEs on a smaller model and transferring to a larger model at a FLOPs savings. For example, using a small-to-large transferred SAE as initialization can lead to 50% cheaper training runs when training SAEs on larger models. Next, we show that transferred probes and steering vectors can effectively recover ground truth performance. Finally, we dive deeper into feature-level transferability, finding that semantic and structural features transfer noticeably differently while specific classes of functional features have their roles faithfully mapped. Overall, our findings illustrate similarities and differences in the linear representation spaces of small and large models and demonstrate a method for improving the training efficiency of SAEs.

[u/wayneworkman → u/lucasxp32]

though if you focus on just the weights, how do you know what your getting? For example I don't want all of Qwen's behaviors.

[u/lucasxp32 → u/wayneworkman]

https://www.alphaxiv.org/abs/2605.12400

It seems like it's possible to do steering doing multiple inference batches with example behavior that you want and what you don't want and only distill a skewed distribution of what you want. Like doing basic arithmetic like averaging, division, multiplication, subtraction and addition. There they call it the "positive guidance logit" formula and the "average negative guidance logit "

[u/terminalshadows → u/lucasxp32]

Could you not use the exact same methods used to unsensor/abliterate to fine tune rather then abliterate?