Hugging Face's logo

open/ acc
community
Activity Feed Request to join this org

AI & ML interests

None defined yet.

Recent Activity
shahrukhx01  authored a paper about 2 months ago
Transformers for molecular property prediction: Domain adaptation efficiently improves performance
cfahlgren1  submitted a paper about 2 months ago
From AGI to ASI
Ritvik19  authored a paper 2 months ago
Aryabhata 2: Scaling Reinforcement Learning for Advanced STEM Reasoning
View all activity
sergiopaniego 
posted an update 4 days ago
view post
Post
2543
Simon Willison (@simonw ) has asked every new model to draw a pelican riding a bicycle for some time now

you look at the drawing and you know. but there is no number, so nothing can train against it, no?

I turned this idea into an rl env in OpenEnv. now, you can eval any model against it, and train against it with TRL

read the details!🤓

https://huggingface.co/blog/sergiopaniego/pelican-env-openenv
  • 2 replies
·
sergiopaniego 
posted an update 5 days ago
sdiazlor 
posted an update 6 days ago
view post
Post
117
Hey! We've released PrunaVAED, a drop-in replacement decoder for LTX-2.3

- ~1.7-2.1x faster decoder & ~50% lower peak VRAM
- Near-original visual quality & no changes to the latent encoding

Check it here: PrunaAI/PrunaVAED
sergiopaniego 
posted an update 7 days ago
view post
Post
2859
quick reminder! 🚨

tomorrow (Tuesday, July 28), we're back with Class 3 of the Training Agents live series

🧠 what: reinforcement learning for training agents (GRPO): how it works, how to implement it in TRL, and end-to-end examples
🗓️ when: Tuesday, July 28 - 🕔 5:00 PM CEST / 8:30 PM IST
📍 where: Live on @huggingface 's X, YouTube, and LinkedIn

live: https://www.youtube.com/watch?v=ztdTed5egrM

class 1: https://x.com/SergioPaniego/status/2069382207618379813
class 2: https://x.com/SergioPaniego/status/2075180665184686187
  • 1 reply
·
RiverRider 
posted an update 10 days ago
view post
Post
158
Train Once, Read Everywhere

Paper title:
Train Once, Read Everywhere: Substrate Invariance of the Linearly Readable Structure in Frozen Language Models

Paper URL:
https://github.com/space-bacon/SRT/blob/main/arxiv_program/paper.md

Repository URL:
https://github.com/space-bacon/SRT

The consolidated findings of the SRT research program are now available.

The program treats frozen production-scale language models as substrates whose internal states carry structure that small, inspectable instruments can read. Results include:

- A ~12 M-parameter adapter that surfaces per-token semiotic signals from a frozen 7 B backbone with zero cross-entropy degradation
- An activation verbalizer that recovers text from single hidden states up to a calibrated paraphrase ceiling
- Linear readout ports spanning dense 3 B models to 94-layer 235 B mixture-of-experts models
- A 22 MB linear head that gives a frozen multimodal chat model image-to-text retrieval performance matching fully trained 2018 dual encoders on the COCO benchmark

The central claim is substrate invariance. The readable structure is a stable property of the model class. A head trained once on one host reads, with no retraining and at most a 42 KB recalibration, across:

- Hosts ten times smaller (31 B → 3 B)
- 4-bit weight precision
- Entirely different silicon and kernels (CUDA/bf16 to Apple Silicon/MLX-Q4)

Deployment tiers differ in latency and cost, never in capability.

All instruments, measurement protocols, invariance evidence, negative results, and artifacts are in the repository.
sergiopaniego 
posted an update 10 days ago
view post
Post
189
you can now train your own coding agents with trl + openenv, starting with opencode

we just added end-to-end support for training agent harnesses:

> TRL: a loop-owning training path (AsyncGRPOTrainer + HarnessRolloutWorker) that launches the agent in an OpenEnv session, reads back its trace, reconstructs the training samples, and trains with AsyncGRPO
> OpenEnv: the OpenCode harness environment plus a transparent proxy that forwards the agent's model calls and records each turn's token ids and logprobs

you train the actual opencode agent as is, it runs its own loop and tools and the policy learns from the exact tokens it produced

we're shipping a self-contained example: local subprocess sandbox, DeepCoder problems, validated on Qwen3-8B.

> example: https://github.com/huggingface/trl/blob/main/examples/scripts/openenv/opencode.py
> docs: https://huggingface.co/docs/trl/main/openenv

and we're working actively on both sides so expect more 🤓
  • 1 reply
·
sergiopaniego 
posted an update 11 days ago
sergiopaniego 
posted an update 12 days ago
view post
Post
221
join us next Tuesday, July 28, for Class 3 of the Training Agents live series!

we'll dive into reinforcement learning for agent training, covering the intuition behind GRPO, how it works, and how to implement it in TRL with practical, e2e examples

see you there 🤠

live: https://www.youtube.com/live/ztdTed5egrM

> in case you missed class 1:
https://x.com/SergioPaniego/status/2069382207618379813
> and in case you missed class 2: https://x.com/SergioPaniego/status/2075180665184686187
osanseviero 
authored a paper 25 days ago
sergiopaniego 
posted an update 26 days ago
view post
Post
7732
Frontier models use distillation as a step of their post-training pipelines.

In 2026 it has three jobs: compress a big model into a small one, merge RL experts into a single model, and let a model teach itself.

I wrote up which frontier models use each one and how: https://huggingface.co/blog/sergiopaniego/distillation-2026

It pairs with Class 2 of the Training an Agent series Ben and I are doing, where we teach these techniques hands-on with TRL!
  • 3 replies
·
osanseviero 
submitted a paper to Daily Papers 27 days ago
suayptalha 
authored a paper 29 days ago
RiverRider 
posted an update about 1 month ago
view post
Post
162
🔮 Gemma-4-31B-it SRT-Sunstone

A read-out that reads images — trained only on words.

A 12.3M side-channel head on a frozen google/gemma-4-31B-it, taught meaning from text alone — to separate discourse communities in the residual stream. It never saw a single picture in training. Hand it a picture and it names what the image means, with zero image training.

Cross-modal transfer. Give it a photo and it lands next to the right words: bicycle → bicycle, rose → flower, dog → pet. It groups images by what they mean, not how they look: image→referent kNN 0.64 against chance 0.10.

Why this is a semiotic read-out, not an image classifier. A classifier is trained on labelled images and learns a fixed map from pixels to a closed label set; it only knows the labels it was shown. This read-out is different in kind. It never saw an image in training — it was trained only on text, to separate discourse communities in the residual stream of a frozen gemma-4-31B. It can interpret a picture because gemma-4 already fuses image and word into one representational stream, and the read-out taps the shared interpretant: the meaning a sign carries, whatever form it arrived in. So it does not classify the image. It tells you what the image means to a system that learned meaning from words — a transfer across modality, from a head that was never cross-trained. That is the result.

Each picture gets two readings: the words it means — the load-bearing evidence — and the discourse it evokes, the nearest of 35 communities it learned from text. Read the second as a flavour, not a category: cars into the automotive community, deer and mushrooms into gardening, cats and dogs into the cozy-domestic communities. Never a class label.

Scored offline through a frozen google/gemma-4-31B-it (62.5 GB, too large to run live)

Try it: RiverRider/srt-sunstone
Model: RiverRider/Gemma-4-31B-it-SRT-Sunstone
Code: https://github.com/space-bacon/SRT
jeffboudier 
posted an update about 1 month ago
bofenghuang 
authored 2 papers about 1 month ago
sergiopaniego 
posted an update about 1 month ago
sergiopaniego 
posted an update about 2 months ago
RiverRider 
posted an update about 2 months ago
view post
Post
277
SRT Showcase: Watch a Frozen Model Think, Token by Token

A frozen Qwen-2.5-7B now narrates its own interpretation in real time. SRT Showcase is the most complete public demonstration of computational semiotics to date, running the backbone with the SRT Adapter and Activation Verbalizer. As the model generates, every token is tinted by its predictive effort, and at the highest-effort positions the Verbalizer decodes the hidden state directly into natural language. You see what the model is representing at the exact moment its computation is most active.

Every verbalization is validated, not asserted. Each decoded thought is re-encoded and compared back to the original hidden state, and the reconstruction closely approximates it. The "this is what the model was thinking" claim carries its own fidelity badge. This is grounded introspection, not plausible narration.

The Showcase goes further than the trace. An A/B panel runs the same prompt with SRT injection on and off under an identical seed, so the side-channel's effect is directly observable. A curated gallery walks through confident recall, false premises, misconceptions, reasoning pivots, genuine uncertainty, and safety boundaries. Live entropy and divergence meters track the crystallization process token by token, with per-layer traces and reflexivity estimates on hover.

None of the backbone weights are touched. The entire mechanism is a lightweight reflexive layer over a frozen model, which is why the same read-out heads already port from Qwen-2.5-7B up to a 235B Mixture of Experts. Frozen models can now be verbalized in real time. No retraining. No fine-tuning. No black box.

First request is a brief cold start while ZeroGPU acquires a GPU. Bring your own prompt.

Try it: RiverRider/srt-showcase

Repository: https://github.com/space-bacon/SRT
shahrukhx01 
authored a paper about 2 months ago