



"""simple docstring"""






import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel

				if is_vision_available():
								from transformers import MaskFormerImageProcessor

if is_vision_available():
				from PIL import Image

class 						__lowerCAmelCase				:


					'''simple docstring'''


					def __init__(   self     ,							a     ,							a=2     ,							a=True     ,							a=False     ,							a=10     ,							a=3     ,							a=32 * 4     ,							a=32 * 6     ,							a=4     ,							a=32     ,							):




										"""simple docstring"""





										snake_case_    :Optional[Any]										=    parent
										snake_case_    :Union[str, Any]										=    batch_size
										snake_case_    :Dict										=    is_training
										snake_case_    :List[Any]										=    use_auxiliary_loss
										snake_case_    :Tuple										=    num_queries
										snake_case_    :List[str]										=    num_channels
										snake_case_    :List[str]										=    min_size
										snake_case_    :Dict										=    max_size
										snake_case_    :Optional[Any]										=    num_labels
										snake_case_    :Optional[Any]										=    mask_feature_size







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :int										=    floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to(
										    _UpperCamelCase )

										snake_case_    :Optional[int]										=    torch.ones([self.batch_size, self.min_size, self.max_size]     ,							device=_UpperCamelCase )

										snake_case_    :Tuple										=    (
										    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]     ,							device=_UpperCamelCase ) > 0.5
										).float()
										snake_case_    :Union[str, Any]										=    (torch.rand((self.batch_size, self.num_labels)     ,							device=_UpperCamelCase ) > 0.5).long()

										snake_case_    :Optional[int]										=    self.get_config()
										return config, pixel_values, pixel_mask, mask_labels, class_labels







					def 		_a			(   self ):




										"""simple docstring"""





										return MaskFormerConfig.from_backbone_and_decoder_configs(
										    backbone_config=SwinConfig(
										        depths=[1, 1, 1, 1]     ,							)     ,							decoder_config=DetrConfig(
										        decoder_ffn_dim=1_28     ,							num_queries=self.num_queries     ,							decoder_attention_heads=2     ,							d_model=self.mask_feature_size     ,							)     ,							mask_feature_size=self.mask_feature_size     ,							fpn_feature_size=self.mask_feature_size     ,							num_channels=self.num_channels     ,							num_labels=self.num_labels     ,							)







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_						,	snake_case_						,	snake_case_						,	snake_case_						,	snake_case_    :int										=    self.prepare_config_and_inputs()
										snake_case_    :int										=    {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
										return config, inputs_dict







					def 		_a			(   self     ,							a     ,							a ):




										"""simple docstring"""





										snake_case_    :Union[str, Any]										=    output.encoder_hidden_states
										snake_case_    :Union[str, Any]										=    output.pixel_decoder_hidden_states
										snake_case_    :str										=    output.transformer_decoder_hidden_states

										self.parent.assertTrue(len(_UpperCamelCase )     ,							len(config.backbone_config.depths ) )
										self.parent.assertTrue(len(_UpperCamelCase )     ,							len(config.backbone_config.depths ) )
										self.parent.assertTrue(len(_UpperCamelCase )     ,							config.decoder_config.decoder_layers )







					def 		_a			(   self     ,							a     ,							a     ,							a     ,							a=False ):




										"""simple docstring"""





										with torch.no_grad():
															snake_case_    :str										=    MaskFormerModel(config=_UpperCamelCase )
															model.to(_UpperCamelCase )
															model.eval()

															snake_case_    :int										=    model(pixel_values=_UpperCamelCase     ,							pixel_mask=_UpperCamelCase )
															snake_case_    :Optional[Any]										=    model(_UpperCamelCase     ,							output_hidden_states=_UpperCamelCase )
										# the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the
										# encoder and pixel decoder
										self.parent.assertEqual(
										    output.transformer_decoder_last_hidden_state.shape     ,							(self.batch_size, self.num_queries, self.mask_feature_size)     ,							)
										# let's ensure the other two hidden state exists
										self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None )
										self.parent.assertTrue(output.encoder_last_hidden_state is not None )

										if output_hidden_states:
															self.check_output_hidden_state(_UpperCamelCase     ,							_UpperCamelCase )







					def 		_a			(   self     ,							a     ,							a     ,							a     ,							a     ,							a ):




										"""simple docstring"""





										snake_case_    :Any										=    MaskFormerForInstanceSegmentation(config=_UpperCamelCase )
										model.to(_UpperCamelCase )
										model.eval()

										def comm_check_on_output(a ):
															# let's still check that all the required stuff is there
															self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None )
															self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None )
															self.parent.assertTrue(result.encoder_last_hidden_state is not None )
															# okay, now we need to check the logits shape
															# due to the encoder compression, masks have a //4 spatial size
															self.parent.assertEqual(
															    result.masks_queries_logits.shape     ,							(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)     ,							)
															# + 1 for null class
															self.parent.assertEqual(
															    result.class_queries_logits.shape     ,							(self.batch_size, self.num_queries, self.num_labels + 1) )

										with torch.no_grad():
															snake_case_    :List[str]										=    model(pixel_values=_UpperCamelCase     ,							pixel_mask=_UpperCamelCase )
															snake_case_    :int										=    model(_UpperCamelCase )

															comm_check_on_output(_UpperCamelCase )

															snake_case_    :Dict										=    model(
															    pixel_values=_UpperCamelCase     ,							pixel_mask=_UpperCamelCase     ,							mask_labels=_UpperCamelCase     ,							class_labels=_UpperCamelCase )

										comm_check_on_output(_UpperCamelCase )

										self.parent.assertTrue(result.loss is not None )
										self.parent.assertEqual(result.loss.shape     ,							torch.Size([1] ) )



@require_torch
class 						__lowerCAmelCase				(A__       ,A__       ,unittest.TestCase	):


					'''simple docstring'''


					a__          =  (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
					a__          =  (
					    {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation}
					    if is_torch_available()
					    else {}
					)

					a__          =  False
					a__          =  False
					a__          =  False
					a__          =  False







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :List[str]										=    MaskFormerModelTester(self )
										snake_case_    :Optional[int]										=    ConfigTester(self     ,							config_class=_UpperCamelCase     ,							has_text_modality=_UpperCamelCase )







					def 		_a			(   self ):




										"""simple docstring"""





										self.config_tester.run_common_tests()







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_						,	snake_case_    :Any										=    self.model_tester.prepare_config_and_inputs_for_common()
										self.model_tester.create_and_check_maskformer_model(_UpperCamelCase     ,							**_UpperCamelCase     ,							output_hidden_states=_UpperCamelCase )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :List[str]										=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*_UpperCamelCase )







					@unittest.skip(reason="MaskFormer does not use inputs_embeds" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







					@unittest.skip(reason="MaskFormer does not have a get_input_embeddings method" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







					@unittest.skip(reason="MaskFormer is not a generative model" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







					@unittest.skip(reason="MaskFormer does not use token embeddings" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







					@require_torch_multi_gpu
					@unittest.skip(
					    reason="MaskFormer has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







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




										"""simple docstring"""





										pass







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_						,	snake_case_    :Any										=    self.model_tester.prepare_config_and_inputs_for_common()

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

															snake_case_    :Optional[int]										=    ["pixel_values"]
															self.assertListEqual(arg_names[:1]     ,							_UpperCamelCase )







					@slow
					def 		_a			(   self ):




										"""simple docstring"""





										for model_name in ["facebook/maskformer-swin-small-coco"]:
															snake_case_    :List[str]										=    MaskFormerModel.from_pretrained(_UpperCamelCase )
															self.assertIsNotNone(_UpperCamelCase )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Any										=    (self.model_tester.min_size,) * 2
										snake_case_    :str										=    {
										    "pixel_values": torch.randn((2, 3, *size)     ,							device=_UpperCamelCase ),
										    "mask_labels": torch.randn((2, 10, *size)     ,							device=_UpperCamelCase ),
										    "class_labels": torch.zeros(2     ,							10     ,							device=_UpperCamelCase ).long(),
										}

										snake_case_    :Optional[Any]										=    MaskFormerForInstanceSegmentation(MaskFormerConfig() ).to(_UpperCamelCase )
										snake_case_    :str										=    model(**_UpperCamelCase )
										self.assertTrue(outputs.loss is not None )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_						,	snake_case_    :int										=    self.model_tester.prepare_config_and_inputs_for_common()
										self.model_tester.create_and_check_maskformer_model(_UpperCamelCase     ,							**_UpperCamelCase     ,							output_hidden_states=_UpperCamelCase )







					def 		_a			(   self ):




										"""simple docstring"""





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

										for model_class in self.all_model_classes:
															snake_case_    :str										=    model_class(_UpperCamelCase ).to(_UpperCamelCase )
															snake_case_    :int										=    model(**_UpperCamelCase     ,							output_attentions=_UpperCamelCase )
															self.assertTrue(outputs.attentions is not None )







					def 		_a			(   self ):




										"""simple docstring"""





										if not self.model_tester.is_training:
															return
										# only MaskFormerForInstanceSegmentation has the loss
										snake_case_    :Any										=    self.all_model_classes[1]
										snake_case_						,	snake_case_						,	snake_case_						,	snake_case_						,	snake_case_    :int										=    self.model_tester.prepare_config_and_inputs()

										snake_case_    :Dict										=    model_class(_UpperCamelCase )
										model.to(_UpperCamelCase )
										model.train()

										snake_case_    :Optional[int]										=    model(_UpperCamelCase     ,							mask_labels=_UpperCamelCase     ,							class_labels=_UpperCamelCase ).loss
										loss.backward()







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Optional[Any]										=    self.all_model_classes[1]
										snake_case_						,	snake_case_						,	snake_case_						,	snake_case_						,	snake_case_    :str										=    self.model_tester.prepare_config_and_inputs()
										snake_case_    :str										=    True
										snake_case_    :int										=    True

										snake_case_    :List[Any]										=    model_class(_UpperCamelCase )
										model.to(_UpperCamelCase )
										model.train()

										snake_case_    :Optional[Any]										=    model(_UpperCamelCase     ,							mask_labels=_UpperCamelCase     ,							class_labels=_UpperCamelCase )

										snake_case_    :str										=    outputs.encoder_hidden_states[0]
										encoder_hidden_states.retain_grad()

										snake_case_    :List[str]										=    outputs.pixel_decoder_hidden_states[0]
										pixel_decoder_hidden_states.retain_grad()
										# we requires_grad=True in inputs_embeds (line 2152), the original implementation don't
										snake_case_    :Dict										=    outputs.transformer_decoder_hidden_states[0]
										transformer_decoder_hidden_states.retain_grad()

										snake_case_    :Any										=    outputs.attentions[0]
										attentions.retain_grad()

										outputs.loss.backward(retain_graph=_UpperCamelCase )

										self.assertIsNotNone(encoder_hidden_states.grad )
										self.assertIsNotNone(pixel_decoder_hidden_states.grad )
										self.assertIsNotNone(transformer_decoder_hidden_states.grad )
										self.assertIsNotNone(attentions.grad )



__UpperCAmelCase   :   Dict        =       1E-4
def   A   (      ):




					"""simple docstring"""
					snake_case_    :Dict										=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
					return image

@require_vision
@slow
class 						__lowerCAmelCase				(unittest.TestCase	):


					'''simple docstring'''


					@cached_property
					def 		_a			(   self ):




										"""simple docstring"""





										return (
										    MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco" )
										    if is_vision_available()
										    else None
										)







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Dict										=    MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco" ).to(_UpperCamelCase )
										snake_case_    :List[str]										=    self.default_image_processor
										snake_case_    :Any										=    prepare_img()
										snake_case_    :Any										=    image_processor(_UpperCamelCase     ,							return_tensors="pt" ).to(_UpperCamelCase )
										snake_case_    :List[Any]										=    inputs["pixel_values"].shape
										# check size is divisible by 32
										self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
										# check size
										self.assertEqual(_UpperCamelCase     ,							(1, 3, 8_00, 10_88) )

										with torch.no_grad():
															snake_case_    :str										=    model(**_UpperCamelCase )

										snake_case_    :Tuple										=    torch.tensor(
										    [[-0.0482, 0.9228, 0.4951], [-0.2547, 0.8017, 0.8527], [-0.0069, 0.3385, -0.0089]] ).to(_UpperCamelCase )
										self.assertTrue(
										    torch.allclose(
										        outputs.encoder_last_hidden_state[0, 0, :3, :3]     ,							_UpperCamelCase     ,							atol=_UpperCamelCase ) )

										snake_case_    :str										=    torch.tensor(
										    [[-0.8422, -0.8434, -0.9718], [-1.0144, -0.5565, -0.4195], [-1.0038, -0.4484, -0.1961]] ).to(_UpperCamelCase )
										self.assertTrue(
										    torch.allclose(
										        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]     ,							_UpperCamelCase     ,							atol=_UpperCamelCase ) )

										snake_case_    :str										=    torch.tensor(
										    [[0.2852, -0.0159, 0.9735], [0.6254, 0.1858, 0.8529], [-0.0680, -0.4116, 1.8413]] ).to(_UpperCamelCase )
										self.assertTrue(
										    torch.allclose(
										        outputs.transformer_decoder_last_hidden_state[0, :3, :3]     ,							_UpperCamelCase     ,							atol=_UpperCamelCase ) )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Any										=    (
										    MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" )
										    .to(_UpperCamelCase )
										    .eval()
										)
										snake_case_    :int										=    self.default_image_processor
										snake_case_    :Optional[int]										=    prepare_img()
										snake_case_    :Tuple										=    image_processor(_UpperCamelCase     ,							return_tensors="pt" ).to(_UpperCamelCase )
										snake_case_    :Optional[Any]										=    inputs["pixel_values"].shape
										# check size is divisible by 32
										self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
										# check size
										self.assertEqual(_UpperCamelCase     ,							(1, 3, 8_00, 10_88) )

										with torch.no_grad():
															snake_case_    :Union[str, Any]										=    model(**_UpperCamelCase )
										# masks_queries_logits
										snake_case_    :str										=    outputs.masks_queries_logits
										self.assertEqual(
										    masks_queries_logits.shape     ,							(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)     ,							)
										snake_case_    :Optional[Any]										=    [
										    [-1.3737124, -1.7724937, -1.9364233],
										    [-1.5977281, -1.9867939, -2.1523695],
										    [-1.5795398, -1.9269832, -2.093942],
										]
										snake_case_    :Optional[int]										=    torch.tensor(_UpperCamelCase ).to(_UpperCamelCase )
										self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]     ,							_UpperCamelCase     ,							atol=_UpperCamelCase ) )
										# class_queries_logits
										snake_case_    :str										=    outputs.class_queries_logits
										self.assertEqual(
										    class_queries_logits.shape     ,							(1, model.config.decoder_config.num_queries, model.config.num_labels + 1) )
										snake_case_    :Union[str, Any]										=    torch.tensor(
										    [
										        [1.6_5_1_2e0_0, -5.2_5_7_2e0_0, -3.3_5_1_9e0_0],
										        [3.6_1_6_9e-0_2, -5.9_0_2_5e0_0, -2.9_3_1_3e0_0],
										        [1.0_7_6_6e-0_4, -7.7_6_3_0e0_0, -5.1_2_6_3e0_0],
										    ] ).to(_UpperCamelCase )
										self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]     ,							_UpperCamelCase     ,							atol=_UpperCamelCase ) )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :str										=    (
										    MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff" )
										    .to(_UpperCamelCase )
										    .eval()
										)
										snake_case_    :str										=    self.default_image_processor
										snake_case_    :List[Any]										=    prepare_img()
										snake_case_    :Optional[Any]										=    image_processor(_UpperCamelCase     ,							return_tensors="pt" ).to(_UpperCamelCase )
										snake_case_    :Tuple										=    inputs["pixel_values"].shape
										# check size is divisible by 32
										self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 )
										# check size
										self.assertEqual(_UpperCamelCase     ,							(1, 3, 8_00, 10_88) )

										with torch.no_grad():
															snake_case_    :Optional[int]										=    model(**_UpperCamelCase )
										# masks_queries_logits
										snake_case_    :int										=    outputs.masks_queries_logits
										self.assertEqual(
										    masks_queries_logits.shape     ,							(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)     ,							)
										snake_case_    :Optional[Any]										=    [[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
										snake_case_    :Union[str, Any]										=    torch.tensor(_UpperCamelCase ).to(_UpperCamelCase )
										self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]     ,							_UpperCamelCase     ,							atol=_UpperCamelCase ) )
										# class_queries_logits
										snake_case_    :List[Any]										=    outputs.class_queries_logits
										self.assertEqual(
										    class_queries_logits.shape     ,							(1, model.config.decoder_config.num_queries, model.config.num_labels + 1) )
										snake_case_    :Dict										=    torch.tensor(
										    [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]] ).to(_UpperCamelCase )
										self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]     ,							_UpperCamelCase     ,							atol=_UpperCamelCase ) )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Optional[int]										=    (
										    MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco" )
										    .to(_UpperCamelCase )
										    .eval()
										)
										snake_case_    :Union[str, Any]										=    self.default_image_processor

										snake_case_    :Union[str, Any]										=    image_processor(
										    [np.zeros((3, 8_00, 13_33) ), np.zeros((3, 8_00, 13_33) )]     ,							segmentation_maps=[np.zeros((3_84, 3_84) ).astype(np.floataa ), np.zeros((3_84, 3_84) ).astype(np.floataa )]     ,							return_tensors="pt"     ,							)

										snake_case_    :Tuple										=    inputs["pixel_values"].to(_UpperCamelCase )
										snake_case_    :str										=    [el.to(_UpperCamelCase ) for el in inputs["mask_labels"]]
										snake_case_    :str										=    [el.to(_UpperCamelCase ) for el in inputs["class_labels"]]

										with torch.no_grad():
															snake_case_    :Optional[int]										=    model(**_UpperCamelCase )

										self.assertTrue(outputs.loss is not None )








from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_           =	logging.get_logger(__name__)

UpperCAmelCase_           =	{
    "microsoft/biogpt": "https://huggingface.co/microsoft/biogpt/resolve/main/config.json",
    # See all BioGPT models at https://huggingface.co/models?filter=biogpt
}




class 			__UpperCamelCase    (							A__    ):
     __A	:  Any							  =   """biogpt"""





     def __init__(     self				,							_UpperCamelCase=42384				,							_UpperCamelCase=1024				,							_UpperCamelCase=24				,							_UpperCamelCase=16				,							_UpperCamelCase=4096				,							_UpperCamelCase="gelu"				,							_UpperCamelCase=0.1				,							_UpperCamelCase=0.1				,							_UpperCamelCase=1024				,							_UpperCamelCase=0.02				,							_UpperCamelCase=1e-12				,							_UpperCamelCase=True				,							_UpperCamelCase=True				,							_UpperCamelCase=0.0				,							_UpperCamelCase=0.0				,							_UpperCamelCase=1				,							_UpperCamelCase=0				,							_UpperCamelCase=2				,							**_UpperCamelCase				,							):
        _UpperCAmelCase           =   vocab_size
        _UpperCAmelCase           =   max_position_embeddings
        _UpperCAmelCase           =   hidden_size
        _UpperCAmelCase           =   num_hidden_layers
        _UpperCAmelCase           =   num_attention_heads
        _UpperCAmelCase           =   intermediate_size
        _UpperCAmelCase           =   hidden_act
        _UpperCAmelCase           =   hidden_dropout_prob
        _UpperCAmelCase           =   attention_probs_dropout_prob
        _UpperCAmelCase           =   initializer_range
        _UpperCAmelCase           =   layer_norm_eps
        _UpperCAmelCase           =   scale_embedding
        _UpperCAmelCase           =   use_cache
        _UpperCAmelCase           =   layerdrop
        _UpperCAmelCase           =   activation_dropout
        super().__init__(pad_token_id=_UpperCamelCase				,							bos_token_id=_UpperCamelCase				,							eos_token_id=_UpperCamelCase				,							**_UpperCamelCase					)