'''simple docstring'''






import itertools
import json
import os
import unittest

from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class    a (       __lowerCAmelCase						,  unittest.TestCase				):



		"""simple docstring"""
		__lowerCAmelCase				      =					RobertaTokenizer
		__lowerCAmelCase				      =					RobertaTokenizerFast
		__lowerCAmelCase				      =					True
		__lowerCAmelCase				      =					{"""cls_token""": """<s>"""}







		def    lowercase_  (							self					):

				'''simple docstring'''







				super().setUp()

				# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
				__UpperCAmelCase:					Optional[Any]		= [
				    """l""",
				    """o""",
				    """w""",
				    """e""",
				    """r""",
				    """s""",
				    """t""",
				    """i""",
				    """d""",
				    """n""",
				    """\u0120""",
				    """\u0120l""",
				    """\u0120n""",
				    """\u0120lo""",
				    """\u0120low""",
				    """er""",
				    """\u0120lowest""",
				    """\u0120newer""",
				    """\u0120wider""",
				    """<unk>""",
				]
				__UpperCAmelCase:					Optional[int]		= dict(zip(snake_case_   ,    range(len(snake_case_					)					)					)					)
				__UpperCAmelCase:					Optional[int]		= ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
				__UpperCAmelCase:					int		= {"""unk_token""": """<unk>"""}

				__UpperCAmelCase:					Tuple		= os.path.join(self.tmpdirname   ,    VOCAB_FILES_NAMES["""vocab_file"""]					)
				__UpperCAmelCase:					Tuple		= os.path.join(self.tmpdirname   ,    VOCAB_FILES_NAMES["""merges_file"""]					)
				with open(self.vocab_file   ,    """w"""   ,    encoding="""utf-8"""					) as fp:
						fp.write(json.dumps(snake_case_					) + """\n"""					)
				with open(self.merges_file   ,    """w"""   ,    encoding="""utf-8"""					) as fp:
						fp.write("""\n""".join(snake_case_					)					)







		def    lowercase_  (							self   ,    **snake_case_					):

				'''simple docstring'''







				kwargs.update(self.special_tokens_map					)
				return self.tokenizer_class.from_pretrained(self.tmpdirname   ,    **snake_case_					)







		def    lowercase_  (							self   ,    **snake_case_					):

				'''simple docstring'''







				kwargs.update(self.special_tokens_map					)
				return RobertaTokenizerFast.from_pretrained(self.tmpdirname   ,    **snake_case_					)







		def    lowercase_  (							self   ,    snake_case_					):

				'''simple docstring'''







				__UpperCAmelCase:					Dict		= """lower newer"""
				__UpperCAmelCase:					List[str]		= """lower newer"""
				return input_text, output_text







		def    lowercase_  (							self					):

				'''simple docstring'''







				__UpperCAmelCase:					Dict		= self.tokenizer_class(self.vocab_file   ,    self.merges_file   ,    **self.special_tokens_map					)
				__UpperCAmelCase:					Union[str, Any]		= """lower newer"""
				__UpperCAmelCase:					List[Any]		= ["""l""", """o""", """w""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
				__UpperCAmelCase:					str		= tokenizer.tokenize(snake_case_					)  # , add_prefix_space=True)
				self.assertListEqual(snake_case_   ,    snake_case_					)

				__UpperCAmelCase:					Optional[int]		= tokens + [tokenizer.unk_token]
				__UpperCAmelCase:					str		= [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
				self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_					)   ,    snake_case_					)







		def    lowercase_  (							self					):

				'''simple docstring'''







				__UpperCAmelCase:					Optional[int]		= self.get_tokenizer()

				self.assertListEqual(tokenizer.encode("""Hello world!"""   ,    add_special_tokens=snake_case_					)   ,    [0, 3_1414, 232, 328, 2]					)
				self.assertListEqual(
				    tokenizer.encode("""Hello world! cécé herlolip 418"""   ,    add_special_tokens=snake_case_					)   ,    [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]   ,    )







		@slow
		def    lowercase_  (							self					):

				'''simple docstring'''







				__UpperCAmelCase:					Union[str, Any]		= self.tokenizer_class.from_pretrained("""roberta-base"""					)

				__UpperCAmelCase:					str		= tokenizer.encode("""sequence builders"""   ,    add_special_tokens=snake_case_					)
				__UpperCAmelCase:					str		= tokenizer.encode("""multi-sequence build"""   ,    add_special_tokens=snake_case_					)

				__UpperCAmelCase:					List[Any]		= tokenizer.encode(
				    """sequence builders"""   ,    add_special_tokens=snake_case_   ,    add_prefix_space=snake_case_					)
				__UpperCAmelCase:					Any		= tokenizer.encode(
				    """sequence builders"""   ,    """multi-sequence build"""   ,    add_special_tokens=snake_case_   ,    add_prefix_space=snake_case_					)

				__UpperCAmelCase:					Dict		= tokenizer.build_inputs_with_special_tokens(snake_case_					)
				__UpperCAmelCase:					int		= tokenizer.build_inputs_with_special_tokens(snake_case_   ,    snake_case_					)

				assert encoded_sentence == encoded_text_from_decode
				assert encoded_pair == encoded_pair_from_decode







		def    lowercase_  (							self					):

				'''simple docstring'''







				__UpperCAmelCase:					Optional[Any]		= self.get_tokenizer()

				__UpperCAmelCase:					Tuple		= """Encode this sequence."""
				__UpperCAmelCase:					Optional[Any]		= tokenizer.byte_encoder[""" """.encode("""utf-8"""					)[0]]

				# Testing encoder arguments
				__UpperCAmelCase:					Dict		= tokenizer.encode(snake_case_   ,    add_special_tokens=snake_case_   ,    add_prefix_space=snake_case_					)
				__UpperCAmelCase:					List[str]		= tokenizer.convert_ids_to_tokens(encoded[0]					)[0]
				self.assertNotEqual(snake_case_   ,    snake_case_					)

				__UpperCAmelCase:					Dict		= tokenizer.encode(snake_case_   ,    add_special_tokens=snake_case_   ,    add_prefix_space=snake_case_					)
				__UpperCAmelCase:					Tuple		= tokenizer.convert_ids_to_tokens(encoded[0]					)[0]
				self.assertEqual(snake_case_   ,    snake_case_					)

				tokenizer.add_special_tokens({"""bos_token""": """<s>"""}					)
				__UpperCAmelCase:					str		= tokenizer.encode(snake_case_   ,    add_special_tokens=snake_case_					)
				__UpperCAmelCase:					Dict		= tokenizer.convert_ids_to_tokens(encoded[1]					)[0]
				self.assertNotEqual(snake_case_   ,    snake_case_					)

				# Testing spaces after special tokens
				__UpperCAmelCase:					Dict		= """<mask>"""
				tokenizer.add_special_tokens(
				    {"""mask_token""": AddedToken(snake_case_   ,    lstrip=snake_case_   ,    rstrip=snake_case_					)}					)  # mask token has a left space
				__UpperCAmelCase:					Any		= tokenizer.convert_tokens_to_ids(snake_case_					)

				__UpperCAmelCase:					List[Any]		= """Encode <mask> sequence"""
				__UpperCAmelCase:					Dict		= """Encode <mask>sequence"""

				__UpperCAmelCase:					Dict		= tokenizer.encode(snake_case_					)
				__UpperCAmelCase:					List[Any]		= encoded.index(snake_case_					)
				__UpperCAmelCase:					Dict		= tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]					)[0]
				self.assertEqual(snake_case_   ,    snake_case_					)

				__UpperCAmelCase:					Any		= tokenizer.encode(snake_case_					)
				__UpperCAmelCase:					List[str]		= encoded.index(snake_case_					)
				__UpperCAmelCase:					List[Any]		= tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]					)[0]
				self.assertNotEqual(snake_case_   ,    snake_case_					)







		def    lowercase_  (							self					):

				'''simple docstring'''







				pass







		def    lowercase_  (							self					):

				'''simple docstring'''







				for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
								__UpperCAmelCase:					Optional[Any]		= self.rust_tokenizer_class.from_pretrained(snake_case_   ,    **snake_case_					)
								__UpperCAmelCase:					Optional[int]		= self.tokenizer_class.from_pretrained(snake_case_   ,    **snake_case_					)
								__UpperCAmelCase:					List[Any]		= """A, <mask> AllenNLP sentence."""
								__UpperCAmelCase:					Optional[Any]		= tokenizer_r.encode_plus(snake_case_   ,    add_special_tokens=snake_case_   ,    return_token_type_ids=snake_case_					)
								__UpperCAmelCase:					List[Any]		= tokenizer_p.encode_plus(snake_case_   ,    add_special_tokens=snake_case_   ,    return_token_type_ids=snake_case_					)

								# token_type_ids should put 0 everywhere
								self.assertEqual(sum(tokens_r["""token_type_ids"""]					)   ,    sum(tokens_p["""token_type_ids"""]					)					)

								# attention_mask should put 1 everywhere, so sum over length should be 1
								self.assertEqual(
								    sum(tokens_r["""attention_mask"""]					) / len(tokens_r["""attention_mask"""]					)   ,    sum(tokens_p["""attention_mask"""]					) / len(tokens_p["""attention_mask"""]					)   ,    )

								__UpperCAmelCase:					List[str]		= tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]					)
								__UpperCAmelCase:					Any		= tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]					)

								# Rust correctly handles the space before the mask while python doesnt
								self.assertSequenceEqual(tokens_p["""input_ids"""]   ,    [0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]					)
								self.assertSequenceEqual(tokens_r["""input_ids"""]   ,    [0, 250, 6, 5_0264, 3823, 487, 2_1992, 3645, 4, 2]					)

								self.assertSequenceEqual(
								    snake_case_   ,    ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]					)
								self.assertSequenceEqual(
								    snake_case_   ,    ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]					)







		def    lowercase_  (							self					):

				'''simple docstring'''







				for trim_offsets, add_prefix_space in itertools.product([True, False]   ,    repeat=2					):
						__UpperCAmelCase:					Optional[Any]		= self.rust_tokenizer_class.from_pretrained(
						    self.tmpdirname   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)

						__UpperCAmelCase:					Tuple		= json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()					)
						__UpperCAmelCase:					Union[str, Any]		= json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()					)

						self.assertEqual(pre_tokenizer_state["""add_prefix_space"""]   ,    snake_case_					)

						self.assertEqual(post_processor_state["""add_prefix_space"""]   ,    snake_case_					)
						self.assertEqual(post_processor_state["""trim_offsets"""]   ,    snake_case_					)







		def    lowercase_  (							self					):

				'''simple docstring'''







				for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
								__UpperCAmelCase:					int		= """hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
								__UpperCAmelCase:					Dict		= F'''{text_of_1_token} {text_of_1_token}'''

								__UpperCAmelCase:					int		= self.rust_tokenizer_class.from_pretrained(
								    snake_case_   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)
								__UpperCAmelCase:					Tuple		= tokenizer_r(snake_case_   ,    return_offsets_mapping=snake_case_   ,    add_special_tokens=snake_case_					)
								self.assertEqual(encoding.offset_mapping[0]   ,    (0, len(snake_case_					))					)
								self.assertEqual(
								    encoding.offset_mapping[1]   ,    (len(snake_case_					) + 1, len(snake_case_					) + 1 + len(snake_case_					))   ,    )

								__UpperCAmelCase:					Optional[Any]		= self.rust_tokenizer_class.from_pretrained(
								    snake_case_   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)
								__UpperCAmelCase:					str		= tokenizer_r(snake_case_   ,    return_offsets_mapping=snake_case_   ,    add_special_tokens=snake_case_					)
								self.assertEqual(encoding.offset_mapping[0]   ,    (0, len(snake_case_					))					)
								self.assertEqual(
								    encoding.offset_mapping[1]   ,    (len(snake_case_					) + 1, len(snake_case_					) + 1 + len(snake_case_					))   ,    )

								__UpperCAmelCase:					Any		= self.rust_tokenizer_class.from_pretrained(
								    snake_case_   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)
								__UpperCAmelCase:					Dict		= tokenizer_r(snake_case_   ,    return_offsets_mapping=snake_case_   ,    add_special_tokens=snake_case_					)
								self.assertEqual(encoding.offset_mapping[0]   ,    (0, len(snake_case_					))					)
								self.assertEqual(
								    encoding.offset_mapping[1]   ,    (len(snake_case_					), len(snake_case_					) + 1 + len(snake_case_					))   ,    )

								__UpperCAmelCase:					int		= self.rust_tokenizer_class.from_pretrained(
								    snake_case_   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)
								__UpperCAmelCase:					Union[str, Any]		= tokenizer_r(snake_case_   ,    return_offsets_mapping=snake_case_   ,    add_special_tokens=snake_case_					)
								self.assertEqual(encoding.offset_mapping[0]   ,    (0, len(snake_case_					))					)
								self.assertEqual(
								    encoding.offset_mapping[1]   ,    (len(snake_case_					), len(snake_case_					) + 1 + len(snake_case_					))   ,    )

								__UpperCAmelCase:					Any		= F''' {text}'''

								# tokenizer_r = self.rust_tokenizer_class.from_pretrained(
								#     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
								# )
								# encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
								# self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
								# self.assertEqual(
								#     encoding.offset_mapping[1],
								#     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
								# )

								__UpperCAmelCase:					int		= self.rust_tokenizer_class.from_pretrained(
								    snake_case_   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)
								__UpperCAmelCase:					Dict		= tokenizer_r(snake_case_   ,    return_offsets_mapping=snake_case_   ,    add_special_tokens=snake_case_					)
								self.assertEqual(encoding.offset_mapping[0]   ,    (1, 1 + len(snake_case_					))					)
								self.assertEqual(
								    encoding.offset_mapping[1]   ,    (1 + len(snake_case_					) + 1, 1 + len(snake_case_					) + 1 + len(snake_case_					))   ,    )

								__UpperCAmelCase:					Optional[int]		= self.rust_tokenizer_class.from_pretrained(
								    snake_case_   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)
								__UpperCAmelCase:					Optional[int]		= tokenizer_r(snake_case_   ,    return_offsets_mapping=snake_case_   ,    add_special_tokens=snake_case_					)
								self.assertEqual(encoding.offset_mapping[0]   ,    (0, 1 + len(snake_case_					))					)
								self.assertEqual(
								    encoding.offset_mapping[1]   ,    (1 + len(snake_case_					), 1 + len(snake_case_					) + 1 + len(snake_case_					))   ,    )

								__UpperCAmelCase:					Optional[int]		= self.rust_tokenizer_class.from_pretrained(
								    snake_case_   ,    use_fast=snake_case_   ,    add_prefix_space=snake_case_   ,    trim_offsets=snake_case_					)
								__UpperCAmelCase:					Tuple		= tokenizer_r(snake_case_   ,    return_offsets_mapping=snake_case_   ,    add_special_tokens=snake_case_					)
								self.assertEqual(encoding.offset_mapping[0]   ,    (0, 1 + len(snake_case_					))					)
								self.assertEqual(
								    encoding.offset_mapping[1]   ,    (1 + len(snake_case_					), 1 + len(snake_case_					) + 1 + len(snake_case_					))   ,    )
'''simple docstring'''






import unittest

import numpy as np

from transformers import AlbertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
    import jax.numpy as jnp

    from transformers.models.albert.modeling_flax_albert import (
        FlaxAlbertForMaskedLM,
        FlaxAlbertForMultipleChoice,
        FlaxAlbertForPreTraining,
        FlaxAlbertForQuestionAnswering,
        FlaxAlbertForSequenceClassification,
        FlaxAlbertForTokenClassification,
        FlaxAlbertModel,
    )




class    a (       unittest.TestCase				):



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_=13   ,    snake_case_=7   ,    snake_case_=True   ,    snake_case_=True   ,    snake_case_=True   ,    snake_case_=True   ,    snake_case_=99   ,    snake_case_=32   ,    snake_case_=5   ,    snake_case_=4   ,    snake_case_=37   ,    snake_case_="gelu"   ,    snake_case_=0.1   ,    snake_case_=0.1   ,    snake_case_=512   ,    snake_case_=16   ,    snake_case_=2   ,    snake_case_=0.0_2   ,    snake_case_=4   ,    ):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[Any]		= parent
    __UpperCAmelCase:					List[str]		= batch_size
    __UpperCAmelCase:					Optional[int]		= seq_length
    __UpperCAmelCase:					Optional[Any]		= is_training
    __UpperCAmelCase:					Any		= use_attention_mask
    __UpperCAmelCase:					List[str]		= use_token_type_ids
    __UpperCAmelCase:					List[str]		= use_labels
    __UpperCAmelCase:					List[str]		= vocab_size
    __UpperCAmelCase:					Optional[Any]		= hidden_size
    __UpperCAmelCase:					List[Any]		= num_hidden_layers
    __UpperCAmelCase:					List[Any]		= num_attention_heads
    __UpperCAmelCase:					Tuple		= intermediate_size
    __UpperCAmelCase:					Dict		= hidden_act
    __UpperCAmelCase:					Dict		= hidden_dropout_prob
    __UpperCAmelCase:					Tuple		= attention_probs_dropout_prob
    __UpperCAmelCase:					List[str]		= max_position_embeddings
    __UpperCAmelCase:					List[Any]		= type_vocab_size
    __UpperCAmelCase:					List[Any]		= type_sequence_label_size
    __UpperCAmelCase:					List[str]		= initializer_range
    __UpperCAmelCase:					List[Any]		= num_choices







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					int		= ids_tensor([self.batch_size, self.seq_length]   ,    self.vocab_size					)

    __UpperCAmelCase:					str		= None
    if self.use_attention_mask:
      __UpperCAmelCase:					Any		= random_attention_mask([self.batch_size, self.seq_length]					)

    __UpperCAmelCase:					List[Any]		= None
    if self.use_token_type_ids:
      __UpperCAmelCase:					Optional[int]		= ids_tensor([self.batch_size, self.seq_length]   ,    self.type_vocab_size					)

    __UpperCAmelCase:					List[Any]		= AlbertConfig(
        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=snake_case_   ,    initializer_range=self.initializer_range   ,    )

    return config, input_ids, token_type_ids, attention_mask







  def    lowercase_  (							self					):

    '''simple docstring'''







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




@require_flax
class    a (       __lowerCAmelCase						,  unittest.TestCase				):



  """simple docstring"""
  __lowerCAmelCase				      =					(
      (
          FlaxAlbertModel,
          FlaxAlbertForPreTraining,
          FlaxAlbertForMaskedLM,
          FlaxAlbertForMultipleChoice,
          FlaxAlbertForQuestionAnswering,
          FlaxAlbertForSequenceClassification,
          FlaxAlbertForTokenClassification,
          FlaxAlbertForQuestionAnswering,
      )
      if is_flax_available()
      else ()
  )







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Union[str, Any]		= FlaxAlbertModelTester(self					)







  @slow
  def    lowercase_  (							self					):

    '''simple docstring'''







    for model_class_name in self.all_model_classes:
      __UpperCAmelCase:					str		= model_class_name.from_pretrained("""albert-base-v2"""					)
      __UpperCAmelCase:					int		= model(np.ones((1, 1)					)					)
      self.assertIsNotNone(snake_case_					)




@require_flax
class    a (       unittest.TestCase				):



  """simple docstring"""







  @slow
  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= FlaxAlbertModel.from_pretrained("""albert-base-v2"""					)
    __UpperCAmelCase:					Dict		= np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]					)
    __UpperCAmelCase:					int		= np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]					)
    __UpperCAmelCase:					Optional[int]		= model(snake_case_   ,    attention_mask=snake_case_					)[0]
    __UpperCAmelCase:					Optional[int]		= (1, 11, 768)
    self.assertEqual(output.shape   ,    snake_case_					)
    __UpperCAmelCase:					str		= np.array(
        [[[-0.6_5_1_3, 1.5_0_3_5, -0.2_7_6_6], [-0.6_5_1_5, 1.5_0_4_6, -0.2_7_8_0], [-0.6_5_1_2, 1.5_0_4_9, -0.2_7_8_4]]]					)

    self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]   ,    snake_case_   ,    atol=1e-4					)					)