




"""simple docstring"""







import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
		import torch


a      =							random.Random()





def 							lowercase					(snake_case__   : Optional[Any]      ,       snake_case__   : Optional[int]=1.0      ,       snake_case__   : Union[str, Any]=None      ,       snake_case__   : List[str]=None )     ->  str:


				'''simple docstring'''






				if rng is None:
								lowerCAmelCase  =				global_rng

				lowerCAmelCase  =				[]
				for batch_idx in range(shape[0] ):
								values.append([] )
								for _ in range(shape[1] ):
												values[-1].append(rng.random() * scale )

				return values







@require_torch
class       SCREAMING_SNAKE_CASE__					(					unittest.TestCase					):


						def __init__(							self				:			Optional[int]						,						lowerCAmelCase				:			Tuple						,						lowerCAmelCase				:			Any=7						,						lowerCAmelCase				:			Optional[int]=400						,						lowerCAmelCase				:			Any=2000						,						lowerCAmelCase				:			List[str]=1						,						lowerCAmelCase				:			Tuple=0.0						,						lowerCAmelCase				:			Any=1_6000						,						lowerCAmelCase				:			Union[str, Any]=True						,						lowerCAmelCase				:			Optional[Any]=80						,						lowerCAmelCase				:			List[str]=16						,						lowerCAmelCase				:			Tuple=64						,						lowerCAmelCase				:			Tuple="hann_window"						,						lowerCAmelCase				:			Optional[int]=80						,						lowerCAmelCase				:			Dict=7600						,						lowerCAmelCase				:			List[str]=1e-10						,						lowerCAmelCase				:			str=True						,						):
										lowerCAmelCase  =				parent
										lowerCAmelCase  =				batch_size
										lowerCAmelCase  =				min_seq_length
										lowerCAmelCase  =				max_seq_length
										lowerCAmelCase  =				(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										lowerCAmelCase  =				feature_size
										lowerCAmelCase  =				padding_value
										lowerCAmelCase  =				sampling_rate
										lowerCAmelCase  =				do_normalize
										lowerCAmelCase  =				num_mel_bins
										lowerCAmelCase  =				hop_length
										lowerCAmelCase  =				win_length
										lowerCAmelCase  =				win_function
										lowerCAmelCase  =				fmin
										lowerCAmelCase  =				fmax
										lowerCAmelCase  =				mel_floor
										lowerCAmelCase  =				return_attention_mask


						def   __lowercase (							self				:			Tuple					):
										return {
										    "feature_size": self.feature_size,
										    "padding_value": self.padding_value,
										    "sampling_rate": self.sampling_rate,
										    "do_normalize": self.do_normalize,
										    "num_mel_bins": self.num_mel_bins,
										    "hop_length": self.hop_length,
										    "win_length": self.win_length,
										    "win_function": self.win_function,
										    "fmin": self.fmin,
										    "fmax": self.fmax,
										    "mel_floor": self.mel_floor,
										    "return_attention_mask": self.return_attention_mask,
										}


						def   __lowercase (							self				:			Dict						,						lowerCAmelCase				:			str=False						,						lowerCAmelCase				:			List[str]=False					):
										def _flatten(lowerCAmelCase				:			Tuple					):
														return list(itertools.chain(*lowerCAmelCase					)					)

										if equal_length:
														lowerCAmelCase  =				floats_list((self.batch_size, self.max_seq_length)					)
										else:
														# make sure that inputs increase in size
														lowerCAmelCase  =				[
														    _flatten(floats_list((x, self.feature_size)					)					)
														    for x in range(self.min_seq_length						,						self.max_seq_length						,						self.seq_length_diff					)
														]

										if numpify:
														lowerCAmelCase  =				[np.asarray(lowerCAmelCase					) for x in speech_inputs]

										return speech_inputs




						def   __lowercase (							self				:			int						,						lowerCAmelCase				:			Optional[int]=False						,						lowerCAmelCase				:			List[str]=False					):
										if equal_length:
														lowerCAmelCase  =				[floats_list((self.max_seq_length, self.num_mel_bins)					) for _ in range(self.batch_size					)]
										else:
														# make sure that inputs increase in size
														lowerCAmelCase  =				[
														    floats_list((x, self.num_mel_bins)					)
														    for x in range(self.min_seq_length						,						self.max_seq_length						,						self.seq_length_diff					)
														]

										if numpify:
														lowerCAmelCase  =				[np.asarray(lowerCAmelCase					) for x in speech_inputs]

										return speech_inputs







@require_torch
class       SCREAMING_SNAKE_CASE__					(					_a						,				unittest.TestCase					):
						_a    						=						SpeechTaFeatureExtractor


						def   __lowercase (							self				:			Dict					):
										lowerCAmelCase  =				SpeechTaFeatureExtractionTester(self					)


						def   __lowercase (							self				:			Tuple						,						lowerCAmelCase				:			Tuple					):
										self.assertTrue(np.all(np.mean(lowerCAmelCase						,						axis=0					) < 1e-3					)					)
										self.assertTrue(np.all(np.abs(np.var(lowerCAmelCase						,						axis=0					) - 1					) < 1e-3					)					)


						def   __lowercase (							self				:			List[Any]					):
										# Tests that all call wrap to encode_plus and batch_encode_plus
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										# create three inputs of length 800, 1000, and 1200
										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in range(800						,						1400						,						200					)]
										lowerCAmelCase  =				[np.asarray(lowerCAmelCase					) for speech_input in speech_inputs]

										# Test not batched input
										lowerCAmelCase  =				feat_extract(speech_inputs[0]						,						return_tensors="""np"""					).input_values
										lowerCAmelCase  =				feat_extract(np_speech_inputs[0]						,						return_tensors="""np"""					).input_values
										self.assertTrue(np.allclose(lowerCAmelCase						,						lowerCAmelCase						,						atol=1e-3					)					)

										# Test batched
										lowerCAmelCase  =				feat_extract(lowerCAmelCase						,						return_tensors="""np"""					).input_values
										lowerCAmelCase  =				feat_extract(lowerCAmelCase						,						return_tensors="""np"""					).input_values
										for enc_seq_a, enc_seq_a in zip(lowerCAmelCase						,						lowerCAmelCase					):
														self.assertTrue(np.allclose(lowerCAmelCase						,						lowerCAmelCase						,						atol=1e-3					)					)


						def   __lowercase (							self				:			Dict					):
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in range(800						,						1400						,						200					)]

										lowerCAmelCase  =				["""longest""", """max_length""", """do_not_pad"""]
										lowerCAmelCase  =				[None, 1600, None]
										for max_length, padding in zip(lowerCAmelCase						,						lowerCAmelCase					):
														lowerCAmelCase  =				feat_extract(lowerCAmelCase						,						padding=lowerCAmelCase						,						max_length=lowerCAmelCase						,						return_tensors="""np"""					)
														lowerCAmelCase  =				processed.input_values

														self._check_zero_mean_unit_variance(input_values[0][:800]					)
														self.assertTrue(input_values[0][800:].sum() < 1e-6					)
														self._check_zero_mean_unit_variance(input_values[1][:1000]					)
														self.assertTrue(input_values[0][1000:].sum() < 1e-6					)
														self._check_zero_mean_unit_variance(input_values[2][:1200]					)


						def   __lowercase (							self				:			Tuple					):
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										lowerCAmelCase  =				range(800						,						1400						,						200					)
										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in lengths]

										lowerCAmelCase  =				["""longest""", """max_length""", """do_not_pad"""]
										lowerCAmelCase  =				[None, 1600, None]

										for max_length, padding in zip(lowerCAmelCase						,						lowerCAmelCase					):
														lowerCAmelCase  =				feat_extract(lowerCAmelCase						,						max_length=lowerCAmelCase						,						padding=lowerCAmelCase					)
														lowerCAmelCase  =				processed.input_values

														self._check_zero_mean_unit_variance(input_values[0][:800]					)
														self._check_zero_mean_unit_variance(input_values[1][:1000]					)
														self._check_zero_mean_unit_variance(input_values[2][:1200]					)


						def   __lowercase (							self				:			Tuple					):
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in range(800						,						1400						,						200					)]
										lowerCAmelCase  =				feat_extract(
										    lowerCAmelCase						,						truncation=lowerCAmelCase						,						max_length=1000						,						padding="""max_length"""						,						return_tensors="""np"""					)
										lowerCAmelCase  =				processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :800]					)
										self._check_zero_mean_unit_variance(input_values[1]					)
										self._check_zero_mean_unit_variance(input_values[2]					)


						def   __lowercase (							self				:			Optional[Any]					):
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in range(800						,						1400						,						200					)]
										lowerCAmelCase  =				feat_extract(
										    lowerCAmelCase						,						truncation=lowerCAmelCase						,						max_length=1000						,						padding="""longest"""						,						return_tensors="""np"""					)
										lowerCAmelCase  =				processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :800]					)
										self._check_zero_mean_unit_variance(input_values[1, :1000]					)
										self._check_zero_mean_unit_variance(input_values[2]					)

										# make sure that if max_length < longest -> then pad to max_length
										self.assertTrue(input_values.shape == (3, 1000)					)

										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in range(800						,						1400						,						200					)]
										lowerCAmelCase  =				feat_extract(
										    lowerCAmelCase						,						truncation=lowerCAmelCase						,						max_length=2000						,						padding="""longest"""						,						return_tensors="""np"""					)
										lowerCAmelCase  =				processed.input_values

										self._check_zero_mean_unit_variance(input_values[0, :800]					)
										self._check_zero_mean_unit_variance(input_values[1, :1000]					)
										self._check_zero_mean_unit_variance(input_values[2]					)

										# make sure that if max_length > longest -> then pad to longest
										self.assertTrue(input_values.shape == (3, 1200)					)


						def   __lowercase (							self				:			List[Any]					):
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										lowerCAmelCase  =				np.random.rand(100					).astype(np.floataa					)
										lowerCAmelCase  =				np_speech_inputs.tolist()

										for inputs in [py_speech_inputs, np_speech_inputs]:
														lowerCAmelCase  =				feature_extractor.pad([{"""input_values""": inputs}]						,						return_tensors="""np"""					)
														self.assertTrue(np_processed.input_values.dtype == np.floataa					)
														lowerCAmelCase  =				feature_extractor.pad([{"""input_values""": inputs}]						,						return_tensors="""pt"""					)
														self.assertTrue(pt_processed.input_values.dtype == torch.floataa					)


						def   __lowercase (							self				:			Optional[Any]					):
										# Tests that all call wrap to encode_plus and batch_encode_plus
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										# create three inputs of length 800, 1000, and 1200
										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in range(800						,						1400						,						200					)]
										lowerCAmelCase  =				[np.asarray(lowerCAmelCase					) for speech_input in speech_inputs]

										# Test feature size
										lowerCAmelCase  =				feature_extractor(audio_target=lowerCAmelCase						,						padding=lowerCAmelCase						,						return_tensors="""np"""					).input_values
										self.assertTrue(input_values.ndim == 3					)
										self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins					)

										# Test not batched input
										lowerCAmelCase  =				feature_extractor(speech_inputs[0]						,						return_tensors="""np"""					).input_values
										lowerCAmelCase  =				feature_extractor(np_speech_inputs[0]						,						return_tensors="""np"""					).input_values
										self.assertTrue(np.allclose(lowerCAmelCase						,						lowerCAmelCase						,						atol=1e-3					)					)

										# Test batched
										lowerCAmelCase  =				feature_extractor(lowerCAmelCase						,						return_tensors="""np"""					).input_values
										lowerCAmelCase  =				feature_extractor(lowerCAmelCase						,						return_tensors="""np"""					).input_values
										for enc_seq_a, enc_seq_a in zip(lowerCAmelCase						,						lowerCAmelCase					):
														self.assertTrue(np.allclose(lowerCAmelCase						,						lowerCAmelCase						,						atol=1e-3					)					)

										# Test 2-D numpy arrays are batched.
										lowerCAmelCase  =				[floats_list((1, x)					)[0] for x in (800, 800, 800)]
										lowerCAmelCase  =				np.asarray(lowerCAmelCase					)
										lowerCAmelCase  =				feature_extractor(lowerCAmelCase						,						return_tensors="""np"""					).input_values
										lowerCAmelCase  =				feature_extractor(lowerCAmelCase						,						return_tensors="""np"""					).input_values
										for enc_seq_a, enc_seq_a in zip(lowerCAmelCase						,						lowerCAmelCase					):
														self.assertTrue(np.allclose(lowerCAmelCase						,						lowerCAmelCase						,						atol=1e-3					)					)


						def   __lowercase (							self				:			List[str]					):
										lowerCAmelCase  =				self.feat_extract_tester.prepare_inputs_for_target()
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_dict					)
										lowerCAmelCase  =				feat_extract.model_input_names[0]

										lowerCAmelCase  =				BatchFeature({input_name: speech_inputs}					)

										self.assertTrue(all(len(lowerCAmelCase					) == len(lowerCAmelCase					) for x, y in zip(lowerCAmelCase						,						processed_features[input_name]					)					)					)

										lowerCAmelCase  =				self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase					)
										lowerCAmelCase  =				BatchFeature({input_name: speech_inputs}						,						tensor_type="""np"""					)

										lowerCAmelCase  =				processed_features[input_name]

										if len(batch_features_input.shape					) < 3:
														lowerCAmelCase  =				batch_features_input[:, :, None]

										self.assertTrue(
										    batch_features_input.shape
										    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)


						@require_torch
						def   __lowercase (							self				:			List[Any]					):
										lowerCAmelCase  =				self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase					)
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_dict					)
										lowerCAmelCase  =				feat_extract.model_input_names[0]

										lowerCAmelCase  =				BatchFeature({input_name: speech_inputs}						,						tensor_type="""pt"""					)

										lowerCAmelCase  =				processed_features[input_name]

										if len(batch_features_input.shape					) < 3:
														lowerCAmelCase  =				batch_features_input[:, :, None]

										self.assertTrue(
										    batch_features_input.shape
										    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)


						@require_torch
						def   __lowercase (							self				:			Optional[Any]					):
										lowerCAmelCase  =				self.feature_extraction_class(**self.feat_extract_dict					)
										lowerCAmelCase  =				self.feat_extract_tester.prepare_inputs_for_target()
										lowerCAmelCase  =				feat_extract.model_input_names[0]

										lowerCAmelCase  =				BatchFeature({input_name: speech_inputs}					)

										lowerCAmelCase  =				feat_extract.num_mel_bins  # hack!

										lowerCAmelCase  =				feat_extract.pad(lowerCAmelCase						,						padding="""longest"""						,						return_tensors="""np"""					)[input_name]
										lowerCAmelCase  =				feat_extract.pad(lowerCAmelCase						,						padding="""longest"""						,						return_tensors="""pt"""					)[input_name]

										self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1e-2					)


						def   __lowercase (							self				:			List[Any]					):
										lowerCAmelCase  =				self.feat_extract_dict
										lowerCAmelCase  =				True
										lowerCAmelCase  =				self.feature_extraction_class(**lowerCAmelCase					)
										lowerCAmelCase  =				self.feat_extract_tester.prepare_inputs_for_target()
										lowerCAmelCase  =				[len(lowerCAmelCase					) for x in speech_inputs]
										lowerCAmelCase  =				feat_extract.model_input_names[0]

										lowerCAmelCase  =				BatchFeature({input_name: speech_inputs}					)

										lowerCAmelCase  =				feat_extract.num_mel_bins  # hack!

										lowerCAmelCase  =				feat_extract.pad(lowerCAmelCase						,						padding="""longest"""						,						return_tensors="""np"""					)
										self.assertIn("""attention_mask"""						,						lowerCAmelCase					)
										self.assertListEqual(list(processed.attention_mask.shape					)						,						list(processed[input_name].shape[:2]					)					)
										self.assertListEqual(processed.attention_mask.sum(-1					).tolist()						,						lowerCAmelCase					)


						def   __lowercase (							self				:			Optional[Any]					):
										lowerCAmelCase  =				self.feat_extract_dict
										lowerCAmelCase  =				True
										lowerCAmelCase  =				self.feature_extraction_class(**lowerCAmelCase					)
										lowerCAmelCase  =				self.feat_extract_tester.prepare_inputs_for_target()
										lowerCAmelCase  =				[len(lowerCAmelCase					) for x in speech_inputs]
										lowerCAmelCase  =				feat_extract.model_input_names[0]

										lowerCAmelCase  =				BatchFeature({input_name: speech_inputs}					)
										lowerCAmelCase  =				min(lowerCAmelCase					)

										lowerCAmelCase  =				feat_extract.num_mel_bins  # hack!

										lowerCAmelCase  =				feat_extract.pad(
										    lowerCAmelCase						,						padding="""max_length"""						,						max_length=lowerCAmelCase						,						truncation=lowerCAmelCase						,						return_tensors="""np"""					)
										self.assertIn("""attention_mask"""						,						lowerCAmelCase					)
										self.assertListEqual(
										    list(processed_pad.attention_mask.shape					)						,						[processed_pad[input_name].shape[0], max_length]					)
										self.assertListEqual(
										    processed_pad.attention_mask[:, :max_length].sum(-1					).tolist()						,						[max_length for x in speech_inputs]					)


						def   __lowercase (							self				:			Tuple						,						lowerCAmelCase				:			List[Any]					):
										from datasets import load_dataset

										lowerCAmelCase  =				load_dataset("""hf-internal-testing/librispeech_asr_dummy"""						,						"""clean"""						,						split="""validation"""					)
										# automatic decoding with librispeech
										lowerCAmelCase  =				ds.sort("""id"""					).select(range(lowerCAmelCase					)					)[:num_samples]["""audio"""]

										return [x["array"] for x in speech_samples]


						def   __lowercase (							self				:			str					):
										# fmt: off
										lowerCAmelCase  =				torch.tensor(
										    [2.3_804e-03, 2.0_752e-03, 1.9_836e-03, 2.1_057e-03, 1.6_174e-03,
										     3.0_518e-04, 9.1_553e-05, 3.3_569e-04, 9.7_656e-04, 1.8_311e-03,
										     2.0_142e-03, 2.1_057e-03, 1.7_395e-03, 4.5_776e-04, -3.9_673e-04,
										     4.5_776e-04, 1.0_071e-03, 9.1_553e-05, 4.8_828e-04, 1.1_597e-03,
										     7.3_242e-04, 9.4_604e-04, 1.8_005e-03, 1.8_311e-03, 8.8_501e-04,
										     4.2_725e-04, 4.8_828e-04, 7.3_242e-04, 1.0_986e-03, 2.1_057e-03]					)
										# fmt: on

										lowerCAmelCase  =				self._load_datasamples(1					)
										lowerCAmelCase  =				SpeechTaFeatureExtractor()
										lowerCAmelCase  =				feature_extractor(lowerCAmelCase						,						return_tensors="""pt"""					).input_values
										self.assertEquals(input_values.shape						,						(1, 9_3680)					)
										self.assertTrue(torch.allclose(input_values[0, :30]						,						lowerCAmelCase						,						atol=1e-6					)					)




						def   __lowercase (							self				:			List[Any]					):
										# fmt: off
										lowerCAmelCase  =				torch.tensor(
										    [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
										     -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
										     -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
										     -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]					)
										# fmt: on

										lowerCAmelCase  =				self._load_datasamples(1					)
										lowerCAmelCase  =				SpeechTaFeatureExtractor()
										lowerCAmelCase  =				feature_extractor(audio_target=lowerCAmelCase						,						return_tensors="""pt"""					).input_values
										self.assertEquals(input_values.shape						,						(1, 366, 80)					)
										self.assertTrue(torch.allclose(input_values[0, 0, :30]						,						lowerCAmelCase						,						atol=1e-4					)					)











"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


a      =							{
    'configuration_owlvit': [
        'OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'OwlViTConfig',
        'OwlViTOnnxConfig',
        'OwlViTTextConfig',
        'OwlViTVisionConfig',
    ],
    'processing_owlvit': ['OwlViTProcessor'],
}


try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a      =							['OwlViTFeatureExtractor']
		a      =							['OwlViTImageProcessor']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a      =							[
		    'OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'OwlViTModel',
		    'OwlViTPreTrainedModel',
		    'OwlViTTextModel',
		    'OwlViTVisionModel',
		    'OwlViTForObjectDetection',
		]

if TYPE_CHECKING:
		from .configuration_owlvit import (
		    OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    OwlViTConfig,
		    OwlViTOnnxConfig,
		    OwlViTTextConfig,
		    OwlViTVisionConfig,
		)
		from .processing_owlvit import OwlViTProcessor

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_owlvit import OwlViTFeatureExtractor
				from .image_processing_owlvit import OwlViTImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_owlvit import (
				    OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    OwlViTForObjectDetection,
				    OwlViTModel,
				    OwlViTPreTrainedModel,
				    OwlViTTextModel,
				    OwlViTVisionModel,
				)

else:
		import sys

		a      =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





