Upload processor

preprocessor_config.json

@@ -1,6 +1,6 @@
 {
   "auto_map": {
-    "AutoImageProcessor": "preprocessor_resnet.ResNetProcessor"
+    "AutoImageProcessor": "preprocessor_lenet.LeNetProcessor"
   },
-  "image_processor_type": "ResNetProcessor"
+  "image_processor_type": "LeNetProcessor"
 }

preprocessor_lenet.py

@@ -1,99 +1,40 @@
 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, 
-    ChannelDimension
-)
+from transformers.image_utils import ImageInput
+import torch
+from torchvision.transforms import v2
+
 
 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
-    ):
+    def __init__(self, **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,
-        images: ImageInput,
-        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"]
-        
-            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)
+    def preprocess(self, images: ImageInput, return_tensors=None, **kwargs) -> BatchFeature:
+        """
+        Preprocess a batch of grayscale images.
+        """
+        if not isinstance(images, list):
+            images = [images]
+
+        transform = v2.Compose([
+            v2.RandomResizedCrop(size=(28, 28), antialias=True),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(
+                mean=[0.1307],
+                std=[0.3081]
+            ),
+        ])
+
+        data = {"pixel_values": transform(images)}
+        return BatchFeature(data=data, tensor_type=return_tensors)