



'''simple docstring'''



import math
import unittest

from transformers import BioGptConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    BioGptForCausalLM,
	    BioGptForSequenceClassification,
	    BioGptForTokenClassification,
	    BioGptModel,
	    BioGptTokenizer,
	)
	from transformers.models.biogpt.modeling_biogpt import BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST






class 					UpperCAmelCase__	:



					def __init__(    self			,				UpperCamelCase			,				UpperCamelCase=13			,				UpperCamelCase=7			,				UpperCamelCase=True			,				UpperCamelCase=True			,				UpperCamelCase=False			,				UpperCamelCase=True			,				UpperCamelCase=99			,				UpperCamelCase=32			,				UpperCamelCase=5			,				UpperCamelCase=4			,				UpperCamelCase=37			,				UpperCamelCase="gelu"			,				UpperCamelCase=0.1			,				UpperCamelCase=0.1			,				UpperCamelCase=512			,				UpperCamelCase=16			,				UpperCamelCase=2			,				UpperCamelCase=0.02			,				UpperCamelCase=3			,				UpperCamelCase=4			,				UpperCamelCase=None			,				)     ->			Any:
						__lowerCAmelCase												=  parent
						__lowerCAmelCase												=  batch_size
						__lowerCAmelCase												=  seq_length
						__lowerCAmelCase												=  is_training
						__lowerCAmelCase												=  use_input_mask
						__lowerCAmelCase												=  use_token_type_ids
						__lowerCAmelCase												=  use_labels
						__lowerCAmelCase												=  vocab_size
						__lowerCAmelCase												=  hidden_size
						__lowerCAmelCase												=  num_hidden_layers
						__lowerCAmelCase												=  num_attention_heads
						__lowerCAmelCase												=  intermediate_size
						__lowerCAmelCase												=  hidden_act
						__lowerCAmelCase												=  hidden_dropout_prob
						__lowerCAmelCase												=  attention_probs_dropout_prob
						__lowerCAmelCase												=  max_position_embeddings
						__lowerCAmelCase												=  type_vocab_size
						__lowerCAmelCase												=  type_sequence_label_size
						__lowerCAmelCase												=  initializer_range
						__lowerCAmelCase												=  num_labels
						__lowerCAmelCase												=  num_choices
						__lowerCAmelCase												=  scope



					def        UpperCAmelCase_ (    self     )     ->			Union[str, Any]:
						__lowerCAmelCase												=  ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size     )

						__lowerCAmelCase												=  None
						if self.use_input_mask:
							__lowerCAmelCase												=  random_attention_mask([self.batch_size, self.seq_length]     )

						__lowerCAmelCase												=  None
						if self.use_token_type_ids:
							__lowerCAmelCase												=  ids_tensor([self.batch_size, self.seq_length]			,				self.type_vocab_size     )

						__lowerCAmelCase												=  None
						__lowerCAmelCase												=  None
						__lowerCAmelCase												=  None
						if self.use_labels:
							__lowerCAmelCase												=  ids_tensor([self.batch_size]			,				self.type_sequence_label_size     )
							__lowerCAmelCase												=  ids_tensor([self.batch_size, self.seq_length]			,				self.num_labels     )
							__lowerCAmelCase												=  ids_tensor([self.batch_size]			,				self.num_choices     )

						__lowerCAmelCase												=  self.get_config()

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



					def        UpperCAmelCase_ (    self     )     ->			Any:
						return BioGptConfig(
						    vocab_size=self.vocab_size			,				hidden_size=self.hidden_size			,				num_hidden_layers=self.num_hidden_layers			,				num_attention_heads=self.num_attention_heads			,				intermediate_size=self.intermediate_size			,				hidden_act=self.hidden_act			,				hidden_dropout_prob=self.hidden_dropout_prob			,				attention_probs_dropout_prob=self.attention_probs_dropout_prob			,				max_position_embeddings=self.max_position_embeddings			,				type_vocab_size=self.type_vocab_size			,				is_decoder=UpperCamelCase			,				initializer_range=self.initializer_range			,				)



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			Any:
						__lowerCAmelCase												=  BioGptModel(config=UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase     )
						__lowerCAmelCase												=  model(UpperCamelCase     )
						self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				)     ->			Optional[int]:
						__lowerCAmelCase												=  BioGptForCausalLM(config=UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase			,				token_type_ids=UpperCamelCase			,				labels=UpperCamelCase     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size)     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				*UpperCamelCase     )     ->			Union[str, Any]:
						__lowerCAmelCase												=  BioGptModel(config=UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()

						# create attention mask
						__lowerCAmelCase												=  torch.ones(input_ids.shape			,				dtype=torch.long			,				device=UpperCamelCase     )
						__lowerCAmelCase												=  self.seq_length // 2
						__lowerCAmelCase												=  0

						# first forward pass
						__lowerCAmelCase							,       __lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase     ).to_tuple()

						# create hypothetical next token and extent to next_input_ids
						__lowerCAmelCase												=  ids_tensor((self.batch_size, 1)			,				config.vocab_size     )

						# change a random masked slice from input_ids
						__lowerCAmelCase												=  ids_tensor((1,)			,				UpperCamelCase     ).item() + 1
						__lowerCAmelCase												=  ids_tensor((self.batch_size, 1)			,				config.vocab_size     ).squeeze(-1     )
						__lowerCAmelCase												=  random_other_next_tokens

						# append to next input_ids and attn_mask
						__lowerCAmelCase												=  torch.cat([input_ids, next_tokens]			,				dim=-1     )
						__lowerCAmelCase												=  torch.cat(
						    [attn_mask, torch.ones((attn_mask.shape[0], 1)			,				dtype=torch.long			,				device=UpperCamelCase     )]			,				dim=1			,				)

						# get two different outputs
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase     )["last_hidden_state"]
						__lowerCAmelCase												=  model(UpperCamelCase			,				past_key_values=UpperCamelCase			,				attention_mask=UpperCamelCase     )["last_hidden_state"]

						# select random slice
						__lowerCAmelCase												=  ids_tensor((1,)			,				output_from_past.shape[-1]     ).item()
						__lowerCAmelCase												=  output_from_no_past[:, -1, random_slice_idx].detach()
						__lowerCAmelCase												=  output_from_past[:, 0, random_slice_idx].detach()

						# test that outputs are equal for slice
						self.parent.assertTrue(torch.allclose(UpperCamelCase			,				UpperCamelCase			,				atol=1E-3     )     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				*UpperCamelCase     )     ->			Tuple:
						__lowerCAmelCase												=  BioGptModel(config=UpperCamelCase     ).to(UpperCamelCase     ).eval()

						__lowerCAmelCase												=  torch.ones(input_ids.shape			,				dtype=torch.long			,				device=UpperCamelCase     )

						# first forward pass
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase			,				use_cache=UpperCamelCase     )

						__lowerCAmelCase							,       __lowerCAmelCase												=  outputs.to_tuple()

						# create hypothetical multiple next token and extent to next_input_ids
						__lowerCAmelCase												=  ids_tensor((self.batch_size, 3)			,				config.vocab_size     )
						__lowerCAmelCase												=  ids_tensor((self.batch_size, 3)			,				2     )

						# append to next input_ids and
						__lowerCAmelCase												=  torch.cat([input_ids, next_tokens]			,				dim=-1     )
						__lowerCAmelCase												=  torch.cat([attention_mask, next_attn_mask]			,				dim=-1     )

						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase     )["last_hidden_state"]
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase			,				past_key_values=UpperCamelCase     )[
						    "last_hidden_state"
						]

						# select random slice
						__lowerCAmelCase												=  ids_tensor((1,)			,				output_from_past.shape[-1]     ).item()
						__lowerCAmelCase												=  output_from_no_past[:, -3:, random_slice_idx].detach()
						__lowerCAmelCase												=  output_from_past[:, :, random_slice_idx].detach()

						self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]     )

						# test that outputs are equal for slice
						self.parent.assertTrue(torch.allclose(UpperCamelCase			,				UpperCamelCase			,				atol=1E-3     )     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				*UpperCamelCase			,				UpperCamelCase=False     )     ->			int:
						__lowerCAmelCase												=  BioGptForCausalLM(UpperCamelCase     )
						model.to(UpperCamelCase     )
						if gradient_checkpointing:
							model.gradient_checkpointing_enable()

						__lowerCAmelCase												=  model(UpperCamelCase			,				labels=UpperCamelCase     )
						self.parent.assertEqual(result.loss.shape			,				()     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.vocab_size)     )
						result.loss.backward()



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				*UpperCamelCase     )     ->			str:
						__lowerCAmelCase												=  BioGptModel(UpperCamelCase     )
						__lowerCAmelCase												=  model.config.initializer_range / math.sqrt(2 * model.config.num_hidden_layers     )
						for key in model.state_dict().keys():
							if "c_proj" in key and "weight" in key:
								self.parent.assertLessEqual(abs(torch.std(model.state_dict()[key]     ) - model_std     )			,				0.0_01     )
								self.parent.assertLessEqual(abs(torch.mean(model.state_dict()[key]     ) - 0.0     )			,				0.01     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				*UpperCamelCase     )     ->			int:
						__lowerCAmelCase												=  self.num_labels
						__lowerCAmelCase												=  BioGptForTokenClassification(UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase			,				token_type_ids=UpperCamelCase     )
						self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.num_labels)     )



					def        UpperCAmelCase_ (    self     )     ->			Any:
						__lowerCAmelCase												=  self.prepare_config_and_inputs()
						(
						    (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       (
						    __lowerCAmelCase
						)							,       
						)												=  config_and_inputs
						__lowerCAmelCase												=  {"input_ids": input_ids, "attention_mask": input_mask}
						return config, inputs_dict






@require_torch
class 					UpperCAmelCase__	(		UpperCamelCase__							,       UpperCamelCase__							,       UpperCamelCase__							,       unittest.TestCase ):
					a      :     Dict        =							(
					    (BioGptModel, BioGptForCausalLM, BioGptForSequenceClassification, BioGptForTokenClassification)
					    if is_torch_available()
					    else ()
					)
					a      :     Union[str, Any]        =							(BioGptForCausalLM,) if is_torch_available() else ()
					a      :     int        =							(
					    {
					        """feature-extraction""": BioGptModel,
					        """text-classification""": BioGptForSequenceClassification,
					        """text-generation""": BioGptForCausalLM,
					        """token-classification""": BioGptForTokenClassification,
					        """zero-shot""": BioGptForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					a      :     Tuple        =							False



					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						__lowerCAmelCase												=  BioGptModelTester(self     )
						__lowerCAmelCase												=  ConfigTester(self			,				config_class=UpperCamelCase			,				hidden_size=37     )



					def        UpperCAmelCase_ (    self     )     ->			Tuple:
						self.config_tester.run_common_tests()



					def        UpperCAmelCase_ (    self     )     ->			List[str]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Dict:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
							__lowerCAmelCase												=  type
							self.model_tester.create_and_check_model(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Union[str, Any]:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_biogpt_model_attention_mask_past(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Dict:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_forward_and_backwards(*UpperCamelCase			,				gradient_checkpointing=UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_biogpt_model_past_large_inputs(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			Tuple:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_biogpt_weight_initialization(*UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_biogpt_for_token_classification(*UpperCamelCase     )



					@slow
					def        UpperCAmelCase_ (    self     )     ->			List[str]:
						__lowerCAmelCase												=  BioGptForCausalLM.from_pretrained("microsoft/biogpt"     )
						model.to(UpperCamelCase     )
						__lowerCAmelCase												=  BioGptTokenizer.from_pretrained("microsoft/biogpt"     )

						__lowerCAmelCase												=  "left"

						# Define PAD Token = EOS Token = 50256
						__lowerCAmelCase												=  tokenizer.eos_token
						__lowerCAmelCase												=  model.config.eos_token_id

						# use different length sentences to test batching
						__lowerCAmelCase												=  [
						    "Hello, my dog is a little",
						    "Today, I",
						]

						__lowerCAmelCase												=  tokenizer(UpperCamelCase			,				return_tensors="pt"			,				padding=UpperCamelCase     )
						__lowerCAmelCase												=  inputs["input_ids"].to(UpperCamelCase     )

						__lowerCAmelCase												=  model.generate(
						    input_ids=UpperCamelCase			,				attention_mask=inputs["attention_mask"].to(UpperCamelCase     )			,				)

						__lowerCAmelCase												=  tokenizer(sentences[0]			,				return_tensors="pt"     ).input_ids.to(UpperCamelCase     )
						__lowerCAmelCase												=  model.generate(input_ids=UpperCamelCase     )

						__lowerCAmelCase												=  inputs_non_padded.shape[-1] - inputs["attention_mask"][-1].long().sum().cpu().item()
						__lowerCAmelCase												=  tokenizer(sentences[1]			,				return_tensors="pt"     ).input_ids.to(UpperCamelCase     )
						__lowerCAmelCase												=  model.generate(input_ids=UpperCamelCase			,				max_length=model.config.max_length - num_paddings     )

						__lowerCAmelCase												=  tokenizer.batch_decode(UpperCamelCase			,				skip_special_tokens=UpperCamelCase     )
						__lowerCAmelCase												=  tokenizer.decode(output_non_padded[0]			,				skip_special_tokens=UpperCamelCase     )
						__lowerCAmelCase												=  tokenizer.decode(output_padded[0]			,				skip_special_tokens=UpperCamelCase     )

						__lowerCAmelCase												=  [
						    "Hello, my dog is a little bit bigger than a little bit.",
						    "Today, I have a good idea of how to use the information",
						]
						self.assertListEqual(UpperCamelCase			,				UpperCamelCase     )
						self.assertListEqual(UpperCamelCase			,				[non_padded_sentence, padded_sentence]     )



					@slow
					def        UpperCAmelCase_ (    self     )     ->			List[Any]:
						for model_name in BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCAmelCase												=  BioGptModel.from_pretrained(UpperCamelCase     )
							self.assertIsNotNone(UpperCamelCase     )



					def        UpperCAmelCase_ (    self     )     ->			int:
						__lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase												=  3
						__lowerCAmelCase												=  input_dict["input_ids"]
						__lowerCAmelCase												=  input_ids.ne(1     ).to(UpperCamelCase     )
						__lowerCAmelCase												=  ids_tensor([self.model_tester.batch_size]			,				self.model_tester.type_sequence_label_size     )
						__lowerCAmelCase												=  BioGptForSequenceClassification(UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase			,				labels=UpperCamelCase     )
						self.assertEqual(result.logits.shape			,				(self.model_tester.batch_size, self.model_tester.num_labels)     )



					def        UpperCAmelCase_ (    self     )     ->			Any:
						__lowerCAmelCase							,       __lowerCAmelCase												=  self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCAmelCase												=  3
						__lowerCAmelCase												=  "multi_label_classification"
						__lowerCAmelCase												=  input_dict["input_ids"]
						__lowerCAmelCase												=  input_ids.ne(1     ).to(UpperCamelCase     )
						__lowerCAmelCase												=  ids_tensor(
						    [self.model_tester.batch_size, config.num_labels]			,				self.model_tester.type_sequence_label_size     ).to(torch.float     )
						__lowerCAmelCase												=  BioGptForSequenceClassification(UpperCamelCase     )
						model.to(UpperCamelCase     )
						model.eval()
						__lowerCAmelCase												=  model(UpperCamelCase			,				attention_mask=UpperCamelCase			,				labels=UpperCamelCase     )
						self.assertEqual(result.logits.shape			,				(self.model_tester.batch_size, self.model_tester.num_labels)     )






@require_torch
class 					UpperCAmelCase__	(		unittest.TestCase ):



					@slow
					def        UpperCAmelCase_ (    self     )     ->			str:
						__lowerCAmelCase												=  BioGptForCausalLM.from_pretrained("microsoft/biogpt"     )
						__lowerCAmelCase												=  torch.tensor([[2, 4805, 9, 656, 21]]     )
						__lowerCAmelCase												=  model(UpperCamelCase     )[0]

						__lowerCAmelCase												=  4_2384

						__lowerCAmelCase												=  torch.Size((1, 5, vocab_size)     )
						self.assertEqual(output.shape			,				UpperCamelCase     )

						__lowerCAmelCase												=  torch.tensor(
						    [[[-9.52_36, -9.89_18, 10.45_57], [-11.04_69, -9.64_23, 8.10_22], [-8.86_64, -7.88_26, 5.53_25]]]     )

						self.assertTrue(torch.allclose(output[:, :3, :3]			,				UpperCamelCase			,				atol=1E-4     )     )



					@slow
					def        UpperCAmelCase_ (    self     )     ->			Optional[Any]:
						__lowerCAmelCase												=  BioGptTokenizer.from_pretrained("microsoft/biogpt"     )
						__lowerCAmelCase												=  BioGptForCausalLM.from_pretrained("microsoft/biogpt"     )
						model.to(UpperCamelCase     )

						torch.manual_seed(0     )
						__lowerCAmelCase												=  tokenizer("COVID-19 is"			,				return_tensors="pt"     ).to(UpperCamelCase     )
						__lowerCAmelCase												=  model.generate(
						    **UpperCamelCase			,				min_length=100			,				max_length=1024			,				num_beams=5			,				early_stopping=UpperCamelCase			,				)
						__lowerCAmelCase												=  tokenizer.decode(output_ids[0]			,				skip_special_tokens=UpperCamelCase     )

						__lowerCAmelCase												=  (
						    "COVID-19 is a global pandemic caused by severe acute respiratory syndrome coronavirus 2 (SARS-CoV-2), the"
						    " causative agent of coronavirus disease 2019 (COVID-19), which has spread to more than 200 countries and"
						    " territories, including the United States (US), Canada, Australia, New Zealand, the United Kingdom (UK),"
						    " and the United States of America (USA), as of March 11, 2020, with more than 800,000 confirmed cases and"
						    " more than 800,000 deaths."
						)
						self.assertEqual(UpperCamelCase			,				UpperCamelCase     )




'''simple docstring'''



import importlib
import os
from dataclasses import dataclass
from enum import Enum
from typing import Any, Dict, Optional, Union

import torch

from ..utils import BaseOutput


lowerCAmelCase	:		Optional[Any]				=   '''scheduler_config.json'''






class 					UpperCAmelCase__	(		UpperCamelCase__ ):
					a      :     str        =							1
					a      :     Optional[int]        =							2
					a      :     int        =							3
					a      :     Union[str, Any]        =							4
					a      :     int        =							5
					a      :     Optional[int]        =							6
					a      :     str        =							7
					a      :     List[Any]        =							8
					a      :     List[str]        =							9
					a      :     List[str]        =							1_0
					a      :     int        =							1_1
					a      :     Any        =							1_2
					a      :     Any        =							1_3
					a      :     Tuple        =							1_4






@dataclass
class 					UpperCAmelCase__	(		UpperCamelCase__ ):
					a      :     torch.FloatTensor






class 					UpperCAmelCase__	:
					a      :     Tuple        =							SCHEDULER_CONFIG_NAME
					a      :     Union[str, Any]        =							[]
					a      :     str        =							True



					@classmethod
					def        UpperCAmelCase_ (    cls			,				UpperCamelCase = None			,				UpperCamelCase = None			,				UpperCamelCase=False			,				**UpperCamelCase			,				)     ->			int:
						__lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase												=  cls.load_config(
						    pretrained_model_name_or_path=UpperCamelCase			,				subfolder=UpperCamelCase			,				return_unused_kwargs=UpperCamelCase			,				return_commit_hash=UpperCamelCase			,				**UpperCamelCase			,				)
						return cls.from_config(UpperCamelCase			,				return_unused_kwargs=UpperCamelCase			,				**UpperCamelCase     )



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase = False			,				**UpperCamelCase     )     ->			Dict:
						self.save_config(save_directory=UpperCamelCase			,				push_to_hub=UpperCamelCase			,				**UpperCamelCase     )



					@property
					def        UpperCAmelCase_ (    self     )     ->			str:
						return self._get_compatibles()



					@classmethod
					def        UpperCAmelCase_ (    cls     )     ->			Tuple:
						__lowerCAmelCase												=  list(set([cls.__name__] + cls._compatibles     )     )
						__lowerCAmelCase												=  importlib.import_module(__name__.split("."     )[0]     )
						__lowerCAmelCase												=  [
						    getattr(UpperCamelCase			,				UpperCamelCase     ) for c in compatible_classes_str if hasattr(UpperCamelCase			,				UpperCamelCase     )
						]
						return compatible_classes