



"""simple docstring"""







import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
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 (
	    MODEL_FOR_PRETRAINING_MAPPING,
	    NezhaForMaskedLM,
	    NezhaForMultipleChoice,
	    NezhaForNextSentencePrediction,
	    NezhaForPreTraining,
	    NezhaForQuestionAnswering,
	    NezhaForSequenceClassification,
	    NezhaForTokenClassification,
	    NezhaModel,
	)
	from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST







class 					A_:







			"""simple docstring"""



			def __init__(	self				,   A				,   A=13				,   A=7				,   A=True				,   A=True				,   A=True				,   A=True				,   A=99				,   A=32				,   A=5				,   A=4				,   A=37				,   A="gelu"				,   A=0.1				,   A=0.1				,   A=128				,   A=32				,   A=16				,   A=2				,   A=0.0_2				,   A=3				,   A=4				,   A=None				,   ):
						_lowerCamelCase					:					Tuple	       =    parent
						_lowerCamelCase					:					Optional[int]	       =    batch_size
						_lowerCamelCase					:					Any	       =    seq_length
						_lowerCamelCase					:					Tuple	       =    is_training
						_lowerCamelCase					:					List[str]	       =    use_input_mask
						_lowerCamelCase					:					List[str]	       =    use_token_type_ids
						_lowerCamelCase					:					Optional[Any]	       =    use_labels
						_lowerCamelCase					:					Union[str, Any]	       =    vocab_size
						_lowerCamelCase					:					Union[str, Any]	       =    hidden_size
						_lowerCamelCase					:					Tuple	       =    num_hidden_layers
						_lowerCamelCase					:					Optional[Any]	       =    num_attention_heads
						_lowerCamelCase					:					Optional[int]	       =    intermediate_size
						_lowerCamelCase					:					Union[str, Any]	       =    hidden_act
						_lowerCamelCase					:					Tuple	       =    hidden_dropout_prob
						_lowerCamelCase					:					Union[str, Any]	       =    attention_probs_dropout_prob
						_lowerCamelCase					:					Any	       =    max_position_embeddings
						_lowerCamelCase					:					str	       =    type_vocab_size
						_lowerCamelCase					:					List[str]	       =    type_sequence_label_size
						_lowerCamelCase					:					Union[str, Any]	       =    initializer_range
						_lowerCamelCase					:					Tuple	       =    num_labels
						_lowerCamelCase					:					Any	       =    num_choices
						_lowerCamelCase					:					Optional[Any]	       =    scope
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Optional[Any]	       =    ids_tensor([self.batch_size, self.seq_length]				,   self.vocab_size							)

						_lowerCamelCase					:					List[str]	       =    None
						if self.use_input_mask:
									_lowerCamelCase					:					List[Any]	       =    random_attention_mask([self.batch_size, self.seq_length]							)

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

						_lowerCamelCase					:					str	       =    None
						_lowerCamelCase					:					Any	       =    None
						_lowerCamelCase					:					List[Any]	       =    None
						if self.use_labels:
									_lowerCamelCase					:					List[str]	       =    ids_tensor([self.batch_size]				,   self.type_sequence_label_size							)
									_lowerCamelCase					:					Optional[int]	       =    ids_tensor([self.batch_size, self.seq_length]				,   self.num_labels							)
									_lowerCamelCase					:					Optional[Any]	       =    ids_tensor([self.batch_size]				,   self.num_choices							)

						_lowerCamelCase					:					List[Any]	       =    self.get_config()

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
			def    _lowerCAmelCase		(	self							):
						return NezhaConfig(
						    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=SCREAMING_SNAKE_CASE_				,   initializer_range=self.initializer_range				,   )
			def    _lowerCAmelCase		(	self							):
						(
						    _lowerCamelCase							
						)					:					Union[str, Any]	       =    self.prepare_config_and_inputs()

						_lowerCamelCase					:					Optional[Any]	       =    True
						_lowerCamelCase					:					Optional[Any]	       =    floats_tensor([self.batch_size, self.seq_length, self.hidden_size]							)
						_lowerCamelCase					:					Dict	       =    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				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					int	       =    NezhaModel(config=SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					int	       =    model(SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					str	       =    model(SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					List[str]	       =    model(SCREAMING_SNAKE_CASE_							)
						self.parent.assertEqual(result.last_hidden_state.shape				,   (self.batch_size, self.seq_length, self.hidden_size)							)
						self.parent.assertEqual(result.pooler_output.shape				,   (self.batch_size, self.hidden_size)							)
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A				,   A				,   A				,   A				,   A				,   A				,   A				,   ):
						_lowerCamelCase					:					Dict	       =    True
						_lowerCamelCase					:					Tuple	       =    NezhaModel(SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					Optional[int]	       =    model(
						    SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   encoder_hidden_states=SCREAMING_SNAKE_CASE_				,   encoder_attention_mask=SCREAMING_SNAKE_CASE_				,   )
						_lowerCamelCase					:					List[str]	       =    model(
						    SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   encoder_hidden_states=SCREAMING_SNAKE_CASE_				,   )
						_lowerCamelCase					:					List[str]	       =    model(SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_							)
						self.parent.assertEqual(result.last_hidden_state.shape				,   (self.batch_size, self.seq_length, self.hidden_size)							)
						self.parent.assertEqual(result.pooler_output.shape				,   (self.batch_size, self.hidden_size)							)
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					Tuple	       =    NezhaForMaskedLM(config=SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					Optional[int]	       =    model(SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   labels=SCREAMING_SNAKE_CASE_							)
						self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.vocab_size)							)
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					Optional[Any]	       =    NezhaForNextSentencePrediction(config=SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					Dict	       =    model(
						    SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   labels=SCREAMING_SNAKE_CASE_				,   )
						self.parent.assertEqual(result.logits.shape				,   (self.batch_size, 2)							)
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					Tuple	       =    NezhaForPreTraining(config=SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					Tuple	       =    model(
						    SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   labels=SCREAMING_SNAKE_CASE_				,   next_sentence_label=SCREAMING_SNAKE_CASE_				,   )
						self.parent.assertEqual(result.prediction_logits.shape				,   (self.batch_size, self.seq_length, self.vocab_size)							)
						self.parent.assertEqual(result.seq_relationship_logits.shape				,   (self.batch_size, 2)							)
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					Optional[Any]	       =    NezhaForQuestionAnswering(config=SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					Any	       =    model(
						    SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   start_positions=SCREAMING_SNAKE_CASE_				,   end_positions=SCREAMING_SNAKE_CASE_				,   )
						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				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					List[str]	       =    self.num_labels
						_lowerCamelCase					:					str	       =    NezhaForSequenceClassification(SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					Dict	       =    model(SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   labels=SCREAMING_SNAKE_CASE_							)
						self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.num_labels)							)
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					int	       =    self.num_labels
						_lowerCamelCase					:					List[str]	       =    NezhaForTokenClassification(config=SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					List[Any]	       =    model(SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   labels=SCREAMING_SNAKE_CASE_							)
						self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.seq_length, self.num_labels)							)
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A				,   A				,   A				,   A				,   A							):
						_lowerCamelCase					:					Tuple	       =    self.num_choices
						_lowerCamelCase					:					Union[str, Any]	       =    NezhaForMultipleChoice(config=SCREAMING_SNAKE_CASE_							)
						model.to(SCREAMING_SNAKE_CASE_							)
						model.eval()
						_lowerCamelCase					:					Dict	       =    input_ids.unsqueeze(1							).expand(-1				,   self.num_choices				,   -1							).contiguous()
						_lowerCamelCase					:					Any	       =    token_type_ids.unsqueeze(1							).expand(-1				,   self.num_choices				,   -1							).contiguous()
						_lowerCamelCase					:					int	       =    input_mask.unsqueeze(1							).expand(-1				,   self.num_choices				,   -1							).contiguous()
						_lowerCamelCase					:					int	       =    model(
						    SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_				,   token_type_ids=SCREAMING_SNAKE_CASE_				,   labels=SCREAMING_SNAKE_CASE_				,   )
						self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.num_choices)							)

			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Tuple	       =    self.prepare_config_and_inputs()
						(
						    _lowerCamelCase							
						)					:					Union[str, Any]	       =    config_and_inputs
						_lowerCamelCase					:					List[str]	       =    {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
						return config, inputs_dict







@require_torch
class 					A_(_lowerCAmelCase   ,   _lowerCAmelCase   ,   _lowerCAmelCase   ,   unittest.TestCase      ):







			"""simple docstring"""



			a_       :			int												=			(
			    (
			        NezhaModel,
			        NezhaForMaskedLM,
			        NezhaForMultipleChoice,
			        NezhaForNextSentencePrediction,
			        NezhaForPreTraining,
			        NezhaForQuestionAnswering,
			        NezhaForSequenceClassification,
			        NezhaForTokenClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			a_       :			Tuple												=			(
			    {
			        """feature-extraction""": NezhaModel,
			        """fill-mask""": NezhaForMaskedLM,
			        """question-answering""": NezhaForQuestionAnswering,
			        """text-classification""": NezhaForSequenceClassification,
			        """token-classification""": NezhaForTokenClassification,
			        """zero-shot""": NezhaForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			a_       :			List[Any]												=			True
			def    _lowerCAmelCase		(	self				,   A				,   A				,   A=False							):
						_lowerCamelCase					:					Dict	       =    super()._prepare_for_class(SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   return_labels=SCREAMING_SNAKE_CASE_							)

						if return_labels:
									if model_class in get_values(SCREAMING_SNAKE_CASE_							):
												_lowerCamelCase					:					Optional[int]	       =    torch.zeros(
												    (self.model_tester.batch_size, self.model_tester.seq_length)				,   dtype=torch.long				,   device=SCREAMING_SNAKE_CASE_							)
												_lowerCamelCase					:					Any	       =    torch.zeros(
												    self.model_tester.batch_size				,   dtype=torch.long				,   device=SCREAMING_SNAKE_CASE_							)
						return inputs_dict
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					List[str]	       =    NezhaModelTester(self							)
						_lowerCamelCase					:					List[str]	       =    ConfigTester(self				,   config_class=SCREAMING_SNAKE_CASE_				,   hidden_size=37							)
			def    _lowerCAmelCase		(	self							):
						self.config_tester.run_common_tests()
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Dict	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					List[Any]	       =    self.model_tester.prepare_config_and_inputs_for_decoder()
						self.model_tester.create_and_check_model_as_decoder(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						# This regression test was failing with PyTorch < 1.3
						(
						    _lowerCamelCase							
						)					:					Any	       =    self.model_tester.prepare_config_and_inputs_for_decoder()

						_lowerCamelCase					:					str	       =    None

						self.model_tester.create_and_check_model_as_decoder(
						    SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_				,   )
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					List[Any]	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Union[str, Any]	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Dict	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_next_sequence_prediction(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Optional[int]	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_pretraining(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Any	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Union[str, Any]	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_							)
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Dict	       =    self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE_							)
			@slow
			def    _lowerCAmelCase		(	self							):
						for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_lowerCamelCase					:					str	       =    NezhaModel.from_pretrained(SCREAMING_SNAKE_CASE_							)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE_							)

			@slow
			@require_torch_gpu
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					List[str]	       =    self.model_tester.prepare_config_and_inputs_for_common()
						for model_class in self.all_model_classes:
									# NezhaForMultipleChoice behaves incorrectly in JIT environments.
									if model_class == NezhaForMultipleChoice:
												return

									_lowerCamelCase					:					Union[str, Any]	       =    True
									_lowerCamelCase					:					Any	       =    model_class(config=SCREAMING_SNAKE_CASE_							)

									_lowerCamelCase					:					Optional[int]	       =    self._prepare_for_class(SCREAMING_SNAKE_CASE_				,   SCREAMING_SNAKE_CASE_							)
									_lowerCamelCase					:					List[Any]	       =    torch.jit.trace(
									    SCREAMING_SNAKE_CASE_				,   (inputs_dict['input_ids'].to('cpu'							), inputs_dict['attention_mask'].to('cpu'							))							)

									with tempfile.TemporaryDirectory() as tmp:
												torch.jit.save(SCREAMING_SNAKE_CASE_				,   os.path.join(SCREAMING_SNAKE_CASE_				,   'bert.pt'							)							)
												_lowerCamelCase					:					Optional[Any]	       =    torch.jit.load(os.path.join(SCREAMING_SNAKE_CASE_				,   'bert.pt'							)				,   map_location=SCREAMING_SNAKE_CASE_							)
												loaded(inputs_dict['input_ids'].to(SCREAMING_SNAKE_CASE_							)				,   inputs_dict['attention_mask'].to(SCREAMING_SNAKE_CASE_							)							)







@require_torch
class 					A_(unittest.TestCase      ):







			"""simple docstring"""



			@slow
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Optional[Any]	       =    NezhaModel.from_pretrained('sijunhe/nezha-cn-base'							)
						_lowerCamelCase					:					List[str]	       =    torch.tensor([[0, 1, 2, 3, 4, 5]]							)
						_lowerCamelCase					:					int	       =    torch.tensor([[0, 1, 1, 1, 1, 1]]							)
						with torch.no_grad():
									_lowerCamelCase					:					int	       =    model(SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_							)[0]
						_lowerCamelCase					:					Optional[Any]	       =    torch.Size((1, 6, 768)							)
						self.assertEqual(output.shape				,   SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					int	       =    torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]]							)

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

			@slow
			def    _lowerCAmelCase		(	self							):
						_lowerCamelCase					:					Tuple	       =    NezhaForMaskedLM.from_pretrained('sijunhe/nezha-cn-base'							)
						_lowerCamelCase					:					Tuple	       =    torch.tensor([[0, 1, 2, 3, 4, 5]]							)
						_lowerCamelCase					:					Optional[Any]	       =    torch.tensor([[1, 1, 1, 1, 1, 1]]							)
						with torch.no_grad():
									_lowerCamelCase					:					str	       =    model(SCREAMING_SNAKE_CASE_				,   attention_mask=SCREAMING_SNAKE_CASE_							)[0]
						_lowerCamelCase					:					str	       =    torch.Size((1, 6, 2_1128)							)
						self.assertEqual(output.shape				,   SCREAMING_SNAKE_CASE_							)
						_lowerCamelCase					:					Tuple	       =    torch.tensor(
						    [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]]							)

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










from typing import TYPE_CHECKING

from ...utils import _LazyModule


a      :  int			     =			{'tokenization_wav2vec2_phoneme': ['Wav2Vec2PhonemeCTCTokenizer']}


if TYPE_CHECKING:
	from .tokenization_wavaveca_phoneme import WavaVecaPhonemeCTCTokenizer
else:
	import sys

	a      :  int			     =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






