
import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
							    MODEL_MAPPING,
							    LevitForImageClassification,
							    LevitForImageClassificationWithTeacher,
							    LevitModel,
							)
							from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import LevitImageProcessor







class        lowercase	(      SCREAMING_SNAKE_CASE__	):




							def 				A__   (       self):
												lowercase					=		self.config_class(**self.inputs_dict)
												self.parent.assertTrue(hasattr(A__     ,'''hidden_sizes'''))
												self.parent.assertTrue(hasattr(A__     ,'''num_attention_heads'''))







class        lowercase	:




							def __init__(       self     ,A__     ,A__=1_3     ,A__=6_4     ,A__=3     ,A__=3     ,A__=2     ,A__=1     ,A__=1_6     ,A__=[1_2_8, 2_5_6, 3_8_4]     ,A__=[4, 6, 8]     ,A__=[2, 3, 4]     ,A__=[1_6, 1_6, 1_6]     ,A__=0     ,A__=[2, 2, 2]     ,A__=[2, 2, 2]     ,A__=0.02     ,A__=True     ,A__=True     ,A__=2     ,):
												lowercase					=		parent
												lowercase					=		batch_size
												lowercase					=		image_size
												lowercase					=		num_channels
												lowercase					=		kernel_size
												lowercase					=		stride
												lowercase					=		padding
												lowercase					=		hidden_sizes
												lowercase					=		num_attention_heads
												lowercase					=		depths
												lowercase					=		key_dim
												lowercase					=		drop_path_rate
												lowercase					=		patch_size
												lowercase					=		attention_ratio
												lowercase					=		mlp_ratio
												lowercase					=		initializer_range
												lowercase					=		[
												    ['''Subsample''', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
												    ['''Subsample''', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
												]
												lowercase					=		is_training
												lowercase					=		use_labels
												lowercase					=		num_labels
												lowercase					=		initializer_range




							def 				A__   (       self):
												lowercase					=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

												lowercase					=		None
												if self.use_labels:
																	lowercase					=		ids_tensor([self.batch_size]     ,self.num_labels)

												lowercase					=		self.get_config()
												return config, pixel_values, labels




							def 				A__   (       self):
												return LevitConfig(
												    image_size=self.image_size     ,num_channels=self.num_channels     ,kernel_size=self.kernel_size     ,stride=self.stride     ,padding=self.padding     ,patch_size=self.patch_size     ,hidden_sizes=self.hidden_sizes     ,num_attention_heads=self.num_attention_heads     ,depths=self.depths     ,key_dim=self.key_dim     ,drop_path_rate=self.drop_path_rate     ,mlp_ratio=self.mlp_ratio     ,attention_ratio=self.attention_ratio     ,initializer_range=self.initializer_range     ,down_ops=self.down_ops     ,)




							def 				A__   (       self     ,A__     ,A__     ,A__):
												lowercase					=		LevitModel(config=A__)
												model.to(A__)
												model.eval()
												lowercase					=		model(A__)
												lowercase					=		(self.image_size, self.image_size)
												lowercase			,		lowercase					=		image_size[0], image_size[1]
												for _ in range(4):
																	lowercase					=		floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1)
																	lowercase					=		floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1)
												self.parent.assertEqual(
												    result.last_hidden_state.shape     ,(self.batch_size, ceil(height / 4) * ceil(width / 4), self.hidden_sizes[-1])     ,)




							def 				A__   (       self     ,A__     ,A__     ,A__):
												lowercase					=		self.num_labels
												lowercase					=		LevitForImageClassification(A__)
												model.to(A__)
												model.eval()
												lowercase					=		model(A__     ,labels=A__)
												self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.num_labels))





							def 				A__   (       self):
												lowercase					=		self.prepare_config_and_inputs()
												lowercase			,		lowercase			,		lowercase					=		config_and_inputs
												lowercase					=		{'''pixel_values''': pixel_values}
												return config, inputs_dict







@require_torch
class        lowercase	(      SCREAMING_SNAKE_CASE__ ,						SCREAMING_SNAKE_CASE__ ,						unittest.TestCase	):
							lowercase_ : str       =(
							    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
							    if is_torch_available()
							    else ()
							)
							lowercase_ : List[str]       =(
							    {
							        '''feature-extraction''': LevitModel,
							        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
							    }
							    if is_torch_available()
							    else {}
							)

							lowercase_ : Tuple       =False
							lowercase_ : List[str]       =False
							lowercase_ : Dict       =False
							lowercase_ : Union[str, Any]       =False
							lowercase_ : List[Any]       =False




							def 				A__   (       self):
												lowercase					=		LevitModelTester(self)
												lowercase					=		ConfigTester(self     ,config_class=A__     ,has_text_modality=A__     ,hidden_size=3_7)




							def 				A__   (       self):
												self.create_and_test_config_common_properties()
												self.config_tester.create_and_test_config_to_json_string()
												self.config_tester.create_and_test_config_to_json_file()
												self.config_tester.create_and_test_config_from_and_save_pretrained()
												self.config_tester.create_and_test_config_with_num_labels()
												self.config_tester.check_config_can_be_init_without_params()
												self.config_tester.check_config_arguments_init()




							def 				A__   (       self):
												return




							@unittest.skip(reason='''Levit does not use inputs_embeds''')
							def 				A__   (       self):
												pass




							@unittest.skip(reason='''Levit does not support input and output embeddings''')
							def 				A__   (       self):
												pass




							@unittest.skip(reason='''Levit does not output attentions''')
							def 				A__   (       self):
												pass




							def 				A__   (       self):
												lowercase			,		lowercase					=		self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	lowercase					=		model_class(A__)
																	lowercase					=		inspect.signature(model.forward)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	lowercase					=		[*signature.parameters.keys()]

																	lowercase					=		['''pixel_values''']
																	self.assertListEqual(arg_names[:1]     ,A__)




							def 				A__   (       self):
												def check_hidden_states_output(A__     ,A__     ,A__):
																	lowercase					=		model_class(A__)
																	model.to(A__)
																	model.eval()

																	with torch.no_grad():
																						lowercase					=		model(**self._prepare_for_class(A__     ,A__))

																	lowercase					=		outputs.hidden_states

																	lowercase					=		len(self.model_tester.depths) + 1
																	self.assertEqual(len(A__)     ,A__)

																	lowercase					=		(self.model_tester.image_size, self.model_tester.image_size)
																	lowercase			,		lowercase					=		image_size[0], image_size[1]
																	for _ in range(4):
																						lowercase					=		floor(
																						    (
																						        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																						        / self.model_tester.stride
																						    )
																						    + 1)
																						lowercase					=		floor(
																						    (
																						        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																						        / self.model_tester.stride
																						    )
																						    + 1)
																	# verify the first hidden states (first block)
																	self.assertListEqual(
																	    list(hidden_states[0].shape[-2:])     ,[
																	        height * width,
																	        self.model_tester.hidden_sizes[0],
																	    ]     ,)

												lowercase			,		lowercase					=		self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																	lowercase					=		True
																	check_hidden_states_output(A__     ,A__     ,A__)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	lowercase					=		True

																	check_hidden_states_output(A__     ,A__     ,A__)




							@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
							def 				A__   (       self):
												pass




							def 				A__   (       self     ,A__     ,A__     ,A__=False):
												lowercase					=		super()._prepare_for_class(A__     ,A__     ,return_labels=A__)

												if return_labels:
																	if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																						del inputs_dict["labels"]

												return inputs_dict




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*A__)




							def 				A__   (       self):
												if not self.model_tester.is_training:
																	return

												lowercase			,		lowercase					=		self.model_tester.prepare_config_and_inputs_for_common()
												lowercase					=		True

												for model_class in self.all_model_classes:
																	# LevitForImageClassificationWithTeacher supports inference-only
																	if (
																	    model_class in get_values(A__)
																	    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																	):
																						continue
																	lowercase					=		model_class(A__)
																	model.to(A__)
																	model.train()
																	lowercase					=		self._prepare_for_class(A__     ,A__     ,return_labels=A__)
																	lowercase					=		model(**A__).loss
																	loss.backward()




							def 				A__   (       self):
												lowercase			,		lowercase					=		self.model_tester.prepare_config_and_inputs_for_common()
												if not self.model_tester.is_training:
																	return

												lowercase					=		False
												lowercase					=		True

												for model_class in self.all_model_classes:
																	if model_class in get_values(A__) or not model_class.supports_gradient_checkpointing:
																						continue
																	# LevitForImageClassificationWithTeacher supports inference-only
																	if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																						continue
																	lowercase					=		model_class(A__)
																	model.gradient_checkpointing_enable()
																	model.to(A__)
																	model.train()
																	lowercase					=		self._prepare_for_class(A__     ,A__     ,return_labels=A__)
																	lowercase					=		model(**A__).loss
																	loss.backward()




							def 				A__   (       self):
												lowercase			,		lowercase					=		self.model_tester.prepare_config_and_inputs_for_common()

												lowercase					=		[
												    {'''title''': '''multi_label_classification''', '''num_labels''': 2, '''dtype''': torch.float},
												    {'''title''': '''single_label_classification''', '''num_labels''': 1, '''dtype''': torch.long},
												    {'''title''': '''regression''', '''num_labels''': 1, '''dtype''': torch.float},
												]

												for model_class in self.all_model_classes:
																	if (
																	    model_class
																	    not in [
																	        *get_values(A__),
																	    ]
																	    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																	):
																						continue

																	for problem_type in problem_types:
																						with self.subTest(msg=f'Testing {model_class} with {problem_type["title"]}'):
																											lowercase					=		problem_type['''title''']
																											lowercase					=		problem_type['''num_labels''']

																											lowercase					=		model_class(A__)
																											model.to(A__)
																											model.train()

																											lowercase					=		self._prepare_for_class(A__     ,A__     ,return_labels=A__)

																											if problem_type["num_labels"] > 1:
																																lowercase					=		inputs['''labels'''].unsqueeze(1).repeat(1     ,problem_type['''num_labels'''])

																											lowercase					=		inputs['''labels'''].to(problem_type['''dtype'''])

																											# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																											# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																											# they have the same size." which is a symptom something in wrong for the regression problem.
																											# See https://github.com/huggingface/transformers/issues/11780
																											with warnings.catch_warnings(record=A__) as warning_list:
																																lowercase					=		model(**A__).loss
																											for w in warning_list:
																																if "Using a target size that is different to the input size" in str(w.message):
																																					raise ValueError(
																																					    f'Something is going wrong in the regression problem: intercepted {w.message}')

																											loss.backward()





							@slow
							def 				A__   (       self):
												for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase					=		LevitModel.from_pretrained(A__)
																	self.assertIsNotNone(A__)



def  UpperCamelCase					(							):
					'''simple docstring'''
					lowercase					=		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
					return image







@require_torch
@require_vision
class        lowercase	(      unittest.TestCase	):




							@cached_property
							def 				A__   (       self):
												return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0])





							@slow
							def 				A__   (       self):
												lowercase					=		LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
												    A__)

												lowercase					=		self.default_image_processor
												lowercase					=		prepare_img()
												lowercase					=		image_processor(images=A__     ,return_tensors='''pt''').to(A__)

												# forward pass
												with torch.no_grad():
																	lowercase					=		model(**A__)

												# verify the logits
												lowercase					=		torch.Size((1, 1_0_0_0))
												self.assertEqual(outputs.logits.shape     ,A__)

												lowercase					=		torch.tensor([1.0448, -0.3745, -1.8317]).to(A__)

												self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,A__     ,atol=1E-4))






import random
import unittest

import numpy as np

import transformers
from transformers import is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax


if is_flax_available():
							import os

							import jax.numpy as jnp
							from jax import jit

							from transformers import AutoTokenizer, FlaxAutoModelForCausalLM
							from transformers.modeling_flax_pytorch_utils import load_flax_weights_in_pytorch_model

							lowercase__	:Optional[Any]										=					"0.12"  # assumed parallelism: 8


if is_torch_available():
							import torch



def  UpperCamelCase					(							lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__=None	):
					'''simple docstring'''
					if rng is None:
										lowercase					=		random.Random()

					lowercase					=		1
					for dim in shape:
										total_dims *= dim

					lowercase					=		[]
					for _ in range(lowerCAmelCase__	):
										values.append(rng.randint(0				,    vocab_size - 1	)	)

					lowercase					=		np.array(lowerCAmelCase__				,    dtype=jnp.intaa	).reshape(lowerCAmelCase__	)

					return output



def  UpperCamelCase					(							lowerCAmelCase__				,    lowerCAmelCase__=None	):
					'''simple docstring'''
					lowercase					=		ids_tensor(lowerCAmelCase__				,    vocab_size=2				,    rng=lowerCAmelCase__	)
					# make sure that at least one token is attended to for each batch
					lowercase					=		1
					return attn_mask







@require_flax
class        lowercase	:
							lowercase_ : Any       =None
							lowercase_ : List[str]       =()




							def 				A__   (       self):
												lowercase			,		lowercase					=		self.model_tester.prepare_config_and_inputs_for_common()

												# cut to half length & take max batch_size 3
												lowercase					=		2
												lowercase					=		inputs['''input_ids'''].shape[-1] // 2
												lowercase					=		inputs['''input_ids'''][:max_batch_size, :sequence_length]

												lowercase					=		jnp.ones_like(A__)
												lowercase					=		attention_mask[:max_batch_size, :sequence_length]

												# generate max 5 tokens
												lowercase					=		input_ids.shape[-1] + 5
												if config.eos_token_id is not None and config.pad_token_id is None:
																	# hack to allow generate for models such as GPT2 as is done in `generate()`
																	lowercase					=		config.eos_token_id
												return config, input_ids, attention_mask, max_length




							@is_pt_flax_cross_test
							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		False
												lowercase					=		max_length
												lowercase					=		0

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model_class.__name__[4:]  # Skip the "Flax" at the beginning
																	lowercase					=		getattr(A__     ,A__)
																	lowercase					=		pt_model_class(A__).eval()
																	lowercase					=		load_flax_weights_in_pytorch_model(A__     ,flax_model.params)

																	lowercase					=		flax_model.generate(A__).sequences
																	lowercase					=		pt_model.generate(torch.tensor(A__     ,dtype=torch.long))

																	if flax_generation_outputs.shape[-1] > pt_generation_outputs.shape[-1]:
																						lowercase					=		flax_generation_outputs[:, : pt_generation_outputs.shape[-1]]

																	self.assertListEqual(pt_generation_outputs.numpy().tolist()     ,flax_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		False
												lowercase					=		max_length

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		True
												lowercase					=		max_length

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		False
												lowercase					=		max_length
												lowercase					=		2

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		False
												lowercase					=		max_length
												lowercase					=		2
												lowercase					=		2

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__).sequences
																	self.assertEqual(generation_outputs.shape[0]     ,input_ids.shape[0] * config.num_return_sequences)




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		True
												lowercase					=		max_length
												lowercase					=		0.8
												lowercase					=		1_0
												lowercase					=		0.3
												lowercase					=		1
												lowercase					=		8
												lowercase					=		9

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		max_length
												lowercase					=		1
												lowercase					=		8
												lowercase					=		9

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()
												lowercase					=		max_length
												lowercase					=		2
												lowercase					=		1
												lowercase					=		8
												lowercase					=		9

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()

												# pad attention mask on the left
												lowercase					=		attention_mask.at[(0, 0)].set(0)

												lowercase					=		False
												lowercase					=		max_length

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__     ,attention_mask=A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__     ,attention_mask=A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())




							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()

												# pad attention mask on the left
												lowercase					=		attention_mask.at[(0, 0)].set(0)

												lowercase					=		True
												lowercase					=		max_length

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__     ,attention_mask=A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__     ,attention_mask=A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())





							def 				A__   (       self):
												lowercase			,		lowercase			,		lowercase			,		lowercase					=		self._get_input_ids_and_config()

												# pad attention mask on the left
												lowercase					=		attention_mask.at[(0, 0)].set(0)

												lowercase					=		2
												lowercase					=		max_length

												for model_class in self.all_generative_model_classes:
																	lowercase					=		model_class(A__)

																	lowercase					=		model.generate(A__     ,attention_mask=A__).sequences
																	self.assertEqual(generation_outputs.shape[-1]     ,A__)

																	lowercase					=		jit(model.generate)
																	lowercase					=		jit_generate(A__     ,attention_mask=A__).sequences

																	self.assertListEqual(generation_outputs.tolist()     ,jit_generation_outputs.tolist())







@require_flax
class        lowercase	(      unittest.TestCase	):




							def 				A__   (       self):
												lowercase					=		AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-bert''')
												lowercase					=		FlaxAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-bert-flax-only''')

												lowercase					=		'''Hello world'''
												lowercase					=		tokenizer(A__     ,return_tensors='''np''').input_ids

												# typos are quickly detected (the correct argument is `do_sample`)
												with self.assertRaisesRegex(A__     ,'''do_samples'''):
																	model.generate(A__     ,do_samples=A__)

												# arbitrary arguments that will not be used anywhere are also not accepted
												with self.assertRaisesRegex(A__     ,'''foo'''):
																	lowercase					=		{'''foo''': '''bar'''}
																	model.generate(A__     ,**A__)




