Fix two transformers-v5 AttributeErrors in Florence-2 remote code

configuration_florence2.py

@@ -261,6 +261,7 @@ class Florence2LanguageConfig(PretrainedConfig):
             **kwargs,
         )
 
+        self.forced_bos_token_id = kwargs.get("forced_bos_token_id", None)
         # ensure backward compatibility for BART CNN models
         if self.forced_bos_token_id is None and kwargs.get("force_bos_token_to_be_generated", False):
             self.forced_bos_token_id = self.bos_token_id

modeling_florence2.py

@@ -2194,7 +2194,13 @@ class Florence2LanguageForConditionalGeneration(Florence2LanguagePreTrainedModel
     ):
         # cut decoder_input_ids if past_key_values is used
         if past_key_values is not None:
-            past_length = past_key_values[0][0].shape[2]
+            # past_key_values is a Cache object (e.g. EncoderDecoderCache) in current
+            # transformers, not the legacy tuple-of-tuples this code was written for --
+            # it isn't subscriptable, but every Cache subclass implements get_seq_length()
+            if hasattr(past_key_values, "get_seq_length"):
+                past_length = past_key_values.get_seq_length()
+            else:
+                past_length = past_key_values[0][0].shape[2]
 
             # Some generation methods already pass only the last input ID
             if decoder_input_ids.shape[1] > past_length:
@@ -2335,17 +2341,26 @@ class Florence2PreTrainedModel(PreTrainedModel):
     def _supports_flash_attn_2(self):
         """
         Retrieve language_model's attribute to check whether the model supports
-        Flash Attention 2 or not.
+        Flash Attention 2 or not. PreTrainedModel.__init__ reads this before
+        self.language_model is assigned (it's set partway through this class's
+        own __init__, after super().__init__() runs), so fall back to the
+        constant Florence2LanguageForConditionalGeneration always declares.
         """
-        return self.language_model._supports_flash_attn_2
+        language_model = getattr(self, "language_model", None)
+        if language_model is None:
+            return True
+        return language_model._supports_flash_attn_2
 
     @property
     def _supports_sdpa(self):
         """
         Retrieve language_model's attribute to check whether the model supports
-        SDPA or not.
+        SDPA or not. Same early-access issue as _supports_flash_attn_2 above.
         """
-        return self.language_model._supports_sdpa
+        language_model = getattr(self, "language_model", None)
+        if language_model is None:
+            return True
+        return language_model._supports_sdpa
 
 
 FLORENCE2_INPUTS_DOCSTRING = r"""
@@ -2814,7 +2829,13 @@ class Florence2ForConditionalGeneration(Florence2PreTrainedModel):
     ):
         # cut decoder_input_ids if past_key_values is used
         if past_key_values is not None:
-            past_length = past_key_values[0][0].shape[2]
+            # past_key_values is a Cache object (e.g. EncoderDecoderCache) in current
+            # transformers, not the legacy tuple-of-tuples this code was written for --
+            # it isn't subscriptable, but every Cache subclass implements get_seq_length()
+            if hasattr(past_key_values, "get_seq_length"):
+                past_length = past_key_values.get_seq_length()
+            else:
+                past_length = past_key_values[0][0].shape[2]
 
             # Some generation methods already pass only the last input ID
             if decoder_input_ids.shape[1] > past_length:

processing_florence2.py

@@ -86,7 +86,9 @@ class Florence2Processor(ProcessorMixin):
 
         tokens_to_add = {
                 'additional_special_tokens': \
-                    tokenizer.additional_special_tokens + \
+                    (getattr(tokenizer, "extra_special_tokens", None)
+                     if getattr(tokenizer, "extra_special_tokens", None) is not None
+                     else getattr(tokenizer, "additional_special_tokens", [])) + \
                     ['<od>', '</od>', '<ocr>', '</ocr>'] + \
                     [f'<loc_{x}>' for x in range(1000)] + \
                     ['<cap>', '</cap>', '<ncap>', '</ncap>','<dcap>', '</dcap>', '<grounding>', '</grounding>', '<seg>', '</seg>', '<sep>', '<region_cap>', '</region_cap>', '<region_to_desciption>', '</region_to_desciption>', '<proposal>', '</proposal>', '<poly>', '</poly>', '<and>']
@@ -249,17 +251,29 @@ class Florence2Processor(ProcessorMixin):
         elif isinstance(text, list) and _is_str_or_image(text[0]):
             pass
 
+        # None-valued kwargs must not be forwarded: this image processor treats an
+        # explicit None as "disable this feature" rather than "use the configured
+        # default", so passing do_resize=None (the default here when the caller
+        # doesn't override it) silently skips resizing -- and do_normalize=None
+        # silently skips normalization, with no error either way.
+        image_processor_overrides = {
+            k: v
+            for k, v in {
+                "do_resize": do_resize,
+                "do_normalize": do_normalize,
+                "image_mean": image_mean,
+                "image_std": image_std,
+                "input_data_format": input_data_format,
+                "resample": resample,
+                "do_convert_rgb": do_convert_rgb,
+            }.items()
+            if v is not None
+        }
         pixel_values = self.image_processor(
             images,
-            do_resize=do_resize,
-            do_normalize=do_normalize,
             return_tensors=return_tensors,
-            image_mean=image_mean,
-            image_std=image_std,
-            input_data_format=input_data_format,
             data_format=data_format,
-            resample=resample,
-            do_convert_rgb=do_convert_rgb,
+            **image_processor_overrides,
         )["pixel_values"]
 
         if max_length is not None: