Upload processor

preprocessor_config.json

@@ -2,24 +2,7 @@
   "auto_map": {
     "AutoImageProcessor": "preprocessor_lenet.LeNetProcessor"
   },
-  "crop_size": null,
-  "data_format": "channels_first",
-  "default_to_square": true,
-  "device": null,
-  "disable_grouping": null,
-  "do_center_crop": null,
-  "do_convert_rgb": null,
-  "do_normalize": null,
-  "do_pad": null,
-  "do_rescale": null,
-  "do_resize": null,
-  "image_mean": null,
   "image_processor_type": "LeNetProcessor",
-  "image_std": null,
-  "input_data_format": null,
-  "pad_size": null,
-  "resample": null,
-  "rescale_factor": 0.00392156862745098,
-  "return_tensors": null,
-  "size": null
+  "mean": 0.1307,
+  "std": 0.3081
 }

preprocessor_lenet.py

@@ -1,20 +1,36 @@
-from transformers import BaseImageProcessorFast, BatchFeature
+import numpy as np
+from PIL import Image
+from transformers import BaseImageProcessor, BatchFeature
 from transformers.image_transforms import (
     normalize, 
+    to_channel_dimension_format
 )
 from transformers.image_utils import (
     ImageInput, 
-    to_numpy_array,
+    ChannelDimension
 )
 
-class LeNetProcessor(BaseImageProcessorFast):
+class LeNetProcessor(BaseImageProcessor):
+    """
+    A custom processor that only normalizes a grayscale image
+    and prepares it for a model.
+    """
     model_input_names = ["pixel_values"]
 
     def __init__(
         self,
+        mean: float = 0.1307,
+        std: float = 0.3081,
         **kwargs
     ):
+        """
+        Args:
+            mean (float): The mean to use for normalization.
+            std (float): The std dev to use for normalization.
+        """
         super().__init__(**kwargs)
+        self.mean = mean
+        self.std = std
 
     def preprocess(
         self,
@@ -22,15 +38,62 @@ class LeNetProcessor(BaseImageProcessorFast):
         return_tensors=None,
         **kwargs
     ) -> BatchFeature:
+        class GrayscaleNormalizeProcessor(BaseImageProcessor):
+            """
+            A custom processor that only normalizes a grayscale image
+            and prepares it for a model.
+            """
+            model_input_names = ["pixel_values"]
         
-        if not isinstance(images, list):
-            images = [images]
-
-        images = [to_numpy_array(img) for img in images]
-
-        processed_images = []
-        for img in images:
-            processed_images.append(normalize(img, mean=0.1307, std=0.3081))
-
-        data = {"pixel_values": processed_images}
-        return BatchFeature(data=data, tensor_type=return_tensors)
+            def __init__(
+                self,
+                mean: float = 0.5,
+                std: float = 0.5,
+                **kwargs
+            ):
+                super().__init__(**kwargs)
+                self.mean = mean
+                self.std = std
+        
+            def preprocess(
+                self,
+                images: ImageInput,
+                return_tensors=None,
+                **kwargs
+            ) -> BatchFeature:
+                """
+                Preprocess a batch of grayscale images.
+                """
+                if not isinstance(images, list):
+                    images = [images]
+        
+                # --- THIS IS THE FIX ---
+                # Call the built-in self.to_numpy_array method.
+                # It handles all validation (PIL, numpy, torch, tf)
+                # and conversion, raising an error if the type is invalid.
+                # No more manual validation or imports needed.
+                try:
+                    images = [self.to_numpy_array(img) for img in images]
+                except ValueError as e:
+                    raise ValueError(
+                        "Input must be a list of PIL Images, NumPy arrays, "
+                        f"PyTorch tensors, or TensorFlow tensors. Error: {e}"
+                    )
+                # --- END FIX ---
+        
+                processed_images = []
+                for img in images:
+                    if img.ndim == 3 and img.shape[2] == 1:
+                        img = img.squeeze(-1)
+                    elif img.ndim == 3:
+                        raise ValueError(
+                            "Image is not grayscale. "
+                            f"Expected 2D array, but got shape {img.shape}"
+                        )
+        
+                    img = normalize(img, mean=self.mean, std=self.std)
+                    img = to_channel_dimension_format(img, ChannelDimension.FIRST)
+                    processed_images.append(img)
+        
+                data = {"pixel_values": processed_images}
+                return BatchFeature(data=data, tensor_type=return_tensors)