Add Videoprism by MHRDYN7 · Pull Request #39895 · huggingface/transformers

MHRDYN7 · 2025-08-04T17:37:52Z

Fixes #39893. This pr adds the VideoPrism model by google deepmind. Original repo

MHRDYN7 · 2025-08-23T21:51:51Z

Summary of the code so far

The VideoPrismModel has been implemented using the modular code on top of Vivit and this is only a video encoder.
The code design is such that the same encoder code is reused as many times as possible.
Batches of video segments of shape (num_frames=16, H=288, W=288) are passed into the model and then the tubelet embedding class is used to convert each frame into hidden states of shape (256, 768) and therefore the whole input becomes (B*num_frame, 256, 768).
These spatial embeddings are passed into a spatial encoder
The outputs of the spatial encoder are reshaped to (B*256, num_frame, 768) and then passed into a temporal encoder
The attention function has an internal attention cap implemented in the modified eager_attention, not sure if this can be somehow used along with sdpa.
The VideoPrismClip model uses VideoPrismModel as a backbone for the video input, passes the embeddings through an auxiliary encoder then through an attention pooling layer.
There is also a standard text encoder that is called inside VideoPrismClip.
All the exact details from the original code have been extracted and correct tensors are being returned for both the models.

@qubvel I'd request your preliminary review on the current code structure. There are detailed comments with "# ?" for ease of review, these will be removed later on.

Todos:

Get started with the tests
Implement the video and text processors
Add code for the video classification model

** Please note that i am currently using the preprocessing utils from the original code in my convert_weights_to_hf script. The code uses mediapy, which uses lanczos interpolation for resizing videos by default. However, lanczos interpolation is not supported in torch yet and that's why we can't get the exact same outputs if a fast video processor is used.

** The videoprism team have not released the weights for the classification head.

** The weights released on hub are in npz format, safetensors need to be uploaded there.

…e fixed

…tokenizer

… exact values of jax.image.resize

qubvel

Hi @MHRDYN7, huge thanks for working on the model addition! You already did a great work, please see the comments to align it further to the transformers standards 🤗

qubvel · 2025-08-26T11:32:16Z

+@dataclass
+class TextEncoderOutput(ModelOutput):
+    """
+    Base class for text encoder outputs.
+    """
+
+    last_hidden_state: Optional[torch.FloatTensor] = None
+    hidden_states: Optional[tuple[torch.FloatTensor, ...]] = None
+    attentions: Optional[tuple[torch.FloatTensor, ...]] = None


This is just a common BaseModelOutput, no need to redefine it

qubvel · 2025-08-26T11:36:49Z

+        if self.mode == "spatial":
+            self.patch_embeddings = VideoPrismTubeletEmbeddings(config)
+            self.spatial_pos_emb = nn.Parameter(torch.zeros(1, self.pos_emb_shape[1] * self.pos_emb_shape[2], config.hidden_size))   # ? (1, 256, 768)
+
+        elif self.mode == "temporal":
+            self.temporal_pos_emb = nn.Parameter(torch.zeros(1, self.pos_emb_shape[0], config.hidden_size))  # ? (1, 16, 768)


Do we have checkpoint releases for both versions? Otherwise, please leave only one.

qubvel · 2025-08-26T11:38:13Z

+    def _interpolate_emb_2d(
+        self, emb: torch.Tensor, source_emb_shape: tuple[int, int], target_emb_shape: tuple[int, int]
+    ):


should be defined in interpolate_pos_encoding instead, no?

didn't use interpolate_pos_encoding because there are two different types interpolation for the pos embeds (spatial first then temporal). Now that the plan is to have two different embedding classes, I'll inherit from VivitEmbeddings for both and they both will have interpolate_pos_encoding method.

qubvel · 2025-08-26T11:40:41Z

+        with torch.no_grad():
+            self.layernorm_before.weight += nn.Parameter(
+                torch.ones(self.config.hidden_size)
+            )
+            self.layernorm_after.weight += nn.Parameter(
+                torch.ones(self.config.hidden_size)
+            )


That seems super strange to me. Why do we need this, is this correct? The operation is in-place, so after each forward pass, are we continuing to increase the weight?

I found it very strange too.

Here is the original code

https://github.com/google-deepmind/videoprism/blob/main/videoprism/layers.py#L182-L193

when direct_scale is set to False (this is always the case), +1 is added to the scale tensor of layernorm.

This code seems more like an attempt to ensure the layernorm scale factor is not zero during training. I can create an issue in the repo to confirm if they want this behavior during inference as well.

You are right that the hf code in the current form means that the layernorm scale will get increased by +1 for every iteration of forward pass. The jax code initializes the Layernorm class on the go just before it is called so this problem does not happen there. If this +1 portion is moved (from forward) to the init of the relevant class, then that does not work as I guess during creation of a model instance, the init methods are evoked with the initialized weights, and later the pretrained weights are placed and that's why +1 does not happen. I've been working with single forward passes of the model, so it's been fine, but this issue still needs to be resolved.

Ok, I suppose we must not modify weight inplace and define it as follows:

import torch import torch.nn as nn import torch.nn.functional as F class VideoPrismLayerNorm(nn.LayerNorm): def forward(self, input: torch.Tensor) -> torch.Tensor: return F.layer_norm( input, self.normalized_shape, self.weight + 1, self.bias, self.eps )

That should be equivalent, right?

Or in case +1 is only for initialization, we should not have it in modeling code, just in _init_weights method.
~~Please keep in mind that logits should match exactly (1e-3/1e-4) with the original implementation, and matching them should give you the right answer whether this addition is relevant~~

P.S. Just saw the message below 👍

alright, using F.layer_norm is a very good solution; I'll rename the weights and refactor the code. Also I got the confirmation from the videoprism team, scale = 0 for initialization, and the +1 is expected to be there.

qubvel · 2025-08-26T11:42:44Z

+        if mode == "spatial":
+            self.layer = nn.ModuleList([VideoPrismLayer(config) for _ in range(config.num_spatial_layers)])
+        elif mode == "temporal":
+            self.layer = nn.ModuleList([VideoPrismLayer(config) for _ in range(config.num_temporal_layers)])
+        elif mode == "auxiliary":
+            self.layer = nn.ModuleList([VideoPrismLayer(config) for _ in range(config.num_auxiliary_layers)])
+        elif mode == "unimodal":
+            self.layer = nn.ModuleList([VideoPrismLayer(config) for _ in range(config.num_unimodal_layers)])
+        else:
+            raise ValueError(f"Unknown mode: {mode}. Supported modes are: spatial, temporal, auxiliary and unimodal.")


I don't see any reason to split it into different if/else. We might have only one attribute num_layers and that's it

If we remove these conditionals, then we will need to set config.num_layers = config.num_spatial_layers, before instantiating the spatial encoder object and then config.num_layers = config.num_temporal_layers before temporal encoder in the model init. It's slightly less explicit, but, since you agreed with the change of config from python_gelu to relu in the init, I'll go ahead with this one too, and then the encoder can be directly used from vivit.

qubvel · 2025-08-26T11:50:45Z

+        with torch.no_grad():
+            self.layernorm.weight += nn.Parameter(torch.ones(self.config.hidden_size))


again, super strange

qubvel · 2025-08-26T11:52:20Z

+class PositionalEmbedding(nn.Module):
+    def __init__(self, config: VideoPrismConfig):
+        super().__init__()
+        self.hidden_size = config.hidden_size
+        self.min_timescale = 1
+        self.max_timescale = 10000
+
+    def forward(self, seq_length):
+        position = torch.arange(seq_length, dtype=torch.float32).unsqueeze(0)  # ? (1, seq_length)
+        num_timescales = self.hidden_size // 2
+
+        log_timescale_increment = math.log(
+            float(self.max_timescale) / float(self.min_timescale)  # ? log(10000/1) = ln(10000)
+        ) / torch.maximum(torch.tensor(num_timescales, dtype=torch.float32) - 1, torch.tensor(1))
+
+        inv_timescales = self.min_timescale * torch.exp(
+            torch.arange(num_timescales, dtype=torch.float32) * -log_timescale_increment
+        )
+
+        scaled_time = position.unsqueeze(-1) * inv_timescales.expand(1, 1, -1)
+
+        embs = torch.cat((torch.sin(scaled_time), torch.cos(scaled_time)), dim=-1)
+
+        return embs


align with the RoPE classes defined in transformers

qubvel · 2025-08-26T11:57:29Z

+        self.backbone = VideoPrismModel(config)
+        self.auxiliary_encoder = VideoPrismEncoder(config, mode="auxiliary")
+        self.contrastive_vision_pooler = VideoPrismMultiheadAttentionPoolingHead(config)
+        self.text_encoder = VideoPrismTextEncoder(config)


I assume we should have the following classes (similar to CLIP)

VideoPrismVideoModel

VideoPrismTextModel

please, align to this

qubvel · 2025-08-26T11:59:47Z

This should be refactored to follow mllama or dinov3_vit conversion script format. We should have a weights mapping dict and manipulate that

MHRDYN7 · 2025-08-27T10:58:28Z

The following notebooks are from the original repo and the expected values of the output tensors used to validate the HF implementation have been taken from here.
Video encoder model notebook
Video Text model notebook

Please note that the output tensors are slightly different for the larger models when a TPU is used. My expected tensor values are for the cpu.

Since the output of the final tensors (of HF code) matches that of the original code, the elements in the current code are aligned with the original implementation, despite that strange layernorm weight increase.

…refactor

…ctly

zucchini-nlp · 2026-04-01T18:16:55Z

run-slow: videoprism

github-actions · 2026-04-01T18:18:10Z

Workflow Run ⚙️

This comment contains run-slow, running the specified jobs:

models: ["models/videoprism"]
quantizations: []

github-actions · 2026-04-01T18:31:55Z

CI Results

Workflow Run ⚙️

Commit Info

Context	Commit	Description
RUN	bb19e5c0	workflow commit (merge commit)
PR	dd80ec0b	branch commit (from PR)
main	f38d6639	base commit (on `main`)

Model CI Report

❌ 3 new failed tests from this PR 😭

videoprism:
tests/models/videoprism/test_modeling_videoprism.py::VideoPrismModelIntegrationTest::test_videoprism_classification_model (✅ ⟹ ❌)
tests/models/videoprism/test_modeling_videoprism.py::VideoPrismModelIntegrationTest::test_videoprism_clip_model (✅ ⟹ ❌)
tests/models/videoprism/test_modeling_videoprism.py::VideoPrismModelIntegrationTest::test_videoprism_vision_model (✅ ⟹ ❌)

github-actions · 2026-04-02T06:08:49Z

[For maintainers] Suggested jobs to run (before merge)

run-slow: auto, videoprism, vivit

github-actions · 2026-04-02T06:12:58Z

[For maintainers] Suggested jobs to run (before merge)

run-slow: auto, videoprism, vivit

MHRDYN7 · 2026-04-02T06:51:42Z

@zucchini-nlp, I investigated the three failing tests on gpu to the core. There was really no issue (except one) so added the cuda logits in the tests. The tolerance might need to be changed as these values are on a L4 machine. Also, please note the the last slow tests skipped FA2 tests (although FA is enabled for the model), but on my machine the FA2 tests still have some logits that don't fall within the tolerances. Let me know if these FA tests are supposed to be skipped or not

zucchini-nlp · 2026-04-02T15:38:05Z

Yeah these tests usually fail due to numerical diff in hardware. We can help you get the correct expectations later on, so you can copy-paste

vasqu

Ok this is a long review but we may have to wait for the vit refactor first tbh (I've linked it somewhere in the review)

This goes over the modular code, not the tests yet. It's often little details to make this more aligned to what we have. A lot can also be done even before the refactor imo

vasqu · 2026-04-02T17:56:39Z

 # Video Processor

-A **Video Processor** is a utility responsible for preparing input features for video models, as well as handling the post-processing of their outputs. It provides transformations such as resizing, normalization, and conversion into PyTorch. Along ith transformations the `VideoProcessor` class handles video decoding from local paths or URLs (requires [`torchcodec`](https://pypi.org/project/torchcodec/)) and frame sampling according to model-specific strategies.
+A **Video Processor** is a utility responsible for preparing input features for video models, as well as handling the post-processing of their outputs. It provides transformations such as resizing, normalization, and conversion into PyTorch. Along with transformations, the `VideoProcessor` class also handles video decoding from local paths or URLs (requires [`torchcodec`](https://pypi.org/project/torchcodec/)) and frame sampling according to model-specific strategies.


Maybe better to move to a different docs PR

I'll remove it from this PR, but I have a suggestion. It would be very nice if a maintainer managed a running issue + pr to collect all these little typos from the community and merged these little improvements biweekly/monthly. This is perhaps a more organized solution than having a bunch of '2 line change' PRs and also does not discourage user to report such issues from time to time.

vasqu · 2026-04-02T17:57:03Z

@@ -0,0 +1,123 @@
+<!--Copyright 2025 The HuggingFace Team. All rights reserved.


Suggested change

<!--Copyright 2025 The HuggingFace Team. All rights reserved.

<!--Copyright 2026 The HuggingFace Team. All rights reserved.

it's been a while :D likely elsewhere marking once here only

vasqu · 2026-04-02T17:59:16Z

+processed_video_inputs = processor(videos=[video_url], return_metadata=True, do_sample_frames=True)
+video_metadata = processed_video_inputs["video_metadata"]
+video_inputs = processed_video_inputs["pixel_values_videos"]


Do we need to move the inputs to model.device? In case its cuda or similar, I suspect this would return cpu no?

vasqu · 2026-04-02T18:07:02Z

@@ -0,0 +1,1094 @@
+from collections.abc import Callable


licence missing

vasqu · 2026-04-02T18:07:20Z

@@ -0,0 +1,565 @@
+import argparse


vasqu · 2026-04-02T19:09:09Z

+        self.auxiliary_encoder = VideoPrismAuxiliaryEncoder(config)
+        self.contrastive_vision_pooler = VideoPrismMultiheadAttentionPoolingHead(config)


Why not merge these into one class? Or does it not make sense?

because contrastive_vision_pooler is also used in the video classification model.

vasqu · 2026-04-02T19:09:53Z

+        if not isinstance(config, VideoPrismConfig):
+            raise TypeError(f"`config` is expected to be of type `VideoPrismConfig` but is of type {type(config)}.")


Suggested change

if not isinstance(config, VideoPrismConfig):

raise TypeError(f"`config` is expected to be of type `VideoPrismConfig` but is of type {type(config)}.")

just makes the code harder to read

vasqu · 2026-04-02T19:10:47Z

+        if video_emb_dim != text_emb_dim:
+            raise ValueError(
+                f"Dimension of video ({video_emb_dim}) and text ({text_emb_dim}) embeddings must match for similarity computation."
+            )


Suggested change

if video_emb_dim != text_emb_dim:

raise ValueError(

f"Dimension of video ({video_emb_dim}) and text ({text_emb_dim}) embeddings must match for similarity computation."

)

I think youll notice I dont like to error out too much :D this would be a config issue then if anything

vasqu · 2026-04-02T19:13:06Z

+            nll = -torch.sum(loglik, dim=-1)
+            loss = nll.mean()
+
+        return VideoPrismClipOutput(


Imo we should follow siglip a bit closer and have pooler outputs it should then be mostly 1:1

vasqu · 2026-04-02T19:13:41Z

+            )
+        super().__init__(config)
+        self.config = config
+        self.encoder = VideoPrismVisionModel._from_config(self.config)


should match with base model prefix

you mean self.vision_model instead of self.encoder? ok will update the weights

github-actions · 2026-04-06T15:19:14Z

[For maintainers] Suggested jobs to run (before merge)

run-slow: auto, videoprism, vivit

github-actions · 2026-04-09T16:14:04Z

[For maintainers] Suggested jobs to run (before merge)

run-slow: auto, videoprism, vivit

github-actions · 2026-04-09T16:14:37Z

[For maintainers] Suggested jobs to run (before merge)

run-slow: auto, videoprism, vivit

MHRDYN7 · 2026-04-10T19:51:57Z

@vasqu thank you very much the detailed review. Certainly this PR needs to wait for the VIT refactor, which should help reduce LOC a lot. Many of the suggestions have been applied and in some cases, further consideration is required. Please see my comments and the reasoning.

In summary, the three key points to decide are

sdpa should stay or not (other models have kept it despite softcap)
MultiheadAttentionPoolingHead (This name has precedent + I'll implement this following the existing pattern phi4multimodal instead of your suggestions on top of my current implementation)
Possibly refactor ClipEmbedding model to accommodate sinusoidal pos embeds so that we can directly import that class in modular file. All the design issues pointed out here stem from that clip class and these propagate via copied from.

vasqu · 2026-04-15T10:19:21Z

@MHRDYN7 Answering your concerns here but will take a look at the vit refactor to get it in first 🫡

Imo, it kind of depends on the sensitivity of the model. We can keep it but then need to raise our tols and indicate that in our tests with proper comments why
Sounds good, if there is precedence I'd rather follow that then indeed. However, definitely the version that keeps the attention interface and does not use the nn.MultiHeadAttention from torch (it does not play nicely within our designs and should be avoided)
If it really is that different, dw about not having perfect modular there then. These are often ideas I have, not fool proof. I'd rather not force change clip for this

github-actions · 2026-04-21T09:43:25Z

[For maintainers] Suggested jobs to run (before merge)

run-slow: auto, videoprism, vivit

github-actions · 2026-04-21T09:58:10Z

View the CircleCI Test Summary for this PR:

https://huggingface.co/spaces/transformers-community/circle-ci-viz?pr=39895&sha=fe2226

vasqu · 2026-04-21T12:41:20Z

Just as a small update: The vit refactor is getting closer to the finish line. We are now just making sure to fix the last details and tests 🤗

MHRDYN7 · 2026-04-21T12:44:43Z

Just as a small update: The vit refactor is getting closer to the finish line. We are now just making sure to fix the last details and tests 🤗

yes I am monitoring that PR, will pull the changes as soon as it is merged with main

MHRDYN7 · 2026-04-21T17:08:24Z

@zucchini-nlp I tried to run the utils.check_auto.py script and there are some undesirable changes in auto_mappings.py like

- ("detr", "DetrConfig"),
+ ("detr", "MaskFormerDetrConfig"),

-("sam3_video", "Sam3VisionConfig"),
-("sam3_vit_model", "Sam3ViTConfig"),
+("sam3_vision_model", "Sam3LiteTextVisionConfig"),
+("sam3_vit_model", "Sam3LiteTextViTConfig"),

-("sam3_vision_model", "sam3"),
-("sam3_vit_model", "sam3"),
+("sam3_vision_model", "sam3_lite_text"),
+("sam3_vit_model", "sam3_lite_text"),

where the values get reassigned when newer models have the model_type of existing models.
The simple fix that prevents this is changing the following lines

transformers/utils/check_auto.py

Lines 99 to 101 in 85099df

    
           if model_type != module_name: 
        
               special_mappings[model_type] = module_name 
        
           model_type_map[model_type] = config_cls_name

to this

    if model_type != module_name:
        if model_type not in special_mappings:
            special_mappings[model_type] = module_name 

    if model_type not in model_type_map:
        model_type_map[model_type] = config_cls_name

This logic of checking existing key worked for me, but I haven't fully read all the other parts of the script. Please let me if the changes are to be made, and if in a separate short PR.

vasqu · 2026-04-21T17:27:07Z

possibly re #45535 cc @yonigozlan, we might need to override the model type in the configs(?). Seems like that branch was out of sync maybe with main

github-actions · 2026-04-22T07:23:07Z

[For maintainers] Suggested jobs to run (before merge)

run-slow: auto, videoprism, vivit

MHRDYN7 added 9 commits August 4, 2025 07:19

inference returns correct logits for base model

0a240be

modular code runs correctly

d50bbab

large backbone model added

ce461e4

a rough random forward pass

ac06354

converted and uploaded both lvt weights

b66cc62

updated lvt checkpoints, modeling code gives the correct logits for base

8e6766a

everything works fine with modular convertion at this point

34e1a28

standardization of the VideoPrismModel code

d702e88

Merge branch 'main' into videoprism

ec5ceeb

MHRDYN7 marked this pull request as ready for review August 23, 2025 21:08

github-actions Bot requested review from ArthurZucker and Rocketknight1 August 23, 2025 21:08

added base classes for model output holders, but signature needs to b…

46be807

…e fixed

ArthurZucker added the New model label Aug 25, 2025

correctly added slow videoprism tokenizer using modular on top of t5 …

87a67a8

…tokenizer

qubvel requested review from qubvel and removed request for ArthurZucker and Rocketknight1 August 25, 2025 10:54

MHRDYN7 added 2 commits August 25, 2025 19:34

temporal interpolation works fine but F.interpolate does not give the…

0d22817

… exact values of jax.image.resize

added fast tokenizer based on t5

e391f2c

qubvel reviewed Aug 26, 2025

View reviewed changes

MHRDYN7 mentioned this pull request Aug 27, 2025

Layernorm scale increase by +1 google-deepmind/videoprism#49

Open

MHRDYN7 added 6 commits August 28, 2025 17:04

Merge branch 'main' into videoprism

728a041

refactored code for VideoPrismModel runs fine on initialised weights

bee89bf

converted lvt base weights, but model outsputs are not correct after …

4452274

…refactor

perdimscale fixed and lvt base weights updated, inference works corre…

df17137

…ctly

refactored perdimscale + sinusoidal posemb to get correct lvt logits

c189df9

Merge branch 'main' into videoprism

6498fc3

added cuda logits in test file

e308526

Merge branch 'main' into videoprism

5f2af36

vasqu reviewed Apr 2, 2026

View reviewed changes

refactor 1

3117aa6

MHRDYN7 added 2 commits April 9, 2026 16:12

refactor 2

a2dc58b

Merge branch 'main' into videoprism

3ab9a10

MHRDYN7 added 2 commits April 21, 2026 09:34

refactor 3

0816237

Merge branch 'main' into videoprism

fe22261

MHRDYN7 added 2 commits April 22, 2026 07:20

correct cuda logits + eager logits for classification model

344f3ea

the main file which was not added to prev commit

28388c7

evalstate mentioned this pull request Apr 29, 2026

Cumulative feature and defect updates from recent Transformers PRs evalstate/transformers#42

Open

		with torch.no_grad():
		self.layernorm.weight += nn.Parameter(torch.ones(self.config.hidden_size))

		@@ -0,0 +1,123 @@
		<!--Copyright 2025 The HuggingFace Team. All rights reserved.

	<!--Copyright 2025 The HuggingFace Team. All rights reserved.
	<!--Copyright 2026 The HuggingFace Team. All rights reserved.

		self.auxiliary_encoder = VideoPrismAuxiliaryEncoder(config)
		self.contrastive_vision_pooler = VideoPrismMultiheadAttentionPoolingHead(config)

		if not isinstance(config, VideoPrismConfig):
		raise TypeError(f"`config` is expected to be of type `VideoPrismConfig` but is of type {type(config)}.")

Conversation

MHRDYN7 commented Aug 4, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

MHRDYN7 commented Aug 23, 2025

Summary of the code so far

Uh oh!

qubvel left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

qubvel Aug 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

qubvel Aug 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

MHRDYN7 Aug 28, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

MHRDYN7 commented Aug 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

zucchini-nlp commented Apr 1, 2026

Uh oh!

github-actions Bot commented Apr 1, 2026

Uh oh!

github-actions Bot commented Apr 1, 2026

CI Results

Commit Info

Model CI Report

Uh oh!

github-actions Bot commented Apr 2, 2026

Uh oh!

github-actions Bot commented Apr 2, 2026

Uh oh!

MHRDYN7 commented Apr 2, 2026

Uh oh!

zucchini-nlp commented Apr 2, 2026

Uh oh!

vasqu left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

MHRDYN7 commented Aug 4, 2025 •

edited

Loading

qubvel Aug 27, 2025 •

edited

Loading

qubvel Aug 27, 2025 •

edited

Loading

MHRDYN7 Aug 28, 2025 •

edited

Loading

MHRDYN7 commented Aug 27, 2025 •

edited

Loading

vasqu commented Apr 21, 2026 •

edited

Loading