


'''simple docstring'''




import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
				import torch


_lowerCAmelCase	:		Optional[Any]		  =						random.Random()

def       __UpperCamelCase     (     _A     :					Union[str, Any]       , _A     :					Union[str, Any]=1.0       , _A     :					Optional[int]=None       , _A     :					Dict=None					)     ->   Any:




	"""simple docstring"""





	if rng is None:
		lowerCAmelCase       :     List[str]   				=			global_rng

	lowerCAmelCase       :     str   				=			[]
	for batch_idx in range(shape[0]					):
		values.append([]					)
		for _ in range(shape[1]					):
			values[-1].append(rng.random() * scale					)

	return values



@require_torch
class 			lowerCAmelCase					(					unittest.TestCase				):



	def __init__(       self			,       snake_case__			,       snake_case__=7			,       snake_case__=400			,       snake_case__=2000			,       snake_case__=1			,       snake_case__=0.0			,       snake_case__=2_4000			,       snake_case__=True			,       ):
		lowerCAmelCase       :     List[str]   				=			parent
		lowerCAmelCase       :     Optional[Any]   				=			batch_size
		lowerCAmelCase       :     Any   				=			min_seq_length
		lowerCAmelCase       :     Any   				=			max_seq_length
		lowerCAmelCase       :     int   				=			(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
		lowerCAmelCase       :     Dict   				=			feature_size
		lowerCAmelCase       :     Any   				=			padding_value
		lowerCAmelCase       :     Tuple   				=			sampling_rate
		lowerCAmelCase       :     Union[str, Any]   				=			return_attention_mask



	def 					lowercase  (       self     ):
		return {
		    "feature_size": self.feature_size,
		    "padding_value": self.padding_value,
		    "sampling_rate": self.sampling_rate,
		    "return_attention_mask": self.return_attention_mask,
		}



	def 					lowercase  (       self			,       snake_case__=False			,       snake_case__=False     ):
		def _flatten(snake_case__     ):
			return list(itertools.chain(*_lowerCamelCase     )     )

		if equal_length:
			lowerCAmelCase       :     Tuple   				=			floats_list((self.batch_size, self.max_seq_length)     )
		else:
			# make sure that inputs increase in size
			lowerCAmelCase       :     Optional[Any]   				=			[
			    _flatten(floats_list((x, self.feature_size)     )     )
			    for x in range(self.min_seq_length			,       self.max_seq_length			,       self.seq_length_diff     )
			]

		if numpify:
			lowerCAmelCase       :     Tuple   				=			[np.asarray(_lowerCamelCase     ) for x in audio_inputs]

		return audio_inputs



@require_torch
class 			lowerCAmelCase					(					a_   ,					unittest.TestCase				):
	_lowerCamelCase :       Optional[int]         =			EncodecFeatureExtractor



	def 					lowercase  (       self     ):
		lowerCAmelCase       :     Optional[int]   				=			EnCodecFeatureExtractionTester(self     )



	def 					lowercase  (       self     ):
		# Tests that all call wrap to encode_plus and batch_encode_plus
		lowerCAmelCase       :     Dict   				=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
		# create three inputs of length 800, 1000, and 1200
		lowerCAmelCase       :     Optional[Any]   				=			[floats_list((1, x)     )[0] for x in range(800			,       1400			,       200     )]
		lowerCAmelCase       :     List[str]   				=			[np.asarray(_lowerCamelCase     ) for audio_input in audio_inputs]

		# Test not batched input
		lowerCAmelCase       :     List[str]   				=			feat_extract(audio_inputs[0]			,       return_tensors='np'     ).input_values
		lowerCAmelCase       :     int   				=			feat_extract(np_audio_inputs[0]			,       return_tensors='np'     ).input_values
		self.assertTrue(np.allclose(_lowerCamelCase			,       _lowerCamelCase			,       atol=1e-3     )     )

		# Test batched
		lowerCAmelCase       :     List[str]   				=			feat_extract(_lowerCamelCase			,       padding=_lowerCamelCase			,       return_tensors='np'     ).input_values
		lowerCAmelCase       :     Union[str, Any]   				=			feat_extract(_lowerCamelCase			,       padding=_lowerCamelCase			,       return_tensors='np'     ).input_values
		for enc_seq_a, enc_seq_a in zip(_lowerCamelCase			,       _lowerCamelCase     ):
			self.assertTrue(np.allclose(_lowerCamelCase			,       _lowerCamelCase			,       atol=1e-3     )     )



	def 					lowercase  (       self     ):
		lowerCAmelCase       :     Any   				=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
		lowerCAmelCase       :     str   				=			np.random.rand(100     ).astype(np.floataa     )
		lowerCAmelCase       :     Optional[Any]   				=			np_audio_inputs.tolist()

		for inputs in [py_audio_inputs, np_audio_inputs]:
			lowerCAmelCase       :     Optional[Any]   				=			feature_extractor.pad([{'input_values': inputs}]			,       return_tensors='np'     )
			self.assertTrue(np_processed.input_values.dtype == np.floataa     )
			lowerCAmelCase       :     List[str]   				=			feature_extractor.pad([{'input_values': inputs}]			,       return_tensors='pt'     )
			self.assertTrue(pt_processed.input_values.dtype == torch.floataa     )



	def 					lowercase  (       self			,       snake_case__     ):
		from datasets import load_dataset

		lowerCAmelCase       :     Tuple   				=			load_dataset('hf-internal-testing/librispeech_asr_dummy'			,       'clean'			,       split='validation'     )
		# automatic decoding with librispeech
		lowerCAmelCase       :     int   				=			ds.sort('id'     ).select(range(_lowerCamelCase     )     )[:num_samples]['audio']

		return [x["array"] for x in audio_samples]



	def 					lowercase  (       self     ):
		# fmt: off
		lowerCAmelCase       :     Union[str, Any]   				=			torch.tensor(
		    [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
		     3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
		     2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
		     4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
		     7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
		     4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]     )
		# fmt: on
		lowerCAmelCase       :     Any   				=			self._load_datasamples(1     )
		lowerCAmelCase       :     Optional[Any]   				=			EncodecFeatureExtractor()
		lowerCAmelCase       :     List[Any]   				=			feature_extractor(_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(input_values.shape			,       (1, 1, 9_3680)     )
		self.assertTrue(torch.allclose(input_values[0, 0, :30]			,       _lowerCamelCase			,       atol=1e-6     )     )



	def 					lowercase  (       self     ):
		# fmt: off
		lowerCAmelCase       :     Dict   				=			torch.tensor(
		    [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
		     3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
		     2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
		     4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
		     7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
		     4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]     )
		# fmt: on
		lowerCAmelCase       :     Optional[int]   				=			self._load_datasamples(1     )
		lowerCAmelCase       :     Dict   				=			[np.tile(input_audio[0][None]			,       reps=(2, 1)     )]
		input_audio[0][1] *= 0.5
		lowerCAmelCase       :     List[Any]   				=			EncodecFeatureExtractor(feature_size=2     )
		lowerCAmelCase       :     List[str]   				=			feature_extractor(_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(input_values.shape			,       (1, 2, 9_3680)     )
		self.assertTrue(torch.allclose(input_values[0, 0, :30]			,       _lowerCamelCase			,       atol=1e-6     )     )
		self.assertTrue(torch.allclose(input_values[0, 1, :30]			,       EXPECTED_INPUT_VALUES * 0.5			,       atol=1e-6     )     )



	def 					lowercase  (       self     ):
		lowerCAmelCase       :     int   				=			self._load_datasamples(2     )
		# would be easier if the stride was like
		lowerCAmelCase       :     Tuple   				=			EncodecFeatureExtractor(feature_size=1			,       chunk_length_s=1			,       overlap=0.0_1     )

		# pad and trunc raise an error ?
		with self.assertRaisesRegex(
		    _lowerCamelCase			,       '^Both padding and truncation were set. Make sure you only set one.$'			,       ):
			lowerCAmelCase       :     str   				=			feature_extractor(
			    _lowerCamelCase			,       padding='max_length'			,       truncation=_lowerCamelCase			,       return_tensors='pt'     ).input_values

		# truncate to chunk
		lowerCAmelCase       :     Any   				=			feature_extractor(_lowerCamelCase			,       truncation=_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(truncated_outputs.shape			,       (2, 1, 7_1520)     )  # 2 chunks

		# force truncate to max_length
		lowerCAmelCase       :     Optional[Any]   				=			feature_extractor(
		    _lowerCamelCase			,       truncation=_lowerCamelCase			,       max_length=4_8000			,       return_tensors='pt'     ).input_values
		self.assertEquals(truncated_outputs.shape			,       (2, 1, 4_8000)     )

		# pad to chunk
		lowerCAmelCase       :     Dict   				=			feature_extractor(_lowerCamelCase			,       padding=_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(padded_outputs.shape			,       (2, 1, 9_5280)     )

		# pad to chunk
		lowerCAmelCase       :     Tuple   				=			feature_extractor(_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(truncated_outputs.shape			,       (2, 1, 9_5280)     )

		# force pad to max length
		lowerCAmelCase       :     Optional[Any]   				=			feature_extractor(
		    _lowerCamelCase			,       padding='max_length'			,       max_length=10_0000			,       return_tensors='pt'     ).input_values
		self.assertEquals(truncated_outputs.shape			,       (2, 1, 10_0000)     )

		# force no pad
		with self.assertRaisesRegex(
		    _lowerCamelCase			,       '^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'			,       ):
			lowerCAmelCase       :     Optional[int]   				=			feature_extractor(_lowerCamelCase			,       padding=_lowerCamelCase			,       return_tensors='pt'     ).input_values

		lowerCAmelCase       :     int   				=			feature_extractor(input_audio[0]			,       padding=_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(truncated_outputs.shape			,       (1, 1, 9_3680)     )

		# no pad if no chunk_length_s
		lowerCAmelCase       :     Tuple   				=			None
		with self.assertRaisesRegex(
		    _lowerCamelCase			,       '^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'			,       ):
			lowerCAmelCase       :     Optional[Any]   				=			feature_extractor(_lowerCamelCase			,       padding=_lowerCamelCase			,       return_tensors='pt'     ).input_values

		lowerCAmelCase       :     Tuple   				=			feature_extractor(input_audio[0]			,       padding=_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(truncated_outputs.shape			,       (1, 1, 9_3680)     )

		# no pad if no overlap
		lowerCAmelCase       :     Union[str, Any]   				=			2
		lowerCAmelCase       :     Union[str, Any]   				=			None
		with self.assertRaisesRegex(
		    _lowerCamelCase			,       '^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$'			,       ):
			lowerCAmelCase       :     Optional[Any]   				=			feature_extractor(_lowerCamelCase			,       padding=_lowerCamelCase			,       return_tensors='pt'     ).input_values

		lowerCAmelCase       :     Optional[int]   				=			feature_extractor(input_audio[0]			,       padding=_lowerCamelCase			,       return_tensors='pt'     ).input_values
		self.assertEquals(truncated_outputs.shape			,       (1, 1, 9_3680)     )








"""simple docstring"""



import inspect
import unittest

import requests

from transformers import MgpstrConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import MgpstrForSceneTextRecognition


if is_vision_available():
    from PIL import Image

    from transformers import MgpstrProcessor

class 			a	:







    def __init__(     self				,						_lowerCamelCase				,						_lowerCamelCase=False				,						_lowerCamelCase=1_3				,						_lowerCamelCase=(3_2, 1_2_8)				,						_lowerCamelCase=4				,						_lowerCamelCase=3				,						_lowerCamelCase=2_7				,						_lowerCamelCase=3_8				,						_lowerCamelCase=9_9				,						_lowerCamelCase=9_9				,						_lowerCamelCase=3_2				,						_lowerCamelCase=5				,						_lowerCamelCase=4				,						_lowerCamelCase=4.0				,						_lowerCamelCase=2_5_7				,						_lowerCamelCase=None				,						):
      lowercase				       =			parent
      lowercase				       =			is_training
      lowercase				       =			batch_size
      lowercase				       =			image_size
      lowercase				       =			patch_size
      lowercase				       =			num_channels
      lowercase				       =			max_token_length
      lowercase				       =			num_character_labels
      lowercase				       =			num_bpe_labels
      lowercase				       =			num_wordpiece_labels
      lowercase				       =			hidden_size
      lowercase				       =			num_hidden_layers
      lowercase				       =			num_attention_heads
      lowercase				       =			mlp_ratio
      lowercase				       =			patch_embeds_hidden_size
      lowercase				       =			output_hidden_states







    def      UpperCamelCase_ (     self			):
      lowercase				       =			floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]			)
      lowercase				       =			self.get_config()
      return config, pixel_values







    def      UpperCamelCase_ (     self			):
      return MgpstrConfig(
          image_size=self.image_size				,						patch_size=self.patch_size				,						num_channels=self.num_channels				,						max_token_length=self.max_token_length				,						num_character_labels=self.num_character_labels				,						num_bpe_labels=self.num_bpe_labels				,						num_wordpiece_labels=self.num_wordpiece_labels				,						hidden_size=self.hidden_size				,						num_hidden_layers=self.num_hidden_layers				,						num_attention_heads=self.num_attention_heads				,						mlp_ratio=self.mlp_ratio				,						output_hidden_states=self.output_hidden_states				,						)







    def      UpperCamelCase_ (     self				,						_lowerCamelCase				,						_lowerCamelCase			):
      lowercase				       =			MgpstrForSceneTextRecognition(_lowerCamelCase			)
      model.to(_lowerCamelCase			)
      model.eval()
      with torch.no_grad():
        lowercase				       =			model(_lowerCamelCase			)
      self.parent.assertEqual(
          generated_ids[0][0].shape				,						(self.batch_size, self.max_token_length, self.num_character_labels)			)







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.prepare_config_and_inputs()
      lowercase       ,	lowercase				       =			config_and_inputs
      lowercase				       =			{'pixel_values': pixel_values}
      return config, inputs_dict


@require_torch
class 			a	(  a_,							a_,							unittest.TestCase      ):
    UpperCAmelCase_					:	Optional[int]      	=(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
    UpperCAmelCase_					:	Optional[Any]      	={"feature-extraction": MgpstrForSceneTextRecognition} if is_torch_available() else {}
    UpperCAmelCase_					:	Union[str, Any]      	=False

    UpperCAmelCase_					:	Optional[Any]      	=False
    UpperCAmelCase_					:	Dict      	=False
    UpperCAmelCase_					:	str      	=False
    UpperCAmelCase_					:	str      	=False







    def      UpperCamelCase_ (     self			):
      lowercase				       =			MgpstrModelTester(self			)
      lowercase				       =			ConfigTester(self				,						config_class=_lowerCamelCase				,						has_text_modality=_lowerCamelCase			)







    def      UpperCamelCase_ (     self			):
      self.config_tester.run_common_tests()







    def      UpperCamelCase_ (     self			):
      lowercase				       =			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCamelCase			)







    @unittest.skip(reason='MgpstrModel does not use inputs_embeds'			)
    def      UpperCamelCase_ (     self			):
      pass







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase				       =			model_class(_lowerCamelCase			)
        self.assertIsInstance(model.get_input_embeddings()				,						(nn.Module)			)
        lowercase				       =			model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(_lowerCamelCase				,						nn.Linear			)			)







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

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

        lowercase				       =			['pixel_values']
        self.assertListEqual(arg_names[:1]				,						_lowerCamelCase			)







    @unittest.skip(reason='MgpstrModel does not support feedforward chunking'			)
    def      UpperCamelCase_ (     self			):
      pass







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        if not model_class.supports_gradient_checkpointing:
          continue

        lowercase				       =			True
        lowercase				       =			model_class(_lowerCamelCase			)
        self.assertTrue(model.is_gradient_checkpointing			)







    def      UpperCamelCase_ (     self			):
      def check_hidden_states_output(_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			):
        lowercase				       =			model_class(_lowerCamelCase			)
        model.to(_lowerCamelCase			)
        model.eval()

        with torch.no_grad():
          lowercase				       =			model(**self._prepare_for_class(_lowerCamelCase				,						_lowerCamelCase			)			)

        lowercase				       =			outputs.hidden_states

        lowercase				       =			getattr(
            self.model_tester				,						'expected_num_hidden_layers'				,						self.model_tester.num_hidden_layers + 1			)
        self.assertEqual(len(_lowerCamelCase			)				,						_lowerCamelCase			)

        self.assertListEqual(
            list(hidden_states[0].shape[-2:]			)				,						[self.model_tester.patch_embeds_hidden_size, self.model_tester.hidden_size]				,						)

      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase				       =			True
        check_hidden_states_output(_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        lowercase				       =			True

        check_hidden_states_output(_lowerCamelCase				,						_lowerCamelCase				,						_lowerCamelCase			)







    def      UpperCamelCase_ (     self			):
      lowercase       ,	lowercase				       =			self.model_tester.prepare_config_and_inputs_for_common()

      lowercase				       =			_config_zero_init(_lowerCamelCase			)
      for model_class in self.all_model_classes:
        lowercase				       =			model_class(config=_lowerCamelCase			)
        for name, param in model.named_parameters():
          if isinstance(_lowerCamelCase				,						(nn.Linear, nn.Convad, nn.LayerNorm)			):
            if param.requires_grad:
              self.assertIn(
                  ((param.data.mean() * 1e9).round() / 1e9).item()				,						[0.0, 1.0]				,						msg=F'Parameter {name} of model {model_class} seems not properly initialized'				,						)







    @unittest.skip(reason='Retain_grad is tested in individual model tests'			)
    def      UpperCamelCase_ (     self			):
      pass


def 		_SCREAMING_SNAKE_CASE					(       ):





  '''simple docstring'''





  lowercase				       =			'https://i.postimg.cc/ZKwLg2Gw/367-14.png'
  lowercase				       =			Image.open(requests.get(__snake_case						,   stream=__snake_case       ).raw       ).convert('RGB'       )
  return im



@require_vision
@require_torch
class 			a	(  unittest.TestCase      ):







    @slow
    def      UpperCamelCase_ (     self			):
      lowercase				       =			'alibaba-damo/mgp-str-base'
      lowercase				       =			MgpstrForSceneTextRecognition.from_pretrained(_lowerCamelCase			).to(_lowerCamelCase			)
      lowercase				       =			MgpstrProcessor.from_pretrained(_lowerCamelCase			)

      lowercase				       =			prepare_img()
      lowercase				       =			processor(images=_lowerCamelCase				,						return_tensors='pt'			).pixel_values.to(_lowerCamelCase			)

      # forward pass
      with torch.no_grad():
        lowercase				       =			model(_lowerCamelCase			)

      # verify the logits
      self.assertEqual(outputs.logits[0].shape				,						torch.Size((1, 2_7, 3_8)			)			)

      lowercase				       =			processor.batch_decode(outputs.logits			)
      lowercase				       =			'ticket'

      self.assertEqual(out_strs['generated_text'][0]				,						_lowerCamelCase			)

      lowercase				       =			torch.tensor(
          [[[-3_9.5_3_9_7, -4_4.4_0_2_4, -3_6.1_8_4_4], [-6_1.4_7_0_9, -6_3.8_6_3_9, -5_8.3_4_5_4], [-7_4.0_2_2_5, -6_8.5_4_9_4, -7_1.2_1_6_4]]]				,						device=_lowerCamelCase				,						)

      self.assertTrue(torch.allclose(outputs.logits[0][:, 1:4, 1:4]				,						_lowerCamelCase				,						atol=1e-4			)			)


