test_image_processing_vit.py 7.08 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# coding=utf-8
# Copyright 2021 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.


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
22
from transformers.utils import is_torch_available, is_vision_available
23

Yih-Dar's avatar
Yih-Dar committed
24
from ...test_feature_extraction_common import FeatureExtractionSavingTestMixin, prepare_image_inputs
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import ViTFeatureExtractor


class ViTFeatureExtractionTester(unittest.TestCase):
    def __init__(
        self,
        parent,
        batch_size=7,
        num_channels=3,
        image_size=18,
        min_resolution=30,
        max_resolution=400,
        do_resize=True,
amyeroberts's avatar
amyeroberts committed
46
        size=None,
NielsRogge's avatar
NielsRogge committed
47
48
49
        do_normalize=True,
        image_mean=[0.5, 0.5, 0.5],
        image_std=[0.5, 0.5, 0.5],
50
    ):
amyeroberts's avatar
amyeroberts committed
51
        size = size if size is not None else {"height": 18, "width": 18}
52
53
54
55
56
57
58
59
        self.parent = parent
        self.batch_size = batch_size
        self.num_channels = num_channels
        self.image_size = image_size
        self.min_resolution = min_resolution
        self.max_resolution = max_resolution
        self.do_resize = do_resize
        self.size = size
NielsRogge's avatar
NielsRogge committed
60
61
62
        self.do_normalize = do_normalize
        self.image_mean = image_mean
        self.image_std = image_std
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

    def prepare_feat_extract_dict(self):
        return {
            "image_mean": self.image_mean,
            "image_std": self.image_std,
            "do_normalize": self.do_normalize,
            "do_resize": self.do_resize,
            "size": self.size,
        }


@require_torch
@require_vision
class ViTFeatureExtractionTest(FeatureExtractionSavingTestMixin, unittest.TestCase):

    feature_extraction_class = ViTFeatureExtractor if is_vision_available() else None

    def setUp(self):
        self.feature_extract_tester = ViTFeatureExtractionTester(self)

    @property
    def feat_extract_dict(self):
        return self.feature_extract_tester.prepare_feat_extract_dict()

    def test_feat_extract_properties(self):
        feature_extractor = self.feature_extraction_class(**self.feat_extract_dict)
        self.assertTrue(hasattr(feature_extractor, "image_mean"))
        self.assertTrue(hasattr(feature_extractor, "image_std"))
        self.assertTrue(hasattr(feature_extractor, "do_normalize"))
        self.assertTrue(hasattr(feature_extractor, "do_resize"))
        self.assertTrue(hasattr(feature_extractor, "size"))

95
96
97
98
99
100
101
    def test_feat_extract_from_dict_with_kwargs(self):
        feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict)
        self.assertEqual(feature_extractor.size, {"height": 18, "width": 18})

        feature_extractor = self.feature_extraction_class.from_dict(self.feat_extract_dict, size=42)
        self.assertEqual(feature_extractor.size, {"height": 42, "width": 42})

102
103
104
105
106
107
108
    def test_batch_feature(self):
        pass

    def test_call_pil(self):
        # Initialize feature_extractor
        feature_extractor = self.feature_extraction_class(**self.feat_extract_dict)
        # create random PIL images
NielsRogge's avatar
NielsRogge committed
109
        image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False)
110
111
112
113
114
115
116
117
118
119
        for image in image_inputs:
            self.assertIsInstance(image, Image.Image)

        # Test not batched input
        encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values
        self.assertEqual(
            encoded_images.shape,
            (
                1,
                self.feature_extract_tester.num_channels,
amyeroberts's avatar
amyeroberts committed
120
121
                self.feature_extract_tester.size["height"],
                self.feature_extract_tester.size["width"],
122
123
124
125
126
127
128
129
130
131
            ),
        )

        # Test batched
        encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values
        self.assertEqual(
            encoded_images.shape,
            (
                self.feature_extract_tester.batch_size,
                self.feature_extract_tester.num_channels,
amyeroberts's avatar
amyeroberts committed
132
133
                self.feature_extract_tester.size["height"],
                self.feature_extract_tester.size["width"],
134
135
136
137
138
139
140
            ),
        )

    def test_call_numpy(self):
        # Initialize feature_extractor
        feature_extractor = self.feature_extraction_class(**self.feat_extract_dict)
        # create random numpy tensors
NielsRogge's avatar
NielsRogge committed
141
        image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, numpify=True)
142
143
144
145
146
147
148
149
150
151
        for image in image_inputs:
            self.assertIsInstance(image, np.ndarray)

        # Test not batched input
        encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values
        self.assertEqual(
            encoded_images.shape,
            (
                1,
                self.feature_extract_tester.num_channels,
amyeroberts's avatar
amyeroberts committed
152
153
                self.feature_extract_tester.size["height"],
                self.feature_extract_tester.size["width"],
154
155
156
157
158
159
160
161
162
163
            ),
        )

        # Test batched
        encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values
        self.assertEqual(
            encoded_images.shape,
            (
                self.feature_extract_tester.batch_size,
                self.feature_extract_tester.num_channels,
amyeroberts's avatar
amyeroberts committed
164
165
                self.feature_extract_tester.size["height"],
                self.feature_extract_tester.size["width"],
166
167
168
169
170
171
172
            ),
        )

    def test_call_pytorch(self):
        # Initialize feature_extractor
        feature_extractor = self.feature_extraction_class(**self.feat_extract_dict)
        # create random PyTorch tensors
NielsRogge's avatar
NielsRogge committed
173
        image_inputs = prepare_image_inputs(self.feature_extract_tester, equal_resolution=False, torchify=True)
174
175
176
177
178
179
180
181
182
183
        for image in image_inputs:
            self.assertIsInstance(image, torch.Tensor)

        # Test not batched input
        encoded_images = feature_extractor(image_inputs[0], return_tensors="pt").pixel_values
        self.assertEqual(
            encoded_images.shape,
            (
                1,
                self.feature_extract_tester.num_channels,
amyeroberts's avatar
amyeroberts committed
184
185
                self.feature_extract_tester.size["height"],
                self.feature_extract_tester.size["width"],
186
187
188
189
190
191
192
193
194
195
            ),
        )

        # Test batched
        encoded_images = feature_extractor(image_inputs, return_tensors="pt").pixel_values
        self.assertEqual(
            encoded_images.shape,
            (
                self.feature_extract_tester.batch_size,
                self.feature_extract_tester.num_channels,
amyeroberts's avatar
amyeroberts committed
196
197
                self.feature_extract_tester.size["height"],
                self.feature_extract_tester.size["width"],
198
199
            ),
        )