Remove null values from fast image processors dict (#42780)

* remove null values from saved preporcessor file for fast image processor

* preserve explicit None values != class default

* Fix flava test

* extend to video processor

Author: yonigozlan

src/transformers/image_processing_utils_fast.py

@@ -936,6 +936,18 @@ def _preprocess(
 
     def to_dict(self):
         encoder_dict = super().to_dict()
-        encoder_dict.pop("_valid_processor_keys", None)
-        encoder_dict.pop("_valid_kwargs_names", None)
-        return encoder_dict
+
+        # Filter out None values that are class defaults, but preserve explicitly set None values
+        filtered_dict = {}
+        for key, value in encoder_dict.items():
+            if value is None:
+                class_default = getattr(type(self), key, "NOT_FOUND")
+                # Keep None if user explicitly set it (class default is non-None)
+                if class_default != "NOT_FOUND" and class_default is not None:
+                    filtered_dict[key] = value
+            else:
+                filtered_dict[key] = value
+
+        filtered_dict.pop("_valid_processor_keys", None)
+        filtered_dict.pop("_valid_kwargs_names", None)
+        return filtered_dict

src/transformers/video_processing_utils.py

@@ -770,11 +770,21 @@ def to_dict(self) -> dict[str, Any]:
             `dict[str, Any]`: Dictionary of all the attributes that make up this video processor instance.
         """
         output = deepcopy(self.__dict__)
-        output.pop("model_valid_processing_keys", None)
-        output.pop("_valid_kwargs_names", None)
-        output["video_processor_type"] = self.__class__.__name__
+        filtered_dict = {}
+        for key, value in output.items():
+            if value is None:
+                class_default = getattr(type(self), key, "NOT_FOUND")
+                # Keep None if user explicitly set it (class default is non-None)
+                if class_default != "NOT_FOUND" and class_default is not None:
+                    filtered_dict[key] = value
+            else:
+                filtered_dict[key] = value
+
+        filtered_dict.pop("model_valid_processing_keys", None)
+        filtered_dict.pop("_valid_kwargs_names", None)
+        filtered_dict["video_processor_type"] = self.__class__.__name__
 
-        return output
+        return filtered_dict
 
     def to_json_string(self) -> str:
         """

tests/models/flava/test_image_processing_flava.py

@@ -66,7 +66,6 @@ def __init__(
         image_std=FLAVA_IMAGE_STD,
         input_size_patches=14,
         total_mask_patches=75,
-        mask_group_max_patches=None,
         mask_group_min_patches=16,
         mask_group_min_aspect_ratio=0.3,
         mask_group_max_aspect_ratio=None,
@@ -103,7 +102,6 @@ def __init__(
 
         self.input_size_patches = input_size_patches
         self.total_mask_patches = total_mask_patches
-        self.mask_group_max_patches = mask_group_max_patches
         self.mask_group_min_patches = mask_group_min_patches
         self.mask_group_min_aspect_ratio = mask_group_min_aspect_ratio
         self.mask_group_max_aspect_ratio = mask_group_max_aspect_ratio
@@ -133,7 +131,6 @@ def prepare_image_processor_dict(self):
             "crop_size": self.crop_size,
             "input_size_patches": self.input_size_patches,
             "total_mask_patches": self.total_mask_patches,
-            "mask_group_max_patches": self.mask_group_max_patches,
             "mask_group_min_patches": self.mask_group_min_patches,
             "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
             "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,

tests/models/mask2former/test_image_processing_mask2former.py

@@ -57,7 +57,6 @@ def __init__(
         num_labels=10,
         do_reduce_labels=True,
         ignore_index=255,
-        pad_size=None,
     ):
         self.parent = parent
         self.batch_size = batch_size
@@ -70,7 +69,6 @@ def __init__(
         self.image_mean = image_mean
         self.image_std = image_std
         self.size_divisor = 0
-        self.pad_size = pad_size
         # for the post_process_functions
         self.batch_size = 2
         self.num_queries = 3
@@ -92,7 +90,6 @@ def prepare_image_processor_dict(self):
             "num_labels": self.num_labels,
             "do_reduce_labels": self.do_reduce_labels,
             "ignore_index": self.ignore_index,
-            "pad_size": self.pad_size,
         }
 
     def get_expected_values(self, image_inputs, batched=False):

tests/test_image_processing_common.py

@@ -341,9 +341,10 @@ def test_save_load_fast_slow(self):
         }
         dict_fast_0 = {key: dict_fast_0[key] for key in set(dict_fast_0) & set(dict_fast_1)}
         dict_fast_1 = {key: dict_fast_1[key] for key in set(dict_fast_0) & set(dict_fast_1)}
-        # check that all additional keys are None, except for `default_to_square` and `data_format` which are only set in fast processors
+        # Fast processors filter None values from to_dict(), so differences should only be special keys
         self.assertTrue(
-            all(value is None for key, value in difference.items() if key not in ["default_to_square", "data_format"])
+            all(key in ["default_to_square", "data_format"] for key in difference.keys()),
+            f"Fast processors should only differ in special keys, found: {list(difference.keys())}",
         )
         # check that the remaining keys are the same
         self.assertEqual(dict_fast_0, dict_fast_1)
@@ -391,9 +392,10 @@ def test_save_load_fast_slow_auto(self):
         }
         dict_fast_0 = {key: dict_fast_0[key] for key in set(dict_fast_0) & set(dict_fast_1)}
         dict_fast_1 = {key: dict_fast_1[key] for key in set(dict_fast_0) & set(dict_fast_1)}
-        # check that all additional keys are None, except for `default_to_square` and `data_format` which are only set in fast processors
+        # Fast processors filter None values from to_dict(), so differences should only be special keys
         self.assertTrue(
-            all(value is None for key, value in difference.items() if key not in ["default_to_square", "data_format"])
+            all(key in ["default_to_square", "data_format"] for key in difference.keys()),
+            f"Fast processors should only differ in special keys, found: {list(difference.keys())}",
         )
         # check that the remaining keys are the same
         self.assertEqual(dict_fast_0, dict_fast_1)
@@ -693,6 +695,37 @@ def _is_old_model_by_commit_date(model_type, date_cutoff=(2025, 9, 1)):
             f"a fast image processor implementation. Please implement the corresponding fast processor.",
         )
 
+    def test_fast_image_processor_explicit_none_preserved(self):
+        """Test that explicitly setting an attribute to None is preserved through save/load."""
+        if self.fast_image_processing_class is None:
+            self.skipTest("Skipping test as fast image processor is not defined")
+
+        # Find an attribute with a non-None class default to test explicit None override
+        test_attr = None
+        for attr in ["do_resize", "do_rescale", "do_normalize"]:
+            if getattr(self.fast_image_processing_class, attr, None) is not None:
+                test_attr = attr
+                break
+
+        if test_attr is None:
+            self.skipTest("Could not find a suitable attribute to test")
+
+        # Create processor with explicit None (override the attribute)
+        kwargs = self.image_processor_dict.copy()
+        kwargs[test_attr] = None
+        image_processor = self.fast_image_processing_class(**kwargs)
+
+        # Verify it's in to_dict() as None (not filtered out)
+        self.assertIn(test_attr, image_processor.to_dict())
+        self.assertIsNone(image_processor.to_dict()[test_attr])
+
+        # Verify explicit None survives save/load cycle
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            image_processor.save_pretrained(tmpdirname)
+            reloaded = self.fast_image_processing_class.from_pretrained(tmpdirname)
+
+        self.assertIsNone(getattr(reloaded, test_attr), f"Explicit None for {test_attr} was lost after reload")
+
 
 class AnnotationFormatTestMixin:
     # this mixin adds a test to assert that usages of the

tests/test_video_processing_common.py

@@ -167,6 +167,35 @@ def test_init_without_params(self):
             video_processor = video_processing_class()
             self.assertIsNotNone(video_processor)
 
+    def test_video_processor_explicit_none_preserved(self):
+        """Test that explicitly setting an attribute to None is preserved through save/load."""
+
+        # Find an attribute with a non-None class default to test explicit None override
+        test_attr = None
+        for attr in ["do_resize", "do_rescale", "do_normalize"]:
+            if getattr(self.fast_video_processing_class, attr, None) is not None:
+                test_attr = attr
+                break
+
+        if test_attr is None:
+            self.skipTest("Could not find a suitable attribute to test")
+
+        # Create processor with explicit None (override the attribute)
+        kwargs = self.video_processor_dict.copy()
+        kwargs[test_attr] = None
+        video_processor = self.fast_video_processing_class(**kwargs)
+
+        # Verify it's in to_dict() as None (not filtered out)
+        self.assertIn(test_attr, video_processor.to_dict())
+        self.assertIsNone(video_processor.to_dict()[test_attr])
+
+        # Verify explicit None survives save/load cycle
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            video_processor.save_pretrained(tmpdirname)
+            reloaded = self.fast_video_processing_class.from_pretrained(tmpdirname)
+
+        self.assertIsNone(getattr(reloaded, test_attr), f"Explicit None for {test_attr} was lost after reload")
+
     @slow
     @require_torch_accelerator
     @require_vision