codingutf8 2023 huggingface inc 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 orglicenseslicense2 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 this function prepares a list of pil images or a list of numpy arrays if one specifies numpifytrue or a list of pytorch tensors if one specifies torchifytrue one can specify whether the images are of the same resolution or not to avoid getting image widthheight 0 if sizedivisor is defined the image needs to have widthsize sizedivisor pil expects the channel dimension as last dimension this function prepares a video as a list of pil imagesnumpy arrayspytorch tensors video for i in rangenumframes video appendnp random randint255 sizenumchannels width height dtypenp uint8 if not numpify and not torchify pil expects the channel dimension as last dimension video image fromarraynp moveaxisframe 0 1 for frame in video if torchify video torch fromnumpyframe for frame in video return video def preparevideoinputs batchsize numframes numchannels minresolution maxresolution equalresolutionfalse numpifyfalse torchifyfalse assert not numpify and torchify you cannot specify both numpy and pytorch tensors at the same time videoinputs for i in rangebatchsize if equalresolution width height maxresolution else width height np random choicenp arangeminresolution maxresolution 2 video preparevideo numframesnumframes numchannelsnumchannels widthwidth heightheight numpifynumpify torchifytorchify videoinputs appendvideo return videoinputs class imageprocessingtestmixin testcastdtype none def testimageprocessortojsonstringself imageprocessor self imageprocessingclassself imageprocessordict obj json loadsimageprocessor tojsonstring for key value in self imageprocessordict items self assertequalobjkey value def testimageprocessortojsonfileself imageprocessorfirst self imageprocessingclassself imageprocessordict with tempfile temporarydirectory as tmpdirname jsonfilepath os path jointmpdirname imageprocessor json imageprocessorfirst tojsonfilejsonfilepath imageprocessorsecond self imageprocessingclass fromjsonfilejsonfilepath self assertequalimageprocessorsecond todict imageprocessorfirst todict def testimageprocessorfromandsavepretrainedself imageprocessorfirst self imageprocessingclassself imageprocessordict with tempfile temporarydirectory as tmpdirname savedfile imageprocessorfirst savepretrainedtmpdirname0 checkjsonfilehascorrectformatsavedfile imageprocessorsecond self imageprocessingclass frompretrainedtmpdirname self assertequalimageprocessorsecond todict imageprocessorfirst todict def testinitwithoutparamsself imageprocessor self imageprocessingclass self assertisnotnoneimageprocessor requiretorch requirevision def testcastdtypedeviceself if self testcastdtype is not none initialize imageprocessor imageprocessor self imageprocessingclassself imageprocessordict create random pytorch tensors imageinputs self imageprocessortester prepareimageinputsequalresolutionfalse torchifytrue encoding imageprocessorimageinputs returntensorspt for layoutlm compatiblity self assertequalencoding pixelvalues device torch devicecpu self assertequalencoding pixelvalues dtype torch float32 encoding imageprocessorimageinputs returntensorspt totorch float16 self assertequalencoding pixelvalues device torch devicecpu self assertequalencoding pixelvalues dtype torch float16 encoding imageprocessorimageinputs returntensorspt tocpu torch bfloat16 self assertequalencoding pixelvalues device torch devicecpu self assertequalencoding pixelvalues dtype torch bfloat16 with self assertraisestypeerror imageprocessorimageinputs returntensorspt totorch bfloat16 cpu try with text image feature encoding imageprocessorimageinputs returntensorspt encoding updateinputids torch longtensor1 2 3 4 5 6 encoding encoding totorch float16 self assertequalencoding pixelvalues device torch devicecpu self assertequalencoding pixelvalues dtype torch float16 self assertequalencoding inputids dtype torch long def testcallpilself initialize imageprocessing imageprocessing self imageprocessingclassself imageprocessordict create random pil images imageinputs self imageprocessortester prepareimageinputsequalresolutionfalse for image in imageinputs self assertisinstanceimage image image test not batched input encodedimages imageprocessingimageinputs0 returntensorspt pixelvalues expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs0 self assertequaltupleencodedimages shape 1 expectedoutputimageshape test batched encodedimages imageprocessingimageinputs returntensorspt pixelvalues expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs self assertequal tupleencodedimages shape self imageprocessortester batchsize expectedoutputimageshape def testcallnumpyself initialize imageprocessing imageprocessing self imageprocessingclassself imageprocessordict create random numpy tensors imageinputs self imageprocessortester prepareimageinputsequalresolutionfalse numpifytrue for image in imageinputs self assertisinstanceimage np ndarray test not batched input encodedimages imageprocessingimageinputs0 returntensorspt pixelvalues expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs0 self assertequaltupleencodedimages shape 1 expectedoutputimageshape test batched encodedimages imageprocessingimageinputs returntensorspt pixelvalues expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs self assertequal tupleencodedimages shape self imageprocessortester batchsize expectedoutputimageshape def testcallpytorchself initialize imageprocessing imageprocessing self imageprocessingclassself imageprocessordict create random pytorch tensors imageinputs self imageprocessortester prepareimageinputsequalresolutionfalse torchifytrue for image in imageinputs self assertisinstanceimage torch tensor test not batched input encodedimages imageprocessingimageinputs0 returntensorspt pixelvalues expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs0 self assertequaltupleencodedimages shape 1 expectedoutputimageshape test batched expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs encodedimages imageprocessingimageinputs returntensorspt pixelvalues self assertequal tupleencodedimages shape self imageprocessortester batchsize expectedoutputimageshape def testcallnumpy4channelsself test that can process images which have an arbitrary number of channels initialize imageprocessing imageprocessor self imageprocessingclassself imageprocessordict create random numpy tensors self imageprocessortester numchannels 4 imageinputs self imageprocessortester prepareimageinputsequalresolutionfalse numpifytrue test not batched input encodedimages imageprocessor imageinputs0 returntensorspt inputdataformatchannelsfirst imagemean0 imagestd1 pixelvalues expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs0 self assertequaltupleencodedimages shape 1 expectedoutputimageshape test batched encodedimages imageprocessor imageinputs returntensorspt inputdataformatchannelsfirst imagemean0 imagestd1 pixelvalues expectedoutputimageshape self imageprocessortester expectedoutputimageshapeimageinputs self assertequal tupleencodedimages shape self imageprocessortester batchsize expectedoutputimageshape coding utf 8 2023 huggingface inc 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 this function prepares a list of pil images or a list of numpy arrays if one specifies numpify true or a list of pytorch tensors if one specifies torchify true one can specify whether the images are of the same resolution or not to avoid getting image width height 0 if size_divisor is defined the image needs to have width size size_divisor pil expects the channel dimension as last dimension this function prepares a video as a list of pil images numpy arrays pytorch tensors pil expects the channel dimension as last dimension this function prepares a batch of videos a list of list of pil images or a list of list of numpy arrays if one specifies numpify true or a list of list of pytorch tensors if one specifies torchify true one can specify whether the videos are of the same resolution or not initialize image_processor create random pytorch tensors for layoutlm compatiblity try with text image feature initialize image_processing create random pil images test not batched input test batched initialize image_processing create random numpy tensors test not batched input test batched initialize image_processing create random pytorch tensors test not batched input test batched test that can process images which have an arbitrary number of channels initialize image_processing create random numpy tensors test not batched input test batched
import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available


if is_torch_available():
    import numpy as np
    import torch

if is_vision_available():
    from PIL import Image


def prepare_image_inputs(
    batch_size,
    min_resolution,
    max_resolution,
    num_channels,
    size_divisor=None,
    equal_resolution=False,
    numpify=False,
    torchify=False,
):
    

    assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

    image_inputs = []
    for i in range(batch_size):
        if equal_resolution:
            width = height = max_resolution
        else:
            
            if size_divisor is not None:
                
                min_resolution = max(size_divisor, min_resolution)
            width, height = np.random.choice(np.arange(min_resolution, max_resolution), 2)
        image_inputs.append(np.random.randint(255, size=(num_channels, width, height), dtype=np.uint8))

    if not numpify and not torchify:
        
        image_inputs = [Image.fromarray(np.moveaxis(image, 0, -1)) for image in image_inputs]

    if torchify:
        image_inputs = [torch.from_numpy(image) for image in image_inputs]

    return image_inputs


def prepare_video(num_frames, num_channels, width=10, height=10, numpify=False, torchify=False):
    

    video = []
    for i in range(num_frames):
        video.append(np.random.randint(255, size=(num_channels, width, height), dtype=np.uint8))

    if not numpify and not torchify:
        
        video = [Image.fromarray(np.moveaxis(frame, 0, -1)) for frame in video]

    if torchify:
        video = [torch.from_numpy(frame) for frame in video]

    return video


def prepare_video_inputs(
    batch_size,
    num_frames,
    num_channels,
    min_resolution,
    max_resolution,
    equal_resolution=False,
    numpify=False,
    torchify=False,
):
    

    assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

    video_inputs = []
    for i in range(batch_size):
        if equal_resolution:
            width = height = max_resolution
        else:
            width, height = np.random.choice(np.arange(min_resolution, max_resolution), 2)
            video = prepare_video(
                num_frames=num_frames,
                num_channels=num_channels,
                width=width,
                height=height,
                numpify=numpify,
                torchify=torchify,
            )
        video_inputs.append(video)

    return video_inputs


class ImageProcessingTestMixin:
    test_cast_dtype = None

    def test_image_processor_to_json_string(self):
        image_processor = self.image_processing_class(**self.image_processor_dict)
        obj = json.loads(image_processor.to_json_string())
        for key, value in self.image_processor_dict.items():
            self.assertEqual(obj[key], value)

    def test_image_processor_to_json_file(self):
        image_processor_first = self.image_processing_class(**self.image_processor_dict)

        with tempfile.TemporaryDirectory() as tmpdirname:
            json_file_path = os.path.join(tmpdirname, "image_processor.json")
            image_processor_first.to_json_file(json_file_path)
            image_processor_second = self.image_processing_class.from_json_file(json_file_path)

        self.assertEqual(image_processor_second.to_dict(), image_processor_first.to_dict())

    def test_image_processor_from_and_save_pretrained(self):
        image_processor_first = self.image_processing_class(**self.image_processor_dict)

        with tempfile.TemporaryDirectory() as tmpdirname:
            saved_file = image_processor_first.save_pretrained(tmpdirname)[0]
            check_json_file_has_correct_format(saved_file)
            image_processor_second = self.image_processing_class.from_pretrained(tmpdirname)

        self.assertEqual(image_processor_second.to_dict(), image_processor_first.to_dict())

    def test_init_without_params(self):
        image_processor = self.image_processing_class()
        self.assertIsNotNone(image_processor)

    @require_torch
    @require_vision
    def test_cast_dtype_device(self):
        if self.test_cast_dtype is not None:
            
            image_processor = self.image_processing_class(**self.image_processor_dict)

            
            image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False, torchify=True)

            encoding = image_processor(image_inputs, return_tensors="pt")
            
            self.assertEqual(encoding.pixel_values.device, torch.device("cpu"))
            self.assertEqual(encoding.pixel_values.dtype, torch.float32)

            encoding = image_processor(image_inputs, return_tensors="pt").to(torch.float16)
            self.assertEqual(encoding.pixel_values.device, torch.device("cpu"))
            self.assertEqual(encoding.pixel_values.dtype, torch.float16)

            encoding = image_processor(image_inputs, return_tensors="pt").to("cpu", torch.bfloat16)
            self.assertEqual(encoding.pixel_values.device, torch.device("cpu"))
            self.assertEqual(encoding.pixel_values.dtype, torch.bfloat16)

            with self.assertRaises(TypeError):
                _ = image_processor(image_inputs, return_tensors="pt").to(torch.bfloat16, "cpu")

            
            encoding = image_processor(image_inputs, return_tensors="pt")
            encoding.update({"input_ids": torch.LongTensor([[1, 2, 3], [4, 5, 6]])})
            encoding = encoding.to(torch.float16)

            self.assertEqual(encoding.pixel_values.device, torch.device("cpu"))
            self.assertEqual(encoding.pixel_values.dtype, torch.float16)
            self.assertEqual(encoding.input_ids.dtype, torch.long)

    def test_call_pil(self):
        
        image_processing = self.image_processing_class(**self.image_processor_dict)
        
        image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False)
        for image in image_inputs:
            self.assertIsInstance(image, Image.Image)

        
        encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape([image_inputs[0]])
        self.assertEqual(tuple(encoded_images.shape), (1, *expected_output_image_shape))

        
        encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape(image_inputs)
        self.assertEqual(
            tuple(encoded_images.shape), (self.image_processor_tester.batch_size, *expected_output_image_shape)
        )

    def test_call_numpy(self):
        
        image_processing = self.image_processing_class(**self.image_processor_dict)
        
        image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False, numpify=True)
        for image in image_inputs:
            self.assertIsInstance(image, np.ndarray)

        
        encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape([image_inputs[0]])
        self.assertEqual(tuple(encoded_images.shape), (1, *expected_output_image_shape))

        
        encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape(image_inputs)
        self.assertEqual(
            tuple(encoded_images.shape), (self.image_processor_tester.batch_size, *expected_output_image_shape)
        )

    def test_call_pytorch(self):
        
        image_processing = self.image_processing_class(**self.image_processor_dict)
        
        image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False, torchify=True)

        for image in image_inputs:
            self.assertIsInstance(image, torch.Tensor)

        
        encoded_images = image_processing(image_inputs[0], return_tensors="pt").pixel_values
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape([image_inputs[0]])
        self.assertEqual(tuple(encoded_images.shape), (1, *expected_output_image_shape))

        
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape(image_inputs)
        encoded_images = image_processing(image_inputs, return_tensors="pt").pixel_values
        self.assertEqual(
            tuple(encoded_images.shape),
            (self.image_processor_tester.batch_size, *expected_output_image_shape),
        )

    def test_call_numpy_4_channels(self):
        
        
        image_processor = self.image_processing_class(**self.image_processor_dict)

        
        self.image_processor_tester.num_channels = 4
        image_inputs = self.image_processor_tester.prepare_image_inputs(equal_resolution=False, numpify=True)

        
        encoded_images = image_processor(
            image_inputs[0],
            return_tensors="pt",
            input_data_format="channels_first",
            image_mean=0,
            image_std=1,
        ).pixel_values
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape([image_inputs[0]])
        self.assertEqual(tuple(encoded_images.shape), (1, *expected_output_image_shape))

        
        encoded_images = image_processor(
            image_inputs,
            return_tensors="pt",
            input_data_format="channels_first",
            image_mean=0,
            image_std=1,
        ).pixel_values
        expected_output_image_shape = self.image_processor_tester.expected_output_image_shape(image_inputs)
        self.assertEqual(
            tuple(encoded_images.shape), (self.image_processor_tester.batch_size, *expected_output_image_shape)
        )