




"""simple docstring"""

import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
		import os

		# The slow tests are often failing with OOM error on GPU
		# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
		# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
		_lowerCamelCase	:      Any   =							'platform'

		import jax
		import jax.numpy as jnp

		from transformers import AutoTokenizer
		from transformers.models.mbart.modeling_flax_mbart import (
		    FlaxMBartForConditionalGeneration,
		    FlaxMBartForQuestionAnswering,
		    FlaxMBartForSequenceClassification,
		    FlaxMBartModel,
		    shift_tokens_right,
		)

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase=None	,   _UpperCAmelCase=None	,   _UpperCAmelCase=None	,   _UpperCAmelCase=None	,   _UpperCAmelCase=None	,   _UpperCAmelCase=None	,   ):




	"""simple docstring"""






	if attention_mask is None:
		A_	:					List[str]						 =		np.where(input_ids != config.pad_token_id	,   1	,   0						)
	if decoder_attention_mask is None:
		A_	:					Optional[Any]						 =		np.where(decoder_input_ids != config.pad_token_id	,   1	,   0						)
	if head_mask is None:
		A_	:					Dict						 =		np.ones((config.encoder_layers, config.encoder_attention_heads)						)
	if decoder_head_mask is None:
		A_	:					Optional[Any]						 =		np.ones((config.decoder_layers, config.decoder_attention_heads)						)
	if cross_attn_head_mask is None:
		A_	:					int						 =		np.ones((config.decoder_layers, config.decoder_attention_heads)						)
	return {
	    "input_ids": input_ids,
	    "decoder_input_ids": decoder_input_ids,
	    "attention_mask": attention_mask,
	    "decoder_attention_mask": decoder_attention_mask,
	}

class 							lowercase   (     unittest.TestCase):







				def __init__(				self :       List[Any]   ,  _lowerCamelCase :       Tuple   ,  _lowerCamelCase :       Optional[Any]=13   ,  _lowerCamelCase :       Optional[int]=7   ,  _lowerCamelCase :       List[Any]=True   ,  _lowerCamelCase :       List[Any]=False   ,  _lowerCamelCase :       Union[str, Any]=99   ,  _lowerCamelCase :       int=16   ,  _lowerCamelCase :       List[str]=2   ,  _lowerCamelCase :       Optional[Any]=4   ,  _lowerCamelCase :       Dict=4   ,  _lowerCamelCase :       Optional[int]="gelu"   ,  _lowerCamelCase :       Union[str, Any]=0.1   ,  _lowerCamelCase :       List[str]=0.1   ,  _lowerCamelCase :       int=32   ,  _lowerCamelCase :       List[str]=2   ,  _lowerCamelCase :       Union[str, Any]=1   ,  _lowerCamelCase :       Union[str, Any]=0   ,  _lowerCamelCase :       List[Any]=2   ,  _lowerCamelCase :       Optional[int]=0.02   ,  ):



					"""simple docstring"""

					A_	:					int						 =		parent
					A_	:					Any						 =		batch_size
					A_	:					str						 =		seq_length
					A_	:					Tuple						 =		is_training
					A_	:					Optional[int]						 =		use_labels
					A_	:					Optional[int]						 =		vocab_size
					A_	:					Dict						 =		hidden_size
					A_	:					List[Any]						 =		num_hidden_layers
					A_	:					int						 =		num_attention_heads
					A_	:					List[Any]						 =		intermediate_size
					A_	:					Dict						 =		hidden_act
					A_	:					str						 =		hidden_dropout_prob
					A_	:					List[str]						 =		attention_probs_dropout_prob
					A_	:					Union[str, Any]						 =		max_position_embeddings
					A_	:					Dict						 =		eos_token_id
					A_	:					List[str]						 =		pad_token_id
					A_	:					Optional[int]						 =		bos_token_id
					A_	:					int						 =		decoder_start_token_id
					A_	:					int						 =		initializer_range







				def        a_	(				self :       Any							):



					"""simple docstring"""

					A_	:					List[Any]						 =		np.clip(ids_tensor([self.batch_size, self.seq_length - 1]   ,  self.vocab_size							)   ,  3   ,  self.vocab_size							)
					A_	:					Dict						 =		np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)   ,  dtype=np.intaa							))   ,  -1							)

					A_	:					str						 =		shift_tokens_right(lowerCamelCase_   ,  1							)

					A_	:					Optional[Any]						 =		MBartConfig(
					    vocab_size=self.vocab_size   ,  d_model=self.hidden_size   ,  encoder_layers=self.num_hidden_layers   ,  decoder_layers=self.num_hidden_layers   ,  encoder_attention_heads=self.num_attention_heads   ,  decoder_attention_heads=self.num_attention_heads   ,  encoder_ffn_dim=self.intermediate_size   ,  decoder_ffn_dim=self.intermediate_size   ,  dropout=self.hidden_dropout_prob   ,  attention_dropout=self.attention_probs_dropout_prob   ,  max_position_embeddings=self.max_position_embeddings   ,  eos_token_id=self.eos_token_id   ,  bos_token_id=self.bos_token_id   ,  pad_token_id=self.pad_token_id   ,  decoder_start_token_id=self.decoder_start_token_id   ,  initializer_range=self.initializer_range   ,  use_cache=lowerCamelCase_   ,  )
					A_	:					Dict						 =		prepare_mbart_inputs_dict(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_							)
					return config, inputs_dict







				def        a_	(				self :       Any							):



					"""simple docstring"""

					A_ ,			A_	:					Optional[Any]						 =		self.prepare_config_and_inputs()
					return config, inputs_dict







				def        a_	(				self :       int   ,  _lowerCamelCase :       Optional[int]   ,  _lowerCamelCase :       List[str]   ,  _lowerCamelCase :       Optional[Any]							):



					"""simple docstring"""

					A_	:					Dict						 =		20
					A_	:					List[Any]						 =		model_class_name(lowerCamelCase_							)

					A_	:					str						 =		model.encode(inputs_dict['''input_ids''']							)

					A_ ,			A_	:					Union[str, Any]						 =		(
					    inputs_dict['''decoder_input_ids'''],
					    inputs_dict['''decoder_attention_mask'''],
					)

					A_	:					Any						 =		model.init_cache(decoder_input_ids.shape[0]   ,  lowerCamelCase_   ,  lowerCamelCase_							)
					A_	:					Optional[Any]						 =		jnp.ones((decoder_input_ids.shape[0], max_decoder_length)   ,  dtype='''i4'''							)

					A_	:					Optional[Any]						 =		jnp.broadcast_to(
					    jnp.arange(decoder_input_ids.shape[-1] - 1							)[None, :]   ,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)   ,  )
					A_	:					str						 =		model.decode(
					    decoder_input_ids[:, :-1]   ,  lowerCamelCase_   ,  decoder_attention_mask=lowerCamelCase_   ,  past_key_values=lowerCamelCase_   ,  decoder_position_ids=lowerCamelCase_   ,  )

					A_	:					Tuple						 =		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   ,  dtype='''i4'''							)
					A_	:					str						 =		model.decode(
					    decoder_input_ids[:, -1:]   ,  lowerCamelCase_   ,  decoder_attention_mask=lowerCamelCase_   ,  past_key_values=outputs_cache.past_key_values   ,  decoder_position_ids=lowerCamelCase_   ,  )

					A_	:					Union[str, Any]						 =		model.decode(lowerCamelCase_   ,  lowerCamelCase_							)

					A_	:					List[str]						 =		np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])							)							)
					self.parent.assertTrue(diff < 1E-3   ,  msg=F"""Max diff is {diff}"""							)







				def        a_	(				self :       Dict   ,  _lowerCamelCase :       List[Any]   ,  _lowerCamelCase :       List[Any]   ,  _lowerCamelCase :       List[str]							):



					"""simple docstring"""

					A_	:					Tuple						 =		20
					A_	:					int						 =		model_class_name(lowerCamelCase_							)

					A_	:					List[str]						 =		model.encode(inputs_dict['''input_ids''']							)

					A_ ,			A_	:					Any						 =		(
					    inputs_dict['''decoder_input_ids'''],
					    inputs_dict['''decoder_attention_mask'''],
					)

					A_	:					Optional[Any]						 =		jnp.concatenate(
					    [
					        decoder_attention_mask,
					        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])							),
					    ]   ,  axis=-1   ,  )

					A_	:					List[str]						 =		model.init_cache(decoder_input_ids.shape[0]   ,  lowerCamelCase_   ,  lowerCamelCase_							)
					A_	:					Any						 =		jnp.broadcast_to(
					    jnp.arange(decoder_input_ids.shape[-1] - 1							)[None, :]   ,  (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)   ,  )

					A_	:					Tuple						 =		model.decode(
					    decoder_input_ids[:, :-1]   ,  lowerCamelCase_   ,  decoder_attention_mask=lowerCamelCase_   ,  past_key_values=lowerCamelCase_   ,  decoder_position_ids=lowerCamelCase_   ,  )
					A_	:					List[str]						 =		jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   ,  dtype='''i4'''							)
					A_	:					int						 =		model.decode(
					    decoder_input_ids[:, -1:]   ,  lowerCamelCase_   ,  past_key_values=outputs_cache.past_key_values   ,  decoder_attention_mask=lowerCamelCase_   ,  decoder_position_ids=lowerCamelCase_   ,  )

					A_	:					Dict						 =		model.decode(lowerCamelCase_   ,  lowerCamelCase_   ,  decoder_attention_mask=lowerCamelCase_							)

					A_	:					List[Any]						 =		np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])							)							)
					self.parent.assertTrue(diff < 1E-3   ,  msg=F"""Max diff is {diff}"""							)

@require_flax
class 							lowercase   (     unittest.TestCase):
				__lowerCAmelCase     :     int								= 99







				def        a_	(				self :       Dict							):



					"""simple docstring"""

					A_	:					List[Any]						 =		np.array(
					    [
					        [71, 82, 18, 33, 46, 91, 2],
					        [68, 34, 26, 58, 30, 82, 2],
					        [5, 97, 17, 39, 94, 40, 2],
					        [76, 83, 94, 25, 70, 78, 2],
					        [87, 59, 41, 35, 48, 66, 2],
					        [55, 13, 16, 58, 5, 2, 1],  # note padding
					        [64, 27, 31, 51, 12, 75, 2],
					        [52, 64, 86, 17, 83, 39, 2],
					        [48, 61, 9, 24, 71, 82, 2],
					        [26, 1, 60, 48, 22, 13, 2],
					        [21, 5, 62, 28, 14, 76, 2],
					        [45, 98, 37, 86, 59, 48, 2],
					        [70, 70, 50, 9, 28, 0, 2],
					    ]   ,  dtype=np.intaa   ,  )

					A_	:					str						 =		input_ids.shape[0]
					A_	:					Optional[Any]						 =		MBartConfig(
					    vocab_size=self.vocab_size   ,  d_model=24   ,  encoder_layers=2   ,  decoder_layers=2   ,  encoder_attention_heads=2   ,  decoder_attention_heads=2   ,  encoder_ffn_dim=32   ,  decoder_ffn_dim=32   ,  max_position_embeddings=48   ,  eos_token_id=2   ,  pad_token_id=1   ,  bos_token_id=0   ,  )
					return config, input_ids, batch_size







				def        a_	(				self :       Union[str, Any]							):



					"""simple docstring"""

					A_ ,			A_ ,			A_	:					int						 =		self._get_config_and_data()
					A_	:					Tuple						 =		FlaxMBartForSequenceClassification(lowerCamelCase_							)
					A_	:					Optional[int]						 =		model(input_ids=lowerCamelCase_   ,  decoder_input_ids=lowerCamelCase_							)
					A_	:					int						 =		(batch_size, config.num_labels)
					self.assertEqual(outputs['''logits'''].shape   ,  lowerCamelCase_							)







				def        a_	(				self :       List[Any]							):



					"""simple docstring"""

					A_ ,			A_ ,			A_	:					List[str]						 =		self._get_config_and_data()
					A_	:					Union[str, Any]						 =		FlaxMBartForQuestionAnswering(lowerCamelCase_							)
					A_	:					Any						 =		model(input_ids=lowerCamelCase_							)

					self.assertEqual(outputs['''start_logits'''].shape   ,  input_ids.shape							)
					self.assertEqual(outputs['''end_logits'''].shape   ,  input_ids.shape							)







				def        a_	(				self :       List[str]							):



					"""simple docstring"""

					A_ ,			A_ ,			A_	:					List[Any]						 =		self._get_config_and_data()
					A_	:					List[str]						 =		FlaxMBartForConditionalGeneration(lowerCamelCase_							)
					A_	:					List[Any]						 =		lm_model(input_ids=lowerCamelCase_							)
					A_	:					List[str]						 =		(batch_size, input_ids.shape[1], config.vocab_size)
					self.assertEqual(outputs['''logits'''].shape   ,  lowerCamelCase_							)







				def        a_	(				self :       List[Any]							):



					"""simple docstring"""

					A_	:					Dict						 =		MBartConfig(
					    vocab_size=self.vocab_size   ,  d_model=14   ,  encoder_layers=2   ,  decoder_layers=2   ,  encoder_attention_heads=2   ,  decoder_attention_heads=2   ,  encoder_ffn_dim=8   ,  decoder_ffn_dim=8   ,  max_position_embeddings=48   ,  )
					A_	:					Tuple						 =		FlaxMBartForConditionalGeneration(lowerCamelCase_							)
					A_	:					Optional[int]						 =		np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]   ,  dtype=np.intaa							)
					A_	:					int						 =		np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]   ,  dtype=np.intaa							)
					A_	:					Any						 =		lm_model(input_ids=lowerCamelCase_   ,  decoder_input_ids=lowerCamelCase_							)
					A_	:					List[str]						 =		(*summary.shape, config.vocab_size)
					self.assertEqual(outputs['''logits'''].shape   ,  lowerCamelCase_							)







				def        a_	(				self :       List[Any]							):



					"""simple docstring"""

					A_	:					Tuple						 =		np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]   ,  dtype=np.intaa							)
					A_	:					int						 =		shift_tokens_right(lowerCamelCase_   ,  1							)
					A_	:					Dict						 =		np.equal(lowerCamelCase_   ,  1							).astype(np.floataa							).sum()
					A_	:					Dict						 =		np.equal(lowerCamelCase_   ,  1							).astype(np.floataa							).sum()
					self.assertEqual(shifted.shape   ,  input_ids.shape							)
					self.assertEqual(lowerCamelCase_   ,  n_pad_before - 1							)
					self.assertTrue(np.equal(shifted[:, 0]   ,  2							).all()							)

@require_flax
class 							lowercase   (     lowerCAmelCase_  ,						unittest.TestCase  ,						lowerCAmelCase_):
				__lowerCAmelCase     :     int								= True
				__lowerCAmelCase     :     Optional[Any]								= (
				    (
				        FlaxMBartModel,
				        FlaxMBartForConditionalGeneration,
				        FlaxMBartForSequenceClassification,
				        FlaxMBartForQuestionAnswering,
				    )
				    if is_flax_available()
				    else ()
				)
				__lowerCAmelCase     :     Any								= (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()







				def        a_	(				self :       Dict							):



					"""simple docstring"""

					A_	:					Optional[Any]						 =		FlaxMBartModelTester(self							)







				def        a_	(				self :       List[str]							):



					"""simple docstring"""

					A_ ,			A_	:					List[Any]						 =		self.model_tester.prepare_config_and_inputs()
					for model_class in self.all_model_classes:
						self.model_tester.check_use_cache_forward(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_							)







				def        a_	(				self :       Optional[int]							):



					"""simple docstring"""

					A_ ,			A_	:					Tuple						 =		self.model_tester.prepare_config_and_inputs()
					for model_class in self.all_model_classes:
						self.model_tester.check_use_cache_forward_with_attn_mask(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_							)







				def        a_	(				self :       Union[str, Any]							):



					"""simple docstring"""

					A_ ,			A_	:					Dict						 =		self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						with self.subTest(model_class.__name__							):
							A_	:					Optional[Any]						 =		self._prepare_for_class(lowerCamelCase_   ,  lowerCamelCase_							)
							A_	:					Union[str, Any]						 =		model_class(lowerCamelCase_							)

							@jax.jit
							def encode_jitted(_lowerCamelCase :       List[Any]   ,  _lowerCamelCase :       Dict=None   ,  **_lowerCamelCase :       str							):
								return model.encode(input_ids=lowerCamelCase_   ,  attention_mask=lowerCamelCase_							)

							with self.subTest('''JIT Enabled'''							):
								A_	:					str						 =		encode_jitted(**lowerCamelCase_							).to_tuple()

							with self.subTest('''JIT Disabled'''							):
								with jax.disable_jit():
									A_	:					Optional[int]						 =		encode_jitted(**lowerCamelCase_							).to_tuple()

							self.assertEqual(len(lowerCamelCase_							)   ,  len(lowerCamelCase_							)							)
							for jitted_output, output in zip(lowerCamelCase_   ,  lowerCamelCase_							):
								self.assertEqual(jitted_output.shape   ,  output.shape							)







				def        a_	(				self :       Optional[Any]							):



					"""simple docstring"""

					A_ ,			A_	:					Optional[Any]						 =		self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						with self.subTest(model_class.__name__							):
							A_	:					List[Any]						 =		model_class(lowerCamelCase_							)
							A_	:					Any						 =		model.encode(inputs_dict['''input_ids''']   ,  inputs_dict['''attention_mask''']							)

							A_	:					str						 =		{
							    '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
							    '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
							    '''encoder_outputs''': encoder_outputs,
							}

							@jax.jit
							def decode_jitted(_lowerCamelCase :       Optional[int]   ,  _lowerCamelCase :       Union[str, Any]   ,  _lowerCamelCase :       List[str]							):
								return model.decode(
								    decoder_input_ids=lowerCamelCase_   ,  decoder_attention_mask=lowerCamelCase_   ,  encoder_outputs=lowerCamelCase_   ,  )

							with self.subTest('''JIT Enabled'''							):
								A_	:					Union[str, Any]						 =		decode_jitted(**lowerCamelCase_							).to_tuple()

							with self.subTest('''JIT Disabled'''							):
								with jax.disable_jit():
									A_	:					str						 =		decode_jitted(**lowerCamelCase_							).to_tuple()

							self.assertEqual(len(lowerCamelCase_							)   ,  len(lowerCamelCase_							)							)
							for jitted_output, output in zip(lowerCamelCase_   ,  lowerCamelCase_							):
								self.assertEqual(jitted_output.shape   ,  output.shape							)







				@slow
				def        a_	(				self :       List[Any]							):



					"""simple docstring"""

					for model_class_name in self.all_model_classes:
						A_	:					int						 =		model_class_name.from_pretrained('''facebook/mbart-large-cc25'''   ,  from_pt=lowerCamelCase_							)
						# FlaxMBartForSequenceClassification expects eos token in input_ids
						A_	:					int						 =		np.ones((1, 1)							) * model.config.eos_token_id
						A_	:					int						 =		model(lowerCamelCase_							)
						self.assertIsNotNone(lowerCamelCase_							)

@require_flax
@require_sentencepiece
@require_tokenizers
class 							lowercase   (     unittest.TestCase):
				__lowerCAmelCase     :     Union[str, Any]								= [
				    ' UN Chief Says There Is No Military Solution in Syria',
				]
				__lowerCAmelCase     :     str								= [
				    'Şeful ONU declară că nu există o soluţie militară în Siria',
				]
				__lowerCAmelCase     :     Any								= 'facebook/mbart-large-en-ro'







				@cached_property
				def        a_	(				self :       Union[str, Any]							):



					"""simple docstring"""

					return AutoTokenizer.from_pretrained(self.model_name							)







				@cached_property
				def        a_	(				self :       Tuple							):



					"""simple docstring"""

					A_	:					Union[str, Any]						 =		FlaxMBartForConditionalGeneration.from_pretrained(self.model_name   ,  from_pt=lowerCamelCase_							)
					return model







				def        a_	(				self :       int   ,  **_lowerCamelCase :       int							):



					"""simple docstring"""

					A_	:					Union[str, Any]						 =		self.translate_src_text(**lowerCamelCase_							)
					self.assertListEqual(self.expected_text   ,  lowerCamelCase_							)







				def        a_	(				self :       Optional[int]   ,  **_lowerCamelCase :       List[str]							):



					"""simple docstring"""

					A_	:					Tuple						 =		self.tokenizer(self.src_text   ,  **lowerCamelCase_   ,  return_tensors='''np'''							)
					A_	:					Optional[int]						 =		self.model.generate(
					    model_inputs.input_ids   ,  attention_mask=model_inputs.attention_mask   ,  decoder_start_token_id=self.tokenizer.lang_code_to_id['''ro_RO''']   ,  early_stopping=lowerCamelCase_   ,  num_beams=2   ,  ).sequences
					A_	:					List[Any]						 =		self.tokenizer.batch_decode(lowerCamelCase_   ,  skip_special_tokens=lowerCamelCase_							)
					return generated_words







				@slow
				def        a_	(				self :       List[str]							):



					"""simple docstring"""

					self._assert_generated_batch_equal_expected()







"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


SCREAMING_SNAKE_CASE_  					= {
    'configuration_deformable_detr': ['DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DeformableDetrConfig'],
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE_  					= ['DeformableDetrFeatureExtractor']
  SCREAMING_SNAKE_CASE_  					= ['DeformableDetrImageProcessor']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE_  					= [
      'DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST',
      'DeformableDetrForObjectDetection',
      'DeformableDetrModel',
      'DeformableDetrPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_deformable_detr import DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, DeformableDetrConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_deformable_detr import DeformableDetrFeatureExtractor
    from .image_processing_deformable_detr import DeformableDetrImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_deformable_detr import (
        DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST,
        DeformableDetrForObjectDetection,
        DeformableDetrModel,
        DeformableDetrPreTrainedModel,
    )

else:
  import sys

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

