





def    _lowerCAmelCase						(				lowerCamelCase_			:  int		,       lowerCamelCase_			:  int				):
			return "\n".join(
			    f"{number} * {i} = {number * i}" for i in range(1		,       number_of_terms + 1				)				)


if __name__ == "__main__":
	print(multiplication_table(number=5, number_of_terms=1_0))












'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
	from huggingface_hub import snapshot_download
	from pyctcdecode import BeamSearchDecoderCTC

	from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
	from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
	from transformers import WavaVecaForCTC






@require_pyctcdecode
class 							__lowercase       (      unittest.TestCase						):







	'''simple docstring'''

	def 						_UpperCAmelCase     (self )							->							Union[str, Any]:







				'''simple docstring'''





				__lowercase										=							'''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
				__lowercase										=							dict(zip(_lowerCamelCase     ,range(len(_lowerCamelCase ) ) ) )

				__lowercase										=							{
				    '''unk_token''': '''<unk>''',
				    '''bos_token''': '''<s>''',
				    '''eos_token''': '''</s>''',
				}
				__lowercase										=							{
				    '''feature_size''': 1,
				    '''padding_value''': 0.0,
				    '''sampling_rate''': 16000,
				    '''return_attention_mask''': False,
				    '''do_normalize''': True,
				}

				__lowercase										=							tempfile.mkdtemp()
				__lowercase										=							os.path.join(self.tmpdirname     ,VOCAB_FILES_NAMES['''vocab_file'''] )
				__lowercase										=							os.path.join(self.tmpdirname     ,_lowerCamelCase )
				with open(self.vocab_file     ,'''w'''     ,encoding='''utf-8''' ) as fp:
							fp.write(json.dumps(_lowerCamelCase ) + '''\n''' )

				with open(self.feature_extraction_file     ,'''w'''     ,encoding='''utf-8''' ) as fp:
							fp.write(json.dumps(_lowerCamelCase ) + '''\n''' )

				# load decoder from hub
				__lowercase										=							'''hf-internal-testing/ngram-beam-search-decoder'''


	def 						_UpperCAmelCase     (self     ,**_lowerCamelCase )							->							List[str]:







				'''simple docstring'''





				__lowercase										=							self.add_kwargs_tokens_map.copy()
				kwargs.update(_lowerCamelCase )
				return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname     ,**_lowerCamelCase )


	def 						_UpperCAmelCase     (self     ,**_lowerCamelCase )							->							List[Any]:







				'''simple docstring'''





				return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname     ,**_lowerCamelCase )


	def 						_UpperCAmelCase     (self     ,**_lowerCamelCase )							->							Dict:







				'''simple docstring'''





				return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name     ,**_lowerCamelCase )


	def 						_UpperCAmelCase     (self )							->							Optional[Any]:







				'''simple docstring'''





				shutil.rmtree(self.tmpdirname )


	def 						_UpperCAmelCase     (self )							->							Optional[Any]:







				'''simple docstring'''





				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				processor.save_pretrained(self.tmpdirname )
				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname )

				# tokenizer
				self.assertEqual(processor.tokenizer.get_vocab()     ,tokenizer.get_vocab() )
				self.assertIsInstance(processor.tokenizer     ,_lowerCamelCase )

				# feature extractor
				self.assertEqual(processor.feature_extractor.to_json_string()     ,feature_extractor.to_json_string() )
				self.assertIsInstance(processor.feature_extractor     ,_lowerCamelCase )

				# decoder
				self.assertEqual(processor.decoder._alphabet.labels     ,decoder._alphabet.labels )
				self.assertEqual(
				    processor.decoder.model_container[decoder._model_key]._unigram_set     ,decoder.model_container[decoder._model_key]._unigram_set     ,)
				self.assertIsInstance(processor.decoder     ,_lowerCamelCase )


	def 						_UpperCAmelCase     (self )							->							Any:







				'''simple docstring'''





				__lowercase										=							WavaVecaProcessorWithLM(
				    tokenizer=self.get_tokenizer()     ,feature_extractor=self.get_feature_extractor()     ,decoder=self.get_decoder() )
				processor.save_pretrained(self.tmpdirname )

				# make sure that error is thrown when decoder alphabet doesn't match
				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained(
				    self.tmpdirname     ,alpha=5.0     ,beta=3.0     ,score_boundary=-7.0     ,unk_score_offset=3 )

				# decoder
				self.assertEqual(processor.language_model.alpha     ,5.0 )
				self.assertEqual(processor.language_model.beta     ,3.0 )
				self.assertEqual(processor.language_model.score_boundary     ,-7.0 )
				self.assertEqual(processor.language_model.unk_score_offset     ,3 )


	def 						_UpperCAmelCase     (self )							->							Dict:







				'''simple docstring'''





				__lowercase										=							self.get_tokenizer()
				# add token to trigger raise
				tokenizer.add_tokens(['''xx'''] )
				with self.assertRaisesRegex(_lowerCamelCase     ,'''include''' ):
							WavaVecaProcessorWithLM(
							    tokenizer=_lowerCamelCase     ,feature_extractor=self.get_feature_extractor()     ,decoder=self.get_decoder() )


	def 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''simple docstring'''





				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							floats_list((3, 1000) )

				__lowercase										=							feature_extractor(_lowerCamelCase     ,return_tensors='''np''' )
				__lowercase										=							processor(_lowerCamelCase     ,return_tensors='''np''' )

				for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()     ,input_processor[key].sum()     ,delta=1E-2 )


	def 						_UpperCAmelCase     (self )							->							List[Any]:







				'''simple docstring'''





				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							'''This is a test string'''

				__lowercase										=							processor(text=_lowerCamelCase )

				__lowercase										=							tokenizer(_lowerCamelCase )

				for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]     ,encoded_processor[key] )


	def 						_UpperCAmelCase     (self     ,_lowerCamelCase=(2, 10, 16)     ,_lowerCamelCase=77 )							->							Optional[int]:







				'''simple docstring'''





				np.random.seed(_lowerCamelCase )
				return np.random.rand(*_lowerCamelCase )


	def 						_UpperCAmelCase     (self )							->							str:







				'''simple docstring'''





				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							self._get_dummy_logits(shape=(10, 16)     ,seed=13 )

				__lowercase										=							processor.decode(_lowerCamelCase )

				__lowercase										=							decoder.decode_beams(_lowerCamelCase )[0]

				self.assertEqual(decoded_decoder[0]     ,decoded_processor.text )
				self.assertEqual('''</s> <s> </s>'''     ,decoded_processor.text )
				self.assertEqual(decoded_decoder[-2]     ,decoded_processor.logit_score )
				self.assertEqual(decoded_decoder[-1]     ,decoded_processor.lm_score )


	@parameterized.expand([[None], ['''fork'''], ['''spawn''']] )
	def 						_UpperCAmelCase     (self     ,_lowerCamelCase )							->							Optional[Any]:







				'''simple docstring'''





				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							self._get_dummy_logits()

				# note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
				#       otherwise, the LM won't be available to the pool's sub-processes.
				# manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
				if pool_context is None:
							__lowercase										=							processor.batch_decode(_lowerCamelCase )
				else:
							with get_context(_lowerCamelCase ).Pool() as pool:
										__lowercase										=							processor.batch_decode(_lowerCamelCase     ,_lowerCamelCase )

				__lowercase										=							list(_lowerCamelCase )

				with get_context('''fork''' ).Pool() as p:
							__lowercase										=							decoder.decode_beams_batch(_lowerCamelCase     ,_lowerCamelCase )

				__lowercase						,		__lowercase						,		__lowercase										=							[], [], []
				for beams in decoded_beams:
							texts_decoder.append(beams[0][0] )
							logit_scores_decoder.append(beams[0][-2] )
							lm_scores_decoder.append(beams[0][-1] )

				self.assertListEqual(_lowerCamelCase     ,decoded_processor.text )
				self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>''']     ,decoded_processor.text )
				self.assertListEqual(_lowerCamelCase     ,decoded_processor.logit_score )
				self.assertListEqual(_lowerCamelCase     ,decoded_processor.lm_score )


	def 						_UpperCAmelCase     (self )							->							Any:







				'''simple docstring'''





				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							self._get_dummy_logits()

				__lowercase										=							15
				__lowercase										=							-2_0.0
				__lowercase										=							-4.0

				__lowercase										=							processor.batch_decode(
				    _lowerCamelCase     ,beam_width=_lowerCamelCase     ,beam_prune_logp=_lowerCamelCase     ,token_min_logp=_lowerCamelCase     ,)
				__lowercase										=							decoded_processor_out.text

				__lowercase										=							list(_lowerCamelCase )

				with get_context('''fork''' ).Pool() as pool:
							__lowercase										=							decoder.decode_beams_batch(
							    _lowerCamelCase     ,_lowerCamelCase     ,beam_width=_lowerCamelCase     ,beam_prune_logp=_lowerCamelCase     ,token_min_logp=_lowerCamelCase     ,)

				__lowercase										=							[d[0][0] for d in decoded_decoder_out]
				__lowercase										=							[d[0][2] for d in decoded_decoder_out]
				__lowercase										=							[d[0][3] for d in decoded_decoder_out]

				self.assertListEqual(_lowerCamelCase     ,_lowerCamelCase )
				self.assertListEqual(['''</s> <s> <s>''', '''<s> <s> <s>''']     ,_lowerCamelCase )

				self.assertTrue(np.array_equal(_lowerCamelCase     ,decoded_processor_out.logit_score ) )
				self.assertTrue(np.allclose([-2_0.0_5_4, -1_8.4_4_7]     ,_lowerCamelCase     ,atol=1E-3 ) )

				self.assertTrue(np.array_equal(_lowerCamelCase     ,decoded_processor_out.lm_score ) )
				self.assertTrue(np.allclose([-1_5.5_5_4, -1_3.9_4_7_4]     ,_lowerCamelCase     ,atol=1E-3 ) )


	def 						_UpperCAmelCase     (self )							->							Union[str, Any]:







				'''simple docstring'''





				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							self._get_dummy_logits()

				__lowercase										=							2.0
				__lowercase										=							5.0
				__lowercase										=							-2_0.0
				__lowercase										=							True

				__lowercase										=							processor.batch_decode(
				    _lowerCamelCase     ,alpha=_lowerCamelCase     ,beta=_lowerCamelCase     ,unk_score_offset=_lowerCamelCase     ,lm_score_boundary=_lowerCamelCase     ,)
				__lowercase										=							decoded_processor_out.text

				__lowercase										=							list(_lowerCamelCase )
				decoder.reset_params(
				    alpha=_lowerCamelCase     ,beta=_lowerCamelCase     ,unk_score_offset=_lowerCamelCase     ,lm_score_boundary=_lowerCamelCase     ,)

				with get_context('''fork''' ).Pool() as pool:
							__lowercase										=							decoder.decode_beams_batch(
							    _lowerCamelCase     ,_lowerCamelCase     ,)

				__lowercase										=							[d[0][0] for d in decoded_decoder_out]

				self.assertListEqual(_lowerCamelCase     ,_lowerCamelCase )
				self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>''']     ,_lowerCamelCase )
				__lowercase										=							processor.decoder.model_container[processor.decoder._model_key]
				self.assertEqual(lm_model.alpha     ,2.0 )
				self.assertEqual(lm_model.beta     ,5.0 )
				self.assertEqual(lm_model.unk_score_offset     ,-2_0.0 )
				self.assertEqual(lm_model.score_boundary     ,_lowerCamelCase )


	def 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''simple docstring'''





				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )

				__lowercase										=							processor.decoder.model_container[processor.decoder._model_key]
				__lowercase										=							Path(language_model._kenlm_model.path.decode('''utf-8''' ) ).parent.parent.absolute()

				__lowercase										=							os.listdir(_lowerCamelCase )
				__lowercase										=							['''alphabet.json''', '''language_model''']

				downloaded_decoder_files.sort()
				expected_decoder_files.sort()

				# test that only decoder relevant files from
				# https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
				# are downloaded and none of the rest (e.g. README.md, ...)
				self.assertListEqual(_lowerCamelCase     ,_lowerCamelCase )


	def 						_UpperCAmelCase     (self )							->							List[Any]:







				'''simple docstring'''





				__lowercase										=							snapshot_download('''hf-internal-testing/processor_with_lm''' )

				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained(_lowerCamelCase )

				__lowercase										=							processor.decoder.model_container[processor.decoder._model_key]
				__lowercase										=							Path(language_model._kenlm_model.path.decode('''utf-8''' ) ).parent.parent.absolute()

				__lowercase										=							os.listdir(_lowerCamelCase )
				__lowercase										=							os.listdir(_lowerCamelCase )

				local_decoder_files.sort()
				expected_decoder_files.sort()

				# test that both decoder form hub and local files in cache are the same
				self.assertListEqual(_lowerCamelCase     ,_lowerCamelCase )


	def 						_UpperCAmelCase     (self )							->							Dict:







				'''simple docstring'''





				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )
				__lowercase										=							AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm''' )

				__lowercase										=							floats_list((3, 1000) )

				__lowercase										=							processor_wavaveca(_lowerCamelCase     ,return_tensors='''np''' )
				__lowercase										=							processor_auto(_lowerCamelCase     ,return_tensors='''np''' )

				for key in input_wavaveca.keys():
							self.assertAlmostEqual(input_wavaveca[key].sum()     ,input_auto[key].sum()     ,delta=1E-2 )

				__lowercase										=							self._get_dummy_logits()

				__lowercase										=							processor_wavaveca.batch_decode(_lowerCamelCase )
				__lowercase										=							processor_auto.batch_decode(_lowerCamelCase )

				self.assertListEqual(decoded_wavaveca.text     ,decoded_auto.text )


	def 						_UpperCAmelCase     (self )							->							Dict:







				'''simple docstring'''





				__lowercase										=							self.get_feature_extractor()
				__lowercase										=							self.get_tokenizer()
				__lowercase										=							self.get_decoder()

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				self.assertListEqual(
				    processor.model_input_names     ,feature_extractor.model_input_names     ,msg='''`processor` and `feature_extractor` model input names do not match'''     ,)


	@staticmethod
	def 						_UpperCAmelCase     (_lowerCamelCase     ,_lowerCamelCase )							->							Optional[Any]:







				'''simple docstring'''





				__lowercase										=							[d[key] for d in offsets]
				return retrieved_list


	def 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''simple docstring'''





				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )
				__lowercase										=							self._get_dummy_logits()[0]

				__lowercase										=							processor.decode(_lowerCamelCase     ,output_word_offsets=_lowerCamelCase )
				# check Wav2Vec2CTCTokenizerOutput keys for word
				self.assertEqual(len(outputs.keys() )     ,4 )
				self.assertTrue('''text''' in outputs )
				self.assertTrue('''word_offsets''' in outputs )
				self.assertTrue(isinstance(_lowerCamelCase     ,_lowerCamelCase ) )

				self.assertEqual(''' '''.join(self.get_from_offsets(outputs['''word_offsets''']     ,'''word''' ) )     ,outputs.text )
				self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']     ,'''word''' )     ,['''<s>''', '''<s>''', '''</s>'''] )
				self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']     ,'''start_offset''' )     ,[0, 2, 4] )
				self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']     ,'''end_offset''' )     ,[1, 3, 5] )


	def 						_UpperCAmelCase     (self )							->							Optional[Any]:







				'''simple docstring'''





				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm''' )
				__lowercase										=							self._get_dummy_logits()

				__lowercase										=							processor.batch_decode(_lowerCamelCase     ,output_word_offsets=_lowerCamelCase )

				# check Wav2Vec2CTCTokenizerOutput keys for word
				self.assertEqual(len(outputs.keys() )     ,4 )
				self.assertTrue('''text''' in outputs )
				self.assertTrue('''word_offsets''' in outputs )
				self.assertTrue(isinstance(_lowerCamelCase     ,_lowerCamelCase ) )

				self.assertListEqual(
				    [''' '''.join(self.get_from_offsets(_lowerCamelCase     ,'''word''' ) ) for o in outputs['''word_offsets''']]     ,outputs.text )
				self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]     ,'''word''' )     ,['''<s>''', '''<s>''', '''</s>'''] )
				self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]     ,'''start_offset''' )     ,[0, 2, 4] )
				self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]     ,'''end_offset''' )     ,[1, 3, 5] )


	@slow
	@require_torch
	@require_torchaudio
	def 						_UpperCAmelCase     (self )							->							List[Any]:







				'''simple docstring'''





				import torch

				__lowercase										=							load_dataset('''common_voice'''     ,'''en'''     ,split='''train'''     ,streaming=_lowerCamelCase )
				__lowercase										=							ds.cast_column('''audio'''     ,datasets.Audio(sampling_rate=16000 ) )
				__lowercase										=							iter(_lowerCamelCase )
				__lowercase										=							next(_lowerCamelCase )

				__lowercase										=							AutoProcessor.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm''' )
				__lowercase										=							WavaVecaForCTC.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm''' )

				# compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
				__lowercase										=							processor(sample['''audio''']['''array''']     ,return_tensors='''pt''' ).input_values

				with torch.no_grad():
							__lowercase										=							model(_lowerCamelCase ).logits.cpu().numpy()

				__lowercase										=							processor.decode(logits[0]     ,output_word_offsets=_lowerCamelCase )

				__lowercase										=							model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
				__lowercase										=							[
				    {
				        '''start_time''': d['''start_offset'''] * time_offset,
				        '''end_time''': d['''end_offset'''] * time_offset,
				        '''word''': d['''word'''],
				    }
				    for d in output['''word_offsets''']
				]

				__lowercase										=							'''WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL'''

				# output words
				self.assertEqual(''' '''.join(self.get_from_offsets(_lowerCamelCase     ,'''word''' ) )     ,_lowerCamelCase )
				self.assertEqual(''' '''.join(self.get_from_offsets(_lowerCamelCase     ,'''word''' ) )     ,output.text )

				# output times
				__lowercase										=							torch.tensor(self.get_from_offsets(_lowerCamelCase     ,'''start_time''' ) )
				__lowercase										=							torch.tensor(self.get_from_offsets(_lowerCamelCase     ,'''end_time''' ) )

				# fmt: off
				__lowercase										=							torch.tensor([1.4_1_9_9, 1.6_5_9_9, 2.2_5_9_9, 3.0, 3.2_4, 3.5_9_9_9, 3.7_9_9_9, 4.0_9_9_9, 4.2_6, 4.9_4, 5.2_8, 5.6_5_9_9, 5.7_8, 5.9_4, 6.3_2, 6.5_3_9_9, 6.6_5_9_9] )
				__lowercase										=							torch.tensor([1.5_3_9_9, 1.8_9_9_9, 2.9, 3.1_6, 3.5_3_9_9, 3.7_2, 4.0_1_9_9, 4.1_7_9_9, 4.7_6, 5.1_5_9_9, 5.5_5_9_9, 5.6_9_9_9, 5.8_6, 6.1_9_9_9, 6.3_8, 6.6_1_9_9, 6.9_4] )
				# fmt: on

				self.assertTrue(torch.allclose(_lowerCamelCase     ,_lowerCamelCase     ,atol=0.0_1 ) )
				self.assertTrue(torch.allclose(_lowerCamelCase     ,_lowerCamelCase     ,atol=0.0_1 ) )





