[Contributions Welcome] Add Fast Image Processors
Author: yonigozlan
Pull request: no
Labels: name: Good First Issue

name: Good Second Issue

name: Vision

name: contributions-welcome

name: Processing

## Community contributions: Add Fast Image Processors

Fast image processors have been rolling out progressively for a while. Now that the [BaseImageProcessorFast](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils_fast.py#L292), from which all fast image processors inherit, is in a more stable state, I'm opening this issue to encourage contributors to add fast image processors for models that still only have a "slow" image processor.

### How to implement a Fast Image Processor

The core principle of fast image processors is to use `torch` and `torchvision` functions for image transformations instead of `PIL` or `numpy`. Among other performance benefits, this enables processing images on GPU, significantly improving inference speed.

Another key difference compared to slow image processors is that, unlike `BaseImageProcessor`, which provides only a minimal skeleton, `BaseImageProcessorFast` includes all the fundamental functionalities needed for a basic image processor. This allows optimizations made in BaseImageProcessorFast to propagate to its inherited classes. Additionally, most repetitive logic for image loading and argument handling is managed within BaseImageProcessorFast. Except in rare cases, inherited classes do not need to handle image loading, conversion, or retrieving arguments from class attributes in the call/preprocess function, this is all handled in `BaseImageProcessorFast`.

#### Getting Started

Run the following command:
```bash
transformers-cli add-fast-image-processor --model-name model_name
```
where `model_name` is the name of the model (as found in its folder under `transformers/src/transformers/models`) for which you're adding the fast image processor.

This command will handle all necessary imports and generate a basic fast image processor, which will look similar to this example for Beit:

```python
# coding=utf-8
# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Fast Image processor class for Beit."""

from ...image_processing_utils_fast import BASE_IMAGE_PROCESSOR_FAST_DOCSTRING, BaseImageProcessorFast
from ...image_utils import IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, PILImageResampling
from ...utils import add_start_docstrings


@add_start_docstrings(
    "Constructs a fast Beit image processor.",
    BASE_IMAGE_PROCESSOR_FAST_DOCSTRING,
)
class BeitImageProcessorFast(BaseImageProcessorFast):
    # This generated class can be used as a starting point for the fast image processor.
    # if the image processor is only used for simple augmentations, such as resizing, center cropping, rescaling, or normalizing,
    # only the default values should be set in the class.
    # If the image processor requires more complex augmentations, methods from BaseImageProcessorFast can be overridden.
    # In most cases, only the `_preprocess` method should be overridden.

    # For an example of a fast image processor requiring more complex augmentations, see `LlavaNextImageProcessorFast`.

    # Default values should be checked against the slow image processor
    # None values left after checking can be removed
    resample = PILImageResampling.BICUBIC
    image_mean = IMAGENET_STANDARD_MEAN
    image_std = IMAGENET_STANDARD_STD
    size = {"height": 256, "width": 256}
    default_to_square = None
    crop_size = {"height": 224, "width": 224}
    do_resize = True
    do_center_crop = True
    do_rescale = True
    do_normalize = True
    do_convert_rgb = None


__all__ = ["BeitImageProcessorFast"]
```

As explained in the generated file, if the image processor only performs basic augmentations such as resizing, center cropping, rescaling, and normalizing, the generated file might be sufficient for a working fast image processor. The class attributes, such as `resample` and `image_mean`, are automatically parsed from the slow image processor when running the script above. However, you should verify their correctness and check for any missing or incorrectly assigned values.

### Customizing the Image Processor

If the image processor requires additional functionalities beyond the basic augmentations, you will need to override the `_preprocess` function in `BaseImageProcessorFast`. Check the `_preprocess` implementation in `BaseImageProcessorFast` for reference. Notably, it leverages `group_images_by_shape` and `reorder_images` to enable batch processing, significantly increasing processing speed, particularly on GPUs. If you create new image processing functions, ensure they support batch processing by utilizing `group_images_by_shape` and `reorder_images` where possible.

If your image processor requires additional kwargs not present in [`DefaultFastImageProcessorKwargs`](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils_fast.py#L172), you must create a `ModelNameFastImageProcessorKwargs` class that inherits from `DefaultFastImageProcessorKwargs` and defines the new kwargs. Additionally, you should document the added kwargs in the class and the `preprocess` function using `add_start_docstrings`. (This documentation process may be simplified soon, but is necessary for now to get a correct documentation).

For an example of handling custom kwargs and documentation, refer to [LlavaNextImageProcessorFast](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llava_next/image_processing_llava_next_fast.py).

### Important Notes

- In nearly all cases, `_preprocess` is the only function in `BaseImageProcessorFast` that needs to be overridden.
- The `_preprocess` function does not require default values for its arguments, as they are automatically derived from class attributes if not explicitly provided.
- Even if `PIL` images or `numpy` arrays are passed to the image processor, the `images` argument in `_preprocess` will always be a list of tensors, with the channel dimension first.

### Handling Edge Cases

- **Nested Images:** If images are provided as nested lists (e.g., `[[image1, image2], [image3]]`), they will be flattened to `[image1, image2, image3]` by default before being passed to `_preprocess`. This behavior can be modified by overriding `_prepare_images_structure`, though flattening is generally recommended.
- **Formatting Custom  Kwargs:** If any custom kwargs require formatting before `_preprocess`, override `_further_process_kwargs`.
- **Validating Custom Kwargs:** If additional validation is needed for custom kwargs or existing ones, override `_validate_preprocess_kwargs`.

### Testing

In the case where the model already has a `test_image_processing_model_name.py` file under `transformers/tests/models/model_name`, the script ran before should have imported the fast image processor to the file, and added it as a `fast_image_processing_class` class attribute to the `ModelNameImageProcessingTest` class.
However this is not enough to get all the tests to run on the fast image processor. For all the test functions under `ModelNameImageProcessingTest`, you need to replace `image_processing = self.image_processing_class(**self.image_processor_dict)` with a loop over `self.image_processor_list`.

For example, the `test_image_processor_properties` test in `test_image_processing_beit.py` which looks like this:

```python
    def test_image_processor_properties(self):
        image_processing = self.image_processing_class(**self.image_processor_dict)
        self.assertTrue(hasattr(image_processing, "do_resize"))
        self.assertTrue(hasattr(image_processing, "size"))
        self.assertTrue(hasattr(image_processing, "do_center_crop"))
        self.assertTrue(hasattr(image_processing, "center_crop"))
        self.assertTrue(hasattr(image_processing, "do_normalize"))
        self.assertTrue(hasattr(image_processing, "image_mean"))
        self.assertTrue(hasattr(image_processing, "image_std"))
        self.assertTrue(hasattr(image_processing, "do_reduce_labels"))
```
should be changed to this:

```python
    def test_image_processor_properties(self):
        for image_processing_class in self.image_processor_list:
            image_processing = image_processing_class(**self.image_processor_dict)
            self.assertTrue(hasattr(image_processing, "do_resize"))
            self.assertTrue(hasattr(image_processing, "size"))
            self.assertTrue(hasattr(image_processing, "do_center_crop"))
            self.assertTrue(hasattr(image_processing, "center_crop"))
            self.assertTrue(hasattr(image_processing, "do_normalize"))
            self.assertTrue(hasattr(image_processing, "image_mean"))
            self.assertTrue(hasattr(image_processing, "image_std"))
            self.assertTrue(hasattr(image_processing, "do_reduce_labels"))
```

In the case where no image processing test file is present, now is a great time to add one! You can have a look at the[ CLIP image processing test file](https://github.com/huggingface/transformers/blob/ad5d40de9c4d4899d5b79243f63e22c72e8b3669/tests/models/clip/test_image_processing_clip.py) to use as a simple starting point.

Don't hesitate to add model-specific tests if you feel like there are some non-standard image processing techniques in the processor :).

To run the tests, use this command:
```bash
RUN_SLOW=1 python -m pytest tests/models/model_name/test_image_processing_model_name.py
```


### Choosing an Image Processor to Implement

The difficulty of implementing a fast image processor varies by model. If this is your first issue, consider starting with an easier one!

Happy coding!

Here is the list of fast image processors left to implement:
- [ ] Aria -> https://github.com/huggingface/transformers/pull/40147
- [x] BEiT -> https://github.com/huggingface/transformers/pull/37005
- [x] BiT -> https://github.com/huggingface/transformers/pull/37180
- [x] Blip
- [x] BridgeTower -> https://github.com/huggingface/transformers/pull/37373
- [x] Chameleon -> https://github.com/huggingface/transformers/pull/37140
- [x] Chinese-CLIP -> https://github.com/huggingface/transformers/pull/37012
- [x] CLIP
- [x] Conditional-DETR -> https://github.com/huggingface/transformers/pull/37071
- [X] ConvNext
- [x] Deepseek_vl -> https://github.com/huggingface/transformers/pull/39739
- [x] Deepseek_vl_hybrid ->https://github.com/huggingface/transformers/pull/39739
- [X] Deformable-DETR 
- [x] Deit
- [x] DepthPro
- [x] ~~Deta~~ (deprecated)
- [x] DETR
- [x] Donut -> https://github.com/huggingface/transformers/pull/37081
- [x] DPT -> https://github.com/huggingface/transformers/pull/37481
- [x] ~~EfficientFormer~~ (deprecated)
- [x] EfficientLoFTR -> https://github.com/huggingface/transformers/pull/41394
- [x] EfficientNet -> https://github.com/huggingface/transformers/pull/37055
- [x] Flava -> https://github.com/huggingface/transformers/pull/37135
- [ ] Emu3
- [x] Fuyu -> https://github.com/huggingface/transformers/pull/41817
- [x] Gemma3
- [x] GLPN -> https://github.com/huggingface/transformers/pull/41725
- [x] GotOcr2
- [x] Grounding Dino -> https://github.com/huggingface/transformers/pull/37108
- [ ] idefics
- [x] Idefics 2 -> https://github.com/huggingface/transformers/pull/38157
- [x] Idefics3 -> https://github.com/huggingface/transformers/pull/38157
- [x] ImageGPT -> https://github.com/huggingface/transformers/pull/39592
- [x] Janus -> https://github.com/huggingface/transformers/pull/39739
- [x] LayoutLMv2 -> https://github.com/huggingface/transformers/pull/37203
- [x] LayoutLMv3 -> https://github.com/huggingface/transformers/pull/37201
- [x] LeViT -> https://github.com/huggingface/transformers/pull/37154
- [x] LightGlue -> https://github.com/huggingface/transformers/pull/41670
- [x] LLava
- [x] LLaVa-NeXT
- [x] LLaVa-Onevision
- [x] Mask2Former -> https://github.com/huggingface/transformers/pull/35685
- [x] MaskFormer -> https://github.com/huggingface/transformers/pull/35685
- [x] MLlama -> https://github.com/huggingface/transformers/pull/37539
- [x] MobileNetV1 -> https://github.com/huggingface/transformers/pull/37111
- [x] MobileNetV2 -> https://github.com/huggingface/transformers/pull/37113
- [x] MobileViT -> https://github.com/huggingface/transformers/pull/37143
- [x] Nougat -> https://github.com/huggingface/transformers/pull/37661
- [x] OneFormer -> https://github.com/huggingface/transformers/pull/38343
- [x] OWLv2 -> https://github.com/huggingface/transformers/pull/37289 / https://github.com/huggingface/transformers/pull/39041
- [x] OwlViT -> https://github.com/huggingface/transformers/pull/37164
- [x] Perceiver -> https://github.com/huggingface/transformers/pull/37176
- [ ] Pix2Struct -> https://github.com/huggingface/transformers/pull/37210
- [x] Pixtral
- [x] PoolFormer -> https://github.com/huggingface/transformers/pull/37182
- [x] PromptDepthAnything -> https://github.com/huggingface/transformers/pull/40602
- [x] Pvt -> https://github.com/huggingface/transformers/pull/37204
- [x] Qwen2-VL (Not standard as it also handles videos, don't use it as an example :) )
- [x] RT-DETR
- [x] SAM -> https://github.com/huggingface/transformers/pull/39385
- [x] Segformer -> https://github.com/huggingface/transformers/pull/37024
- [ ] SegGPT
- [x] SigLIP
- [x] SigLIP2
- [x] SmolVLM -> https://github.com/huggingface/transformers/pull/38157
- [x] SuperGlue -> https://github.com/huggingface/transformers/pull/41394
- [x] SuperPoint -> https://github.com/huggingface/transformers/pull/37804
- [x] Swin2SR  -> https://github.com/huggingface/transformers/pull/37169
- [x] TextNet -> https://github.com/huggingface/transformers/pull/39884
- [x] ~~TVLT~~ (deprecated)
- [x] TVP -> https://github.com/huggingface/transformers/pull/39529
- [ ] Video-LLaVA -> https://github.com/huggingface/transformers/pull/37023
- [ ] VideoMAE -> https://github.com/huggingface/transformers/pull/37191
- [x] Vilt -> https://github.com/huggingface/transformers/pull/37304
- [x] ViT
- [x] ~~ViT hybrid~~ (deprecated)
- [x] ViTMatte -> https://github.com/huggingface/transformers/pull/37616
- [ ] VitPose -> https://github.com/huggingface/transformers/pull/40149/files
- [ ] Vivit
- [x] YOLOS -> https://github.com/huggingface/transformers/pull/37292
- [x] ZoeDepth -> https://github.com/huggingface/transformers/pull/38515

Comments:
Hey! I'd like to work on this issue with **MobileViT** 😊

@yonigozlan have you considered adopting [`kornia`](https://github.com/kornia/kornia) for that ? we have been curating algorithms (+700 ops) already for several years in terms of image processing and low level vision using exclusively pytorch.

I would love to pick one and start contributing. Good task for this week..!

@edgarriba I love kornia! But for image processors at inference time, it might be a bit overkill since 90% of the time, we only need a mix of resizing, normalizing, padding, and cropping, combined with some model-specific logic. I’ve found that `torch`/`torchvision` functional transforms usually cover these needs well, and pipelines like kornia `ImageSequential` or torchvision `Compose` aren’t always a good fit because some models require additional processing steps or custom logic in between. We also wanted to avoid adding an extra dependency to Transformers for fast image processors.

That said, I do think kornia could be valuable down the line, especially for batch processing. I'm still exploring how to optimize batch processing performance on both GPU and CPU, and kornia likely handles this more efficiently than our current approach.

The core of the library is pure functional -- that has been always the scope. The top layers you mention were added later just for commodity just for the case of augmentations but big part of the library has been designed as free functions for the exact purposes you mention. In any case, we are always open to collaborations and improvements.

Hi! I'd like to start with YOLOS 🚀


Hi! i'd like to work on Segformer 😊 , any thoughts on this , it's my first contribution
here's my [draft PR](https://github.com/huggingface/transformers/pull/37024), thank you 

I'd like to start with mllama

I would like to start with EfficientNet but some tests don't pass. Would be great if someone could have a look

https://github.com/huggingface/transformers/pull/37055

@zshn25 sad I have also worked on Efficientnet... I succeeded to fix the tests so you can have a look . anyway, I will let the maintainers decide which pull request to keep.

Hi! I'd like to work on this issue with ImageGPT 🤗

Hi. I would like to do this for ZoeDepth if that's ok?

Hi, I would like to work on `LayoutLMv3`.

Hi, 

I worked on the MobileNetV1, and raised the PR #37111 

Thanks!

Hi 🤗, I’m trying to test the equivalence between the slow and fast image processors for MobileViT, and I noticed a noticeable difference between the outputs after preprocessing.

I raised draft PR, and is there something I might be missing in configuration?

Thanks in advance!

Hi, I'd like to work on `Idefics3`. 

Hi, I'd like to work on `EfficientFormer` .

Hi! I'd like to work on this issue with **Vilt** 🤗

Hi! I'd like to work on this issue with vit hybrid :)

Hi, I am working on BiT: https://github.com/huggingface/transformers/pull/37180

Hi all I said I would take ZoeDepth, but I think this is one of the more challenging ones to adapt, due to the need for `ensure_multiple_of` and `keep_aspect_ratio`. I opened this [draft MR](https://github.com/huggingface/transformers/pull/37158) just to show where I got but I know I've gone down the wrong path there 😓 I'm going to hand it back for someone else to have a go at and then will learn from their PR.

So ZoeDepth is up for grabs if anyone want to take it.  I'll take a look and see if there is a more straightforward one to do.

Hi, I'd like to work on this issue with `swin2sr`

Hi, I going to try to work on VideoMAE!

I would like to work with ImageGPT

I would like to work on Nougat.

I'm working on Vivit. Will update very soon if I can complete or not.

~UPDATE: I have a [draft MR](https://github.com/huggingface/transformers/pull/37270) but a) realised this is a video model and so perhaps the approach should be different and b) the test_slow_fast_equivalence tests are failing. I left a [comment](https://github.com/huggingface/transformers/pull/37023#issuecomment-2777797565) here asking for help which will hopefully unblock me but also happy for someone else to take over - would be good learning for me to see the working implementation.~

The PR is closed now, after discussion on the PR,  as Vivit is video only

Hi, I would like to handle Pix2Struct.

Hi @yonigozlan - would it make sense to add the Fast Image Processor to SmolVLM? It could be beneficial especially because their default resolution is pretty high (2048 px). If so, I can tackle it!

Hi, I'd like to work on fuyu.


I'd like to work on LLaVa-NeXT-Video

Hi @yonigozlan! Could I work on imageGPT?


Hi, @yonigozlan! Could I work on Grounding Dino?

Hi, opened a PR for LLava-next-video 

https://github.com/huggingface/transformers/pull/37297

@yonigozlan I would like to work on BridgeTower

I am working on DPT, as my [PR for Vivit didn't go ahead](https://github.com/huggingface/transformers/issues/36978#issuecomment-2771924154)
UPDATE 4/14/25 -[PR](https://github.com/huggingface/transformers/pull/37481) is open and tests passing. Will be ready for review soon

I am working on `OneFormer`

Update: I am working on Nougat, I will create the PR during the weekend. 

@yonigozlan I would like work on GLPN

Working on ViTMatte, should be able to create the PR sometime this weekend.

UPDATE: This will take a bit longer since it appears that the original preprocessing may have a bug if the input format is ChannelDimension.First  which makes it hard to compare the performance on torch.Tensor....

@yonigozlan hi i would like to work on Superpoint, will raise pr soon. 


@yonigozlan  Hi, I would work on instructblipvideo, will raise pr! thank you

Hi @yonigozlan I'd like to work on the image processor for mobilenet. Will raise a PR! Thanks

Hi!  @yonigozlan  Here is the PR for Nougat https://github.com/huggingface/transformers/pull/37661. 

@yonigozlan 
I need help for OneFormer, it has a Kwarg called max_size and I am unsure how to handle this scenario. 
This example does not ignite insight: [LlavaNextImageProcessorFast](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llava_next/image_processing_llava_next_fast.py).

I can also do ZoeDepth sometime soon as it seems that's up for grabs again, may take a week or two though.
Update: Been busier than expected, but I am almost there, PR will be raised very soon.

Hi @yonigozlan , I would love to work on `vivit`! Will raise a PR soon :)

Hi! I'd like to work on glpn. Let me know if it's still available!


> Hi! I'd like to work on glpn. Let me know if it's still available!

Heya @aryanchauhan31 , I was originally working on GLPN, but due to other commitments, I haven't been able to dedicate enough time to it. Please feel free to take it over. If I can be of any help please feel free to reach out.

> > Hi! I'd like to work on glpn. Let me know if it's still available!
> 
> Heya [@aryanchauhan31](https://github.com/aryanchauhan31) , I was originally working on GLPN, but due to other commitments, I haven't been able to dedicate enough time to it. Please feel free to take it over. If I can be of any help please feel free to reach out.

Thanks. Sure i'll let you know 

Hi. I'd like to work on VitPose

Hi @yonigozlan 👋,

I'd like to contribute by implementing the Fast Image Processor for **Pix2Struct**.  
This seems like a valuable opportunity to contribute to a multimodal model, and I’m excited to dive in.

Please let me know if this model is still unassigned or if there’s anything specific I should be aware of before getting started.

Thanks!  
— Shubham

Hi, I'd love to contribute by implementing the Fast Image Processor for MobileNetV2. Please let me know if it's still unclaimed. Thanks,

Hey! I noticed that **TVP**  doesn’t currently have a FastImageProcessor implementation. I will be taking it up . Will raise a pr soon!

Hello @yonigozlan ,
I am interested in contributing to this as my first issue. However, I find it confusing to identify which models are left. I know that those with a PR link in front of them, regardless of whether the box is ticked or not, have been fixed but how do I know those that have not been fixed, especially since some of them have their boxes ticked and some do not? Also, how do i know videos that should be ignored (I saw in the discussion that video-only models should be left out).

I'm on vivit @yonigozlan, looks like it's still open

Hey @yonigozlan ,
I noticed that Janus (ref: [here](https://github.com/huggingface/transformers/tree/main/src/transformers/models/janus)) doesn’t currently have a FastImageProcessor implementation. I would like to contribute that to Janus. I will raise a PR soon.

@kasliwalshreyas Thanks for flagging this! Happy to review when the PR is ready

Hi @yonigozlan, I'd like to work on ImageGPT as there haven't been any changes to the initial PR.

Hey @yonigozlan I noticed that some models without BaseImageProcessorFast are not included in the list. These are the models

1.  aria [model card](https://huggingface.co/ETH-CVG/lightglue_superpoint), [ref](https://github.com/huggingface/transformers/blob/main/src/transformers/models/aria/image_processing_aria.py)
2.  textnet [model card](https://huggingface.co/czczup/textnet-base), [ref](https://github.com/huggingface/transformers/blob/main/src/transformers/models/textnet/image_processing_textnet.py)
3. lightGlue [model card](https://huggingface.co/ETH-CVG/lightglue_superpoint), [ref](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lightglue/image_processing_lightglue.py)
4. SuperGlue [model card](https://huggingface.co/magic-leap-community/superglue_outdoor), [ref](https://github.com/huggingface/transformers/blob/main/src/transformers/models/superglue/image_processing_superglue.py)

are these models going to be deprecated in future releases? if not I am happy to work on a PR.  Also, the image_processing files are auto generated for the aria and lightGlue models based on the modular file, can the procedure you have outlined be applied to convert the image processors of these models as well?

Hi @rahzaazhar ! Thanks for flagging these! I'll add them to the least, feel free to start working on them!
And yes absolutely for modular.

Hi @yonigozlan @rahzaazhar,
Thanks for raising this! If no one has started on it yet, would it be okay for me to take on the lightglue model? I’d be happy to contribute a PR. Please let me know if that works!

I am working on a PR for the textnet model

Hi @yonigozlan, I am working on Deepseek_vl. 


Hi @tanuj-rai and @rahzaazhar , sorry for the late notice, but I just opened a PR for Janus, Deepseek VL and Deepseek VL hybrid, as these image processors were a bit of a priority.
Feel free to choose other models on the list, including those which have stale PRs!

> Hi [@tanuj-rai](https://github.com/tanuj-rai) and [@rahzaazhar](https://github.com/rahzaazhar) , sorry for the late notice, but I just opened a PR for Janus, Deepseek VL and Deepseek VL hybrid, as these image processors were a bit of a priority. Feel free to choose other models on the list, including those which have stale PRs!

Thank you @yonigozlan, for the updates. I am interested in working on pix2struct model. Would it be okay to work on it? 

Thank you @yonigozlan  for taking the time to add the contribution models — it must have been quite a bit of work, but it really opens the door for many people to contribute.
Would it be okay if I take on implementing Fast Image Processors for the newly added LightGlue?

Hi, in https://github.com/search?q=repo%3Ahuggingface%2Ftransformers+ProcessorFast&type=code&p=1, there is no Unittest for Fast Image Processor (`ProcessorFast`). Is building unittest for `ProcessorFast` like #40086 can be a milestone?

Hi @yonigozlan,
I’d like to contribute to this effort and implement the Fast Image Processor for the MobileNetV2 model. I’ve reviewed the guidelines and understand the steps — generating the base class with the CLI tool, verifying defaults against the slow version, and adjusting _preprocess() if needed.
Please let me know if MobileNetV2 is still available so I can get started right away. 

@yonigozlan I worked on the EfficientLOTR Fast processor, here is the [PR link](https://github.com/huggingface/transformers/pull/40215). Please take a look at it and let me know if I should change anything

> Hi [@yonigozlan](https://github.com/yonigozlan), I’d like to contribute to this effort and implement the Fast Image Processor for the MobileNetV2 model. I’ve reviewed the guidelines and understand the steps — generating the base class with the CLI tool, verifying defaults against the slow version, and adjusting _preprocess() if needed. Please let me know if MobileNetV2 is still available so I can get started right away.

Hi @yonigozlan , just following up to check if MobileNetV2 is still open for the Fast Image Processor implementation. I’d be happy to start right away if it is.

Hi @yonigozlan Is the list of fast image up to date? I can take care of the rest if that's ok. 

Hey all - I'm starting to work on PromptDepthAnything.
Available here https://github.com/huggingface/transformers/pull/40602 and should be ready to review @yonigozlan. Thanks!

Hello @yonigozlan,

I'm interested in contributing to this issue and i was wondering if the _Vivit_ model is still available for contribution. Thank you in advance!

hey @yonigozlan ! iam participating in hacktober fest and new to open source, caniwork on this issue?

Hi @yonigozlan ! The transformers-cli is no longer available. Is there an alterantive?


Hey @Aravind-11 , the cli still exists, you can use the same commands as before just prefacing them by `transformers` instead.

```bash
transformers add-fast-image-processor --model-name MODEL_NAME
```

I think it was changed to this:
```bash
transformers add-fast-image-processor MODEL_NAME
```

> Hey [@Aravind-11](https://github.com/Aravind-11) , the cli still exists, you can use the same commands as before just prefacing them by `transformers` instead.
> 
> transformers add-fast-image-processor --model-name MODEL_NAME

Thank you

hi i would like to contribute on fuyu processor 

@yonigozlan 

Hi, Would like to contribute on ViViT if available, Shall I proceed? 

@yonigozlan 
I had opened a pr for fuyu fast image processors could you plz check it out once.