fix: compatibility patches for newer transformers (4.50+ / 5.x)

## Summary

Compatibility patches for newer `transformers` versions (4.50+ / 5.x) that broke Florence-2's custom code. Each fix is a minimal `getattr`/wrapper-style change that preserves behavior on older transformers while not crashing on newer ones.

## Changes

### 1. `configuration_florence2.py` — `forced_bos_token_id` access
Newer transformers no longer auto-creates `forced_bos_token_id` on `PretrainedConfig` subclasses, causing `AttributeError` during `Florence2LanguageConfig.__init__`. Wrap with `getattr(self, "forced_bos_token_id", None)` for safe access.

### 2. `modeling_florence2.py` — `torch.linspace().item()` on meta tensors
Newer transformers instantiates the model on the `meta` device first (lazy loading), then materializes weights. The DaViT vision tower's `__init__` calls `[x.item() for x in torch.linspace(...)]` which fails on meta tensors. Replaced with pure-Python list comprehension that doesn't touch tensors during init.

### 3. `modeling_florence2.py` — `_supports_sdpa` / `_supports_flash_attn_2` properties
These were `@property` methods that delegated to `self.language_model._supports_sdpa`. But during `super().__init__()` (parent class init), `self.language_model` doesn't exist yet, causing `AttributeError`. Replaced with class-level attributes (`_supports_sdpa = True`, `_supports_flash_attn_2 = False`) since the support state is known at class definition.

### 4. `processing_florence2.py` — `tokenizer.additional_special_tokens` access
Newer transformers `RobertaTokenizer` (and others) no longer expose `additional_special_tokens` as a direct attribute. Use `getattr(tokenizer, 'additional_special_tokens', [])` for safe access with empty-list fallback.

## Caveat / Known Limitation

These patches resolve the **Python-level** errors during model loading. There remains a CUDA-level segfault during the SDPA forward pass with `transformers 5.x` + `torch 2.10+` — that's a deeper compatibility issue with the language model's SDPA attention path that this PR does not address. As a workaround, users on transformers 5.x can use `attn_implementation="eager"` to avoid the SDPA path entirely.

For users on `transformers <= 4.49`, these 4 patches are sufficient for Florence-2 to work correctly with newer attribute access patterns.

## Tested with
- transformers 4.49.0 + torch 2.11.0+cu128 + CUDA 12.8 — works
- transformers 5.5.0 — Python errors fixed by these patches, but separate CUDA SDPA crash remains (not addressed here)

configuration_florence2.py

@@ -262,7 +262,7 @@ class Florence2LanguageConfig(PretrainedConfig):
         )
 
         # 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):
+        if getattr(self, "forced_bos_token_id", None) is None and kwargs.get("force_bos_token_to_be_generated", False):
             self.forced_bos_token_id = self.bos_token_id
             warnings.warn(
                 f"Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. "

modeling_florence2.py

@@ -554,7 +554,13 @@ class DaViT(nn.Module):
         assert self.num_stages == len(self.num_heads) == len(self.num_groups)
 
         num_stages = len(embed_dims)
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths)*2)]
+        _n_dpr = sum(depths) * 2
+        if _n_dpr == 0:
+            dpr = []
+        elif _n_dpr == 1:
+            dpr = [0.0]
+        else:
+            dpr = [drop_path_rate * i / (_n_dpr - 1) for i in range(_n_dpr)]
 
         depth_offset = 0
         convs = []
@@ -2331,21 +2337,8 @@ class Florence2PreTrainedModel(PreTrainedModel):
     supports_gradient_checkpointing = True
     _skip_keys_device_placement = "past_key_values"
 
-    @property
-    def _supports_flash_attn_2(self):
-        """
-        Retrieve language_model's attribute to check whether the model supports
-        Flash Attention 2 or not.
-        """
-        return self.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.
-        """
-        return self.language_model._supports_sdpa
+    _supports_flash_attn_2 = False
+    _supports_sdpa = True
 
 
 FLORENCE2_INPUTS_DOCSTRING = r"""

processing_florence2.py

@@ -84,7 +84,7 @@ class Florence2Processor(ProcessorMixin):
 
         tokens_to_add = {
                 'additional_special_tokens': \
-                    tokenizer.additional_special_tokens + \
+                    list(getattr(tokenizer, 'additional_special_tokens', []) or []) + \
                     ['<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>']