Upload folder using huggingface_hub

.hfd/last_download_command

@@ -0,0 +1 @@
+REPO_ID=YannQi/R-4B TOOL=aria2c INCLUDE_PATTERNS= EXCLUDE_PATTERNS= DATASET=0 HF_USERNAME= HF_TOKEN= HF_TOKEN=https://huggingface.co REVISION=main

.hfd/repo_metadata.json

@@ -0,0 +1 @@
+{"_id":"6899c7b833b8a4a0398a0ed2","id":"YannQi/R-4B","private":false,"pipeline_tag":"visual-question-answering","tags":["safetensors","R","visual-question-answering","custom_code","en","base_model:Qwen/Qwen3-4B","base_model:finetune:Qwen/Qwen3-4B","license:apache-2.0","region:us"],"downloads":0,"likes":3,"modelId":"YannQi/R-4B","author":"YannQi","sha":"9fcd58d9d7b03add99ea92df619b24fa60a0e1ac","lastModified":"2025-08-11T11:55:23.000Z","gated":false,"disabled":false,"model-index":null,"config":{"auto_map":{"AutoConfig":"configuration_r.RConfig","AutoModel":"modeling_r.RForConditionalGeneration","AutoModelForCausalLM":"modeling_r.RForConditionalGeneration"},"architectures":["RForConditionalGeneration"],"model_type":"R","tokenizer_config":{"bos_token":null,"eos_token":"<|im_end|>","pad_token":"<|endoftext|>","unk_token":null},"chat_template_jinja":"{% for message in messages %}{{'<|im_start|>' + message['role'] + '\n'}}{# Render all images first #}{% for content in message['content'] | selectattr('type', 'equalto', 'image') %}{{ '<image>\n' }}{% endfor %}{# Render all video then #}{% for content in message['content'] | selectattr('type', 'equalto', 'video') %}{{ '<video>\n' }}{% endfor %}{# Render all text next #}{% if message['role'] != 'assistant' %}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{{ content['text'] }}{% endfor %}{% else %}{% for content in message['content'] | selectattr('type', 'equalto', 'text') %}{% generation %}{{ content['text'] }}{% endgeneration %}{% endfor %}{% endif %}{{'<|im_end|>' + '\n'}}{% endfor %}{% if add_generation_prompt %}{{ '<|im_start|>assistant\n<think>' }}{% endif %}{%- if add_generation_prompt %}{%- if thinking_mode is defined and thinking_mode == 'short' %}{{- '\n\n</think>\n\n' }}{%- endif %}{%- if thinking_mode is defined and thinking_mode == 'long' %}{{- '\n' }}{%- endif %}{%- endif %}\n"},"cardData":{"license":"apache-2.0","language":["en"],"base_model":["Qwen/Qwen3-4B"],"pipeline_tag":"visual-question-answering"},"siblings":[{"rfilename":".gitattributes"},{"rfilename":"README.md"},{"rfilename":"added_tokens.json"},{"rfilename":"asset/R-4B.png"},{"rfilename":"asset/performance.png"},{"rfilename":"chat_template.jinja"},{"rfilename":"config.json"},{"rfilename":"configuration_r.py"},{"rfilename":"generation_config.json"},{"rfilename":"image_processing_r.py"},{"rfilename":"image_processing_r_fast.py"},{"rfilename":"merges.txt"},{"rfilename":"model-00001-of-00003.safetensors"},{"rfilename":"model-00002-of-00003.safetensors"},{"rfilename":"model-00003-of-00003.safetensors"},{"rfilename":"model.safetensors.index.json"},{"rfilename":"modeling_r.py"},{"rfilename":"preprocessor_config.json"},{"rfilename":"processing_r.py"},{"rfilename":"processor_config.json"},{"rfilename":"special_tokens_map.json"},{"rfilename":"tokenizer.json"},{"rfilename":"tokenizer_config.json"},{"rfilename":"video_preprocessor_config.json"},{"rfilename":"vocab.json"}],"spaces":[],"createdAt":"2025-08-11T10:36:40.000Z","safetensors":{"parameters":{"BF16":4819012384},"total":4819012384},"usedStorage":9653302738}

configuration_r.py

@@ -27,7 +27,6 @@ class RConfig(PretrainedConfig):
     model_type = "R"
     attribute_map = {
         "image_token_id": "image_token_index",
-        "video_token_id": "video_token_index",
     }
     sub_configs = {"text_config": AutoConfig, "vision_config": AutoConfig}
 
@@ -36,7 +35,6 @@ class RConfig(PretrainedConfig):
         vision_config=None,
         text_config=None,
         image_token_index=151646,
-        video_token_index=151647,
         projector_hidden_act="gelu",
         vision_feature_select_strategy="full",
         vision_feature_layer=-1,
@@ -48,7 +46,6 @@ class RConfig(PretrainedConfig):
         **kwargs,
     ):
         self.image_token_index = image_token_index
-        self.video_token_index = video_token_index
         self.projector_hidden_act = projector_hidden_act
         self.multimodal_projector_bias = multimodal_projector_bias
 

modeling_r.py

@@ -44,8 +44,6 @@ class RModelOutputWithPast(BaseModelOutputWithPast):
 
     image_hidden_states: Optional[torch.FloatTensor] = None
 
-    video_hidden_states: Optional[torch.FloatTensor] = None
-
 
 @dataclass
 class RCausalLMOutputWithPast(ModelOutput):
@@ -57,8 +55,6 @@ class RCausalLMOutputWithPast(ModelOutput):
     attentions: Optional[tuple[torch.FloatTensor]] = None
     image_hidden_states: Optional[torch.FloatTensor] = None
 
-    video_hidden_states: Optional[torch.FloatTensor] = None
-
 
 class RPooler(nn.Module):
     def __init__(self, config):
@@ -364,8 +360,6 @@ class RModel(RPreTrainedModel):
         input_ids: torch.LongTensor = None,
         pixel_values: torch.FloatTensor = None,
         image_sizes: Optional[torch.LongTensor] = None,
-        pixel_values_videos: torch.FloatTensor = None,
-        image_sizes_videos: Optional[torch.LongTensor] = None,
         attention_mask: Optional[torch.Tensor] = None,
         position_ids: Optional[torch.LongTensor] = None,
         past_key_values: Optional[list[torch.FloatTensor]] = None,
@@ -403,9 +397,9 @@ class RModel(RPreTrainedModel):
         if (input_ids is None) ^ (inputs_embeds is not None):
             raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
 
-        if (pixel_values is not None or pixel_values_videos is not None) and inputs_embeds is not None:
+        if pixel_values is not None and inputs_embeds is not None:
             raise ValueError(
-                "You cannot specify both `pixel_values`/`pixel_values_videos` and `inputs_embeds` at the same time, "
+                "You cannot specify both `pixel_values` and `inputs_embeds` at the same time, "
                 "and must specify either one"
             )
         if inputs_embeds is None:
@@ -434,30 +428,6 @@ class RModel(RPreTrainedModel):
             image_features = image_features.to(inputs_embeds.device, inputs_embeds.dtype)
             inputs_embeds = inputs_embeds.masked_scatter(special_image_mask, image_features)
 
-        # Video are simply embedded and further pooled to decrease seq len
-        if pixel_values_videos is not None:
-            video_features = self.get_video_features(
-                pixel_values_videos,
-                vision_feature_layer=vision_feature_layer,
-                vision_feature_select_strategy=vision_feature_select_strategy,
-            )
-            image_newline = (
-                self.image_newline[None, None, :].repeat(video_features.shape[0], 1, 1).to(video_features.device)
-            )
-            video_features = torch.cat((video_features, image_newline), dim=1)
-            video_features = video_features.flatten(0, 1)
-
-            special_video_mask = (input_ids == self.config.video_token_id).unsqueeze(-1)
-            special_video_mask = special_video_mask.expand_as(inputs_embeds).to(inputs_embeds.device)
-            if not is_torchdynamo_compiling() and inputs_embeds[special_video_mask].numel() != video_features.numel():
-                n_video_tokens = (input_ids == self.config.video_token_id).sum()
-                n_video_features = video_features.shape[0]
-                raise ValueError(
-                    f"Video features and video tokens do not match: tokens: {n_video_tokens}, features {n_video_features}"
-                )
-            video_features = video_features.to(inputs_embeds.device, inputs_embeds.dtype)
-            inputs_embeds = inputs_embeds.masked_scatter(special_video_mask, video_features)
-
         outputs = self.language_model(
             attention_mask=attention_mask,
             position_ids=position_ids,
@@ -477,7 +447,6 @@ class RModel(RPreTrainedModel):
             hidden_states=outputs.hidden_states,
             attentions=outputs.attentions,
             image_hidden_states=image_features if pixel_values is not None else None,
-            video_hidden_states=video_features if pixel_values_videos is not None else None,
         )
 
     def apply_pooling(self, image_features):
@@ -494,36 +463,6 @@ class RModel(RPreTrainedModel):
         image_features = image_features.view(batch_frames, -1, dim)
         return image_features
 
-    def get_video_features(
-        self,
-        pixel_values: torch.FloatTensor,
-        vision_feature_layer: Union[int, list[int]],
-        vision_feature_select_strategy: str,
-    ):
-        batch_size, frames, channels, height, width = pixel_values.shape
-        pixel_values = pixel_values.view(batch_size * frames, channels, height, width)
-        video_features = self.vision_tower(pixel_values, output_hidden_states=True)
-
-        # If we have one vision feature layer, return the corresponding hidden states,
-        # otherwise, select the hidden states of each feature layer and concatenate them
-        if isinstance(vision_feature_layer, int):
-            selected_video_feature = video_features.hidden_states[vision_feature_layer]
-        else:
-            hs_pool = [video_features.hidden_states[layer_idx] for layer_idx in vision_feature_layer]
-            selected_video_feature = torch.cat(hs_pool, dim=-1)
-
-        if vision_feature_select_strategy == "default":
-            selected_video_feature = selected_video_feature[:, 1:]
-        elif vision_feature_select_strategy == "full":
-            selected_video_feature = selected_video_feature
-        video_features = self.multi_modal_projector(selected_video_feature)
-
-        video_features = self.apply_pooling(video_features)
-        video_features = video_features.reshape(batch_size, frames * video_features.shape[1], -1)
-
-        return video_features
-
-
 class RForConditionalGeneration(RPreTrainedModel, GenerationMixin):
     _checkpoint_conversion_mapping = {
         "^language_model.model": "model.language_model",
@@ -599,8 +538,6 @@ class RForConditionalGeneration(RPreTrainedModel, GenerationMixin):
         input_ids: torch.LongTensor = None,
         pixel_values: torch.FloatTensor = None,
         image_sizes: Optional[torch.LongTensor] = None,
-        pixel_values_videos: torch.FloatTensor = None,
-        image_sizes_videos: Optional[torch.LongTensor] = None,
         attention_mask: Optional[torch.Tensor] = None,
         position_ids: Optional[torch.LongTensor] = None,
         past_key_values: Optional[list[torch.FloatTensor]] = None,
@@ -641,9 +578,7 @@ class RForConditionalGeneration(RPreTrainedModel, GenerationMixin):
         outputs = self.model(
             input_ids=input_ids,
             pixel_values=pixel_values,
-            pixel_values_videos=pixel_values_videos,
             image_sizes=image_sizes,
-            image_sizes_videos=image_sizes_videos,
             vision_aspect_ratio=vision_aspect_ratio,
             vision_feature_layer=vision_feature_layer,
             vision_feature_select_strategy=vision_feature_select_strategy,
@@ -679,7 +614,6 @@ class RForConditionalGeneration(RPreTrainedModel, GenerationMixin):
             hidden_states=outputs.hidden_states,
             attentions=outputs.attentions,
             image_hidden_states=outputs.image_hidden_states,
-            video_hidden_states=outputs.video_hidden_states,
         )
 
     def prepare_inputs_for_generation(
@@ -689,8 +623,6 @@ class RForConditionalGeneration(RPreTrainedModel, GenerationMixin):
         inputs_embeds=None,
         pixel_values=None,
         image_sizes=None,
-        pixel_values_videos=None,
-        image_sizes_videos=None,
         attention_mask=None,
         cache_position=None,
         logits_to_keep=None,
@@ -713,8 +645,6 @@ class RForConditionalGeneration(RPreTrainedModel, GenerationMixin):
             # Otherwise we need pixel values to be passed to model
             model_inputs["pixel_values"] = pixel_values
             model_inputs["image_sizes"] = image_sizes
-            model_inputs["pixel_values_videos"] = pixel_values_videos
-            model_inputs["image_sizes_videos"] = image_sizes_videos
 
         return model_inputs
 
@@ -754,17 +684,5 @@ class RForConditionalGeneration(RPreTrainedModel, GenerationMixin):
 
         return causal_mask
 
-    def get_video_features(
-        self,
-        pixel_values: torch.FloatTensor,
-        vision_feature_layer: Optional[Union[int, list[int]]] = None,
-        vision_feature_select_strategy: Optional[str] = None,
-    ):
-        return self.model.get_video_features(
-            pixel_values=pixel_values,
-            vision_feature_layer=vision_feature_layer,
-            vision_feature_select_strategy=vision_feature_select_strategy,
-        )
-
 
 __all__ = ["RModel", "RForConditionalGeneration", "RPreTrainedModel"]

processing_r.py

@@ -36,61 +36,49 @@ class RProcessorKwargs(ProcessingKwargs, total=False):
 
         },
         "image_kwargs": {},
-        "videos_kwargs": {},
     }
 
 
 class RProcessor(ProcessorMixin):
-    attributes = ["image_processor", "tokenizer", "video_processor"]
+    attributes = ["image_processor", "tokenizer"]
     valid_kwargs = [
         "chat_template",
         "num_image_tokens",
         "image_processor_type",
         "vision_feature_select_strategy",
         "image_token",
-        "video_token",
         "vision_aspect_ratio",
     ]
     image_processor_class = "AutoImageProcessor"
     tokenizer_class = "AutoTokenizer"
-    video_processor_class = "AutoVideoProcessor"
 
     def __init__(
         self,
         image_processor=None,
         tokenizer=None,
-        video_processor=None,
         num_image_tokens=None,
         vision_feature_select_strategy=None,
         chat_template=None,
         image_token="<image>",
-        video_token="<video>",
         vision_aspect_ratio= "anyres",
         **kwargs,
     ):
         self.num_image_tokens = num_image_tokens
         self.vision_feature_select_strategy = vision_feature_select_strategy
         self.image_token = tokenizer.image_token if hasattr(tokenizer, "image_token") else image_token
-        self.video_token = tokenizer.video_token if hasattr(tokenizer, "video_token") else video_token
         self.image_token_id = (
             tokenizer.image_token_id
             if getattr(tokenizer, "image_token_id", None)
             else tokenizer.convert_tokens_to_ids(self.image_token)
         )
-        self.video_token_id = (
-            tokenizer.video_token_id
-            if getattr(tokenizer, "video_token_id", None)
-            else tokenizer.convert_tokens_to_ids(self.video_token)
-        )
         self.vision_aspect_ratio = vision_aspect_ratio
-        super().__init__(image_processor, tokenizer, video_processor, chat_template=chat_template)
+        super().__init__(image_processor, tokenizer, chat_template=chat_template)
 
     def __call__(
         self,
         images: ImageInput = None,
         text: Union[TextInput, PreTokenizedInput, list[TextInput], list[PreTokenizedInput]] = None,
         audio=None,
-        videos=None,
         **kwargs: Unpack[RProcessorKwargs],
     ) -> BatchFeature:
         output_kwargs = self._merge_kwargs(
@@ -104,7 +92,7 @@ class RProcessor(ProcessorMixin):
         elif not isinstance(text, list) and not isinstance(text[0], str):
             raise ValueError("Invalid input text. Please provide a string, or a list of strings")
 
-        image_inputs = video_inputs = {}
+        image_inputs = {}
 
         if images is not None:
             image_inputs = self.image_processor(images, **output_kwargs["images_kwargs"])
@@ -119,28 +107,13 @@ class RProcessor(ProcessorMixin):
                 text, image_sizes, height, width, self.image_token, batch_num_images
             )
 
-        if videos is not None:
-            video_inputs = self.video_processor(videos, **output_kwargs["videos_kwargs"])
-
-            one_video = video_inputs.get("pixel_values_videos")[0]
-            if isinstance(video_inputs.get("pixel_values_videos")[0], (list, tuple)):
-                one_video = np.array(one_video)
-            else:
-                one_video = to_numpy_array(one_video)
-            height, width = get_image_size(one_video[0], channel_dim=output_kwargs["images_kwargs"].get("data_format"))
-            num_frames = one_video.shape[0]  # frame dim is always after batch dim
-            patches_height_width = int(math.sqrt(self.num_image_tokens))
-            pooled_height_width = math.ceil(patches_height_width / 2)
-            num_video_tokens = (num_frames * pooled_height_width * pooled_height_width) + 1  # +1 for newline token
-            text = [sample.replace(self.video_token, self.video_token * num_video_tokens) for sample in text] 
-
         return_tensors = output_kwargs["text_kwargs"].pop("return_tensors", None)
         
         text_inputs = self.tokenizer(text, **output_kwargs["text_kwargs"])
         self._check_special_mm_tokens(text, text_inputs, modalities=["image"])
 
     
-        return BatchFeature(data={**text_inputs, **image_inputs, **video_inputs}, tensor_type=return_tensors)
+        return BatchFeature(data={**text_inputs, **image_inputs}, tensor_type=return_tensors)
 
     def _expand_image_tokens(
         self,