




'''simple docstring'''

import unittest

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

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


if is_torch_available():
		import torch

		from transformers import (
		    RemBertConfig,
		    RemBertForCausalLM,
		    RemBertForMaskedLM,
		    RemBertForMultipleChoice,
		    RemBertForQuestionAnswering,
		    RemBertForSequenceClassification,
		    RemBertForTokenClassification,
		    RemBertModel,
		)
		from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST





class __magic_name__:






						def __init__(   self						:						str					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						Any=1_3					,   __UpperCamelCase						:						Any=7					,   __UpperCamelCase						:						Dict=True					,   __UpperCamelCase						:						Tuple=True					,   __UpperCamelCase						:						Tuple=True					,   __UpperCamelCase						:						Optional[int]=True					,   __UpperCamelCase						:						str=9_9					,   __UpperCamelCase						:						str=3_2					,   __UpperCamelCase						:						int=1_8					,   __UpperCamelCase						:						Any=4_3					,   __UpperCamelCase						:						int=5					,   __UpperCamelCase						:						Optional[Any]=4					,   __UpperCamelCase						:						List[str]=3_7					,   __UpperCamelCase						:						Union[str, Any]="gelu"					,   __UpperCamelCase						:						Optional[int]=0.1					,   __UpperCamelCase						:						Optional[int]=0.1					,   __UpperCamelCase						:						Optional[int]=5_1_2					,   __UpperCamelCase						:						Dict=1_6					,   __UpperCamelCase						:						Optional[int]=2					,   __UpperCamelCase						:						Any=0.02					,   __UpperCamelCase						:						Optional[Any]=3					,   __UpperCamelCase						:						Union[str, Any]=4					,   __UpperCamelCase						:						str=None					,   ):



									'''simple docstring'''






									snake_case__          =						parent
									snake_case__          =						batch_size
									snake_case__          =						seq_length
									snake_case__          =						is_training
									snake_case__          =						use_input_mask
									snake_case__          =						use_token_type_ids
									snake_case__          =						use_labels
									snake_case__          =						vocab_size
									snake_case__          =						hidden_size
									snake_case__          =						input_embedding_size
									snake_case__          =						output_embedding_size
									snake_case__          =						num_hidden_layers
									snake_case__          =						num_attention_heads
									snake_case__          =						intermediate_size
									snake_case__          =						hidden_act
									snake_case__          =						hidden_dropout_prob
									snake_case__          =						attention_probs_dropout_prob
									snake_case__          =						max_position_embeddings
									snake_case__          =						type_vocab_size
									snake_case__          =						type_sequence_label_size
									snake_case__          =						initializer_range
									snake_case__          =						num_labels
									snake_case__          =						num_choices
									snake_case__          =						scope






						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									snake_case__          =						ids_tensor([self.batch_size, self.seq_length]					,   self.vocab_size       )

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

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

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

									snake_case__          =						RemBertConfig(
									    vocab_size=self.vocab_size					,   hidden_size=self.hidden_size					,   input_embedding_size=self.input_embedding_size					,   output_embedding_size=self.output_embedding_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					,   )

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






						def       __lowerCAmelCase(   self						:						Dict       ):



									'''simple docstring'''






									(
									    (
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			
									)          =						self.prepare_config_and_inputs()

									snake_case__          =						True
									snake_case__          =						floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
									snake_case__          =						ids_tensor([self.batch_size, self.seq_length]					,   vocab_size=2       )

									return (
									    config,
									    input_ids,
									    token_type_ids,
									    input_mask,
									    sequence_labels,
									    token_labels,
									    choice_labels,
									    encoder_hidden_states,
									    encoder_attention_mask,
									)






						def       __lowerCAmelCase(   self						:						List[Any]					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						Union[str, Any]					,   __UpperCamelCase						:						List[str]					,   __UpperCamelCase						:						List[str]					,   __UpperCamelCase						:						Tuple       ):



									'''simple docstring'''






									snake_case__          =						RemBertModel(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						model(__UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase       )
									snake_case__          =						model(__UpperCamelCase					,   token_type_ids=__UpperCamelCase       )
									snake_case__          =						model(__UpperCamelCase       )
									self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size)       )






						def       __lowerCAmelCase(   self						:						str					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						int					,   __UpperCamelCase						:						int					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						Optional[Any]					,   __UpperCamelCase						:						Union[str, Any]					,   ):



									'''simple docstring'''






									snake_case__          =						True
									snake_case__          =						RemBertModel(__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						model(
									    __UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase					,   encoder_hidden_states=__UpperCamelCase					,   encoder_attention_mask=__UpperCamelCase					,   )
									snake_case__          =						model(
									    __UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase					,   encoder_hidden_states=__UpperCamelCase					,   )
									snake_case__          =						model(__UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase       )
									self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size)       )






						def       __lowerCAmelCase(   self						:						Dict					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Optional[Any]					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Tuple					,   ):



									'''simple docstring'''






									snake_case__          =						RemBertForCausalLM(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						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       __lowerCAmelCase(   self						:						str					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						int					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						Dict       ):



									'''simple docstring'''






									snake_case__          =						RemBertForMaskedLM(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						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       __lowerCAmelCase(   self						:						Tuple					,   __UpperCamelCase						:						Union[str, Any]					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						Union[str, Any]					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						List[str]					,   __UpperCamelCase						:						Optional[Any]					,   ):



									'''simple docstring'''






									snake_case__          =						True
									snake_case__          =						True
									snake_case__          =						RemBertForCausalLM(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()

									# first forward pass
									snake_case__          =						model(
									    __UpperCamelCase					,   attention_mask=__UpperCamelCase					,   encoder_hidden_states=__UpperCamelCase					,   encoder_attention_mask=__UpperCamelCase					,   use_cache=__UpperCamelCase					,   )
									snake_case__          =						outputs.past_key_values

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

									# append to next input_ids and
									snake_case__          =						torch.cat([input_ids, next_tokens]					,   dim=-1       )
									snake_case__          =						torch.cat([input_mask, next_mask]					,   dim=-1       )

									snake_case__          =						model(
									    __UpperCamelCase					,   attention_mask=__UpperCamelCase					,   encoder_hidden_states=__UpperCamelCase					,   encoder_attention_mask=__UpperCamelCase					,   output_hidden_states=__UpperCamelCase					,   )["""hidden_states"""][0]
									snake_case__          =						model(
									    __UpperCamelCase					,   attention_mask=__UpperCamelCase					,   encoder_hidden_states=__UpperCamelCase					,   encoder_attention_mask=__UpperCamelCase					,   past_key_values=__UpperCamelCase					,   output_hidden_states=__UpperCamelCase					,   )["""hidden_states"""][0]

									# select random slice
									snake_case__          =						ids_tensor((1,)					,   output_from_past.shape[-1]       ).item()
									snake_case__          =						output_from_no_past[:, -3:, random_slice_idx].detach()
									snake_case__          =						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       __lowerCAmelCase(   self						:						Union[str, Any]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						int					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						List[str]					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						Union[str, Any]       ):



									'''simple docstring'''






									snake_case__          =						RemBertForQuestionAnswering(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						model(
									    __UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase					,   start_positions=__UpperCamelCase					,   end_positions=__UpperCamelCase					,   )
									self.parent.assertEqual(result.start_logits.shape					,   (self.batch_size, self.seq_length)       )
									self.parent.assertEqual(result.end_logits.shape					,   (self.batch_size, self.seq_length)       )






						def       __lowerCAmelCase(   self						:						List[Any]					,   __UpperCamelCase						:						Tuple					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						List[str]					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						Dict					,   __UpperCamelCase						:						Optional[int]       ):



									'''simple docstring'''






									snake_case__          =						self.num_labels
									snake_case__          =						RemBertForSequenceClassification(__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						model(__UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase					,   labels=__UpperCamelCase       )
									self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.num_labels)       )






						def       __lowerCAmelCase(   self						:						Optional[Any]					,   __UpperCamelCase						:						str					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						Optional[Any]					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						Union[str, Any]					,   __UpperCamelCase						:						Union[str, Any]       ):



									'''simple docstring'''






									snake_case__          =						self.num_labels
									snake_case__          =						RemBertForTokenClassification(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						model(__UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase					,   labels=__UpperCamelCase       )
									self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.num_labels)       )






						def       __lowerCAmelCase(   self						:						Any					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						List[Any]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						Optional[int]					,   __UpperCamelCase						:						Optional[Any]					,   __UpperCamelCase						:						Any					,   __UpperCamelCase						:						Optional[Any]       ):



									'''simple docstring'''






									snake_case__          =						self.num_choices
									snake_case__          =						RemBertForMultipleChoice(config=__UpperCamelCase       )
									model.to(__UpperCamelCase       )
									model.eval()
									snake_case__          =						input_ids.unsqueeze(1       ).expand(-1					,   self.num_choices					,   -1       ).contiguous()
									snake_case__          =						token_type_ids.unsqueeze(1       ).expand(-1					,   self.num_choices					,   -1       ).contiguous()
									snake_case__          =						input_mask.unsqueeze(1       ).expand(-1					,   self.num_choices					,   -1       ).contiguous()
									snake_case__          =						model(
									    __UpperCamelCase					,   attention_mask=__UpperCamelCase					,   token_type_ids=__UpperCamelCase					,   labels=__UpperCamelCase					,   )
									self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.num_choices)       )







						def       __lowerCAmelCase(   self						:						Optional[int]       ):



									'''simple docstring'''






									snake_case__          =						self.prepare_config_and_inputs()
									(
									    (
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			
									)          =						config_and_inputs
									snake_case__          =						{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
									return config, inputs_dict







@require_torch
class __magic_name__(						__lowerCAmelCase    ,		__lowerCAmelCase    ,		unittest.TestCase      ):
						UpperCAmelCase_		:					Tuple    =  (
						    (
						        RemBertModel,
						        RemBertForMaskedLM,
						        RemBertForCausalLM,
						        RemBertForMultipleChoice,
						        RemBertForQuestionAnswering,
						        RemBertForSequenceClassification,
						        RemBertForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCAmelCase_		:					Dict    =  (RemBertForCausalLM,) if is_torch_available() else ()
						UpperCAmelCase_		:					Dict    =  (
						    {
						        """feature-extraction""": RemBertModel,
						        """fill-mask""": RemBertForMaskedLM,
						        """question-answering""": RemBertForQuestionAnswering,
						        """text-classification""": RemBertForSequenceClassification,
						        """text-generation""": RemBertForCausalLM,
						        """token-classification""": RemBertForTokenClassification,
						        """zero-shot""": RemBertForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)






						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									snake_case__          =						RemBertModelTester(self       )
									snake_case__          =						ConfigTester(self					,   config_class=__UpperCamelCase					,   hidden_size=3_7       )






						def       __lowerCAmelCase(   self						:						str       ):



									'''simple docstring'''






									self.config_tester.run_common_tests()






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



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						Any       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
												snake_case__          =						type
												self.model_tester.create_and_check_model(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						Any       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						Tuple       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_multiple_choice(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_decoder_model_past_large_inputs(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						List[Any]       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase       )






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



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									snake_case__          =						self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_model_as_decoder(*__UpperCamelCase       )






						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									(
									    (
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			(
									    snake_case__
									)    ,			
									)          =						self.model_tester.prepare_config_and_inputs_for_decoder()

									snake_case__          =						None

									self.model_tester.create_and_check_model_as_decoder(
									    __UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase					,   __UpperCamelCase					,   )







						@slow
						def       __lowerCAmelCase(   self						:						Union[str, Any]       ):



									'''simple docstring'''






									for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												snake_case__          =						RemBertModel.from_pretrained(__UpperCamelCase       )
												self.assertIsNotNone(__UpperCamelCase       )







@require_torch
class __magic_name__(						unittest.TestCase      ):






						@slow
						def       __lowerCAmelCase(   self						:						str       ):



									'''simple docstring'''






									snake_case__          =						RemBertModel.from_pretrained("""google/rembert"""       )
									snake_case__          =						torch.tensor([[3_1_2, 5_6_4_9_8, 3_1_3, 2_1_2_5, 3_1_3]]       )
									snake_case__          =						torch.tensor([[0, 0, 0, 1, 1]]       )
									with torch.no_grad():
												snake_case__          =						model(__UpperCamelCase					,   token_type_ids=__UpperCamelCase					,   output_hidden_states=__UpperCamelCase       )

									snake_case__          =						1_1_5_2

									snake_case__          =						torch.Size((1, 5, hidden_size)       )
									self.assertEqual(output["""last_hidden_state"""].shape					,   __UpperCamelCase       )

									snake_case__          =						torch.tensor(
									    [
									        [
									            [0.07_54, -0.20_22, 0.19_04],
									            [-0.33_54, -0.36_92, -0.47_91],
									            [-0.23_14, -0.67_29, -0.07_49],
									            [-0.03_96, -0.31_05, -0.42_34],
									            [-0.15_71, -0.05_25, 0.53_53],
									        ]
									    ]       )

									# Running on the original tf implementation gives slightly different results here.
									# Not clear why this variations is present
									# TODO: Find reason for discrepancy
									# expected_original_implementation = [[
									#     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
									#     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
									#     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
									#     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
									#     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
									# ]]

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





'''simple docstring'''

from typing import TYPE_CHECKING

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


a__         =     {'''configuration_gptj''': ['''GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPTJConfig''', '''GPTJOnnxConfig''']}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a__         =     [
		    '''GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''GPTJForCausalLM''',
		    '''GPTJForQuestionAnswering''',
		    '''GPTJForSequenceClassification''',
		    '''GPTJModel''',
		    '''GPTJPreTrainedModel''',
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a__         =     [
		    '''TFGPTJForCausalLM''',
		    '''TFGPTJForQuestionAnswering''',
		    '''TFGPTJForSequenceClassification''',
		    '''TFGPTJModel''',
		    '''TFGPTJPreTrainedModel''',
		]

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		a__         =     [
		    '''FlaxGPTJForCausalLM''',
		    '''FlaxGPTJModel''',
		    '''FlaxGPTJPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_gptj import GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTJConfig, GPTJOnnxConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_gptj import (
				    GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST,
				    GPTJForCausalLM,
				    GPTJForQuestionAnswering,
				    GPTJForSequenceClassification,
				    GPTJModel,
				    GPTJPreTrainedModel,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_gptj import (
				    TFGPTJForCausalLM,
				    TFGPTJForQuestionAnswering,
				    TFGPTJForSequenceClassification,
				    TFGPTJModel,
				    TFGPTJPreTrainedModel,
				)

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel, FlaxGPTJPreTrainedModel

else:
		import sys

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