code
stringlengths
86
54.5k
code_codestyle
int64
0
371
style_context
stringlengths
87
49.2k
style_context_codestyle
int64
0
349
label
int64
0
1
import qiskit def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int = 2 ): '''simple docstring''' __snake_case : Tuple = qubits # Using Aer's simulator __snake_case : Dict = qiskit.Aer.get_backend("""aer_simulator""" ) # Creating a Quantum Circuit acting on the q register __snake_case : List[Any] = qiskit.QuantumCircuit(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # Adding a H gate on qubit 0 (now q0 in superposition) circuit.h(0 ) for i in range(1 , __SCREAMING_SNAKE_CASE ): # Adding CX (CNOT) gate circuit.cx(i - 1 , __SCREAMING_SNAKE_CASE ) # Mapping the quantum measurement to the classical bits circuit.measure(list(range(__SCREAMING_SNAKE_CASE ) ) , list(range(__SCREAMING_SNAKE_CASE ) ) ) # Now measuring any one qubit would affect other qubits to collapse # their super position and have same state as the measured one. # Executing the circuit on the simulator __snake_case : Optional[int] = qiskit.execute(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , shots=1_0_0_0 ) return job.result().get_counts(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": print(F'''Total count for various states are: {quantum_entanglement(3)}''')
20
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 SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Any ): __snake_case : Dict = """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split() __snake_case : str = dict(zip(_lowerCAmelCase , range(len(_lowerCAmelCase ) ) ) ) __snake_case : List[str] = { """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>""", } __snake_case : str = { """feature_size""": 1, """padding_value""": 0.0, """sampling_rate""": 1_60_00, """return_attention_mask""": False, """do_normalize""": True, } __snake_case : Optional[Any] = tempfile.mkdtemp() __snake_case : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Any = 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 __snake_case : Optional[int] = """hf-internal-testing/ngram-beam-search-decoder""" def snake_case__ ( self : Optional[Any] , **_lowerCAmelCase : Tuple ): __snake_case : int = self.add_kwargs_tokens_map.copy() kwargs.update(_lowerCAmelCase ) return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , **_lowerCAmelCase : Optional[int] ): return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : Tuple ): return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name , **_lowerCAmelCase ) def snake_case__ ( self : List[str] ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Tuple = self.get_feature_extractor() __snake_case : Dict = self.get_decoder() __snake_case : List[str] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) __snake_case : Dict = 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 snake_case__ ( self : Tuple ): __snake_case : Tuple = 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 __snake_case : Optional[Any] = 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 snake_case__ ( self : int ): __snake_case : Tuple = 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 snake_case__ ( self : Dict ): __snake_case : int = self.get_feature_extractor() __snake_case : str = self.get_tokenizer() __snake_case : Dict = self.get_decoder() __snake_case : Any = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : List[Any] = floats_list((3, 10_00) ) __snake_case : Optional[Any] = feature_extractor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Tuple = 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 snake_case__ ( self : Optional[int] ): __snake_case : Any = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = """This is a test string""" __snake_case : Union[str, Any] = processor(text=_lowerCAmelCase ) __snake_case : Dict = tokenizer(_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : List[str] , _lowerCAmelCase : List[Any]=(2, 10, 16) , _lowerCAmelCase : str=77 ): np.random.seed(_lowerCAmelCase ) return np.random.rand(*_lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : List[str] = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : List[str] = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = self._get_dummy_logits(shape=(10, 16) , seed=13 ) __snake_case : int = processor.decode(_lowerCAmelCase ) __snake_case : Optional[int] = 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 snake_case__ ( self : List[str] , _lowerCAmelCase : List[str] ): __snake_case : int = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = 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: __snake_case : Tuple = processor.batch_decode(_lowerCAmelCase ) else: with get_context(_lowerCAmelCase ).Pool() as pool: __snake_case : int = processor.batch_decode(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as p: __snake_case : Tuple = decoder.decode_beams_batch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case , __snake_case , __snake_case : List[Any] = [], [], [] 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 snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = self.get_feature_extractor() __snake_case : int = self.get_tokenizer() __snake_case : str = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = self._get_dummy_logits() __snake_case : List[str] = 15 __snake_case : Optional[Any] = -20.0 __snake_case : Tuple = -4.0 __snake_case : List[Any] = processor.batch_decode( _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : List[str] = decoded_processor_out.text __snake_case : str = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as pool: __snake_case : Dict = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : int = [d[0][0] for d in decoded_decoder_out] __snake_case : List[Any] = [d[0][2] for d in decoded_decoder_out] __snake_case : List[Any] = [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([-20.054, -18.447] , _lowerCAmelCase , atol=1e-3 ) ) self.assertTrue(np.array_equal(_lowerCAmelCase , decoded_processor_out.lm_score ) ) self.assertTrue(np.allclose([-15.554, -13.9474] , _lowerCAmelCase , atol=1e-3 ) ) def snake_case__ ( self : Any ): __snake_case : List[Any] = self.get_feature_extractor() __snake_case : Any = self.get_tokenizer() __snake_case : Union[str, Any] = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Any = self._get_dummy_logits() __snake_case : Any = 2.0 __snake_case : int = 5.0 __snake_case : Optional[int] = -20.0 __snake_case : Optional[int] = True __snake_case : Any = processor.batch_decode( _lowerCAmelCase , alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) __snake_case : str = decoded_processor_out.text __snake_case : int = list(_lowerCAmelCase ) decoder.reset_params( alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) with get_context("""fork""" ).Pool() as pool: __snake_case : Tuple = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , ) __snake_case : int = [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 ) __snake_case : List[str] = 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 , -20.0 ) self.assertEqual(lm_model.score_boundary , _lowerCAmelCase ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Union[str, Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : Union[str, Any] = os.listdir(_lowerCAmelCase ) __snake_case : List[str] = ["""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 snake_case__ ( self : Optional[Any] ): __snake_case : Union[str, Any] = snapshot_download("""hf-internal-testing/processor_with_lm""" ) __snake_case : Dict = WavaVecaProcessorWithLM.from_pretrained(_lowerCAmelCase ) __snake_case : Optional[Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : List[str] = os.listdir(_lowerCAmelCase ) __snake_case : List[Any] = 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 snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : str = AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = floats_list((3, 10_00) ) __snake_case : Union[str, Any] = processor_wavaveca(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Union[str, Any] = 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 ) __snake_case : Dict = self._get_dummy_logits() __snake_case : List[Any] = processor_wavaveca.batch_decode(_lowerCAmelCase ) __snake_case : List[Any] = processor_auto.batch_decode(_lowerCAmelCase ) self.assertListEqual(decoded_wavaveca.text , decoded_auto.text ) def snake_case__ ( self : str ): __snake_case : int = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : Optional[Any] = self.get_decoder() __snake_case : Union[str, Any] = 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 snake_case__ ( _lowerCAmelCase : Any , _lowerCAmelCase : Tuple ): __snake_case : Union[str, Any] = [d[key] for d in offsets] return retrieved_list def snake_case__ ( self : Dict ): __snake_case : int = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : List[str] = self._get_dummy_logits()[0] __snake_case : str = 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 snake_case__ ( self : List[str] ): __snake_case : Any = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = self._get_dummy_logits() __snake_case : int = 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 snake_case__ ( self : Optional[Any] ): import torch __snake_case : Optional[Any] = load_dataset("""common_voice""" , """en""" , split="""train""" , streaming=_lowerCAmelCase ) __snake_case : Any = ds.cast_column("""audio""" , datasets.Audio(sampling_rate=1_60_00 ) ) __snake_case : List[Any] = iter(_lowerCAmelCase ) __snake_case : Optional[int] = next(_lowerCAmelCase ) __snake_case : str = AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) __snake_case : str = 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 __snake_case : List[str] = processor(sample["""audio"""]["""array"""] , return_tensors="""pt""" ).input_values with torch.no_grad(): __snake_case : Dict = model(_lowerCAmelCase ).logits.cpu().numpy() __snake_case : Any = processor.decode(logits[0] , output_word_offsets=_lowerCAmelCase ) __snake_case : Optional[Any] = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate __snake_case : Dict = [ { """start_time""": d["""start_offset"""] * time_offset, """end_time""": d["""end_offset"""] * time_offset, """word""": d["""word"""], } for d in output["""word_offsets"""] ] __snake_case : Dict = """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 __snake_case : Dict = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """start_time""" ) ) __snake_case : Optional[Any] = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """end_time""" ) ) # fmt: off __snake_case : Optional[Any] = torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599] ) __snake_case : Optional[int] = torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94] ) # fmt: on self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) ) self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) )
20
1
import functools def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : list[int] ): '''simple docstring''' # Validation if not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) or not all(isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) for day in days ): raise ValueError("""The parameter days should be a list of integers""" ) if len(__SCREAMING_SNAKE_CASE ) != 3 or not all(isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) for cost in costs ): raise ValueError("""The parameter costs should be a list of three integers""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: return 0 if min(__SCREAMING_SNAKE_CASE ) <= 0: raise ValueError("""All days elements should be greater than 0""" ) if max(__SCREAMING_SNAKE_CASE ) >= 3_6_6: raise ValueError("""All days elements should be less than 366""" ) __snake_case : Dict = set(__SCREAMING_SNAKE_CASE ) @functools.cache def dynamic_programming(__SCREAMING_SNAKE_CASE : int ) -> int: if index > 3_6_5: return 0 if index not in days_set: return dynamic_programming(index + 1 ) return min( costs[0] + dynamic_programming(index + 1 ) , costs[1] + dynamic_programming(index + 7 ) , costs[2] + dynamic_programming(index + 3_0 ) , ) return dynamic_programming(1 ) if __name__ == "__main__": import doctest doctest.testmod()
20
import argparse import re import torch from CLAP import create_model from transformers import AutoFeatureExtractor, ClapConfig, ClapModel lowercase_ = { "text_branch": "text_model", "audio_branch": "audio_model.audio_encoder", "attn": "attention.self", "self.proj": "output.dense", "attention.self_mask": "attn_mask", "mlp.fc1": "intermediate.dense", "mlp.fc2": "output.dense", "norm1": "layernorm_before", "norm2": "layernorm_after", "bn0": "batch_norm", } lowercase_ = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc") def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any]=False ): '''simple docstring''' __snake_case , __snake_case : str = create_model( """HTSAT-tiny""" , """roberta""" , __SCREAMING_SNAKE_CASE , precision="""fp32""" , device="""cuda:0""" if torch.cuda.is_available() else """cpu""" , enable_fusion=__SCREAMING_SNAKE_CASE , fusion_type="""aff_2d""" if enable_fusion else None , ) return model, model_cfg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Union[str, Any] = {} __snake_case : List[Any] = R""".*sequential.(\d+).*""" __snake_case : Union[str, Any] = R""".*_projection.(\d+).*""" for key, value in state_dict.items(): # check if any key needs to be modified for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items(): if key_to_modify in key: __snake_case : Optional[Any] = key.replace(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): # replace sequential layers with list __snake_case : Optional[Any] = re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) __snake_case : Dict = key.replace(F'''sequential.{sequential_layer}.''' , F'''layers.{int(__SCREAMING_SNAKE_CASE )//3}.linear.''' ) elif re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : str = int(re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) ) # Because in CLAP they use `nn.Sequential`... __snake_case : List[Any] = 1 if projecton_layer == 0 else 2 __snake_case : Tuple = key.replace(F'''_projection.{projecton_layer}.''' , F'''_projection.linear{transformers_projection_layer}.''' ) if "audio" and "qkv" in key: # split qkv into query key and value __snake_case : Optional[int] = value __snake_case : Any = mixed_qkv.size(0 ) // 3 __snake_case : List[Any] = mixed_qkv[:qkv_dim] __snake_case : Tuple = mixed_qkv[qkv_dim : qkv_dim * 2] __snake_case : List[Any] = mixed_qkv[qkv_dim * 2 :] __snake_case : Any = query_layer __snake_case : Dict = key_layer __snake_case : Optional[Any] = value_layer else: __snake_case : List[str] = value return model_state_dict def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Optional[Any]=False ): '''simple docstring''' __snake_case , __snake_case : List[str] = init_clap(__SCREAMING_SNAKE_CASE , enable_fusion=__SCREAMING_SNAKE_CASE ) clap_model.eval() __snake_case : Tuple = clap_model.state_dict() __snake_case : Union[str, Any] = rename_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = ClapConfig() __snake_case : Tuple = enable_fusion __snake_case : Any = ClapModel(__SCREAMING_SNAKE_CASE ) # ignore the spectrogram embedding layer model.load_state_dict(__SCREAMING_SNAKE_CASE , strict=__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) transformers_config.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not") lowercase_ = parser.parse_args() convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list] ): '''simple docstring''' __snake_case : Dict = current_set.copy() for row_index, row in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : List[Any] = row[0] for column_index, column in enumerate(__SCREAMING_SNAKE_CASE ): if magnitude == 0: __snake_case : Dict = column continue __snake_case : Union[str, Any] = column / magnitude # Subtract to cancel term __snake_case : str = current_set[0] __snake_case : List[Any] = [first_row] __snake_case : int = current_set[1::] for row in current_set: __snake_case : Optional[Any] = [] # If first term is 0, it is already in form we want, so we preserve it if row[0] == 0: final_set.append(__SCREAMING_SNAKE_CASE ) continue for column_index in range(len(__SCREAMING_SNAKE_CASE ) ): temp_row.append(first_row[column_index] - row[column_index] ) final_set.append(__SCREAMING_SNAKE_CASE ) # Create next recursion iteration set if len(final_set[0] ) != 3: __snake_case : Any = final_set[0] __snake_case : List[Any] = [] __snake_case : int = [] for row in final_set[1::]: current_first_column.append(row[0] ) next_iteration.append(row[1::] ) __snake_case : str = simplify(__SCREAMING_SNAKE_CASE ) for i in range(len(__SCREAMING_SNAKE_CASE ) ): resultant[i].insert(0 , current_first_column[i] ) resultant.insert(0 , __SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = resultant return final_set def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list] ): '''simple docstring''' if len(__SCREAMING_SNAKE_CASE ) == 0: raise IndexError("""solve_simultaneous() requires n lists of length n+1""" ) __snake_case : int = len(__SCREAMING_SNAKE_CASE ) + 1 if any(len(__SCREAMING_SNAKE_CASE ) != _length for item in equations ): raise IndexError("""solve_simultaneous() requires n lists of length n+1""" ) for row in equations: if any(not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) for column in row ): raise ValueError("""solve_simultaneous() requires lists of integers""" ) if len(__SCREAMING_SNAKE_CASE ) == 1: return [equations[0][-1] / equations[0][0]] __snake_case : Optional[Any] = equations.copy() if any(0 in row for row in data_set ): __snake_case : Optional[Any] = data_set.copy() __snake_case : int = [] for row_index, row in enumerate(__SCREAMING_SNAKE_CASE ): if 0 not in row: __snake_case : Optional[Any] = data_set.pop(__SCREAMING_SNAKE_CASE ) break if not full_row: raise ValueError("""solve_simultaneous() requires at least 1 full equation""" ) data_set.insert(0 , __SCREAMING_SNAKE_CASE ) __snake_case : List[str] = data_set.copy() __snake_case : str = simplify(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = simplified[::-1] __snake_case : list = [] for row in simplified: __snake_case : Tuple = row[-1] if not solutions: if row[-2] == 0: solutions.append(0 ) continue solutions.append(current_solution / row[-2] ) continue __snake_case : Tuple = row.copy()[: len(__SCREAMING_SNAKE_CASE ) - 1 :] while temp_row[0] == 0: temp_row.pop(0 ) if len(__SCREAMING_SNAKE_CASE ) == 0: solutions.append(0 ) continue __snake_case : Optional[Any] = temp_row[1::] __snake_case : Any = temp_row[::-1] for column_index, column in enumerate(__SCREAMING_SNAKE_CASE ): current_solution -= column * solutions[column_index] solutions.append(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = [] for item in solutions: final.append(float(round(__SCREAMING_SNAKE_CASE , 5 ) ) ) return final[::-1] if __name__ == "__main__": import doctest doctest.testmod() lowercase_ = [ [2, 1, 1, 1, 1, 4], [1, 2, 1, 1, 1, 5], [1, 1, 2, 1, 1, 6], [1, 1, 1, 2, 1, 7], [1, 1, 1, 1, 2, 8], ] print(solve_simultaneous(eq)) print(solve_simultaneous([[4, 2]]))
20
import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = "▁" lowercase_ = {"vocab_file": "vocab.txt", "sentencepiece_model_ckpt": "sentencepiece.bpe.model"} lowercase_ = { "sentencepiece_model_file": "sentencepiece.bpe.model", "vocab_file": "vocab.txt", } lowercase_ = { "vocab_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", }, "sentencepiece_model_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", }, } lowercase_ = { "ernie-m-base": 5_14, "ernie-m-large": 5_14, } lowercase_ = { "ernie-m-base": {"do_lower_case": False}, "ernie-m-large": {"do_lower_case": False}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = ["input_ids"] A : Tuple = VOCAB_FILES_NAMES A : List[Any] = PRETRAINED_INIT_CONFIGURATION A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP A : Optional[Any] = RESOURCE_FILES_NAMES def __init__( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : Dict=False , _lowerCAmelCase : List[Any]="utf8" , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : Optional[int]="[SEP]" , _lowerCAmelCase : List[str]="[PAD]" , _lowerCAmelCase : Dict="[CLS]" , _lowerCAmelCase : List[Any]="[MASK]" , _lowerCAmelCase : Optional[Dict[str, Any]] = None , **_lowerCAmelCase : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. __snake_case : List[Any] = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , vocab_file=_lowerCAmelCase , encoding=_lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCAmelCase , ) __snake_case : List[Any] = do_lower_case __snake_case : Any = sentencepiece_model_ckpt __snake_case : int = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCAmelCase ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: __snake_case : int = self.load_vocab(filepath=_lowerCAmelCase ) else: __snake_case : Tuple = {self.sp_model.id_to_piece(_lowerCAmelCase ): id for id in range(self.sp_model.get_piece_size() )} __snake_case : str = {v: k for k, v in self.vocab.items()} def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[Any] ): if text is None: return None __snake_case : List[Any] = self.tokenize(_lowerCAmelCase ) __snake_case , __snake_case : Optional[Any] = """""", [] for i, ch in enumerate(_lowerCAmelCase ): if ch in self.SP_CHAR_MAPPING: __snake_case : Any = self.SP_CHAR_MAPPING.get(_lowerCAmelCase ) else: __snake_case : Dict = unicodedata.normalize("""NFKC""" , _lowerCAmelCase ) if self.is_whitespace(_lowerCAmelCase ): continue normalized_text += ch char_mapping.extend([i] * len(_lowerCAmelCase ) ) __snake_case , __snake_case , __snake_case : str = normalized_text, [], 0 if self.do_lower_case: __snake_case : int = text.lower() for token in split_tokens: if token[:1] == "▁": __snake_case : int = token[1:] __snake_case : Optional[int] = text[offset:].index(_lowerCAmelCase ) + offset __snake_case : int = start + len(_lowerCAmelCase ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) __snake_case : str = end return token_mapping @property def snake_case__ ( self : Tuple ): return len(self.vocab ) def snake_case__ ( self : Dict ): return dict(self.vocab , **self.added_tokens_encoder ) def __getstate__( self : int ): __snake_case : str = self.__dict__.copy() __snake_case : Union[str, Any] = None return state def __setstate__( self : Optional[Any] , _lowerCAmelCase : List[str] ): __snake_case : Union[str, Any] = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): __snake_case : Optional[Any] = {} __snake_case : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def snake_case__ ( self : str , _lowerCAmelCase : Optional[int] ): return "".join((self.SP_CHAR_MAPPING.get(_lowerCAmelCase , _lowerCAmelCase ) for c in text) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Optional[Any]=64 , _lowerCAmelCase : Optional[int]=0.1 ): if self.sp_model_kwargs.get("""enable_sampling""" ) is True: __snake_case : List[str] = True if self.sp_model_kwargs.get("""alpha""" ) is not None: __snake_case : Dict = self.sp_model_kwargs.get("""alpha""" ) if self.sp_model_kwargs.get("""nbest_size""" ) is not None: __snake_case : List[Any] = self.sp_model_kwargs.get("""nbest_size""" ) if not enable_sampling: __snake_case : str = self.sp_model.EncodeAsPieces(_lowerCAmelCase ) else: __snake_case : Tuple = self.sp_model.SampleEncodeAsPieces(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = [] for pi, piece in enumerate(_lowerCAmelCase ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(_lowerCAmelCase ) and pi != 0: new_pieces.append(_lowerCAmelCase ) continue else: continue __snake_case : Optional[int] = 0 for i, chunk in enumerate(_lowerCAmelCase ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(_lowerCAmelCase ) or self.is_punct(_lowerCAmelCase ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(_lowerCAmelCase ) __snake_case : Tuple = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : List[str] = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : Tuple = i if len(_lowerCAmelCase ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): __snake_case : int = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): __snake_case : int = self.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : Any = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): return self.vocab.get(_lowerCAmelCase , self.vocab.get(self.unk_token ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Dict ): return self.reverse_vocab.get(_lowerCAmelCase , self.unk_token ) def snake_case__ ( self : Any , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any]=None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] __snake_case : Optional[Any] = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None ): if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Optional[Any]=False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( """You should not supply a second sequence if the provided sequence of """ """ids is already formatted with special tokens for the model.""" ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] + ([0] * len(_lowerCAmelCase )) + [1] return [1] + ([0] * len(_lowerCAmelCase )) + [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method if token_ids_a is None: # [CLS] X [SEP] return (len(_lowerCAmelCase ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(_lowerCAmelCase ) + 1) + [1] * (len(_lowerCAmelCase ) + 3) def snake_case__ ( self : Tuple , _lowerCAmelCase : List[str] ): if "\u4e00" <= char <= "\u9fff": return True return False def snake_case__ ( self : List[str] , _lowerCAmelCase : Any ): if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def snake_case__ ( self : int , _lowerCAmelCase : List[Any] ): if char in ",;:.?!~,;:。?!《》【】": return True return False def snake_case__ ( self : str , _lowerCAmelCase : Optional[Any] ): if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(_lowerCAmelCase ) == 1: __snake_case : Dict = unicodedata.category(_lowerCAmelCase ) if cat == "Zs": return True return False def snake_case__ ( self : str , _lowerCAmelCase : List[Any] ): __snake_case : Dict = {} with io.open(_lowerCAmelCase , """r""" , encoding="""utf-8""" ) as f: for index, line in enumerate(_lowerCAmelCase ): __snake_case : Tuple = line.rstrip("""\n""" ) __snake_case : List[str] = int(_lowerCAmelCase ) return token_to_idx def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : Optional[int] = 0 if os.path.isdir(_lowerCAmelCase ): __snake_case : int = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) else: __snake_case : Optional[Any] = (filename_prefix + """-""" if filename_prefix else """""") + save_directory with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as writer: for token, token_index in sorted(self.vocab.items() , key=lambda _lowerCAmelCase : kv[1] ): if index != token_index: logger.warning( f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.''' """ Please check that the vocabulary is not corrupted!""" ) __snake_case : Union[str, Any] = token_index writer.write(token + """\n""" ) index += 1 __snake_case : List[Any] = os.path.join(_lowerCAmelCase , """sentencepiece.bpe.model""" ) with open(_lowerCAmelCase , """wb""" ) as fi: __snake_case : List[Any] = self.sp_model.serialized_model_proto() fi.write(_lowerCAmelCase ) return (vocab_file,)
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' if index == r: for j in range(__SCREAMING_SNAKE_CASE ): print(data[j] , end=""" """ ) print(""" """ ) return # When no more elements are there to put in data[] if i >= n: return # current is included, put next at next location __snake_case : List[Any] = arr[i] combination_util(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , index + 1 , __SCREAMING_SNAKE_CASE , i + 1 ) # current is excluded, replace it with # next (Note that i+1 is passed, but # index is not changed) combination_util(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , i + 1 ) # The main function that prints all combinations # of size r in arr[] of size n. This function # mainly uses combinationUtil() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' # A temporary array to store all combination one by one __snake_case : str = [0] * r # Print all combination using temporary array 'data[]' combination_util(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , 0 , __SCREAMING_SNAKE_CASE , 0 ) if __name__ == "__main__": # Driver code to check the function above lowercase_ = [10, 20, 30, 40, 50] print_combination(arr, len(arr), 3) # This code is contributed by Ambuj sahu
20
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "xlm-mlm-en-2048": "https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json", "xlm-mlm-ende-1024": "https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json", "xlm-mlm-enfr-1024": "https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json", "xlm-mlm-enro-1024": "https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json", "xlm-mlm-tlm-xnli15-1024": "https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json", "xlm-mlm-xnli15-1024": "https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json", "xlm-clm-enfr-1024": "https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json", "xlm-clm-ende-1024": "https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json", "xlm-mlm-17-1280": "https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json", "xlm-mlm-100-1280": "https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = "xlm" A : List[str] = { "hidden_size": "emb_dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", "n_words": "vocab_size", # For backward compatibility } def __init__( self : List[Any] , _lowerCAmelCase : Optional[Any]=3_01_45 , _lowerCAmelCase : Optional[Any]=20_48 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : int=16 , _lowerCAmelCase : Tuple=0.1 , _lowerCAmelCase : List[Any]=0.1 , _lowerCAmelCase : str=True , _lowerCAmelCase : List[str]=False , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Dict=False , _lowerCAmelCase : Dict=1 , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Optional[Any]=5_12 , _lowerCAmelCase : List[Any]=20_48**-0.5 , _lowerCAmelCase : List[str]=1e-12 , _lowerCAmelCase : List[Any]=0.02 , _lowerCAmelCase : List[str]=0 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Dict=2 , _lowerCAmelCase : List[str]=3 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : Optional[int]=True , _lowerCAmelCase : Tuple="first" , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any=0.1 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : List[str]=5 , _lowerCAmelCase : Optional[Any]=0 , _lowerCAmelCase : Tuple=0 , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Union[str, Any]=0 , **_lowerCAmelCase : Tuple , ): __snake_case : Optional[Any] = vocab_size __snake_case : Tuple = emb_dim __snake_case : int = n_layers __snake_case : List[str] = n_heads __snake_case : Union[str, Any] = dropout __snake_case : Optional[int] = attention_dropout __snake_case : Optional[Any] = gelu_activation __snake_case : Tuple = sinusoidal_embeddings __snake_case : List[Any] = causal __snake_case : Dict = asm __snake_case : int = n_langs __snake_case : str = use_lang_emb __snake_case : Dict = layer_norm_eps __snake_case : List[Any] = bos_index __snake_case : Union[str, Any] = eos_index __snake_case : Dict = pad_index __snake_case : Any = unk_index __snake_case : Dict = mask_index __snake_case : Any = is_encoder __snake_case : Dict = max_position_embeddings __snake_case : Optional[Any] = embed_init_std __snake_case : List[Any] = init_std __snake_case : str = summary_type __snake_case : Optional[Any] = summary_use_proj __snake_case : str = summary_activation __snake_case : Optional[int] = summary_proj_to_labels __snake_case : Dict = summary_first_dropout __snake_case : Dict = start_n_top __snake_case : int = end_n_top __snake_case : str = mask_token_id __snake_case : int = lang_id if "n_words" in kwargs: __snake_case : Dict = kwargs["""n_words"""] super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Dict ): if self.task == "multiple-choice": __snake_case : Optional[int] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : Tuple = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis), ] )
20
1
from __future__ import annotations import math from collections.abc import Callable def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Callable[[int | float], int | float] , __SCREAMING_SNAKE_CASE : int | float , __SCREAMING_SNAKE_CASE : int | float , __SCREAMING_SNAKE_CASE : int = 1_0_0 , ): '''simple docstring''' __snake_case : List[str] = x_start __snake_case : Tuple = fnc(__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = 0.0 for _ in range(__SCREAMING_SNAKE_CASE ): # Approximates curve as a sequence of linear lines and sums their length __snake_case : List[Any] = (x_end - x_start) / steps + xa __snake_case : Union[str, Any] = fnc(__SCREAMING_SNAKE_CASE ) length += math.hypot(xa - xa , fxa - fxa ) # Increment step __snake_case : Union[str, Any] = xa __snake_case : Union[str, Any] = fxa return length if __name__ == "__main__": def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] ): '''simple docstring''' return math.sin(1_0 * x ) print("f(x) = sin(10 * x)") print("The length of the curve from x = -10 to x = 10 is:") lowercase_ = 10 while i <= 10_00_00: print(F'''With {i} steps: {line_length(f, -10, 10, i)}''') i *= 10
20
import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "facebook/encodec_24khz": "https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json", "facebook/encodec_48khz": "https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[Any] = "encodec" def __init__( self : Tuple , _lowerCAmelCase : Union[str, Any]=[1.5, 3.0, 6.0, 12.0, 24.0] , _lowerCAmelCase : Tuple=2_40_00 , _lowerCAmelCase : List[Any]=1 , _lowerCAmelCase : Optional[int]=False , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : int=1_28 , _lowerCAmelCase : List[Any]=32 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Union[str, Any]=[8, 5, 4, 2] , _lowerCAmelCase : str="weight_norm" , _lowerCAmelCase : Tuple=7 , _lowerCAmelCase : str=7 , _lowerCAmelCase : Any=3 , _lowerCAmelCase : int=2 , _lowerCAmelCase : str=True , _lowerCAmelCase : Dict="reflect" , _lowerCAmelCase : Tuple=2 , _lowerCAmelCase : List[Any]=2 , _lowerCAmelCase : int=1.0 , _lowerCAmelCase : Optional[int]=10_24 , _lowerCAmelCase : int=None , _lowerCAmelCase : List[str]=True , **_lowerCAmelCase : List[Any] , ): __snake_case : Optional[int] = target_bandwidths __snake_case : int = sampling_rate __snake_case : List[Any] = audio_channels __snake_case : str = normalize __snake_case : Union[str, Any] = chunk_length_s __snake_case : Union[str, Any] = overlap __snake_case : Union[str, Any] = hidden_size __snake_case : Union[str, Any] = num_filters __snake_case : Optional[Any] = num_residual_layers __snake_case : List[Any] = upsampling_ratios __snake_case : List[str] = norm_type __snake_case : Union[str, Any] = kernel_size __snake_case : Optional[int] = last_kernel_size __snake_case : Optional[Any] = residual_kernel_size __snake_case : Dict = dilation_growth_rate __snake_case : int = use_causal_conv __snake_case : Tuple = pad_mode __snake_case : str = compress __snake_case : Optional[Any] = num_lstm_layers __snake_case : List[Any] = trim_right_ratio __snake_case : Any = codebook_size __snake_case : int = codebook_dim if codebook_dim is not None else hidden_size __snake_case : int = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( f'''self.norm_type must be one of `"weight_norm"`, `"time_group_norm"`), got {self.norm_type}''' ) super().__init__(**_lowerCAmelCase ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def snake_case__ ( self : Tuple ): return int(10_00 * self.target_bandwidths[-1] // (self.frame_rate * 10) )
20
1
import copy import os import tempfile from unittest import TestCase from unittest.mock import patch import numpy as np import pyarrow as pa import pyarrow.parquet as pq import pytest from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence from datasets.features import ArrayaD, ClassLabel, Features, Image, Value from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects from datasets.keyhash import DuplicatedKeysError, InvalidKeyError from .utils import require_pil class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def snake_case__ ( self : Optional[int] ): __snake_case : Any = pa.array(TypedSequence([1, 2, 3] ) ) self.assertEqual(arr.type , pa.intaa() ) def snake_case__ ( self : str ): with self.assertRaises(_lowerCAmelCase ): __snake_case : Dict = pa.array(TypedSequence([1, 2, 3] ) , type=pa.intaa() ) def snake_case__ ( self : Tuple ): with self.assertRaises(_lowerCAmelCase ): __snake_case : str = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""bool""" ) , type=Value("""int64""" ) ) ) def snake_case__ ( self : int ): __snake_case : Optional[int] = pa.array(TypedSequence([1, 2, 3] , type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def snake_case__ ( self : Optional[int] ): with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): __snake_case : Dict = pa.array(TypedSequence(["""foo""", """bar"""] , type=Value("""int64""" ) ) ) def snake_case__ ( self : Optional[int] ): __snake_case : Any = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=Value("""int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) def snake_case__ ( self : Any ): __snake_case : Optional[Any] = pa.array(TypedSequence([[[1, 2, 3]]] , type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def snake_case__ ( self : List[Any] ): with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): __snake_case : Optional[Any] = pa.array(TypedSequence(["""foo""", """bar"""] , type=ArrayaD((1, 3) , """int64""" ) ) ) def snake_case__ ( self : List[Any] ): __snake_case : str = pa.array(TypedSequence([[[1, 2, 3]]] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def snake_case__ ( self : Tuple ): __snake_case : List[Any] = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) @require_pil def snake_case__ ( self : List[str] ): import PIL.Image __snake_case : Dict = PIL.Image.fromarray(np.arange(10 , dtype=np.uinta ).reshape(2 , 5 ) ) with patch( """datasets.arrow_writer.cast_to_python_objects""" , side_effect=_lowerCAmelCase ) as mock_cast_to_python_objects: __snake_case : int = pa.array(TypedSequence([{"""path""": None, """bytes""": b"""image_bytes"""}, pil_image] , type=Image() ) ) __snake_case , __snake_case : List[str] = mock_cast_to_python_objects.call_args_list[-1] self.assertIn("""optimize_list_casting""" , _lowerCAmelCase ) self.assertFalse(kwargs["""optimize_list_casting"""] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Dict = pa.BufferReader(__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , pa.Buffer ) else pa.memory_map(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = pa.ipc.open_stream(__SCREAMING_SNAKE_CASE ) __snake_case : pa.Table = f.read_all() assert len(pa_table.to_batches() ) == expected_num_chunks assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} del pa_table @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : List[Any] ): '''simple docstring''' __snake_case : Dict = pa.BufferOutputStream() __snake_case : List[str] = pa.schema(__SCREAMING_SNAKE_CASE ) if fields else None with ArrowWriter(stream=__SCREAMING_SNAKE_CASE , schema=__SCREAMING_SNAKE_CASE , writer_batch_size=__SCREAMING_SNAKE_CASE ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) __snake_case , __snake_case : List[str] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: __snake_case : List[str] = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(__SCREAMING_SNAKE_CASE , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Optional[Any] = pa.BufferOutputStream() __snake_case : Any = Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} ) with ArrowWriter(stream=__SCREAMING_SNAKE_CASE , features=__SCREAMING_SNAKE_CASE ) as writer: writer.write({"""labels""": 0} ) writer.write({"""labels""": 1} ) __snake_case , __snake_case : Tuple = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == features.arrow_schema assert writer._schema.metadata == features.arrow_schema.metadata __snake_case : int = pa.BufferReader(output.getvalue() ) __snake_case : List[Any] = pa.ipc.open_stream(__SCREAMING_SNAKE_CASE ) __snake_case : pa.Table = f.read_all() __snake_case : int = pa_table.schema assert pa_table.num_rows == 2 assert schema == features.arrow_schema assert schema.metadata == features.arrow_schema.metadata assert features == Features.from_arrow_schema(__SCREAMING_SNAKE_CASE ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] ): '''simple docstring''' __snake_case : Any = pa.BufferOutputStream() with ArrowWriter( stream=__SCREAMING_SNAKE_CASE , writer_batch_size=__SCREAMING_SNAKE_CASE , hash_salt="""split_name""" , check_duplicates=__SCREAMING_SNAKE_CASE , ) as writer: with pytest.raises(__SCREAMING_SNAKE_CASE ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=[1, 2] ) __snake_case , __snake_case : str = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' __snake_case : str = pa.BufferOutputStream() with ArrowWriter( stream=__SCREAMING_SNAKE_CASE , writer_batch_size=__SCREAMING_SNAKE_CASE , hash_salt="""split_name""" , check_duplicates=__SCREAMING_SNAKE_CASE , ) as writer: with pytest.raises(__SCREAMING_SNAKE_CASE ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1_0 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=1_0 ) __snake_case , __snake_case : str = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case : str = pa.BufferOutputStream() with ArrowWriter( stream=__SCREAMING_SNAKE_CASE , writer_batch_size=__SCREAMING_SNAKE_CASE , hash_salt="""split_name""" , check_duplicates=__SCREAMING_SNAKE_CASE , ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=2 ) __snake_case , __snake_case : Optional[Any] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' __snake_case : Dict = pa.BufferOutputStream() __snake_case : Optional[int] = pa.schema(__SCREAMING_SNAKE_CASE ) if fields else None with ArrowWriter(stream=__SCREAMING_SNAKE_CASE , schema=__SCREAMING_SNAKE_CASE , writer_batch_size=__SCREAMING_SNAKE_CASE ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) writer.write_batch({"""col_1""": [], """col_2""": []} ) __snake_case , __snake_case : int = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: __snake_case : List[Any] = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(__SCREAMING_SNAKE_CASE , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' __snake_case : int = pa.BufferOutputStream() __snake_case : Any = pa.schema(__SCREAMING_SNAKE_CASE ) if fields else None with ArrowWriter(stream=__SCREAMING_SNAKE_CASE , schema=__SCREAMING_SNAKE_CASE , writer_batch_size=__SCREAMING_SNAKE_CASE ) as writer: writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) ) __snake_case , __snake_case : Union[str, Any] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: __snake_case : List[Any] = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(__SCREAMING_SNAKE_CASE , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' __snake_case : str = pa.BufferOutputStream() __snake_case : int = pa.schema(__SCREAMING_SNAKE_CASE ) if fields else None with ArrowWriter(stream=__SCREAMING_SNAKE_CASE , schema=__SCREAMING_SNAKE_CASE , writer_batch_size=__SCREAMING_SNAKE_CASE ) as writer: writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) ) writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) ) __snake_case , __snake_case : int = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: __snake_case : Any = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(__SCREAMING_SNAKE_CASE , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def __lowerCAmelCase ( ): '''simple docstring''' with tempfile.TemporaryDirectory() as tmp_dir: __snake_case : Union[str, Any] = {"""col_1""": pa.string(), """col_2""": pa.intaa()} __snake_case : str = os.path.join(__SCREAMING_SNAKE_CASE , """test.arrow""" ) with ArrowWriter(path=__SCREAMING_SNAKE_CASE , schema=pa.schema(__SCREAMING_SNAKE_CASE ) ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) __snake_case , __snake_case : Any = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == pa.schema(__SCREAMING_SNAKE_CASE , metadata=writer._schema.metadata ) _check_output(__SCREAMING_SNAKE_CASE , 1 ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] ): '''simple docstring''' if pa.types.is_list(__SCREAMING_SNAKE_CASE ): return get_base_dtype(arr_type.value_type ) else: return arr_type def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if isinstance(lst[0] , __SCREAMING_SNAKE_CASE ): change_first_primitive_element_in_list(lst[0] , __SCREAMING_SNAKE_CASE ) else: __snake_case : Tuple = value @pytest.mark.parametrize("""optimized_int_type, expected_dtype""" , [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' __snake_case : Union[str, Any] = pa.array(TypedSequence(__SCREAMING_SNAKE_CASE , optimized_int_type=__SCREAMING_SNAKE_CASE ) ) assert get_base_dtype(arr.type ) == expected_dtype @pytest.mark.parametrize( """col, expected_dtype""" , [ ("""attention_mask""", pa.inta()), ("""special_tokens_mask""", pa.inta()), ("""token_type_ids""", pa.inta()), ("""input_ids""", pa.intaa()), ("""other""", pa.intaa()), ] , ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' # in range __snake_case : Optional[int] = pa.array(OptimizedTypedSequence(__SCREAMING_SNAKE_CASE , col=__SCREAMING_SNAKE_CASE ) ) assert get_base_dtype(arr.type ) == expected_dtype # not in range if col != "other": # avoids errors due to in-place modifications __snake_case : Optional[Any] = copy.deepcopy(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[int] = np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1 change_first_primitive_element_in_list(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Any = pa.array(OptimizedTypedSequence(__SCREAMING_SNAKE_CASE , col=__SCREAMING_SNAKE_CASE ) ) assert get_base_dtype(arr.type ) == pa.intaa() @pytest.mark.parametrize("""raise_exception""" , [False, True] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' __snake_case : int = str(tmp_path / """dataset-train.arrow""" ) try: with ArrowWriter(path=__SCREAMING_SNAKE_CASE ) as writer: if raise_exception: raise pa.lib.ArrowInvalid() else: writer.stream.close() except pa.lib.ArrowInvalid: pass finally: assert writer.stream.closed def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' __snake_case : Any = """mock://dataset-train.arrow""" with ArrowWriter(path=__SCREAMING_SNAKE_CASE , storage_options=mockfs.storage_options ) as writer: assert isinstance(writer._fs , type(__SCREAMING_SNAKE_CASE ) ) assert writer._fs.storage_options == mockfs.storage_options writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) __snake_case , __snake_case : Tuple = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert mockfs.exists(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Tuple = pa.BufferOutputStream() with ParquetWriter(stream=__SCREAMING_SNAKE_CASE ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) __snake_case , __snake_case : Optional[Any] = writer.finalize() assert num_examples == 2 assert num_bytes > 0 __snake_case : str = pa.BufferReader(output.getvalue() ) __snake_case : pa.Table = pq.read_table(__SCREAMING_SNAKE_CASE ) assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} @require_pil @pytest.mark.parametrize("""embed_local_files""" , [False, True] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' import PIL.Image __snake_case : List[Any] = str(tmp_path / """test_image_rgb.jpg""" ) PIL.Image.fromarray(np.zeros((5, 5) , dtype=np.uinta ) ).save(__SCREAMING_SNAKE_CASE , format="""png""" ) __snake_case : List[str] = pa.BufferOutputStream() with ParquetWriter( stream=__SCREAMING_SNAKE_CASE , features=Features({"""image""": Image()} ) , embed_local_files=__SCREAMING_SNAKE_CASE ) as writer: writer.write({"""image""": image_path} ) writer.finalize() __snake_case : List[str] = pa.BufferReader(output.getvalue() ) __snake_case : pa.Table = pq.read_table(__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = pa_table.to_pydict() if embed_local_files: assert isinstance(out["""image"""][0]["""path"""] , __SCREAMING_SNAKE_CASE ) with open(__SCREAMING_SNAKE_CASE , """rb""" ) as f: assert out["image"][0]["bytes"] == f.read() else: assert out["image"][0]["path"] == image_path assert out["image"][0]["bytes"] is None def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Any = pa.schema([pa.field("""col_1""" , pa.string() , nullable=__SCREAMING_SNAKE_CASE )] ) __snake_case : Union[str, Any] = pa.BufferOutputStream() with ArrowWriter(stream=__SCREAMING_SNAKE_CASE ) as writer: writer._build_writer(inferred_schema=__SCREAMING_SNAKE_CASE ) assert writer._schema == pa.schema([pa.field("""col_1""" , pa.string() )] )
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : str = [] __snake_case , __snake_case : List[str] = input_list[low:mid], input_list[mid : high + 1] while left and right: result.append((left if left[0] <= right[0] else right).pop(0 ) ) __snake_case : List[Any] = result + left + right return input_list def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if len(__SCREAMING_SNAKE_CASE ) <= 1: return input_list __snake_case : Union[str, Any] = list(__SCREAMING_SNAKE_CASE ) # iteration for two-way merging __snake_case : Tuple = 2 while p <= len(__SCREAMING_SNAKE_CASE ): # getting low, high and middle value for merge-sort of single list for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = i + p - 1 __snake_case : Optional[Any] = (low + high + 1) // 2 __snake_case : str = merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # final merge of last two parts if p * 2 >= len(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = merge(__SCREAMING_SNAKE_CASE , 0 , __SCREAMING_SNAKE_CASE , len(__SCREAMING_SNAKE_CASE ) - 1 ) break p *= 2 return input_list if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() if user_input == "": lowercase_ = [] else: lowercase_ = [int(item.strip()) for item in user_input.split(",")] print(iter_merge_sort(unsorted))
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) lowercase_ = {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["ViTFeatureExtractor"] lowercase_ = ["ViTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "VIT_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTForImageClassification", "ViTForMaskedImageModeling", "ViTModel", "ViTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFViTForImageClassification", "TFViTModel", "TFViTPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxViTForImageClassification", "FlaxViTModel", "FlaxViTPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
import random import sys import numpy as np from matplotlib import pyplot as plt from matplotlib.colors import ListedColormap lowercase_ = "Usage of script: script_name <size_of_canvas:int>" lowercase_ = [0] * 1_00 + [1] * 10 random.shuffle(choice) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : List[str] = [[False for i in range(__SCREAMING_SNAKE_CASE )] for j in range(__SCREAMING_SNAKE_CASE )] return canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' for i, row in enumerate(__SCREAMING_SNAKE_CASE ): for j, _ in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : int = bool(random.getrandbits(1 ) ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Union[str, Any] = np.array(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = np.array(create_canvas(current_canvas.shape[0] ) ) for r, row in enumerate(__SCREAMING_SNAKE_CASE ): for c, pt in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : Optional[Any] = __judge_point( __SCREAMING_SNAKE_CASE , current_canvas[r - 1 : r + 2, c - 1 : c + 2] ) __snake_case : List[str] = next_gen_canvas del next_gen_canvas # cleaning memory as we move on. __snake_case : list[list[bool]] = current_canvas.tolist() return return_canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Any = 0 __snake_case : Dict = 0 # finding dead or alive neighbours count. for i in neighbours: for status in i: if status: alive += 1 else: dead += 1 # handling duplicate entry for focus pt. if pt: alive -= 1 else: dead -= 1 # running the rules of game here. __snake_case : str = pt if pt: if alive < 2: __snake_case : Optional[Any] = False elif alive == 2 or alive == 3: __snake_case : Union[str, Any] = True elif alive > 3: __snake_case : Optional[int] = False else: if alive == 3: __snake_case : List[Any] = True return state if __name__ == "__main__": if len(sys.argv) != 2: raise Exception(usage_doc) lowercase_ = int(sys.argv[1]) # main working structure of this module. lowercase_ = create_canvas(canvas_size) seed(c) lowercase_ , lowercase_ = plt.subplots() fig.show() lowercase_ = ListedColormap(["w", "k"]) try: while True: lowercase_ = run(c) ax.matshow(c, cmap=cmap) fig.canvas.draw() ax.cla() except KeyboardInterrupt: # do nothing. pass
20
1
import argparse import json import os from tensorflow.core.protobuf.saved_model_pba import SavedModel # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_copies.py lowercase_ = "." # Internal TensorFlow ops that can be safely ignored (mostly specific to a saved model) lowercase_ = [ "Assert", "AssignVariableOp", "EmptyTensorList", "MergeV2Checkpoints", "ReadVariableOp", "ResourceGather", "RestoreV2", "SaveV2", "ShardedFilename", "StatefulPartitionedCall", "StaticRegexFullMatch", "VarHandleOp", ] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Dict = SavedModel() __snake_case : Any = [] with open(os.path.join(__SCREAMING_SNAKE_CASE , """utils""" , """tf_ops""" , """onnx.json""" ) ) as f: __snake_case : Optional[int] = json.load(__SCREAMING_SNAKE_CASE )["""opsets"""] for i in range(1 , opset + 1 ): onnx_ops.extend(onnx_opsets[str(__SCREAMING_SNAKE_CASE )] ) with open(__SCREAMING_SNAKE_CASE , """rb""" ) as f: saved_model.ParseFromString(f.read() ) __snake_case : Tuple = set() # Iterate over every metagraph in case there is more than one (a saved model can contain multiple graphs) for meta_graph in saved_model.meta_graphs: # Add operations in the graph definition model_op_names.update(node.op for node in meta_graph.graph_def.node ) # Go through the functions in the graph definition for func in meta_graph.graph_def.library.function: # Add operations in each function model_op_names.update(node.op for node in func.node_def ) # Convert to list, sorted if you want __snake_case : Tuple = sorted(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = [] for op in model_op_names: if op not in onnx_ops and op not in INTERNAL_OPS: incompatible_ops.append(__SCREAMING_SNAKE_CASE ) if strict and len(__SCREAMING_SNAKE_CASE ) > 0: raise Exception(F'''Found the following incompatible ops for the opset {opset}:\n''' + incompatible_ops ) elif len(__SCREAMING_SNAKE_CASE ) > 0: print(F'''Found the following incompatible ops for the opset {opset}:''' ) print(*__SCREAMING_SNAKE_CASE , sep="""\n""" ) else: print(F'''The saved model {saved_model_path} can properly be converted with ONNX.''' ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--saved_model_path", help="Path of the saved model to check (the .pb file).") parser.add_argument( "--opset", default=12, type=int, help="The ONNX opset against which the model has to be tested." ) parser.add_argument( "--framework", choices=["onnx"], default="onnx", help="Frameworks against which to test the saved model." ) parser.add_argument( "--strict", action="store_true", help="Whether make the checking strict (raise errors) or not (raise warnings)" ) lowercase_ = parser.parse_args() if args.framework == "onnx": onnx_compliancy(args.saved_model_path, args.strict, args.opset)
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def __lowerCAmelCase ( *__SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Optional[Union[Dict, Any]] = None , __SCREAMING_SNAKE_CASE : Any=True , __SCREAMING_SNAKE_CASE : int=2 ): '''simple docstring''' from .. import __version__ __snake_case : List[Any] = take_from __snake_case : List[Any] = () if not isinstance(args[0] , __SCREAMING_SNAKE_CASE ): __snake_case : str = (args,) for attribute, version_name, message in args: if version.parse(version.parse(__SCREAMING_SNAKE_CASE ).base_version ) >= version.parse(__SCREAMING_SNAKE_CASE ): raise ValueError( F'''The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers\'''' F''' version {__version__} is >= {version_name}''' ) __snake_case : Optional[Any] = None if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(__SCREAMING_SNAKE_CASE ),) __snake_case : Optional[Any] = F'''The `{attribute}` argument is deprecated and will be removed in version {version_name}.''' elif hasattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): values += (getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ),) __snake_case : Any = F'''The `{attribute}` attribute is deprecated and will be removed in version {version_name}.''' elif deprecated_kwargs is None: __snake_case : Tuple = F'''`{attribute}` is deprecated and will be removed in version {version_name}.''' if warning is not None: __snake_case : Optional[Any] = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , __SCREAMING_SNAKE_CASE , stacklevel=__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and len(__SCREAMING_SNAKE_CASE ) > 0: __snake_case : Dict = inspect.getouterframes(inspect.currentframe() )[1] __snake_case : int = call_frame.filename __snake_case : int = call_frame.lineno __snake_case : List[str] = call_frame.function __snake_case , __snake_case : List[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(F'''{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`''' ) if len(__SCREAMING_SNAKE_CASE ) == 0: return elif len(__SCREAMING_SNAKE_CASE ) == 1: return values[0] return values
20
1
import inspect import os import torch from transformers import AutoModel from transformers.testing_utils import mockenv_context from transformers.trainer_utils import set_seed import accelerate from accelerate.accelerator import Accelerator from accelerate.state import AcceleratorState from accelerate.test_utils.testing import ( AccelerateTestCase, TempDirTestCase, execute_subprocess_async, require_cuda, require_fsdp, require_multi_gpu, slow, ) from accelerate.utils.constants import ( FSDP_AUTO_WRAP_POLICY, FSDP_BACKWARD_PREFETCH, FSDP_SHARDING_STRATEGY, FSDP_STATE_DICT_TYPE, ) from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin from accelerate.utils.other import patch_environment set_seed(42) lowercase_ = "bert-base-cased" lowercase_ = "fp16" lowercase_ = "bf16" lowercase_ = [FPaa, BFaa] @require_fsdp @require_cuda class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def snake_case__ ( self : Tuple ): super().setUp() __snake_case : int = dict( ACCELERATE_USE_FSDP="""true""" , MASTER_ADDR="""localhost""" , MASTER_PORT="""10999""" , RANK="""0""" , LOCAL_RANK="""0""" , WORLD_SIZE="""1""" , ) def snake_case__ ( self : Optional[int] ): from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy for i, strategy in enumerate(_lowerCAmelCase ): __snake_case : str = self.dist_env.copy() __snake_case : int = f'''{i + 1}''' __snake_case : List[str] = strategy with mockenv_context(**_lowerCAmelCase ): __snake_case : Any = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.sharding_strategy , ShardingStrategy(i + 1 ) ) def snake_case__ ( self : Union[str, Any] ): from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch for i, prefetch_policy in enumerate(_lowerCAmelCase ): __snake_case : int = self.dist_env.copy() __snake_case : int = prefetch_policy with mockenv_context(**_lowerCAmelCase ): __snake_case : Union[str, Any] = FullyShardedDataParallelPlugin() if prefetch_policy == "NO_PREFETCH": self.assertIsNone(fsdp_plugin.backward_prefetch ) else: self.assertEqual(fsdp_plugin.backward_prefetch , BackwardPrefetch(i + 1 ) ) def snake_case__ ( self : str ): from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType for i, state_dict_type in enumerate(_lowerCAmelCase ): __snake_case : Union[str, Any] = self.dist_env.copy() __snake_case : Any = state_dict_type with mockenv_context(**_lowerCAmelCase ): __snake_case : List[Any] = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.state_dict_type , StateDictType(i + 1 ) ) if state_dict_type == "FULL_STATE_DICT": self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu ) self.assertTrue(fsdp_plugin.state_dict_config.ranka_only ) def snake_case__ ( self : List[Any] ): __snake_case : Optional[Any] = AutoModel.from_pretrained(_lowerCAmelCase ) for policy in FSDP_AUTO_WRAP_POLICY: __snake_case : str = self.dist_env.copy() __snake_case : List[str] = policy if policy == "TRANSFORMER_BASED_WRAP": __snake_case : List[str] = """BertLayer""" elif policy == "SIZE_BASED_WRAP": __snake_case : str = """2000""" with mockenv_context(**_lowerCAmelCase ): __snake_case : List[Any] = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(_lowerCAmelCase ) if policy == "NO_WRAP": self.assertIsNone(fsdp_plugin.auto_wrap_policy ) else: self.assertIsNotNone(fsdp_plugin.auto_wrap_policy ) __snake_case : int = self.dist_env.copy() __snake_case : Any = """TRANSFORMER_BASED_WRAP""" __snake_case : Optional[Any] = """T5Layer""" with mockenv_context(**_lowerCAmelCase ): __snake_case : str = FullyShardedDataParallelPlugin() with self.assertRaises(_lowerCAmelCase ) as cm: fsdp_plugin.set_auto_wrap_policy(_lowerCAmelCase ) self.assertTrue("""Could not find the transformer layer class to wrap in the model.""" in str(cm.exception ) ) __snake_case : Any = self.dist_env.copy() __snake_case : str = """SIZE_BASED_WRAP""" __snake_case : Optional[int] = """0""" with mockenv_context(**_lowerCAmelCase ): __snake_case : Tuple = FullyShardedDataParallelPlugin() fsdp_plugin.set_auto_wrap_policy(_lowerCAmelCase ) self.assertIsNone(fsdp_plugin.auto_wrap_policy ) def snake_case__ ( self : Union[str, Any] ): from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler for mp_dtype in dtypes: __snake_case : int = self.dist_env.copy() __snake_case : Any = mp_dtype with mockenv_context(**_lowerCAmelCase ): __snake_case : Optional[Any] = Accelerator() if mp_dtype == "fp16": __snake_case : Tuple = torch.floataa elif mp_dtype == "bf16": __snake_case : Tuple = torch.bfloataa __snake_case : List[str] = MixedPrecision(param_dtype=_lowerCAmelCase , reduce_dtype=_lowerCAmelCase , buffer_dtype=_lowerCAmelCase ) self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy , _lowerCAmelCase ) if mp_dtype == FPaa: self.assertTrue(isinstance(accelerator.scaler , _lowerCAmelCase ) ) elif mp_dtype == BFaa: self.assertIsNone(accelerator.scaler ) AcceleratorState._reset_state(_lowerCAmelCase ) def snake_case__ ( self : Optional[int] ): from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload for flag in [True, False]: __snake_case : List[Any] = self.dist_env.copy() __snake_case : Tuple = str(_lowerCAmelCase ).lower() with mockenv_context(**_lowerCAmelCase ): __snake_case : int = FullyShardedDataParallelPlugin() self.assertEqual(fsdp_plugin.cpu_offload , CPUOffload(offload_params=_lowerCAmelCase ) ) @require_fsdp @require_multi_gpu @slow class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def snake_case__ ( self : Tuple ): super().setUp() __snake_case : Optional[Any] = 0.82 __snake_case : List[Any] = [ """fsdp_shard_grad_op_transformer_based_wrap""", """fsdp_full_shard_transformer_based_wrap""", ] __snake_case : Dict = { """multi_gpu_fp16""": 32_00, """fsdp_shard_grad_op_transformer_based_wrap_fp16""": 20_00, """fsdp_full_shard_transformer_based_wrap_fp16""": 19_00, # Disabling below test as it overwhelms the RAM memory usage # on CI self-hosted runner leading to tests getting killed. # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500, # fp16 was leading to indefinite hang } __snake_case : List[str] = 1_60 __snake_case : Dict = 1_60 __snake_case : Dict = inspect.getfile(accelerate.test_utils ) __snake_case : List[Any] = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ["""scripts""", """external_deps"""] ) def snake_case__ ( self : List[str] ): __snake_case : List[str] = os.path.join(self.test_scripts_folder , """test_performance.py""" ) __snake_case : Union[str, Any] = ["""accelerate""", """launch""", """--num_processes=2""", """--num_machines=1""", """--machine_rank=0""", """--use_fsdp"""] for config in self.performance_configs: __snake_case : Tuple = cmd.copy() for i, strategy in enumerate(_lowerCAmelCase ): if strategy.lower() in config: cmd_config.append(f'''--fsdp_sharding_strategy={i+1}''' ) break if "fp32" in config: cmd_config.append("""--mixed_precision=no""" ) else: cmd_config.append("""--mixed_precision=fp16""" ) if "cpu_offload" in config: cmd_config.append("""--fsdp_offload_params=True""" ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in config: cmd_config.append(f'''--fsdp_auto_wrap_policy={policy}''' ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append("""--fsdp_transformer_layer_cls_to_wrap=BertLayer""" ) elif policy == "SIZE_BASED_WRAP": cmd_config.append("""--fsdp_min_num_params=2000""" ) cmd_config.extend( [ self.test_file_path, f'''--output_dir={self.tmpdir}''', f'''--performance_lower_bound={self.performance_lower_bound}''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(_lowerCAmelCase , env=os.environ.copy() ) def snake_case__ ( self : Optional[Any] ): __snake_case : Any = os.path.join(self.test_scripts_folder , """test_checkpointing.py""" ) __snake_case : Dict = [ """accelerate""", """launch""", """--num_processes=2""", """--num_machines=1""", """--machine_rank=0""", """--use_fsdp""", """--mixed_precision=fp16""", """--fsdp_transformer_layer_cls_to_wrap=BertLayer""", ] for i, strategy in enumerate(_lowerCAmelCase ): __snake_case : int = cmd.copy() cmd_config.append(f'''--fsdp_sharding_strategy={i+1}''' ) if strategy != "FULL_SHARD": continue __snake_case : List[Any] = len(_lowerCAmelCase ) for state_dict_type in FSDP_STATE_DICT_TYPE: __snake_case : List[str] = cmd_config[:state_dict_config_index] cmd_config.append(f'''--fsdp_state_dict_type={state_dict_type}''' ) cmd_config.extend( [ self.test_file_path, f'''--output_dir={self.tmpdir}''', """--partial_train_epoch=1""", ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(_lowerCAmelCase , env=os.environ.copy() ) __snake_case : Optional[int] = cmd_config[:-1] __snake_case : Union[str, Any] = os.path.join(self.tmpdir , """epoch_0""" ) cmd_config.extend( [ f'''--resume_from_checkpoint={resume_from_checkpoint}''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(_lowerCAmelCase , env=os.environ.copy() ) def snake_case__ ( self : Any ): __snake_case : Optional[int] = os.path.join(self.test_scripts_folder , """test_peak_memory_usage.py""" ) __snake_case : Dict = [ """accelerate""", """launch""", """--num_processes=2""", """--num_machines=1""", """--machine_rank=0""", ] for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items(): __snake_case : Any = cmd.copy() if "fp16" in spec: cmd_config.extend(["""--mixed_precision=fp16"""] ) else: cmd_config.extend(["""--mixed_precision=no"""] ) if "multi_gpu" in spec: continue else: cmd_config.extend(["""--use_fsdp"""] ) for i, strategy in enumerate(_lowerCAmelCase ): if strategy.lower() in spec: cmd_config.append(f'''--fsdp_sharding_strategy={i+1}''' ) break if "cpu_offload" in spec: cmd_config.append("""--fsdp_offload_params=True""" ) for policy in FSDP_AUTO_WRAP_POLICY: if policy.lower() in spec: cmd_config.append(f'''--fsdp_auto_wrap_policy={policy}''' ) break if policy == "TRANSFORMER_BASED_WRAP": cmd_config.append("""--fsdp_transformer_layer_cls_to_wrap=BertLayer""" ) elif policy == "SIZE_BASED_WRAP": cmd_config.append("""--fsdp_min_num_params=2000""" ) cmd_config.extend( [ self.test_file_path, f'''--output_dir={self.tmpdir}''', f'''--peak_memory_upper_bound={peak_mem_upper_bound}''', f'''--n_train={self.n_train}''', f'''--n_val={self.n_val}''', ] ) with patch_environment(omp_num_threads=1 ): execute_subprocess_async(_lowerCAmelCase , env=os.environ.copy() )
20
import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() lowercase_ = { "bart": ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), "bert": ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-uncased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-cased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-base-cased-finetuned-mrpc": ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "dpr": ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), "gpt2": ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlnet": ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm": ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm-roberta": ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "transfo-xl": ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "openai-gpt": ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "roberta": ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "layoutlm": ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), "roberta-large-mnli": ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "camembert": ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "flaubert": ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert": ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert-base-distilled-squad": ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert": ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert-visual-feature-encoder": ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "ctrl": ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "albert": ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "t5": ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "electra": ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "wav2vec2": ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str]=False , __SCREAMING_SNAKE_CASE : List[Any]=True ): '''simple docstring''' if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case : Any = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) __snake_case : Dict = config_class.from_json_file(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = True __snake_case : Union[str, Any] = True print(F'''Building TensorFlow model from configuration: {config}''' ) __snake_case : List[Any] = model_class(__SCREAMING_SNAKE_CASE ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): __snake_case : Optional[Any] = cached_file( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: __snake_case : List[Any] = load_pytorch_checkpoint_in_tfa_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if compare_with_pt_model: __snake_case : Tuple = tf_model(tf_model.dummy_inputs , training=__SCREAMING_SNAKE_CASE ) # build the network __snake_case : List[str] = torch.load(__SCREAMING_SNAKE_CASE , map_location="""cpu""" ) __snake_case : Any = pt_model_class.from_pretrained( pretrained_model_name_or_path=__SCREAMING_SNAKE_CASE , config=__SCREAMING_SNAKE_CASE , state_dict=__SCREAMING_SNAKE_CASE ) with torch.no_grad(): __snake_case : Union[str, Any] = pt_model(**pt_model.dummy_inputs ) __snake_case : Any = pto[0].numpy() __snake_case : Optional[int] = tfo[0].numpy() __snake_case : Optional[int] = np.amax(np.abs(np_pt - np_tf ) ) print(F'''Max absolute difference between models outputs {diff}''' ) assert diff <= 2E-2, F'''Error, model absolute difference is >2e-2: {diff}''' # Save pytorch-model print(F'''Save TensorFlow model to {tf_dump_path}''' ) tf_model.save_weights(__SCREAMING_SNAKE_CASE , save_format="""h5""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : List[str]=None , __SCREAMING_SNAKE_CASE : Any=None , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : List[Any]=False , __SCREAMING_SNAKE_CASE : Any=False , ): '''simple docstring''' if args_model_type is None: __snake_case : Tuple = list(MODEL_CLASSES.keys() ) else: __snake_case : Union[str, Any] = [args_model_type] for j, model_type in enumerate(__SCREAMING_SNAKE_CASE , start=1 ): print("""=""" * 1_0_0 ) print(F''' Converting model type {j}/{len(__SCREAMING_SNAKE_CASE )}: {model_type}''' ) print("""=""" * 1_0_0 ) if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case , __snake_case : Optional[int] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: __snake_case : int = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: __snake_case : Union[str, Any] = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , start=1 ): print("""-""" * 1_0_0 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(F''' Skipping finetuned checkpoint {model_shortcut_name}''' ) continue __snake_case : List[Any] = model_shortcut_name elif only_convert_finetuned_models: print(F''' Skipping not finetuned checkpoint {model_shortcut_name}''' ) continue print( F''' Converting checkpoint {i}/{len(__SCREAMING_SNAKE_CASE )}: {model_shortcut_name} - model_type {model_type}''' ) print("""-""" * 1_0_0 ) if config_shortcut_name in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : Dict = config_shortcut_name if model_shortcut_name in aws_model_maps: __snake_case : Union[str, Any] = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : List[Any] = model_shortcut_name if os.path.isfile(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = """converted_model""" convert_pt_checkpoint_to_tf( model_type=__SCREAMING_SNAKE_CASE , pytorch_checkpoint_path=__SCREAMING_SNAKE_CASE , config_file=__SCREAMING_SNAKE_CASE , tf_dump_path=os.path.join(__SCREAMING_SNAKE_CASE , model_shortcut_name + """-tf_model.h5""" ) , compare_with_pt_model=__SCREAMING_SNAKE_CASE , ) if remove_cached_files: os.remove(__SCREAMING_SNAKE_CASE ) os.remove(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--tf_dump_path", default=None, type=str, required=True, help="Path to the output Tensorflow dump file." ) parser.add_argument( "--model_type", default=None, type=str, help=( F'''Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ''' "convert all the models from AWS." ), ) parser.add_argument( "--pytorch_checkpoint_path", default=None, type=str, help=( "Path to the PyTorch checkpoint path or shortcut name to download from AWS. " "If not given, will download and convert all the checkpoints from AWS." ), ) parser.add_argument( "--config_file", default=None, type=str, help=( "The config json file corresponding to the pre-trained model. \n" "This specifies the model architecture. If not given and " "--pytorch_checkpoint_path is not given or is a shortcut name " "use the configuration associated to the shortcut name on the AWS" ), ) parser.add_argument( "--compare_with_pt_model", action="store_true", help="Compare Tensorflow and PyTorch model predictions." ) parser.add_argument( "--use_cached_models", action="store_true", help="Use cached models if possible instead of updating to latest checkpoint versions.", ) parser.add_argument( "--remove_cached_files", action="store_true", help="Remove pytorch models after conversion (save memory when converting in batches).", ) parser.add_argument("--only_convert_finetuned_models", action="store_true", help="Only convert finetuned models.") lowercase_ = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
20
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowercase_ = {"configuration_yolos": ["YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP", "YolosConfig", "YolosOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["YolosFeatureExtractor"] lowercase_ = ["YolosImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST", "YolosForObjectDetection", "YolosModel", "YolosPreTrainedModel", ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
import random def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case , __snake_case , __snake_case : Tuple = [], [], [] for element in data: if element < pivot: less.append(__SCREAMING_SNAKE_CASE ) elif element > pivot: greater.append(__SCREAMING_SNAKE_CASE ) else: equal.append(__SCREAMING_SNAKE_CASE ) return less, equal, greater def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' # index = len(items) // 2 when trying to find the median # (value of index when items is sorted) # invalid input if index >= len(__SCREAMING_SNAKE_CASE ) or index < 0: return None __snake_case : int = items[random.randint(0 , len(__SCREAMING_SNAKE_CASE ) - 1 )] __snake_case : Tuple = 0 __snake_case , __snake_case , __snake_case : List[str] = _partition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = len(__SCREAMING_SNAKE_CASE ) __snake_case : int = len(__SCREAMING_SNAKE_CASE ) # index is the pivot if m <= index < m + count: return pivot # must be in smaller elif m > index: return quick_select(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # must be in larger else: return quick_select(__SCREAMING_SNAKE_CASE , index - (m + count) )
20
1
import shutil import tempfile import unittest from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartTokenizer, MBartTokenizerFast, is_torch_available from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, ) from ...test_tokenization_common import TokenizerTesterMixin lowercase_ = get_tests_dir("fixtures/test_sentencepiece.model") if is_torch_available(): from transformers.models.mbart.modeling_mbart import shift_tokens_right lowercase_ = 25_00_04 lowercase_ = 25_00_20 @require_sentencepiece @require_tokenizers class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , unittest.TestCase ): A : Any = MBartTokenizer A : Optional[Any] = MBartTokenizerFast A : List[Any] = True A : int = True def snake_case__ ( self : Tuple ): super().setUp() # We have a SentencePiece fixture for testing __snake_case : Dict = MBartTokenizer(_lowerCAmelCase , keep_accents=_lowerCAmelCase ) tokenizer.save_pretrained(self.tmpdirname ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = MBartTokenizer(_lowerCAmelCase , keep_accents=_lowerCAmelCase ) __snake_case : int = tokenizer.tokenize("""This is a test""" ) self.assertListEqual(_lowerCAmelCase , ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_lowerCAmelCase ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) __snake_case : Optional[int] = tokenizer.tokenize("""I was born in 92000, and this is falsé.""" ) self.assertListEqual( _lowerCAmelCase , [ SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """9""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """é""", """.""", ] , ) __snake_case : Tuple = tokenizer.convert_tokens_to_ids(_lowerCAmelCase ) self.assertListEqual( _lowerCAmelCase , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] # ^ unk: 2 + 1 = 3 unk: 2 + 1 = 3 ^ ] , ) __snake_case : str = tokenizer.convert_ids_to_tokens(_lowerCAmelCase ) self.assertListEqual( _lowerCAmelCase , [ SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """<unk>""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """<unk>""", """.""", ] , ) def snake_case__ ( self : Tuple ): if not self.test_slow_tokenizer: # as we don't have a slow version, we can't compare the outputs between slow and fast versions return __snake_case : Any = (self.rust_tokenizer_class, """hf-internal-testing/tiny-random-mbart""", {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __snake_case : List[str] = self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : List[Any] = self.tokenizer_class.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : List[Any] = tempfile.mkdtemp() __snake_case : Tuple = tokenizer_r.save_pretrained(_lowerCAmelCase ) __snake_case : Dict = tokenizer_p.save_pretrained(_lowerCAmelCase ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files ) ) __snake_case : str = tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f ) self.assertSequenceEqual(_lowerCAmelCase , _lowerCAmelCase ) # Checks everything loads correctly in the same way __snake_case : Union[str, Any] = tokenizer_r.from_pretrained(_lowerCAmelCase ) __snake_case : Dict = tokenizer_p.from_pretrained(_lowerCAmelCase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowerCAmelCase , _lowerCAmelCase ) ) # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key)) # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id")) shutil.rmtree(_lowerCAmelCase ) # Save tokenizer rust, legacy_format=True __snake_case : List[str] = tempfile.mkdtemp() __snake_case : Dict = tokenizer_r.save_pretrained(_lowerCAmelCase , legacy_format=_lowerCAmelCase ) __snake_case : List[str] = tokenizer_p.save_pretrained(_lowerCAmelCase ) # Checks it save with the same files self.assertSequenceEqual(_lowerCAmelCase , _lowerCAmelCase ) # Checks everything loads correctly in the same way __snake_case : List[Any] = tokenizer_r.from_pretrained(_lowerCAmelCase ) __snake_case : int = tokenizer_p.from_pretrained(_lowerCAmelCase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowerCAmelCase , _lowerCAmelCase ) ) shutil.rmtree(_lowerCAmelCase ) # Save tokenizer rust, legacy_format=False __snake_case : int = tempfile.mkdtemp() __snake_case : List[Any] = tokenizer_r.save_pretrained(_lowerCAmelCase , legacy_format=_lowerCAmelCase ) __snake_case : List[str] = tokenizer_p.save_pretrained(_lowerCAmelCase ) # Checks it saved the tokenizer.json file self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way __snake_case : Union[str, Any] = tokenizer_r.from_pretrained(_lowerCAmelCase ) __snake_case : Tuple = tokenizer_p.from_pretrained(_lowerCAmelCase ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(_lowerCAmelCase , _lowerCAmelCase ) ) shutil.rmtree(_lowerCAmelCase ) @require_torch @require_sentencepiece @require_tokenizers class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): A : List[str] = "facebook/mbart-large-en-ro" A : Optional[Any] = [ " UN Chief Says There Is No Military Solution in Syria", " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.", ] A : Dict = [ "Şeful ONU declară că nu există o soluţie militară în Siria", "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei" " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor" " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.", ] A : Tuple = [8274, 127873, 25916, 7, 8622, 2071, 438, 67485, 53, 187895, 23, 51712, 2, EN_CODE] @classmethod def snake_case__ ( cls : Tuple ): __snake_case : MBartTokenizer = MBartTokenizer.from_pretrained( cls.checkpoint_name , src_lang="""en_XX""" , tgt_lang="""ro_RO""" ) __snake_case : Optional[int] = 1 return cls def snake_case__ ( self : Union[str, Any] ): self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ar_AR"""] , 25_00_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""en_EN"""] , 25_00_04 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ro_RO"""] , 25_00_20 ) def snake_case__ ( self : Dict ): __snake_case : Any = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , _lowerCAmelCase ) def snake_case__ ( self : str ): self.assertIn(_lowerCAmelCase , self.tokenizer.all_special_ids ) __snake_case : Optional[Any] = [RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2] __snake_case : int = self.tokenizer.decode(_lowerCAmelCase , skip_special_tokens=_lowerCAmelCase ) __snake_case : Any = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=_lowerCAmelCase ) self.assertEqual(_lowerCAmelCase , _lowerCAmelCase ) self.assertNotIn(self.tokenizer.eos_token , _lowerCAmelCase ) def snake_case__ ( self : int ): __snake_case : Tuple = ["""this is gunna be a long sentence """ * 20] assert isinstance(src_text[0] , _lowerCAmelCase ) __snake_case : Optional[Any] = 10 __snake_case : Dict = self.tokenizer(_lowerCAmelCase , max_length=_lowerCAmelCase , truncation=_lowerCAmelCase ).input_ids[0] self.assertEqual(ids[-2] , 2 ) self.assertEqual(ids[-1] , _lowerCAmelCase ) self.assertEqual(len(_lowerCAmelCase ) , _lowerCAmelCase ) def snake_case__ ( self : Any ): self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""] ) , [25_00_26, 25_00_01] ) def snake_case__ ( self : List[Any] ): __snake_case : Union[str, Any] = tempfile.mkdtemp() __snake_case : List[Any] = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(_lowerCAmelCase ) __snake_case : Any = MBartTokenizer.from_pretrained(_lowerCAmelCase ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , _lowerCAmelCase ) @require_torch def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = self.tokenizer(self.src_text , text_target=self.tgt_text , padding=_lowerCAmelCase , return_tensors="""pt""" ) __snake_case : Optional[int] = shift_tokens_right(batch["""labels"""] , self.tokenizer.pad_token_id ) # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4 assert batch.input_ids[1][-2:].tolist() == [2, EN_CODE] assert batch.decoder_input_ids[1][0].tolist() == RO_CODE assert batch.decoder_input_ids[1][-1] == 2 assert batch.labels[1][-2:].tolist() == [2, RO_CODE] @require_torch def snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=_lowerCAmelCase , truncation=_lowerCAmelCase , max_length=len(self.expected_src_tokens ) , return_tensors="""pt""" , ) __snake_case : Any = shift_tokens_right(batch["""labels"""] , self.tokenizer.pad_token_id ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) self.assertEqual((2, 14) , batch.input_ids.shape ) self.assertEqual((2, 14) , batch.attention_mask.shape ) __snake_case : List[Any] = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , _lowerCAmelCase ) self.assertEqual(2 , batch.decoder_input_ids[0, -1] ) # EOS # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id, EN_CODE] ) def snake_case__ ( self : Tuple ): __snake_case : Union[str, Any] = self.tokenizer(self.src_text , padding=_lowerCAmelCase , truncation=_lowerCAmelCase , max_length=3 , return_tensors="""pt""" ) __snake_case : List[str] = self.tokenizer( text_target=self.tgt_text , padding=_lowerCAmelCase , truncation=_lowerCAmelCase , max_length=10 , return_tensors="""pt""" ) __snake_case : Union[str, Any] = targets["""input_ids"""] __snake_case : Tuple = shift_tokens_right(_lowerCAmelCase , self.tokenizer.pad_token_id ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def snake_case__ ( self : List[str] ): __snake_case : Any = self.tokenizer._build_translation_inputs( """A test""" , return_tensors="""pt""" , src_lang="""en_XX""" , tgt_lang="""ar_AR""" ) self.assertEqual( nested_simplify(_lowerCAmelCase ) , { # A, test, EOS, en_XX """input_ids""": [[62, 30_34, 2, 25_00_04]], """attention_mask""": [[1, 1, 1, 1]], # ar_AR """forced_bos_token_id""": 25_00_01, } , )
20
import json from typing import List, Optional, Tuple from tokenizers import normalizers from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_roformer import RoFormerTokenizer from .tokenization_utils import JiebaPreTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": { "junnyu/roformer_chinese_small": "https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt", "junnyu/roformer_chinese_base": "https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt", "junnyu/roformer_chinese_char_small": ( "https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt" ), "junnyu/roformer_chinese_char_base": ( "https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt" ), "junnyu/roformer_small_discriminator": ( "https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt" ), "junnyu/roformer_small_generator": ( "https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt" ), } } lowercase_ = { "junnyu/roformer_chinese_small": 15_36, "junnyu/roformer_chinese_base": 15_36, "junnyu/roformer_chinese_char_small": 5_12, "junnyu/roformer_chinese_char_base": 5_12, "junnyu/roformer_small_discriminator": 1_28, "junnyu/roformer_small_generator": 1_28, } lowercase_ = { "junnyu/roformer_chinese_small": {"do_lower_case": True}, "junnyu/roformer_chinese_base": {"do_lower_case": True}, "junnyu/roformer_chinese_char_small": {"do_lower_case": True}, "junnyu/roformer_chinese_char_base": {"do_lower_case": True}, "junnyu/roformer_small_discriminator": {"do_lower_case": True}, "junnyu/roformer_small_generator": {"do_lower_case": True}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = VOCAB_FILES_NAMES A : Optional[int] = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : int = PRETRAINED_INIT_CONFIGURATION A : List[str] = RoFormerTokenizer def __init__( self : Optional[Any] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any="[UNK]" , _lowerCAmelCase : int="[SEP]" , _lowerCAmelCase : Optional[int]="[PAD]" , _lowerCAmelCase : Optional[int]="[CLS]" , _lowerCAmelCase : Optional[Any]="[MASK]" , _lowerCAmelCase : Optional[Any]=True , _lowerCAmelCase : Optional[Any]=None , **_lowerCAmelCase : Dict , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Dict = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( pre_tok_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or pre_tok_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents ): __snake_case : Tuple = getattr(_lowerCAmelCase , pre_tok_state.pop("""type""" ) ) __snake_case : List[Any] = do_lower_case __snake_case : Optional[Any] = strip_accents __snake_case : List[str] = pre_tok_class(**_lowerCAmelCase ) __snake_case : Optional[Any] = do_lower_case def __getstate__( self : Optional[Any] ): __snake_case : Optional[int] = self.__dict__.copy() __snake_case : Optional[Any] = BertPreTokenizer() return state def __setstate__( self : str , _lowerCAmelCase : Dict ): __snake_case : str = d __snake_case : int = self.__dict__["""_tokenizer"""].get_vocab() __snake_case : List[str] = PreTokenizer.custom(JiebaPreTokenizer(_lowerCAmelCase ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int]=None ): __snake_case : Dict = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : Optional[int] = [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : int = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase ) def snake_case__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Tuple=None , _lowerCAmelCase : Union[str, Any]=False , **_lowerCAmelCase : Tuple , ): __snake_case : Tuple = BertPreTokenizer() return super().save_pretrained(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase )
20
1
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] ): # This function is recursive '''simple docstring''' __snake_case : Dict = len(__SCREAMING_SNAKE_CASE ) # If the array contains only one element, we return it (it's the stop condition of # recursion) if array_length <= 1: return array # Else __snake_case : Tuple = array[0] __snake_case : List[Any] = False __snake_case : str = 1 __snake_case : list[int] = [] while not is_found and i < array_length: if array[i] < pivot: __snake_case : Any = True __snake_case : Optional[Any] = [element for element in array[i:] if element >= array[i]] __snake_case : Union[str, Any] = longest_subsequence(__SCREAMING_SNAKE_CASE ) if len(__SCREAMING_SNAKE_CASE ) > len(__SCREAMING_SNAKE_CASE ): __snake_case : int = temp_array else: i += 1 __snake_case : Optional[int] = [element for element in array[1:] if element >= pivot] __snake_case : List[str] = [pivot, *longest_subsequence(__SCREAMING_SNAKE_CASE )] if len(__SCREAMING_SNAKE_CASE ) > len(__SCREAMING_SNAKE_CASE ): return temp_array else: return longest_subseq if __name__ == "__main__": import doctest doctest.testmod()
20
from __future__ import annotations import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if depth < 0: raise ValueError("""Depth cannot be less than 0""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: raise ValueError("""Scores cannot be empty""" ) if depth == height: return scores[node_index] if is_max: return max( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) return min( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : str = [9_0, 2_3, 6, 3_3, 2_1, 6_5, 1_2_3, 3_4_4_2_3] __snake_case : Optional[Any] = math.log(len(__SCREAMING_SNAKE_CASE ) , 2 ) print("""Optimal value : """ , end="""""" ) print(minimax(0 , 0 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
20
1
import argparse from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--dump_path", default=None, type=str, required=True, help="Path to the output model.") parser.add_argument( "--txt2img_unclip", default="kakaobrain/karlo-v1-alpha", type=str, required=False, help="The pretrained txt2img unclip.", ) lowercase_ = parser.parse_args() lowercase_ = UnCLIPPipeline.from_pretrained(args.txtaimg_unclip) lowercase_ = CLIPImageProcessor() lowercase_ = CLIPVisionModelWithProjection.from_pretrained("openai/clip-vit-large-patch14") lowercase_ = UnCLIPImageVariationPipeline( decoder=txtaimg.decoder, text_encoder=txtaimg.text_encoder, tokenizer=txtaimg.tokenizer, text_proj=txtaimg.text_proj, feature_extractor=feature_extractor, image_encoder=image_encoder, super_res_first=txtaimg.super_res_first, super_res_last=txtaimg.super_res_last, decoder_scheduler=txtaimg.decoder_scheduler, super_res_scheduler=txtaimg.super_res_scheduler, ) imgaimg.save_pretrained(args.dump_path)
20
import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType lowercase_ = None lowercase_ = "<" if sys.byteorder == "little" else ">" # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image lowercase_ = [ np.dtype("|b1"), np.dtype("|u1"), np.dtype("<u2"), np.dtype(">u2"), np.dtype("<i2"), np.dtype(">i2"), np.dtype("<u4"), np.dtype(">u4"), np.dtype("<i4"), np.dtype(">i4"), np.dtype("<f4"), np.dtype(">f4"), np.dtype("<f8"), np.dtype(">f8"), ] @dataclass class SCREAMING_SNAKE_CASE__ : A : bool = True A : Optional[str] = None # Automatically constructed A : ClassVar[str] = "PIL.Image.Image" A : ClassVar[Any] = pa.struct({"bytes": pa.binary(), "path": pa.string()} ) A : str = field(default="Image" , init=__UpperCamelCase , repr=__UpperCamelCase ) def __call__( self : Any ): return self.pa_type def snake_case__ ( self : List[Any] , _lowerCAmelCase : Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] ): if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : str = np.array(_lowerCAmelCase ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": value, "bytes": None} elif isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": None, "bytes": value} elif isinstance(_lowerCAmelCase , np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(_lowerCAmelCase ) elif isinstance(_lowerCAmelCase , PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(_lowerCAmelCase ) elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("""path""" )} elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )} else: raise ValueError( f'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''' ) def snake_case__ ( self : List[str] , _lowerCAmelCase : dict , _lowerCAmelCase : Dict=None ): if not self.decode: raise RuntimeError("""Decoding is disabled for this feature. Please use Image(decode=True) instead.""" ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support decoding images, please install 'Pillow'.""" ) if token_per_repo_id is None: __snake_case : Tuple = {} __snake_case , __snake_case : str = value["""path"""], value["""bytes"""] if bytes_ is None: if path is None: raise ValueError(f'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.''' ) else: if is_local_path(_lowerCAmelCase ): __snake_case : str = PIL.Image.open(_lowerCAmelCase ) else: __snake_case : List[str] = path.split("""::""" )[-1] try: __snake_case : Dict = string_to_dict(_lowerCAmelCase , config.HUB_DATASETS_URL )["""repo_id"""] __snake_case : int = token_per_repo_id.get(_lowerCAmelCase ) except ValueError: __snake_case : List[Any] = None with xopen(_lowerCAmelCase , """rb""" , use_auth_token=_lowerCAmelCase ) as f: __snake_case : Union[str, Any] = BytesIO(f.read() ) __snake_case : Dict = PIL.Image.open(bytes_ ) else: __snake_case : Optional[Any] = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def snake_case__ ( self : Union[str, Any] ): from .features import Value return ( self if self.decode else { "bytes": Value("""binary""" ), "path": Value("""string""" ), } ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Union[pa.StringArray, pa.StructArray, pa.ListArray] ): if pa.types.is_string(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, storage] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays([storage, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("""bytes""" ) >= 0: __snake_case : List[str] = storage.field("""bytes""" ) else: __snake_case : List[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) if storage.type.get_field_index("""path""" ) >= 0: __snake_case : Optional[int] = storage.field("""path""" ) else: __snake_case : int = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : Tuple = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_list(storage.type ): __snake_case : Optional[Any] = pa.array( [encode_np_array(np.array(_lowerCAmelCase ) )["""bytes"""] if arr is not None else None for arr in storage.to_pylist()] , type=pa.binary() , ) __snake_case : Optional[int] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays( [bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : pa.StructArray ): @no_op_if_value_is_null def path_to_bytes(_lowerCAmelCase : Tuple ): with xopen(_lowerCAmelCase , """rb""" ) as f: __snake_case : Optional[int] = f.read() return bytes_ __snake_case : Tuple = pa.array( [ (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) __snake_case : Optional[Any] = pa.array( [os.path.basename(_lowerCAmelCase ) if path is not None else None for path in storage.field("""path""" ).to_pylist()] , type=pa.string() , ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def __lowerCAmelCase ( ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() __snake_case : Optional[Any] = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' __snake_case : List[Any] = BytesIO() if image.format in list_image_compression_formats(): __snake_case : Union[str, Any] = image.format else: __snake_case : List[Any] = """PNG""" if image.mode in ["""1""", """L""", """LA""", """RGB""", """RGBA"""] else """TIFF""" image.save(__SCREAMING_SNAKE_CASE , format=__SCREAMING_SNAKE_CASE ) return buffer.getvalue() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' if hasattr(__SCREAMING_SNAKE_CASE , """filename""" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : np.ndarray ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) __snake_case : List[Any] = array.dtype __snake_case : List[Any] = dtype.byteorder if dtype.byteorder != """=""" else _NATIVE_BYTEORDER __snake_case : Dict = dtype.kind __snake_case : Union[str, Any] = dtype.itemsize __snake_case : Tuple = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: __snake_case : int = np.dtype("""|u1""" ) if dtype_kind not in ["u", "i"]: raise TypeError( F'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.''' ) if dtype is not dest_dtype: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: __snake_case : List[str] = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: __snake_case : int = dtype_byteorder + dtype_kind + str(__SCREAMING_SNAKE_CASE ) __snake_case : Any = np.dtype(__SCREAMING_SNAKE_CASE ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( F'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}''' ) __snake_case : Optional[int] = PIL.Image.fromarray(array.astype(__SCREAMING_SNAKE_CASE ) ) return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]] ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if objs: __snake_case , __snake_case : Any = first_non_null_value(__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(__SCREAMING_SNAKE_CASE , np.ndarray ): __snake_case : int = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] elif isinstance(__SCREAMING_SNAKE_CASE , PIL.Image.Image ): __snake_case : List[str] = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] else: return objs else: return objs
20
1
import argparse import json import gdown import numpy as np import torch from huggingface_hub import hf_hub_download from transformers import ( VideoMAEConfig, VideoMAEForPreTraining, VideoMAEForVideoClassification, VideoMAEImageProcessor, ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case : List[Any] = VideoMAEConfig() set_architecture_configs(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if "finetuned" not in model_name: __snake_case : Tuple = False if "finetuned" in model_name: __snake_case : str = """huggingface/label-files""" if "kinetics" in model_name: __snake_case : str = 4_0_0 __snake_case : List[str] = """kinetics400-id2label.json""" elif "ssv2" in model_name: __snake_case : int = 1_7_4 __snake_case : Any = """something-something-v2-id2label.json""" else: raise ValueError("""Model name should either contain 'kinetics' or 'ssv2' in case it's fine-tuned.""" ) __snake_case : Optional[int] = json.load(open(hf_hub_download(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , repo_type="""dataset""" ) , """r""" ) ) __snake_case : Any = {int(__SCREAMING_SNAKE_CASE ): v for k, v in idalabel.items()} __snake_case : List[str] = idalabel __snake_case : Tuple = {v: k for k, v in idalabel.items()} return config def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' if "small" in model_name: __snake_case : str = 3_8_4 __snake_case : Dict = 1_5_3_6 __snake_case : Tuple = 1_2 __snake_case : Any = 1_6 __snake_case : Optional[Any] = 1_2 __snake_case : Any = 3 __snake_case : Any = 1_9_2 __snake_case : str = 7_6_8 elif "large" in model_name: __snake_case : List[str] = 1_0_2_4 __snake_case : Union[str, Any] = 4_0_9_6 __snake_case : Optional[int] = 2_4 __snake_case : List[str] = 1_6 __snake_case : str = 1_2 __snake_case : int = 8 __snake_case : Optional[Any] = 5_1_2 __snake_case : Union[str, Any] = 2_0_4_8 elif "huge" in model_name: __snake_case : int = 1_2_8_0 __snake_case : Dict = 5_1_2_0 __snake_case : List[Any] = 3_2 __snake_case : Tuple = 1_6 __snake_case : str = 1_2 __snake_case : int = 8 __snake_case : Any = 6_4_0 __snake_case : Union[str, Any] = 2_5_6_0 elif "base" not in model_name: raise ValueError("""Model name should include either \"small\", \"base\", \"large\", or \"huge\"""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if "encoder." in name: __snake_case : int = name.replace("""encoder.""" , """""" ) if "cls_token" in name: __snake_case : str = name.replace("""cls_token""" , """videomae.embeddings.cls_token""" ) if "decoder_pos_embed" in name: __snake_case : Dict = name.replace("""decoder_pos_embed""" , """decoder.decoder_pos_embed""" ) if "pos_embed" in name and "decoder" not in name: __snake_case : Union[str, Any] = name.replace("""pos_embed""" , """videomae.embeddings.position_embeddings""" ) if "patch_embed.proj" in name: __snake_case : Union[str, Any] = name.replace("""patch_embed.proj""" , """videomae.embeddings.patch_embeddings.projection""" ) if "patch_embed.norm" in name: __snake_case : int = name.replace("""patch_embed.norm""" , """videomae.embeddings.norm""" ) if "decoder.blocks" in name: __snake_case : int = name.replace("""decoder.blocks""" , """decoder.decoder_layers""" ) if "blocks" in name: __snake_case : List[Any] = name.replace("""blocks""" , """videomae.encoder.layer""" ) if "attn.proj" in name: __snake_case : str = name.replace("""attn.proj""" , """attention.output.dense""" ) if "attn" in name and "bias" not in name: __snake_case : List[str] = name.replace("""attn""" , """attention.self""" ) if "attn" in name: __snake_case : int = name.replace("""attn""" , """attention.attention""" ) if "norm1" in name: __snake_case : Dict = name.replace("""norm1""" , """layernorm_before""" ) if "norm2" in name: __snake_case : str = name.replace("""norm2""" , """layernorm_after""" ) if "mlp.fc1" in name: __snake_case : List[str] = name.replace("""mlp.fc1""" , """intermediate.dense""" ) if "mlp.fc2" in name: __snake_case : Any = name.replace("""mlp.fc2""" , """output.dense""" ) if "decoder_embed" in name: __snake_case : List[str] = name.replace("""decoder_embed""" , """decoder.decoder_embed""" ) if "decoder_norm" in name: __snake_case : Union[str, Any] = name.replace("""decoder_norm""" , """decoder.decoder_norm""" ) if "decoder_pred" in name: __snake_case : int = name.replace("""decoder_pred""" , """decoder.decoder_pred""" ) if "norm.weight" in name and "decoder" not in name and "fc" not in name: __snake_case : Optional[Any] = name.replace("""norm.weight""" , """videomae.layernorm.weight""" ) if "norm.bias" in name and "decoder" not in name and "fc" not in name: __snake_case : List[str] = name.replace("""norm.bias""" , """videomae.layernorm.bias""" ) if "head" in name and "decoder" not in name: __snake_case : List[Any] = name.replace("""head""" , """classifier""" ) return name def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' for key in orig_state_dict.copy().keys(): __snake_case : List[Any] = orig_state_dict.pop(__SCREAMING_SNAKE_CASE ) if key.startswith("""encoder.""" ): __snake_case : Any = key.replace("""encoder.""" , """""" ) if "qkv" in key: __snake_case : Any = key.split(""".""" ) if key.startswith("""decoder.blocks""" ): __snake_case : List[Any] = config.decoder_hidden_size __snake_case : Any = int(key_split[2] ) __snake_case : Optional[int] = """decoder.decoder_layers.""" if "weight" in key: __snake_case : Union[str, Any] = val[:dim, :] __snake_case : int = val[dim : dim * 2, :] __snake_case : Tuple = val[-dim:, :] else: __snake_case : Tuple = config.hidden_size __snake_case : Dict = int(key_split[1] ) __snake_case : Any = """videomae.encoder.layer.""" if "weight" in key: __snake_case : Any = val[:dim, :] __snake_case : Optional[Any] = val[dim : dim * 2, :] __snake_case : List[str] = val[-dim:, :] else: __snake_case : Union[str, Any] = val return orig_state_dict def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Dict = hf_hub_download( repo_id="""hf-internal-testing/spaghetti-video""" , filename="""eating_spaghetti.npy""" , repo_type="""dataset""" ) __snake_case : Dict = np.load(__SCREAMING_SNAKE_CASE ) return list(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' __snake_case : Any = get_videomae_config(__SCREAMING_SNAKE_CASE ) if "finetuned" in model_name: __snake_case : Tuple = VideoMAEForVideoClassification(__SCREAMING_SNAKE_CASE ) else: __snake_case : int = VideoMAEForPreTraining(__SCREAMING_SNAKE_CASE ) # download original checkpoint, hosted on Google Drive __snake_case : Optional[Any] = """pytorch_model.bin""" gdown.cached_download(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , quiet=__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = torch.load(__SCREAMING_SNAKE_CASE , map_location="""cpu""" ) if "model" in files: __snake_case : Any = files["""model"""] else: __snake_case : List[str] = files["""module"""] __snake_case : List[str] = convert_state_dict(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) model.load_state_dict(__SCREAMING_SNAKE_CASE ) model.eval() # verify model on basic input __snake_case : Tuple = VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] , image_std=[0.5, 0.5, 0.5] ) __snake_case : int = prepare_video() __snake_case : str = image_processor(__SCREAMING_SNAKE_CASE , return_tensors="""pt""" ) if "finetuned" not in model_name: __snake_case : Optional[int] = hf_hub_download(repo_id="""hf-internal-testing/bool-masked-pos""" , filename="""bool_masked_pos.pt""" ) __snake_case : str = torch.load(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = model(**__SCREAMING_SNAKE_CASE ) __snake_case : str = outputs.logits __snake_case : Tuple = [ """videomae-small-finetuned-kinetics""", """videomae-small-finetuned-ssv2""", # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600) """videomae-base-short""", """videomae-base-short-finetuned-kinetics""", """videomae-base""", """videomae-base-finetuned-kinetics""", """videomae-large""", """videomae-large-finetuned-kinetics""", """videomae-huge-finetuned-kinetics""", # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400) """videomae-base-short-ssv2""", """videomae-base-short-finetuned-ssv2""", """videomae-base-ssv2""", """videomae-base-finetuned-ssv2""", ] # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5] if model_name == "videomae-small-finetuned-kinetics": __snake_case : List[Any] = torch.Size([1, 4_0_0] ) __snake_case : Tuple = torch.tensor([-0.92_91, -0.40_61, -0.93_07] ) elif model_name == "videomae-small-finetuned-ssv2": __snake_case : str = torch.Size([1, 1_7_4] ) __snake_case : int = torch.tensor([0.26_71, -0.46_89, -0.82_35] ) elif model_name == "videomae-base": __snake_case : List[str] = torch.Size([1, 1_4_0_8, 1_5_3_6] ) __snake_case : Dict = torch.tensor([[0.77_39, 0.79_68, 0.70_89], [0.67_01, 0.74_87, 0.62_09], [0.42_87, 0.51_58, 0.47_73]] ) elif model_name == "videomae-base-short": __snake_case : List[str] = torch.Size([1, 1_4_0_8, 1_5_3_6] ) __snake_case : List[str] = torch.tensor([[0.79_94, 0.96_12, 0.85_08], [0.74_01, 0.89_58, 0.83_02], [0.58_62, 0.74_68, 0.73_25]] ) # we verified the loss both for normalized and unnormalized targets for this one __snake_case : Optional[int] = torch.tensor([0.51_42] ) if config.norm_pix_loss else torch.tensor([0.64_69] ) elif model_name == "videomae-large": __snake_case : Tuple = torch.Size([1, 1_4_0_8, 1_5_3_6] ) __snake_case : Optional[Any] = torch.tensor([[0.71_49, 0.79_97, 0.69_66], [0.67_68, 0.78_69, 0.69_48], [0.51_39, 0.62_21, 0.56_05]] ) elif model_name == "videomae-large-finetuned-kinetics": __snake_case : Optional[Any] = torch.Size([1, 4_0_0] ) __snake_case : Dict = torch.tensor([0.07_71, 0.00_11, -0.36_25] ) elif model_name == "videomae-huge-finetuned-kinetics": __snake_case : Optional[int] = torch.Size([1, 4_0_0] ) __snake_case : Optional[Any] = torch.tensor([0.24_33, 0.16_32, -0.48_94] ) elif model_name == "videomae-base-short-finetuned-kinetics": __snake_case : str = torch.Size([1, 4_0_0] ) __snake_case : Dict = torch.tensor([0.65_88, 0.09_90, -0.24_93] ) elif model_name == "videomae-base-finetuned-kinetics": __snake_case : Any = torch.Size([1, 4_0_0] ) __snake_case : Union[str, Any] = torch.tensor([0.36_69, -0.06_88, -0.24_21] ) elif model_name == "videomae-base-short-ssv2": __snake_case : List[str] = torch.Size([1, 1_4_0_8, 1_5_3_6] ) __snake_case : str = torch.tensor([[0.47_12, 0.52_96, 0.57_86], [0.22_78, 0.27_29, 0.40_26], [0.03_52, 0.07_30, 0.25_06]] ) elif model_name == "videomae-base-short-finetuned-ssv2": __snake_case : Optional[int] = torch.Size([1, 1_7_4] ) __snake_case : Optional[Any] = torch.tensor([-0.05_37, -0.15_39, -0.32_66] ) elif model_name == "videomae-base-ssv2": __snake_case : str = torch.Size([1, 1_4_0_8, 1_5_3_6] ) __snake_case : Any = torch.tensor([[0.81_31, 0.87_27, 0.85_46], [0.73_66, 0.93_77, 0.88_70], [0.59_35, 0.88_74, 0.85_64]] ) elif model_name == "videomae-base-finetuned-ssv2": __snake_case : Optional[int] = torch.Size([1, 1_7_4] ) __snake_case : Union[str, Any] = torch.tensor([0.19_61, -0.83_37, -0.63_89] ) else: raise ValueError(F'''Model name not supported. Should be one of {model_names}''' ) # verify logits assert logits.shape == expected_shape if "finetuned" in model_name: assert torch.allclose(logits[0, :3] , __SCREAMING_SNAKE_CASE , atol=1E-4 ) else: print("""Logits:""" , logits[0, :3, :3] ) assert torch.allclose(logits[0, :3, :3] , __SCREAMING_SNAKE_CASE , atol=1E-4 ) print("""Logits ok!""" ) # verify loss, if applicable if model_name == "videomae-base-short": __snake_case : List[Any] = outputs.loss assert torch.allclose(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , atol=1E-4 ) print("""Loss ok!""" ) if pytorch_dump_folder_path is not None: print(F'''Saving model and image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) if push_to_hub: print("""Pushing to the hub...""" ) model.push_to_hub(__SCREAMING_SNAKE_CASE , organization="""nielsr""" ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--checkpoint_url", default="https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4", type=str, help=( "URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct" " download link." ), ) parser.add_argument( "--pytorch_dump_folder_path", default="/Users/nielsrogge/Documents/VideoMAE/Test", type=str, help="Path to the output PyTorch model directory.", ) parser.add_argument("--model_name", default="videomae-base", type=str, help="Name of the model.") parser.add_argument( "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub." ) lowercase_ = parser.parse_args() convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING lowercase_ = logging.get_logger(__name__) @add_end_docstrings(__UpperCamelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : Dict , *_lowerCAmelCase : Dict , **_lowerCAmelCase : int ): super().__init__(*_lowerCAmelCase , **_lowerCAmelCase ) requires_backends(self , """vision""" ) self.check_model_type( TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING ) def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[str]=None , _lowerCAmelCase : Any=None , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = {} __snake_case : int = {} if prompt is not None: __snake_case : Dict = prompt if generate_kwargs is not None: __snake_case : List[Any] = generate_kwargs if max_new_tokens is not None: if "generate_kwargs" not in forward_kwargs: __snake_case : Optional[int] = {} if "max_new_tokens" in forward_kwargs["generate_kwargs"]: raise ValueError( """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,""" """ please use only one""" ) __snake_case : Any = max_new_tokens return preprocess_params, forward_kwargs, {} def __call__( self : Optional[Any] , _lowerCAmelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] , **_lowerCAmelCase : Union[str, Any] ): return super().__call__(_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = load_image(_lowerCAmelCase ) if prompt is not None: if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): raise ValueError( f'''Received an invalid text input, got - {type(_lowerCAmelCase )} - but expected a single string. ''' """Note also that one single text can be provided for conditional image to text generation.""" ) __snake_case : Tuple = self.model.config.model_type if model_type == "git": __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Any = self.tokenizer(text=_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ).input_ids __snake_case : Tuple = [self.tokenizer.cls_token_id] + input_ids __snake_case : int = torch.tensor(_lowerCAmelCase ).unsqueeze(0 ) model_inputs.update({"""input_ids""": input_ids} ) elif model_type == "pix2struct": __snake_case : Dict = self.image_processor(images=_lowerCAmelCase , header_text=_lowerCAmelCase , return_tensors=self.framework ) elif model_type != "vision-encoder-decoder": # vision-encoder-decoder does not support conditional generation __snake_case : int = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Optional[Any] = self.tokenizer(_lowerCAmelCase , return_tensors=self.framework ) model_inputs.update(_lowerCAmelCase ) else: raise ValueError(f'''Model type {model_type} does not support conditional text generation''' ) else: __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) if self.model.config.model_type == "git" and prompt is None: __snake_case : int = None return model_inputs def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : str=None ): # Git model sets `model_inputs["input_ids"] = None` in `preprocess` (when `prompt=None`). In batch model, the # pipeline will group them into a list of `None`, which fail `_forward`. Avoid this by checking it first. if ( "input_ids" in model_inputs and isinstance(model_inputs["""input_ids"""] , _lowerCAmelCase ) and all(x is None for x in model_inputs["""input_ids"""] ) ): __snake_case : List[Any] = None if generate_kwargs is None: __snake_case : Dict = {} # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py` # parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas # the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name` # in the `_prepare_model_inputs` method. __snake_case : Dict = model_inputs.pop(self.model.main_input_name ) __snake_case : Optional[int] = self.model.generate(_lowerCAmelCase , **_lowerCAmelCase , **_lowerCAmelCase ) return model_outputs def snake_case__ ( self : List[Any] , _lowerCAmelCase : str ): __snake_case : Union[str, Any] = [] for output_ids in model_outputs: __snake_case : Union[str, Any] = { """generated_text""": self.tokenizer.decode( _lowerCAmelCase , skip_special_tokens=_lowerCAmelCase , ) } records.append(_lowerCAmelCase ) return records
20
1
import os import warnings from typing import List, Optional from ...tokenization_utils_base import BatchEncoding from ...utils import logging from .configuration_rag import RagConfig lowercase_ = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE__ : def __init__( self : List[str] , _lowerCAmelCase : Any , _lowerCAmelCase : str ): __snake_case : List[Any] = question_encoder __snake_case : Any = generator __snake_case : Optional[int] = self.question_encoder def snake_case__ ( self : str , _lowerCAmelCase : str ): if os.path.isfile(_lowerCAmelCase ): raise ValueError(f'''Provided path ({save_directory}) should be a directory, not a file''' ) os.makedirs(_lowerCAmelCase , exist_ok=_lowerCAmelCase ) __snake_case : Union[str, Any] = os.path.join(_lowerCAmelCase , """question_encoder_tokenizer""" ) __snake_case : Tuple = os.path.join(_lowerCAmelCase , """generator_tokenizer""" ) self.question_encoder.save_pretrained(_lowerCAmelCase ) self.generator.save_pretrained(_lowerCAmelCase ) @classmethod def snake_case__ ( cls : Union[str, Any] , _lowerCAmelCase : Tuple , **_lowerCAmelCase : List[str] ): # dynamically import AutoTokenizer from ..auto.tokenization_auto import AutoTokenizer __snake_case : List[Any] = kwargs.pop("""config""" , _lowerCAmelCase ) if config is None: __snake_case : Any = RagConfig.from_pretrained(_lowerCAmelCase ) __snake_case : Optional[Any] = AutoTokenizer.from_pretrained( _lowerCAmelCase , config=config.question_encoder , subfolder="""question_encoder_tokenizer""" ) __snake_case : Optional[int] = AutoTokenizer.from_pretrained( _lowerCAmelCase , config=config.generator , subfolder="""generator_tokenizer""" ) return cls(question_encoder=_lowerCAmelCase , generator=_lowerCAmelCase ) def __call__( self : List[str] , *_lowerCAmelCase : str , **_lowerCAmelCase : Union[str, Any] ): return self.current_tokenizer(*_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , *_lowerCAmelCase : Optional[int] , **_lowerCAmelCase : Optional[int] ): return self.generator.batch_decode(*_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : int , *_lowerCAmelCase : Tuple , **_lowerCAmelCase : List[str] ): return self.generator.decode(*_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[int] ): __snake_case : Any = self.question_encoder def snake_case__ ( self : Optional[Any] ): __snake_case : Dict = self.generator def snake_case__ ( self : Any , _lowerCAmelCase : List[str] , _lowerCAmelCase : Optional[List[str]] = None , _lowerCAmelCase : Optional[int] = None , _lowerCAmelCase : Optional[int] = None , _lowerCAmelCase : str = "longest" , _lowerCAmelCase : str = None , _lowerCAmelCase : bool = True , **_lowerCAmelCase : List[str] , ): warnings.warn( """`prepare_seq2seq_batch` is deprecated and will be removed in version 5 of 🤗 Transformers. Use the """ """regular `__call__` method to prepare your inputs and the tokenizer under the `with_target_tokenizer` """ """context manager to prepare your targets. See the documentation of your specific tokenizer for more """ """details""" , _lowerCAmelCase , ) if max_length is None: __snake_case : str = self.current_tokenizer.model_max_length __snake_case : Any = self( _lowerCAmelCase , add_special_tokens=_lowerCAmelCase , return_tensors=_lowerCAmelCase , max_length=_lowerCAmelCase , padding=_lowerCAmelCase , truncation=_lowerCAmelCase , **_lowerCAmelCase , ) if tgt_texts is None: return model_inputs # Process tgt_texts if max_target_length is None: __snake_case : str = self.current_tokenizer.model_max_length __snake_case : Optional[Any] = self( text_target=_lowerCAmelCase , add_special_tokens=_lowerCAmelCase , return_tensors=_lowerCAmelCase , padding=_lowerCAmelCase , max_length=_lowerCAmelCase , truncation=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Optional[int] = labels["""input_ids"""] return model_inputs
20
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowercase_ = {"configuration_yolos": ["YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP", "YolosConfig", "YolosOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["YolosFeatureExtractor"] lowercase_ = ["YolosImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST", "YolosForObjectDetection", "YolosModel", "YolosPreTrainedModel", ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[int]] ): '''simple docstring''' # preprocessing the first row for i in range(1 , len(matrix[0] ) ): matrix[0][i] += matrix[0][i - 1] # preprocessing the first column for i in range(1 , len(__SCREAMING_SNAKE_CASE ) ): matrix[i][0] += matrix[i - 1][0] # updating the path cost for current position for i in range(1 , len(__SCREAMING_SNAKE_CASE ) ): for j in range(1 , len(matrix[0] ) ): matrix[i][j] += min(matrix[i - 1][j] , matrix[i][j - 1] ) return matrix[-1][-1] if __name__ == "__main__": import doctest doctest.testmod()
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = "microsoft/speecht5_tts" A : List[Any] = ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) A : str = "text_reader" A : Optional[Any] = SpeechTaProcessor A : Any = SpeechTaForTextToSpeech A : Optional[Any] = SpeechTaHifiGan A : str = ["text"] A : Union[str, Any] = ["audio"] def snake_case__ ( self : List[Any] ): if self.post_processor is None: __snake_case : Tuple = """microsoft/speecht5_hifigan""" super().setup() def snake_case__ ( self : Any , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Tuple=None ): __snake_case : str = self.pre_processor(text=_lowerCAmelCase , return_tensors="""pt""" , truncation=_lowerCAmelCase ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) __snake_case : List[Any] = load_dataset("""Matthijs/cmu-arctic-xvectors""" , split="""validation""" ) __snake_case : str = torch.tensor(embeddings_dataset[73_05]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def snake_case__ ( self : List[Any] , _lowerCAmelCase : Dict ): with torch.no_grad(): return self.model.generate_speech(**_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): with torch.no_grad(): return self.post_processor(_lowerCAmelCase ).cpu().detach()
20
1
import argparse import os import re import packaging.version lowercase_ = "examples/" lowercase_ = { "examples": (re.compile(r"^check_min_version\(\"[^\"]+\"\)\s*$", re.MULTILINE), "check_min_version(\"VERSION\")\n"), "init": (re.compile(r"^__version__\s+=\s+\"([^\"]+)\"\s*$", re.MULTILINE), "__version__ = \"VERSION\"\n"), "setup": (re.compile(r"^(\s*)version\s*=\s*\"[^\"]+\",", re.MULTILINE), r"\1version=\"VERSION\","), "doc": (re.compile(r"^(\s*)release\s*=\s*\"[^\"]+\"$", re.MULTILINE), "release = \"VERSION\"\n"), } lowercase_ = { "init": "src/transformers/__init__.py", "setup": "setup.py", } lowercase_ = "README.md" def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' with open(__SCREAMING_SNAKE_CASE , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: __snake_case : int = f.read() __snake_case , __snake_case : int = REPLACE_PATTERNS[pattern] __snake_case : Tuple = replace.replace("""VERSION""" , __SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = re_pattern.sub(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) with open(__SCREAMING_SNAKE_CASE , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.write(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' for folder, directories, fnames in os.walk(__SCREAMING_SNAKE_CASE ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("""research_projects""" ) if "legacy" in directories: directories.remove("""legacy""" ) for fname in fnames: if fname.endswith(""".py""" ): update_version_in_file(os.path.join(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE , pattern="""examples""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str]=False ): '''simple docstring''' for pattern, fname in REPLACE_FILES.items(): update_version_in_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if not patch: update_version_in_examples(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Union[str, Any] = """🤗 Transformers currently provides the following architectures""" __snake_case : Optional[Any] = """1. Want to contribute a new model?""" with open(__SCREAMING_SNAKE_CASE , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: __snake_case : str = f.readlines() # Find the start of the list. __snake_case : Tuple = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 __snake_case : List[str] = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("""1.""" ): __snake_case : str = lines[index].replace( """https://huggingface.co/docs/transformers/main/model_doc""" , """https://huggingface.co/docs/transformers/model_doc""" , ) index += 1 with open(__SCREAMING_SNAKE_CASE , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.writelines(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( ): '''simple docstring''' with open(REPLACE_FILES["""init"""] , """r""" ) as f: __snake_case : Any = f.read() __snake_case : Tuple = REPLACE_PATTERNS["""init"""][0].search(__SCREAMING_SNAKE_CASE ).groups()[0] return packaging.version.parse(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[Any]=False ): '''simple docstring''' __snake_case : Optional[Any] = get_version() if patch and default_version.is_devrelease: raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" ) if default_version.is_devrelease: __snake_case : str = default_version.base_version elif patch: __snake_case : Tuple = F'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}''' else: __snake_case : Optional[int] = F'''{default_version.major}.{default_version.minor + 1}.0''' # Now let's ask nicely if that's the right one. __snake_case : Optional[int] = input(F'''Which version are you releasing? [{default_version}]''' ) if len(__SCREAMING_SNAKE_CASE ) == 0: __snake_case : Union[str, Any] = default_version print(F'''Updating version to {version}.''' ) global_version_update(__SCREAMING_SNAKE_CASE , patch=__SCREAMING_SNAKE_CASE ) if not patch: print("""Cleaning main README, don't forget to run `make fix-copies`.""" ) clean_main_ref_in_model_list() def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Union[str, Any] = get_version() __snake_case : int = F'''{current_version.major}.{current_version.minor + 1}.0.dev0''' __snake_case : Optional[int] = current_version.base_version # Check with the user we got that right. __snake_case : Dict = input(F'''Which version are we developing now? [{dev_version}]''' ) if len(__SCREAMING_SNAKE_CASE ) == 0: __snake_case : Optional[Any] = dev_version print(F'''Updating version to {version}.''' ) global_version_update(__SCREAMING_SNAKE_CASE ) print("""Cleaning main README, don't forget to run `make fix-copies`.""" ) clean_main_ref_in_model_list() if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--post_release", action="store_true", help="Whether this is pre or post release.") parser.add_argument("--patch", action="store_true", help="Whether or not this is a patch release.") lowercase_ = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print("Nothing to do after a patch :-)") else: post_release_work()
20
import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * power_factor def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * math.sqrt(1 - power_factor**2 ) if __name__ == "__main__": import doctest doctest.testmod()
20
1
import numpy as np lowercase_ = [ ["a", "b", "c", "d", "e"], ["f", "g", "h", "i", "k"], ["l", "m", "n", "o", "p"], ["q", "r", "s", "t", "u"], ["v", "w", "x", "y", "z"], ] class SCREAMING_SNAKE_CASE__ : def __init__( self : Any ): __snake_case : Optional[Any] = np.array(_lowerCAmelCase ) def snake_case__ ( self : Tuple , _lowerCAmelCase : str ): __snake_case , __snake_case : Tuple = np.where(letter == self.SQUARE ) __snake_case : Tuple = np.concatenate([indexa + 1, indexa + 1] ) return indexes def snake_case__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : int ): __snake_case : Optional[Any] = self.SQUARE[indexa - 1, indexa - 1] return letter def snake_case__ ( self : Any , _lowerCAmelCase : str ): __snake_case : Any = message.lower() __snake_case : Optional[int] = message.replace(""" """ , """""" ) __snake_case : Optional[int] = message.replace("""j""" , """i""" ) __snake_case : Union[str, Any] = np.empty((2, len(_lowerCAmelCase )) ) for letter_index in range(len(_lowerCAmelCase ) ): __snake_case : Tuple = self.letter_to_numbers(message[letter_index] ) __snake_case : Optional[Any] = numbers[0] __snake_case : Optional[Any] = numbers[1] __snake_case : Optional[int] = first_step.reshape(2 * len(_lowerCAmelCase ) ) __snake_case : List[Any] = """""" for numbers_index in range(len(_lowerCAmelCase ) ): __snake_case : str = int(second_step[numbers_index * 2] ) __snake_case : Union[str, Any] = int(second_step[(numbers_index * 2) + 1] ) __snake_case : Any = self.numbers_to_letter(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = encoded_message + letter return encoded_message def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str ): __snake_case : List[str] = message.lower() message.replace(""" """ , """""" ) __snake_case : Optional[Any] = np.empty(2 * len(_lowerCAmelCase ) ) for letter_index in range(len(_lowerCAmelCase ) ): __snake_case : Dict = self.letter_to_numbers(message[letter_index] ) __snake_case : Optional[int] = numbers[0] __snake_case : int = numbers[1] __snake_case : Union[str, Any] = first_step.reshape((2, len(_lowerCAmelCase )) ) __snake_case : Dict = """""" for numbers_index in range(len(_lowerCAmelCase ) ): __snake_case : Dict = int(second_step[0, numbers_index] ) __snake_case : Optional[int] = int(second_step[1, numbers_index] ) __snake_case : Union[str, Any] = self.numbers_to_letter(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = decoded_message + letter return decoded_message
20
from .constants import ( MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SCALER_NAME, SCHEDULER_NAME, TORCH_LAUNCH_PARAMS, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ) from .dataclasses import ( BnbQuantizationConfig, ComputeEnvironment, CustomDtype, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FPaRecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProjectConfiguration, RNGType, SageMakerDistributedType, TensorInformation, TorchDynamoPlugin, ) from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env from .imports import ( get_ccl_version, is_abit_bnb_available, is_abit_bnb_available, is_aim_available, is_bfaa_available, is_bnb_available, is_botoa_available, is_ccl_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_fpa_available, is_ipex_available, is_megatron_lm_available, is_mlflow_available, is_mps_available, is_npu_available, is_rich_available, is_safetensors_available, is_sagemaker_available, is_tensorboard_available, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) from .modeling import ( check_device_map, check_tied_parameters_in_config, check_tied_parameters_on_same_device, compute_module_sizes, convert_file_size_to_int, dtype_byte_size, find_tied_parameters, get_balanced_memory, get_max_layer_size, get_max_memory, get_mixed_precision_context_manager, id_tensor_storage, infer_auto_device_map, load_checkpoint_in_model, load_offloaded_weights, load_state_dict, named_module_tensors, retie_parameters, set_module_tensor_to_device, shard_checkpoint, ) from .offload import ( OffloadedWeightsLoader, PrefixedDataset, extract_submodules_state_dict, load_offloaded_weight, offload_state_dict, offload_weight, save_offload_index, ) from .operations import ( broadcast, broadcast_object_list, concatenate, convert_outputs_to_fpaa, convert_to_fpaa, find_batch_size, find_device, gather, gather_object, get_data_structure, honor_type, initialize_tensors, is_namedtuple, is_tensor_information, is_torch_tensor, listify, pad_across_processes, recursively_apply, reduce, send_to_device, slice_tensors, ) from .versions import compare_versions, is_torch_version if is_deepspeed_available(): from .deepspeed import ( DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler, HfDeepSpeedConfig, ) from .bnb import has_abit_bnb_layers, load_and_quantize_model from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer from .launch import ( PrepareForLaunch, _filter_args, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, ) from .megatron_lm import ( AbstractTrainStep, BertTrainStep, GPTTrainStep, MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, TaTrainStep, avg_losses_across_data_parallel_group, gather_across_data_parallel_groups, ) from .megatron_lm import initialize as megatron_lm_initialize from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader from .megatron_lm import prepare_model as megatron_lm_prepare_model from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler from .memory import find_executable_batch_size, release_memory from .other import ( extract_model_from_parallel, get_pretty_name, is_port_in_use, merge_dicts, patch_environment, save, wait_for_everyone, write_basic_config, ) from .random import set_seed, synchronize_rng_state, synchronize_rng_states from .torch_xla import install_xla from .tqdm import tqdm from .transformer_engine import convert_model, has_transformer_engine_layers
20
1
import sys from .dependency_versions_table import deps from .utils.versions import require_version, require_version_core # define which module versions we always want to check at run time # (usually the ones defined in `install_requires` in setup.py) # # order specific notes: # - tqdm must be checked before tokenizers lowercase_ = "python tqdm regex requests packaging filelock numpy tokenizers".split() if sys.version_info < (3, 7): pkgs_to_check_at_runtime.append("dataclasses") if sys.version_info < (3, 8): pkgs_to_check_at_runtime.append("importlib_metadata") for pkg in pkgs_to_check_at_runtime: if pkg in deps: if pkg == "tokenizers": # must be loaded here, or else tqdm check may fail from .utils import is_tokenizers_available if not is_tokenizers_available(): continue # not required, check version only if installed require_version_core(deps[pkg]) else: raise ValueError(F'''can\'t find {pkg} in {deps.keys()}, check dependency_versions_table.py''') def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[Any]=None ): '''simple docstring''' require_version(deps[pkg] , __SCREAMING_SNAKE_CASE )
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase_ = { "configuration_blenderbot_small": [ "BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "BlenderbotSmallConfig", "BlenderbotSmallOnnxConfig", ], "tokenization_blenderbot_small": ["BlenderbotSmallTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["BlenderbotSmallTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST", "BlenderbotSmallForCausalLM", "BlenderbotSmallForConditionalGeneration", "BlenderbotSmallModel", "BlenderbotSmallPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFBlenderbotSmallForConditionalGeneration", "TFBlenderbotSmallModel", "TFBlenderbotSmallPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxBlenderbotSmallForConditionalGeneration", "FlaxBlenderbotSmallModel", "FlaxBlenderbotSmallPreTrainedModel", ] if TYPE_CHECKING: from .configuration_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotSmallConfig, BlenderbotSmallOnnxConfig, ) from .tokenization_blenderbot_small import BlenderbotSmallTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_small_fast import BlenderbotSmallTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotSmallForCausalLM, BlenderbotSmallForConditionalGeneration, BlenderbotSmallModel, BlenderbotSmallPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot_small import ( TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel, TFBlenderbotSmallPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot_small import ( FlaxBlenderbotSmallForConditionalGeneration, FlaxBlenderbotSmallModel, FlaxBlenderbotSmallPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
from __future__ import annotations import json import requests from bsa import BeautifulSoup from fake_useragent import UserAgent lowercase_ = {"UserAgent": UserAgent().random} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' __snake_case : Any = script.contents[0] __snake_case : Optional[Any] = json.loads(data[data.find("""{\"config\"""" ) : -1] ) return info["entry_data"]["ProfilePage"][0]["graphql"]["user"] class SCREAMING_SNAKE_CASE__ : def __init__( self : Optional[int] , _lowerCAmelCase : Optional[int] ): __snake_case : Any = f'''https://www.instagram.com/{username}/''' __snake_case : List[Any] = self.get_json() def snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = requests.get(self.url , headers=_lowerCAmelCase ).text __snake_case : List[Any] = BeautifulSoup(_lowerCAmelCase , """html.parser""" ).find_all("""script""" ) try: return extract_user_profile(scripts[4] ) except (json.decoder.JSONDecodeError, KeyError): return extract_user_profile(scripts[3] ) def __repr__( self : Any ): return f'''{self.__class__.__name__}(\'{self.username}\')''' def __str__( self : Dict ): return f'''{self.fullname} ({self.username}) is {self.biography}''' @property def snake_case__ ( self : Union[str, Any] ): return self.user_data["username"] @property def snake_case__ ( self : List[Any] ): return self.user_data["full_name"] @property def snake_case__ ( self : Union[str, Any] ): return self.user_data["biography"] @property def snake_case__ ( self : Dict ): return self.user_data["business_email"] @property def snake_case__ ( self : Tuple ): return self.user_data["external_url"] @property def snake_case__ ( self : Union[str, Any] ): return self.user_data["edge_followed_by"]["count"] @property def snake_case__ ( self : Optional[Any] ): return self.user_data["edge_follow"]["count"] @property def snake_case__ ( self : Any ): return self.user_data["edge_owner_to_timeline_media"]["count"] @property def snake_case__ ( self : Tuple ): return self.user_data["profile_pic_url_hd"] @property def snake_case__ ( self : Optional[Any] ): return self.user_data["is_verified"] @property def snake_case__ ( self : Tuple ): return self.user_data["is_private"] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str = "github" ): '''simple docstring''' import os if os.environ.get("""CI""" ): return # test failing on GitHub Actions __snake_case : Union[str, Any] = InstagramUser(__SCREAMING_SNAKE_CASE ) assert instagram_user.user_data assert isinstance(instagram_user.user_data , __SCREAMING_SNAKE_CASE ) assert instagram_user.username == username if username != "github": return assert instagram_user.fullname == "GitHub" assert instagram_user.biography == "Built for developers." assert instagram_user.number_of_posts > 1_5_0 assert instagram_user.number_of_followers > 1_2_0_0_0_0 assert instagram_user.number_of_followings > 1_5 assert instagram_user.email == "[email protected]" assert instagram_user.website == "https://github.com/readme" assert instagram_user.profile_picture_url.startswith("""https://instagram.""" ) assert instagram_user.is_verified is True assert instagram_user.is_private is False if __name__ == "__main__": import doctest doctest.testmod() lowercase_ = InstagramUser("github") print(instagram_user) print(F'''{instagram_user.number_of_posts = }''') print(F'''{instagram_user.number_of_followers = }''') print(F'''{instagram_user.number_of_followings = }''') print(F'''{instagram_user.email = }''') print(F'''{instagram_user.website = }''') print(F'''{instagram_user.profile_picture_url = }''') print(F'''{instagram_user.is_verified = }''') print(F'''{instagram_user.is_private = }''')
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) lowercase_ = {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["ViTFeatureExtractor"] lowercase_ = ["ViTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "VIT_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTForImageClassification", "ViTForMaskedImageModeling", "ViTModel", "ViTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFViTForImageClassification", "TFViTModel", "TFViTPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxViTForImageClassification", "FlaxViTModel", "FlaxViTPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' return 1 if digit in (0, 1) else (digit * factorial(digit - 1 )) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : List[str] = 0 __snake_case : Any = number while duplicate > 0: __snake_case , __snake_case : Any = divmod(__SCREAMING_SNAKE_CASE , 1_0 ) fact_sum += factorial(__SCREAMING_SNAKE_CASE ) return fact_sum == number if __name__ == "__main__": print("Program to check whether a number is a Krisnamurthy Number or not.") lowercase_ = int(input("Enter number: ").strip()) print( F'''{number} is {"" if krishnamurthy(number) else "not "}a Krishnamurthy Number.''' )
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if (direction == 1 and array[indexa] > array[indexa]) or ( direction == 0 and array[indexa] < array[indexa] ): __snake_case , __snake_case : str = array[indexa], array[indexa] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Tuple = int(length / 2 ) for i in range(__SCREAMING_SNAKE_CASE , low + middle ): comp_and_swap(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , i + middle , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Optional[Any] = int(length / 2 ) bitonic_sort(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , 1 ) bitonic_sort(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , 0 ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() lowercase_ = [int(item.strip()) for item in user_input.split(",")] bitonic_sort(unsorted, 0, len(unsorted), 1) print("\nSorted array in ascending order is: ", end="") print(*unsorted, sep=", ") bitonic_merge(unsorted, 0, len(unsorted), 0) print("Sorted array in descending order is: ", end="") print(*unsorted, sep=", ")
20
1
from jiwer import compute_measures import datasets lowercase_ = "\\n@inproceedings{inproceedings,\n author = {Morris, Andrew and Maier, Viktoria and Green, Phil},\n year = {2004},\n month = {01},\n pages = {},\n title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}\n}\n" lowercase_ = "\\nWord error rate (WER) is a common metric of the performance of an automatic speech recognition system.\n\nThe general difficulty of measuring performance lies in the fact that the recognized word sequence can have a different length from the reference word sequence (supposedly the correct one). The WER is derived from the Levenshtein distance, working at the word level instead of the phoneme level. The WER is a valuable tool for comparing different systems as well as for evaluating improvements within one system. This kind of measurement, however, provides no details on the nature of translation errors and further work is therefore required to identify the main source(s) of error and to focus any research effort.\n\nThis problem is solved by first aligning the recognized word sequence with the reference (spoken) word sequence using dynamic string alignment. Examination of this issue is seen through a theory called the power law that states the correlation between perplexity and word error rate.\n\nWord error rate can then be computed as:\n\nWER = (S + D + I) / N = (S + D + I) / (S + D + C)\n\nwhere\n\nS is the number of substitutions,\nD is the number of deletions,\nI is the number of insertions,\nC is the number of correct words,\nN is the number of words in the reference (N=S+D+C).\n\nThis value indicates the average number of errors per reference word. The lower the value, the better the\nperformance of the ASR system with a WER of 0 being a perfect score.\n" lowercase_ = "\nCompute WER score of transcribed segments against references.\n\nArgs:\n references: List of references for each speech input.\n predictions: List of transcriptions to score.\n concatenate_texts (bool, default=False): Whether to concatenate all input texts or compute WER iteratively.\n\nReturns:\n (float): the word error rate\n\nExamples:\n\n >>> predictions = [\"this is the prediction\", \"there is an other sample\"]\n >>> references = [\"this is the reference\", \"there is another one\"]\n >>> wer = datasets.load_metric(\"wer\")\n >>> wer_score = wer.compute(predictions=predictions, references=references)\n >>> print(wer_score)\n 0.5\n" @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE__ ( datasets.Metric ): def snake_case__ ( self : List[str] ): return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Value("""string""" , id="""sequence""" ), """references""": datasets.Value("""string""" , id="""sequence""" ), } ) , codebase_urls=["""https://github.com/jitsi/jiwer/"""] , reference_urls=[ """https://en.wikipedia.org/wiki/Word_error_rate""", ] , ) def snake_case__ ( self : List[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Any=None , _lowerCAmelCase : str=False ): if concatenate_texts: return compute_measures(_lowerCAmelCase , _lowerCAmelCase )["wer"] else: __snake_case : Optional[Any] = 0 __snake_case : Tuple = 0 for prediction, reference in zip(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : Dict = compute_measures(_lowerCAmelCase , _lowerCAmelCase ) incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"] total += measures["substitutions"] + measures["deletions"] + measures["hits"] return incorrect / total
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , ): '''simple docstring''' __snake_case : Optional[int] = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } __snake_case , __snake_case : Tuple = input_paths_and_base_extractors[compression_format] if input_path is None: __snake_case : Tuple = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) assert base_extractor.is_extractable(__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : List[str] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : int = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any] , ): '''simple docstring''' __snake_case : Union[str, Any] = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } __snake_case : int = input_paths[compression_format] if input_path is None: __snake_case : int = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) __snake_case : Any = Extractor.infer_extractor_format(__SCREAMING_SNAKE_CASE ) assert extractor_format is not None __snake_case : Tuple = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : Union[str, Any] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Union[str, Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' import tarfile __snake_case : List[str] = tmp_path / """data_dot_dot""" directory.mkdir() __snake_case : Optional[Any] = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(__SCREAMING_SNAKE_CASE , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' import tarfile __snake_case : Dict = tmp_path / """data_sym_link""" directory.mkdir() __snake_case : Tuple = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=__SCREAMING_SNAKE_CASE ) with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' __snake_case : Any = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } __snake_case : int = insecure_tar_files[insecure_tar_file] __snake_case : Optional[int] = tmp_path / """extracted""" TarExtractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number __snake_case : Optional[Any] = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 __snake_case : List[str] = ( b"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" b"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" b"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" b"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(__SCREAMING_SNAKE_CASE ) assert zipfile.is_zipfile(str(__SCREAMING_SNAKE_CASE ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(__SCREAMING_SNAKE_CASE ) # but we're right
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if density <= 0: raise ValueError("""Impossible fluid density""" ) if bulk_modulus <= 0: raise ValueError("""Impossible bulk modulus""" ) return (bulk_modulus / density) ** 0.5 if __name__ == "__main__": import doctest doctest.testmod()
20
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 SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Any ): __snake_case : Dict = """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split() __snake_case : str = dict(zip(_lowerCAmelCase , range(len(_lowerCAmelCase ) ) ) ) __snake_case : List[str] = { """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>""", } __snake_case : str = { """feature_size""": 1, """padding_value""": 0.0, """sampling_rate""": 1_60_00, """return_attention_mask""": False, """do_normalize""": True, } __snake_case : Optional[Any] = tempfile.mkdtemp() __snake_case : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Any = 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 __snake_case : Optional[int] = """hf-internal-testing/ngram-beam-search-decoder""" def snake_case__ ( self : Optional[Any] , **_lowerCAmelCase : Tuple ): __snake_case : int = self.add_kwargs_tokens_map.copy() kwargs.update(_lowerCAmelCase ) return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , **_lowerCAmelCase : Optional[int] ): return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : Tuple ): return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name , **_lowerCAmelCase ) def snake_case__ ( self : List[str] ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Tuple = self.get_feature_extractor() __snake_case : Dict = self.get_decoder() __snake_case : List[str] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) __snake_case : Dict = 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 snake_case__ ( self : Tuple ): __snake_case : Tuple = 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 __snake_case : Optional[Any] = 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 snake_case__ ( self : int ): __snake_case : Tuple = 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 snake_case__ ( self : Dict ): __snake_case : int = self.get_feature_extractor() __snake_case : str = self.get_tokenizer() __snake_case : Dict = self.get_decoder() __snake_case : Any = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : List[Any] = floats_list((3, 10_00) ) __snake_case : Optional[Any] = feature_extractor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Tuple = 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 snake_case__ ( self : Optional[int] ): __snake_case : Any = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = """This is a test string""" __snake_case : Union[str, Any] = processor(text=_lowerCAmelCase ) __snake_case : Dict = tokenizer(_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : List[str] , _lowerCAmelCase : List[Any]=(2, 10, 16) , _lowerCAmelCase : str=77 ): np.random.seed(_lowerCAmelCase ) return np.random.rand(*_lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : List[str] = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : List[str] = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = self._get_dummy_logits(shape=(10, 16) , seed=13 ) __snake_case : int = processor.decode(_lowerCAmelCase ) __snake_case : Optional[int] = 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 snake_case__ ( self : List[str] , _lowerCAmelCase : List[str] ): __snake_case : int = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = 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: __snake_case : Tuple = processor.batch_decode(_lowerCAmelCase ) else: with get_context(_lowerCAmelCase ).Pool() as pool: __snake_case : int = processor.batch_decode(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as p: __snake_case : Tuple = decoder.decode_beams_batch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case , __snake_case , __snake_case : List[Any] = [], [], [] 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 snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = self.get_feature_extractor() __snake_case : int = self.get_tokenizer() __snake_case : str = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = self._get_dummy_logits() __snake_case : List[str] = 15 __snake_case : Optional[Any] = -20.0 __snake_case : Tuple = -4.0 __snake_case : List[Any] = processor.batch_decode( _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : List[str] = decoded_processor_out.text __snake_case : str = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as pool: __snake_case : Dict = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : int = [d[0][0] for d in decoded_decoder_out] __snake_case : List[Any] = [d[0][2] for d in decoded_decoder_out] __snake_case : List[Any] = [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([-20.054, -18.447] , _lowerCAmelCase , atol=1e-3 ) ) self.assertTrue(np.array_equal(_lowerCAmelCase , decoded_processor_out.lm_score ) ) self.assertTrue(np.allclose([-15.554, -13.9474] , _lowerCAmelCase , atol=1e-3 ) ) def snake_case__ ( self : Any ): __snake_case : List[Any] = self.get_feature_extractor() __snake_case : Any = self.get_tokenizer() __snake_case : Union[str, Any] = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Any = self._get_dummy_logits() __snake_case : Any = 2.0 __snake_case : int = 5.0 __snake_case : Optional[int] = -20.0 __snake_case : Optional[int] = True __snake_case : Any = processor.batch_decode( _lowerCAmelCase , alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) __snake_case : str = decoded_processor_out.text __snake_case : int = list(_lowerCAmelCase ) decoder.reset_params( alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) with get_context("""fork""" ).Pool() as pool: __snake_case : Tuple = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , ) __snake_case : int = [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 ) __snake_case : List[str] = 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 , -20.0 ) self.assertEqual(lm_model.score_boundary , _lowerCAmelCase ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Union[str, Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : Union[str, Any] = os.listdir(_lowerCAmelCase ) __snake_case : List[str] = ["""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 snake_case__ ( self : Optional[Any] ): __snake_case : Union[str, Any] = snapshot_download("""hf-internal-testing/processor_with_lm""" ) __snake_case : Dict = WavaVecaProcessorWithLM.from_pretrained(_lowerCAmelCase ) __snake_case : Optional[Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : List[str] = os.listdir(_lowerCAmelCase ) __snake_case : List[Any] = 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 snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : str = AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = floats_list((3, 10_00) ) __snake_case : Union[str, Any] = processor_wavaveca(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Union[str, Any] = 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 ) __snake_case : Dict = self._get_dummy_logits() __snake_case : List[Any] = processor_wavaveca.batch_decode(_lowerCAmelCase ) __snake_case : List[Any] = processor_auto.batch_decode(_lowerCAmelCase ) self.assertListEqual(decoded_wavaveca.text , decoded_auto.text ) def snake_case__ ( self : str ): __snake_case : int = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : Optional[Any] = self.get_decoder() __snake_case : Union[str, Any] = 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 snake_case__ ( _lowerCAmelCase : Any , _lowerCAmelCase : Tuple ): __snake_case : Union[str, Any] = [d[key] for d in offsets] return retrieved_list def snake_case__ ( self : Dict ): __snake_case : int = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : List[str] = self._get_dummy_logits()[0] __snake_case : str = 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 snake_case__ ( self : List[str] ): __snake_case : Any = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = self._get_dummy_logits() __snake_case : int = 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 snake_case__ ( self : Optional[Any] ): import torch __snake_case : Optional[Any] = load_dataset("""common_voice""" , """en""" , split="""train""" , streaming=_lowerCAmelCase ) __snake_case : Any = ds.cast_column("""audio""" , datasets.Audio(sampling_rate=1_60_00 ) ) __snake_case : List[Any] = iter(_lowerCAmelCase ) __snake_case : Optional[int] = next(_lowerCAmelCase ) __snake_case : str = AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) __snake_case : str = 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 __snake_case : List[str] = processor(sample["""audio"""]["""array"""] , return_tensors="""pt""" ).input_values with torch.no_grad(): __snake_case : Dict = model(_lowerCAmelCase ).logits.cpu().numpy() __snake_case : Any = processor.decode(logits[0] , output_word_offsets=_lowerCAmelCase ) __snake_case : Optional[Any] = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate __snake_case : Dict = [ { """start_time""": d["""start_offset"""] * time_offset, """end_time""": d["""end_offset"""] * time_offset, """word""": d["""word"""], } for d in output["""word_offsets"""] ] __snake_case : Dict = """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 __snake_case : Dict = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """start_time""" ) ) __snake_case : Optional[Any] = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """end_time""" ) ) # fmt: off __snake_case : Optional[Any] = torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599] ) __snake_case : Optional[int] = torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94] ) # fmt: on self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) ) self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) )
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) lowercase_ = { "configuration_resnet": ["RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "ResNetConfig", "ResNetOnnxConfig"] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "RESNET_PRETRAINED_MODEL_ARCHIVE_LIST", "ResNetForImageClassification", "ResNetModel", "ResNetPreTrainedModel", "ResNetBackbone", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST", "TFResNetForImageClassification", "TFResNetModel", "TFResNetPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxResNetForImageClassification", "FlaxResNetModel", "FlaxResNetPreTrainedModel", ] if TYPE_CHECKING: from .configuration_resnet import RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ResNetConfig, ResNetOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_resnet import ( RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, ResNetBackbone, ResNetForImageClassification, ResNetModel, ResNetPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_resnet import ( TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFResNetForImageClassification, TFResNetModel, TFResNetPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel, FlaxResNetPreTrainedModel else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure)
20
import argparse import re import torch from CLAP import create_model from transformers import AutoFeatureExtractor, ClapConfig, ClapModel lowercase_ = { "text_branch": "text_model", "audio_branch": "audio_model.audio_encoder", "attn": "attention.self", "self.proj": "output.dense", "attention.self_mask": "attn_mask", "mlp.fc1": "intermediate.dense", "mlp.fc2": "output.dense", "norm1": "layernorm_before", "norm2": "layernorm_after", "bn0": "batch_norm", } lowercase_ = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc") def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any]=False ): '''simple docstring''' __snake_case , __snake_case : str = create_model( """HTSAT-tiny""" , """roberta""" , __SCREAMING_SNAKE_CASE , precision="""fp32""" , device="""cuda:0""" if torch.cuda.is_available() else """cpu""" , enable_fusion=__SCREAMING_SNAKE_CASE , fusion_type="""aff_2d""" if enable_fusion else None , ) return model, model_cfg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Union[str, Any] = {} __snake_case : List[Any] = R""".*sequential.(\d+).*""" __snake_case : Union[str, Any] = R""".*_projection.(\d+).*""" for key, value in state_dict.items(): # check if any key needs to be modified for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items(): if key_to_modify in key: __snake_case : Optional[Any] = key.replace(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): # replace sequential layers with list __snake_case : Optional[Any] = re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) __snake_case : Dict = key.replace(F'''sequential.{sequential_layer}.''' , F'''layers.{int(__SCREAMING_SNAKE_CASE )//3}.linear.''' ) elif re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : str = int(re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) ) # Because in CLAP they use `nn.Sequential`... __snake_case : List[Any] = 1 if projecton_layer == 0 else 2 __snake_case : Tuple = key.replace(F'''_projection.{projecton_layer}.''' , F'''_projection.linear{transformers_projection_layer}.''' ) if "audio" and "qkv" in key: # split qkv into query key and value __snake_case : Optional[int] = value __snake_case : Any = mixed_qkv.size(0 ) // 3 __snake_case : List[Any] = mixed_qkv[:qkv_dim] __snake_case : Tuple = mixed_qkv[qkv_dim : qkv_dim * 2] __snake_case : List[Any] = mixed_qkv[qkv_dim * 2 :] __snake_case : Any = query_layer __snake_case : Dict = key_layer __snake_case : Optional[Any] = value_layer else: __snake_case : List[str] = value return model_state_dict def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Optional[Any]=False ): '''simple docstring''' __snake_case , __snake_case : List[str] = init_clap(__SCREAMING_SNAKE_CASE , enable_fusion=__SCREAMING_SNAKE_CASE ) clap_model.eval() __snake_case : Tuple = clap_model.state_dict() __snake_case : Union[str, Any] = rename_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = ClapConfig() __snake_case : Tuple = enable_fusion __snake_case : Any = ClapModel(__SCREAMING_SNAKE_CASE ) # ignore the spectrogram embedding layer model.load_state_dict(__SCREAMING_SNAKE_CASE , strict=__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) transformers_config.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not") lowercase_ = parser.parse_args() convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
20
1
from __future__ import annotations from typing import Any def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if not postfix_notation: return 0 __snake_case : Union[str, Any] = {"""+""", """-""", """*""", """/"""} __snake_case : list[Any] = [] for token in postfix_notation: if token in operations: __snake_case , __snake_case : List[str] = stack.pop(), stack.pop() if token == "+": stack.append(a + b ) elif token == "-": stack.append(a - b ) elif token == "*": stack.append(a * b ) else: if a * b < 0 and a % b != 0: stack.append(a // b + 1 ) else: stack.append(a // b ) else: stack.append(int(__SCREAMING_SNAKE_CASE ) ) return stack.pop() if __name__ == "__main__": import doctest doctest.testmod()
20
import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = "▁" lowercase_ = {"vocab_file": "vocab.txt", "sentencepiece_model_ckpt": "sentencepiece.bpe.model"} lowercase_ = { "sentencepiece_model_file": "sentencepiece.bpe.model", "vocab_file": "vocab.txt", } lowercase_ = { "vocab_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", }, "sentencepiece_model_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", }, } lowercase_ = { "ernie-m-base": 5_14, "ernie-m-large": 5_14, } lowercase_ = { "ernie-m-base": {"do_lower_case": False}, "ernie-m-large": {"do_lower_case": False}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = ["input_ids"] A : Tuple = VOCAB_FILES_NAMES A : List[Any] = PRETRAINED_INIT_CONFIGURATION A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP A : Optional[Any] = RESOURCE_FILES_NAMES def __init__( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : Dict=False , _lowerCAmelCase : List[Any]="utf8" , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : Optional[int]="[SEP]" , _lowerCAmelCase : List[str]="[PAD]" , _lowerCAmelCase : Dict="[CLS]" , _lowerCAmelCase : List[Any]="[MASK]" , _lowerCAmelCase : Optional[Dict[str, Any]] = None , **_lowerCAmelCase : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. __snake_case : List[Any] = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , vocab_file=_lowerCAmelCase , encoding=_lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCAmelCase , ) __snake_case : List[Any] = do_lower_case __snake_case : Any = sentencepiece_model_ckpt __snake_case : int = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCAmelCase ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: __snake_case : int = self.load_vocab(filepath=_lowerCAmelCase ) else: __snake_case : Tuple = {self.sp_model.id_to_piece(_lowerCAmelCase ): id for id in range(self.sp_model.get_piece_size() )} __snake_case : str = {v: k for k, v in self.vocab.items()} def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[Any] ): if text is None: return None __snake_case : List[Any] = self.tokenize(_lowerCAmelCase ) __snake_case , __snake_case : Optional[Any] = """""", [] for i, ch in enumerate(_lowerCAmelCase ): if ch in self.SP_CHAR_MAPPING: __snake_case : Any = self.SP_CHAR_MAPPING.get(_lowerCAmelCase ) else: __snake_case : Dict = unicodedata.normalize("""NFKC""" , _lowerCAmelCase ) if self.is_whitespace(_lowerCAmelCase ): continue normalized_text += ch char_mapping.extend([i] * len(_lowerCAmelCase ) ) __snake_case , __snake_case , __snake_case : str = normalized_text, [], 0 if self.do_lower_case: __snake_case : int = text.lower() for token in split_tokens: if token[:1] == "▁": __snake_case : int = token[1:] __snake_case : Optional[int] = text[offset:].index(_lowerCAmelCase ) + offset __snake_case : int = start + len(_lowerCAmelCase ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) __snake_case : str = end return token_mapping @property def snake_case__ ( self : Tuple ): return len(self.vocab ) def snake_case__ ( self : Dict ): return dict(self.vocab , **self.added_tokens_encoder ) def __getstate__( self : int ): __snake_case : str = self.__dict__.copy() __snake_case : Union[str, Any] = None return state def __setstate__( self : Optional[Any] , _lowerCAmelCase : List[str] ): __snake_case : Union[str, Any] = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): __snake_case : Optional[Any] = {} __snake_case : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def snake_case__ ( self : str , _lowerCAmelCase : Optional[int] ): return "".join((self.SP_CHAR_MAPPING.get(_lowerCAmelCase , _lowerCAmelCase ) for c in text) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Optional[Any]=64 , _lowerCAmelCase : Optional[int]=0.1 ): if self.sp_model_kwargs.get("""enable_sampling""" ) is True: __snake_case : List[str] = True if self.sp_model_kwargs.get("""alpha""" ) is not None: __snake_case : Dict = self.sp_model_kwargs.get("""alpha""" ) if self.sp_model_kwargs.get("""nbest_size""" ) is not None: __snake_case : List[Any] = self.sp_model_kwargs.get("""nbest_size""" ) if not enable_sampling: __snake_case : str = self.sp_model.EncodeAsPieces(_lowerCAmelCase ) else: __snake_case : Tuple = self.sp_model.SampleEncodeAsPieces(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = [] for pi, piece in enumerate(_lowerCAmelCase ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(_lowerCAmelCase ) and pi != 0: new_pieces.append(_lowerCAmelCase ) continue else: continue __snake_case : Optional[int] = 0 for i, chunk in enumerate(_lowerCAmelCase ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(_lowerCAmelCase ) or self.is_punct(_lowerCAmelCase ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(_lowerCAmelCase ) __snake_case : Tuple = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : List[str] = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : Tuple = i if len(_lowerCAmelCase ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): __snake_case : int = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): __snake_case : int = self.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : Any = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): return self.vocab.get(_lowerCAmelCase , self.vocab.get(self.unk_token ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Dict ): return self.reverse_vocab.get(_lowerCAmelCase , self.unk_token ) def snake_case__ ( self : Any , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any]=None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] __snake_case : Optional[Any] = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None ): if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Optional[Any]=False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( """You should not supply a second sequence if the provided sequence of """ """ids is already formatted with special tokens for the model.""" ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] + ([0] * len(_lowerCAmelCase )) + [1] return [1] + ([0] * len(_lowerCAmelCase )) + [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method if token_ids_a is None: # [CLS] X [SEP] return (len(_lowerCAmelCase ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(_lowerCAmelCase ) + 1) + [1] * (len(_lowerCAmelCase ) + 3) def snake_case__ ( self : Tuple , _lowerCAmelCase : List[str] ): if "\u4e00" <= char <= "\u9fff": return True return False def snake_case__ ( self : List[str] , _lowerCAmelCase : Any ): if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def snake_case__ ( self : int , _lowerCAmelCase : List[Any] ): if char in ",;:.?!~,;:。?!《》【】": return True return False def snake_case__ ( self : str , _lowerCAmelCase : Optional[Any] ): if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(_lowerCAmelCase ) == 1: __snake_case : Dict = unicodedata.category(_lowerCAmelCase ) if cat == "Zs": return True return False def snake_case__ ( self : str , _lowerCAmelCase : List[Any] ): __snake_case : Dict = {} with io.open(_lowerCAmelCase , """r""" , encoding="""utf-8""" ) as f: for index, line in enumerate(_lowerCAmelCase ): __snake_case : Tuple = line.rstrip("""\n""" ) __snake_case : List[str] = int(_lowerCAmelCase ) return token_to_idx def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : Optional[int] = 0 if os.path.isdir(_lowerCAmelCase ): __snake_case : int = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) else: __snake_case : Optional[Any] = (filename_prefix + """-""" if filename_prefix else """""") + save_directory with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as writer: for token, token_index in sorted(self.vocab.items() , key=lambda _lowerCAmelCase : kv[1] ): if index != token_index: logger.warning( f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.''' """ Please check that the vocabulary is not corrupted!""" ) __snake_case : Union[str, Any] = token_index writer.write(token + """\n""" ) index += 1 __snake_case : List[Any] = os.path.join(_lowerCAmelCase , """sentencepiece.bpe.model""" ) with open(_lowerCAmelCase , """wb""" ) as fi: __snake_case : List[Any] = self.sp_model.serialized_model_proto() fi.write(_lowerCAmelCase ) return (vocab_file,)
20
1
from math import pi, sqrt def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if num <= 0: raise ValueError("""math domain error""" ) if num > 1_71.5: raise OverflowError("""math range error""" ) elif num - int(__SCREAMING_SNAKE_CASE ) not in (0, 0.5): raise NotImplementedError("""num must be an integer or a half-integer""" ) elif num == 0.5: return sqrt(__SCREAMING_SNAKE_CASE ) else: return 1.0 if num == 1 else (num - 1) * gamma(num - 1 ) def __lowerCAmelCase ( ): '''simple docstring''' assert gamma(0.5 ) == sqrt(__SCREAMING_SNAKE_CASE ) assert gamma(1 ) == 1.0 assert gamma(2 ) == 1.0 if __name__ == "__main__": from doctest import testmod testmod() lowercase_ = 1.0 while num: lowercase_ = float(input("Gamma of: ")) print(F'''gamma({num}) = {gamma(num)}''') print("\nEnter 0 to exit...")
20
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "xlm-mlm-en-2048": "https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json", "xlm-mlm-ende-1024": "https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json", "xlm-mlm-enfr-1024": "https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json", "xlm-mlm-enro-1024": "https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json", "xlm-mlm-tlm-xnli15-1024": "https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json", "xlm-mlm-xnli15-1024": "https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json", "xlm-clm-enfr-1024": "https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json", "xlm-clm-ende-1024": "https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json", "xlm-mlm-17-1280": "https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json", "xlm-mlm-100-1280": "https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = "xlm" A : List[str] = { "hidden_size": "emb_dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", "n_words": "vocab_size", # For backward compatibility } def __init__( self : List[Any] , _lowerCAmelCase : Optional[Any]=3_01_45 , _lowerCAmelCase : Optional[Any]=20_48 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : int=16 , _lowerCAmelCase : Tuple=0.1 , _lowerCAmelCase : List[Any]=0.1 , _lowerCAmelCase : str=True , _lowerCAmelCase : List[str]=False , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Dict=False , _lowerCAmelCase : Dict=1 , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Optional[Any]=5_12 , _lowerCAmelCase : List[Any]=20_48**-0.5 , _lowerCAmelCase : List[str]=1e-12 , _lowerCAmelCase : List[Any]=0.02 , _lowerCAmelCase : List[str]=0 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Dict=2 , _lowerCAmelCase : List[str]=3 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : Optional[int]=True , _lowerCAmelCase : Tuple="first" , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any=0.1 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : List[str]=5 , _lowerCAmelCase : Optional[Any]=0 , _lowerCAmelCase : Tuple=0 , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Union[str, Any]=0 , **_lowerCAmelCase : Tuple , ): __snake_case : Optional[Any] = vocab_size __snake_case : Tuple = emb_dim __snake_case : int = n_layers __snake_case : List[str] = n_heads __snake_case : Union[str, Any] = dropout __snake_case : Optional[int] = attention_dropout __snake_case : Optional[Any] = gelu_activation __snake_case : Tuple = sinusoidal_embeddings __snake_case : List[Any] = causal __snake_case : Dict = asm __snake_case : int = n_langs __snake_case : str = use_lang_emb __snake_case : Dict = layer_norm_eps __snake_case : List[Any] = bos_index __snake_case : Union[str, Any] = eos_index __snake_case : Dict = pad_index __snake_case : Any = unk_index __snake_case : Dict = mask_index __snake_case : Any = is_encoder __snake_case : Dict = max_position_embeddings __snake_case : Optional[Any] = embed_init_std __snake_case : List[Any] = init_std __snake_case : str = summary_type __snake_case : Optional[Any] = summary_use_proj __snake_case : str = summary_activation __snake_case : Optional[int] = summary_proj_to_labels __snake_case : Dict = summary_first_dropout __snake_case : Dict = start_n_top __snake_case : int = end_n_top __snake_case : str = mask_token_id __snake_case : int = lang_id if "n_words" in kwargs: __snake_case : Dict = kwargs["""n_words"""] super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Dict ): if self.task == "multiple-choice": __snake_case : Optional[int] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : Tuple = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis), ] )
20
1
# DISCLAIMER: This file is strongly influenced by https://github.com/yang-song/score_sde_pytorch import math from dataclasses import dataclass from typing import Optional, Tuple, Union import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin, SchedulerOutput @dataclass class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : torch.FloatTensor A : torch.FloatTensor class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , __UpperCamelCase ): A : str = 1 @register_to_config def __init__( self : Tuple , _lowerCAmelCase : int = 20_00 , _lowerCAmelCase : float = 0.15 , _lowerCAmelCase : float = 0.01 , _lowerCAmelCase : float = 1348.0 , _lowerCAmelCase : float = 1e-5 , _lowerCAmelCase : int = 1 , ): # standard deviation of the initial noise distribution __snake_case : List[str] = sigma_max # setable values __snake_case : Optional[int] = None self.set_sigmas(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Any , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : Optional[int] = None ): return sample def snake_case__ ( self : List[Any] , _lowerCAmelCase : int , _lowerCAmelCase : float = None , _lowerCAmelCase : Union[str, torch.device] = None ): __snake_case : str = sampling_eps if sampling_eps is not None else self.config.sampling_eps __snake_case : Optional[int] = torch.linspace(1 , _lowerCAmelCase , _lowerCAmelCase , device=_lowerCAmelCase ) def snake_case__ ( self : List[Any] , _lowerCAmelCase : int , _lowerCAmelCase : float = None , _lowerCAmelCase : float = None , _lowerCAmelCase : float = None ): __snake_case : List[Any] = sigma_min if sigma_min is not None else self.config.sigma_min __snake_case : str = sigma_max if sigma_max is not None else self.config.sigma_max __snake_case : Dict = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) __snake_case : Any = torch.exp(torch.linspace(math.log(_lowerCAmelCase ) , math.log(_lowerCAmelCase ) , _lowerCAmelCase ) ) __snake_case : Tuple = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def snake_case__ ( self : Dict , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : str ): return torch.where( timesteps == 0 , torch.zeros_like(t.to(timesteps.device ) ) , self.discrete_sigmas[timesteps - 1].to(timesteps.device ) , ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : int , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : Optional[torch.Generator] = None , _lowerCAmelCase : bool = True , ): if self.timesteps is None: raise ValueError( """`self.timesteps` is not set, you need to run 'set_timesteps' after creating the scheduler""" ) __snake_case : List[Any] = timestep * torch.ones( sample.shape[0] , device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) __snake_case : str = (timestep * (len(self.timesteps ) - 1)).long() # mps requires indices to be in the same device, so we use cpu as is the default with cuda __snake_case : List[str] = timesteps.to(self.discrete_sigmas.device ) __snake_case : Tuple = self.discrete_sigmas[timesteps].to(sample.device ) __snake_case : Union[str, Any] = self.get_adjacent_sigma(_lowerCAmelCase , _lowerCAmelCase ).to(sample.device ) __snake_case : str = torch.zeros_like(_lowerCAmelCase ) __snake_case : Dict = (sigma**2 - adjacent_sigma**2) ** 0.5 # equation 6 in the paper: the model_output modeled by the network is grad_x log pt(x) # also equation 47 shows the analog from SDE models to ancestral sampling methods __snake_case : Optional[Any] = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): __snake_case : List[str] = diffusion.unsqueeze(-1 ) __snake_case : Union[str, Any] = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of __snake_case : List[str] = randn_tensor( sample.shape , layout=sample.layout , generator=_lowerCAmelCase , device=sample.device , dtype=sample.dtype ) __snake_case : Dict = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? __snake_case : Dict = prev_sample_mean + diffusion * noise # add impact of diffusion field g if not return_dict: return (prev_sample, prev_sample_mean) return SdeVeOutput(prev_sample=_lowerCAmelCase , prev_sample_mean=_lowerCAmelCase ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : Optional[torch.Generator] = None , _lowerCAmelCase : bool = True , ): if self.timesteps is None: raise ValueError( """`self.timesteps` is not set, you need to run 'set_timesteps' after creating the scheduler""" ) # For small batch sizes, the paper "suggest replacing norm(z) with sqrt(d), where d is the dim. of z" # sample noise for correction __snake_case : str = randn_tensor(sample.shape , layout=sample.layout , generator=_lowerCAmelCase ).to(sample.device ) # compute step size from the model_output, the noise, and the snr __snake_case : Dict = torch.norm(model_output.reshape(model_output.shape[0] , -1 ) , dim=-1 ).mean() __snake_case : List[str] = torch.norm(noise.reshape(noise.shape[0] , -1 ) , dim=-1 ).mean() __snake_case : Union[str, Any] = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 __snake_case : List[str] = step_size * torch.ones(sample.shape[0] ).to(sample.device ) # self.repeat_scalar(step_size, sample.shape[0]) # compute corrected sample: model_output term and noise term __snake_case : Optional[Any] = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): __snake_case : str = step_size.unsqueeze(-1 ) __snake_case : Union[str, Any] = sample + step_size * model_output __snake_case : Union[str, Any] = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=_lowerCAmelCase ) def snake_case__ ( self : Tuple , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : torch.FloatTensor , ): # Make sure sigmas and timesteps have the same device and dtype as original_samples __snake_case : List[str] = timesteps.to(original_samples.device ) __snake_case : int = self.discrete_sigmas.to(original_samples.device )[timesteps] __snake_case : Tuple = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(_lowerCAmelCase ) * sigmas[:, None, None, None] ) __snake_case : str = noise + original_samples return noisy_samples def __len__( self : Tuple ): return self.config.num_train_timesteps
20
import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "facebook/encodec_24khz": "https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json", "facebook/encodec_48khz": "https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[Any] = "encodec" def __init__( self : Tuple , _lowerCAmelCase : Union[str, Any]=[1.5, 3.0, 6.0, 12.0, 24.0] , _lowerCAmelCase : Tuple=2_40_00 , _lowerCAmelCase : List[Any]=1 , _lowerCAmelCase : Optional[int]=False , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : int=1_28 , _lowerCAmelCase : List[Any]=32 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Union[str, Any]=[8, 5, 4, 2] , _lowerCAmelCase : str="weight_norm" , _lowerCAmelCase : Tuple=7 , _lowerCAmelCase : str=7 , _lowerCAmelCase : Any=3 , _lowerCAmelCase : int=2 , _lowerCAmelCase : str=True , _lowerCAmelCase : Dict="reflect" , _lowerCAmelCase : Tuple=2 , _lowerCAmelCase : List[Any]=2 , _lowerCAmelCase : int=1.0 , _lowerCAmelCase : Optional[int]=10_24 , _lowerCAmelCase : int=None , _lowerCAmelCase : List[str]=True , **_lowerCAmelCase : List[Any] , ): __snake_case : Optional[int] = target_bandwidths __snake_case : int = sampling_rate __snake_case : List[Any] = audio_channels __snake_case : str = normalize __snake_case : Union[str, Any] = chunk_length_s __snake_case : Union[str, Any] = overlap __snake_case : Union[str, Any] = hidden_size __snake_case : Union[str, Any] = num_filters __snake_case : Optional[Any] = num_residual_layers __snake_case : List[Any] = upsampling_ratios __snake_case : List[str] = norm_type __snake_case : Union[str, Any] = kernel_size __snake_case : Optional[int] = last_kernel_size __snake_case : Optional[Any] = residual_kernel_size __snake_case : Dict = dilation_growth_rate __snake_case : int = use_causal_conv __snake_case : Tuple = pad_mode __snake_case : str = compress __snake_case : Optional[Any] = num_lstm_layers __snake_case : List[Any] = trim_right_ratio __snake_case : Any = codebook_size __snake_case : int = codebook_dim if codebook_dim is not None else hidden_size __snake_case : int = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( f'''self.norm_type must be one of `"weight_norm"`, `"time_group_norm"`), got {self.norm_type}''' ) super().__init__(**_lowerCAmelCase ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def snake_case__ ( self : Tuple ): return int(10_00 * self.target_bandwidths[-1] // (self.frame_rate * 10) )
20
1
from collections import OrderedDict from typing import TYPE_CHECKING, Any, Mapping, Optional, Union from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging if TYPE_CHECKING: from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType lowercase_ = logging.get_logger(__name__) lowercase_ = { "microsoft/deberta-v2-xlarge": "https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json", "microsoft/deberta-v2-xxlarge": "https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json", "microsoft/deberta-v2-xlarge-mnli": ( "https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json" ), "microsoft/deberta-v2-xxlarge-mnli": ( "https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json" ), } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = "deberta-v2" def __init__( self : Dict , _lowerCAmelCase : Any=12_81_00 , _lowerCAmelCase : str=15_36 , _lowerCAmelCase : Any=24 , _lowerCAmelCase : int=24 , _lowerCAmelCase : List[str]=61_44 , _lowerCAmelCase : List[str]="gelu" , _lowerCAmelCase : Dict=0.1 , _lowerCAmelCase : Dict=0.1 , _lowerCAmelCase : List[Any]=5_12 , _lowerCAmelCase : Dict=0 , _lowerCAmelCase : List[str]=0.02 , _lowerCAmelCase : str=1e-7 , _lowerCAmelCase : List[str]=False , _lowerCAmelCase : str=-1 , _lowerCAmelCase : int=0 , _lowerCAmelCase : Any=True , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : Tuple=0 , _lowerCAmelCase : int="gelu" , **_lowerCAmelCase : int , ): super().__init__(**_lowerCAmelCase ) __snake_case : int = hidden_size __snake_case : str = num_hidden_layers __snake_case : List[Any] = num_attention_heads __snake_case : List[str] = intermediate_size __snake_case : str = hidden_act __snake_case : str = hidden_dropout_prob __snake_case : Union[str, Any] = attention_probs_dropout_prob __snake_case : List[str] = max_position_embeddings __snake_case : Tuple = type_vocab_size __snake_case : str = initializer_range __snake_case : Optional[Any] = relative_attention __snake_case : List[Any] = max_relative_positions __snake_case : Tuple = pad_token_id __snake_case : List[str] = position_biased_input # Backwards compatibility if type(_lowerCAmelCase ) == str: __snake_case : Dict = [x.strip() for x in pos_att_type.lower().split("""|""" )] __snake_case : Union[str, Any] = pos_att_type __snake_case : Optional[int] = vocab_size __snake_case : Union[str, Any] = layer_norm_eps __snake_case : Optional[int] = kwargs.get("""pooler_hidden_size""" , _lowerCAmelCase ) __snake_case : Optional[int] = pooler_dropout __snake_case : Optional[Any] = pooler_hidden_act class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Any ): if self.task == "multiple-choice": __snake_case : Optional[int] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : str = {0: """batch""", 1: """sequence"""} if self._config.type_vocab_size > 0: return OrderedDict( [("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis)] ) else: return OrderedDict([("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis)] ) @property def snake_case__ ( self : Optional[int] ): return 12 def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"] , _lowerCAmelCase : int = -1 , _lowerCAmelCase : int = -1 , _lowerCAmelCase : int = -1 , _lowerCAmelCase : bool = False , _lowerCAmelCase : Optional["TensorType"] = None , _lowerCAmelCase : int = 3 , _lowerCAmelCase : int = 40 , _lowerCAmelCase : int = 40 , _lowerCAmelCase : "PreTrainedTokenizerBase" = None , ): __snake_case : Any = super().generate_dummy_inputs(preprocessor=_lowerCAmelCase , framework=_lowerCAmelCase ) if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs: del dummy_inputs["token_type_ids"] return dummy_inputs
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : str = [] __snake_case , __snake_case : List[str] = input_list[low:mid], input_list[mid : high + 1] while left and right: result.append((left if left[0] <= right[0] else right).pop(0 ) ) __snake_case : List[Any] = result + left + right return input_list def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if len(__SCREAMING_SNAKE_CASE ) <= 1: return input_list __snake_case : Union[str, Any] = list(__SCREAMING_SNAKE_CASE ) # iteration for two-way merging __snake_case : Tuple = 2 while p <= len(__SCREAMING_SNAKE_CASE ): # getting low, high and middle value for merge-sort of single list for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = i + p - 1 __snake_case : Optional[Any] = (low + high + 1) // 2 __snake_case : str = merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # final merge of last two parts if p * 2 >= len(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = merge(__SCREAMING_SNAKE_CASE , 0 , __SCREAMING_SNAKE_CASE , len(__SCREAMING_SNAKE_CASE ) - 1 ) break p *= 2 return input_list if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() if user_input == "": lowercase_ = [] else: lowercase_ = [int(item.strip()) for item in user_input.split(",")] print(iter_merge_sort(unsorted))
20
1
from string import ascii_lowercase, ascii_uppercase def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' if not sentence: return "" __snake_case : str = dict(zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) return lower_to_upper.get(sentence[0] , sentence[0] ) + sentence[1:] if __name__ == "__main__": from doctest import testmod testmod()
20
import random import sys import numpy as np from matplotlib import pyplot as plt from matplotlib.colors import ListedColormap lowercase_ = "Usage of script: script_name <size_of_canvas:int>" lowercase_ = [0] * 1_00 + [1] * 10 random.shuffle(choice) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : List[str] = [[False for i in range(__SCREAMING_SNAKE_CASE )] for j in range(__SCREAMING_SNAKE_CASE )] return canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' for i, row in enumerate(__SCREAMING_SNAKE_CASE ): for j, _ in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : int = bool(random.getrandbits(1 ) ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Union[str, Any] = np.array(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = np.array(create_canvas(current_canvas.shape[0] ) ) for r, row in enumerate(__SCREAMING_SNAKE_CASE ): for c, pt in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : Optional[Any] = __judge_point( __SCREAMING_SNAKE_CASE , current_canvas[r - 1 : r + 2, c - 1 : c + 2] ) __snake_case : List[str] = next_gen_canvas del next_gen_canvas # cleaning memory as we move on. __snake_case : list[list[bool]] = current_canvas.tolist() return return_canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Any = 0 __snake_case : Dict = 0 # finding dead or alive neighbours count. for i in neighbours: for status in i: if status: alive += 1 else: dead += 1 # handling duplicate entry for focus pt. if pt: alive -= 1 else: dead -= 1 # running the rules of game here. __snake_case : str = pt if pt: if alive < 2: __snake_case : Optional[Any] = False elif alive == 2 or alive == 3: __snake_case : Union[str, Any] = True elif alive > 3: __snake_case : Optional[int] = False else: if alive == 3: __snake_case : List[Any] = True return state if __name__ == "__main__": if len(sys.argv) != 2: raise Exception(usage_doc) lowercase_ = int(sys.argv[1]) # main working structure of this module. lowercase_ = create_canvas(canvas_size) seed(c) lowercase_ , lowercase_ = plt.subplots() fig.show() lowercase_ = ListedColormap(["w", "k"]) try: while True: lowercase_ = run(c) ax.matshow(c, cmap=cmap) fig.canvas.draw() ax.cla() except KeyboardInterrupt: # do nothing. pass
20
1
import json from typing import List, Optional, Tuple from tokenizers import normalizers from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_roformer import RoFormerTokenizer from .tokenization_utils import JiebaPreTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": { "junnyu/roformer_chinese_small": "https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt", "junnyu/roformer_chinese_base": "https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt", "junnyu/roformer_chinese_char_small": ( "https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt" ), "junnyu/roformer_chinese_char_base": ( "https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt" ), "junnyu/roformer_small_discriminator": ( "https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt" ), "junnyu/roformer_small_generator": ( "https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt" ), } } lowercase_ = { "junnyu/roformer_chinese_small": 15_36, "junnyu/roformer_chinese_base": 15_36, "junnyu/roformer_chinese_char_small": 5_12, "junnyu/roformer_chinese_char_base": 5_12, "junnyu/roformer_small_discriminator": 1_28, "junnyu/roformer_small_generator": 1_28, } lowercase_ = { "junnyu/roformer_chinese_small": {"do_lower_case": True}, "junnyu/roformer_chinese_base": {"do_lower_case": True}, "junnyu/roformer_chinese_char_small": {"do_lower_case": True}, "junnyu/roformer_chinese_char_base": {"do_lower_case": True}, "junnyu/roformer_small_discriminator": {"do_lower_case": True}, "junnyu/roformer_small_generator": {"do_lower_case": True}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = VOCAB_FILES_NAMES A : Optional[int] = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : int = PRETRAINED_INIT_CONFIGURATION A : List[str] = RoFormerTokenizer def __init__( self : Optional[Any] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any="[UNK]" , _lowerCAmelCase : int="[SEP]" , _lowerCAmelCase : Optional[int]="[PAD]" , _lowerCAmelCase : Optional[int]="[CLS]" , _lowerCAmelCase : Optional[Any]="[MASK]" , _lowerCAmelCase : Optional[Any]=True , _lowerCAmelCase : Optional[Any]=None , **_lowerCAmelCase : Dict , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Dict = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( pre_tok_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or pre_tok_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents ): __snake_case : Tuple = getattr(_lowerCAmelCase , pre_tok_state.pop("""type""" ) ) __snake_case : List[Any] = do_lower_case __snake_case : Optional[Any] = strip_accents __snake_case : List[str] = pre_tok_class(**_lowerCAmelCase ) __snake_case : Optional[Any] = do_lower_case def __getstate__( self : Optional[Any] ): __snake_case : Optional[int] = self.__dict__.copy() __snake_case : Optional[Any] = BertPreTokenizer() return state def __setstate__( self : str , _lowerCAmelCase : Dict ): __snake_case : str = d __snake_case : int = self.__dict__["""_tokenizer"""].get_vocab() __snake_case : List[str] = PreTokenizer.custom(JiebaPreTokenizer(_lowerCAmelCase ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int]=None ): __snake_case : Dict = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : Optional[int] = [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : int = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase ) def snake_case__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Tuple=None , _lowerCAmelCase : Union[str, Any]=False , **_lowerCAmelCase : Tuple , ): __snake_case : Tuple = BertPreTokenizer() return super().save_pretrained(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase )
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def __lowerCAmelCase ( *__SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Optional[Union[Dict, Any]] = None , __SCREAMING_SNAKE_CASE : Any=True , __SCREAMING_SNAKE_CASE : int=2 ): '''simple docstring''' from .. import __version__ __snake_case : List[Any] = take_from __snake_case : List[Any] = () if not isinstance(args[0] , __SCREAMING_SNAKE_CASE ): __snake_case : str = (args,) for attribute, version_name, message in args: if version.parse(version.parse(__SCREAMING_SNAKE_CASE ).base_version ) >= version.parse(__SCREAMING_SNAKE_CASE ): raise ValueError( F'''The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers\'''' F''' version {__version__} is >= {version_name}''' ) __snake_case : Optional[Any] = None if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(__SCREAMING_SNAKE_CASE ),) __snake_case : Optional[Any] = F'''The `{attribute}` argument is deprecated and will be removed in version {version_name}.''' elif hasattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): values += (getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ),) __snake_case : Any = F'''The `{attribute}` attribute is deprecated and will be removed in version {version_name}.''' elif deprecated_kwargs is None: __snake_case : Tuple = F'''`{attribute}` is deprecated and will be removed in version {version_name}.''' if warning is not None: __snake_case : Optional[Any] = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , __SCREAMING_SNAKE_CASE , stacklevel=__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and len(__SCREAMING_SNAKE_CASE ) > 0: __snake_case : Dict = inspect.getouterframes(inspect.currentframe() )[1] __snake_case : int = call_frame.filename __snake_case : int = call_frame.lineno __snake_case : List[str] = call_frame.function __snake_case , __snake_case : List[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(F'''{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`''' ) if len(__SCREAMING_SNAKE_CASE ) == 0: return elif len(__SCREAMING_SNAKE_CASE ) == 1: return values[0] return values
20
1
import json import os import shutil import tempfile import unittest import numpy as np from transformers import BertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer from transformers.testing_utils import require_tokenizers, require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor @require_tokenizers @require_vision class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : List[Any] ): __snake_case : List[str] = tempfile.mkdtemp() # fmt: off __snake_case : Dict = ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest"""] # fmt: on __snake_case : Dict = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) __snake_case : Union[str, Any] = { """do_resize""": True, """size""": {"""height""": 18, """width""": 18}, """do_normalize""": True, """image_mean""": [0.5, 0.5, 0.5], """image_std""": [0.5, 0.5, 0.5], } __snake_case : List[Any] = os.path.join(self.tmpdirname , _lowerCAmelCase ) with open(self.image_processor_file , """w""" , encoding="""utf-8""" ) as fp: json.dump(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : Dict ): return BertTokenizer.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : List[Any] ): return ViTImageProcessor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Tuple ): __snake_case : int = [np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta )] __snake_case : int = [Image.fromarray(np.moveaxis(_lowerCAmelCase , 0 , -1 ) ) for x in image_inputs] return image_inputs def snake_case__ ( self : Any ): __snake_case : Dict = self.get_tokenizer() __snake_case : List[str] = self.get_image_processor() __snake_case : Optional[int] = VisionTextDualEncoderProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) __snake_case : int = VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.tokenizer , (BertTokenizer, BertTokenizerFast) ) self.assertEqual(processor.image_processor.to_json_string() , image_processor.to_json_string() ) self.assertIsInstance(processor.image_processor , _lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : Union[str, Any] = VisionTextDualEncoderProcessor( tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) __snake_case : List[str] = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) __snake_case : Tuple = self.get_image_processor(do_normalize=_lowerCAmelCase , padding_value=1.0 ) __snake_case : Optional[int] = VisionTextDualEncoderProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=_lowerCAmelCase , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , (BertTokenizer, BertTokenizerFast) ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , _lowerCAmelCase ) def snake_case__ ( self : Optional[int] ): __snake_case : Optional[int] = self.get_image_processor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Union[str, Any] = VisionTextDualEncoderProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : List[Any] = self.prepare_image_inputs() __snake_case : Optional[Any] = image_processor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : List[Any] = processor(images=_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 snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = self.get_image_processor() __snake_case : Tuple = self.get_tokenizer() __snake_case : str = VisionTextDualEncoderProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : Dict = """lower newer""" __snake_case : Dict = processor(text=_lowerCAmelCase ) __snake_case : int = tokenizer(_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : Tuple ): __snake_case : Any = self.get_image_processor() __snake_case : Any = self.get_tokenizer() __snake_case : List[str] = VisionTextDualEncoderProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : Any = """lower newer""" __snake_case : Optional[Any] = self.prepare_image_inputs() __snake_case : Dict = processor(text=_lowerCAmelCase , images=_lowerCAmelCase ) self.assertListEqual(list(inputs.keys() ) , ["""input_ids""", """token_type_ids""", """attention_mask""", """pixel_values"""] ) # test if it raises when no input is passed with self.assertRaises(_lowerCAmelCase ): processor() def snake_case__ ( self : int ): __snake_case : Any = self.get_image_processor() __snake_case : Optional[Any] = self.get_tokenizer() __snake_case : Optional[Any] = VisionTextDualEncoderProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : int = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] __snake_case : List[Any] = processor.batch_decode(_lowerCAmelCase ) __snake_case : Any = tokenizer.batch_decode(_lowerCAmelCase ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Any ): __snake_case : str = self.get_image_processor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Union[str, Any] = VisionTextDualEncoderProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : str = """lower newer""" __snake_case : int = self.prepare_image_inputs() __snake_case : int = processor(text=_lowerCAmelCase , images=_lowerCAmelCase ) self.assertListEqual(list(inputs.keys() ) , processor.model_input_names )
20
import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() lowercase_ = { "bart": ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), "bert": ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-uncased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-cased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-base-cased-finetuned-mrpc": ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "dpr": ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), "gpt2": ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlnet": ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm": ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm-roberta": ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "transfo-xl": ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "openai-gpt": ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "roberta": ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "layoutlm": ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), "roberta-large-mnli": ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "camembert": ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "flaubert": ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert": ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert-base-distilled-squad": ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert": ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert-visual-feature-encoder": ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "ctrl": ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "albert": ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "t5": ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "electra": ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "wav2vec2": ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str]=False , __SCREAMING_SNAKE_CASE : List[Any]=True ): '''simple docstring''' if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case : Any = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) __snake_case : Dict = config_class.from_json_file(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = True __snake_case : Union[str, Any] = True print(F'''Building TensorFlow model from configuration: {config}''' ) __snake_case : List[Any] = model_class(__SCREAMING_SNAKE_CASE ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): __snake_case : Optional[Any] = cached_file( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: __snake_case : List[Any] = load_pytorch_checkpoint_in_tfa_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if compare_with_pt_model: __snake_case : Tuple = tf_model(tf_model.dummy_inputs , training=__SCREAMING_SNAKE_CASE ) # build the network __snake_case : List[str] = torch.load(__SCREAMING_SNAKE_CASE , map_location="""cpu""" ) __snake_case : Any = pt_model_class.from_pretrained( pretrained_model_name_or_path=__SCREAMING_SNAKE_CASE , config=__SCREAMING_SNAKE_CASE , state_dict=__SCREAMING_SNAKE_CASE ) with torch.no_grad(): __snake_case : Union[str, Any] = pt_model(**pt_model.dummy_inputs ) __snake_case : Any = pto[0].numpy() __snake_case : Optional[int] = tfo[0].numpy() __snake_case : Optional[int] = np.amax(np.abs(np_pt - np_tf ) ) print(F'''Max absolute difference between models outputs {diff}''' ) assert diff <= 2E-2, F'''Error, model absolute difference is >2e-2: {diff}''' # Save pytorch-model print(F'''Save TensorFlow model to {tf_dump_path}''' ) tf_model.save_weights(__SCREAMING_SNAKE_CASE , save_format="""h5""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : List[str]=None , __SCREAMING_SNAKE_CASE : Any=None , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : List[Any]=False , __SCREAMING_SNAKE_CASE : Any=False , ): '''simple docstring''' if args_model_type is None: __snake_case : Tuple = list(MODEL_CLASSES.keys() ) else: __snake_case : Union[str, Any] = [args_model_type] for j, model_type in enumerate(__SCREAMING_SNAKE_CASE , start=1 ): print("""=""" * 1_0_0 ) print(F''' Converting model type {j}/{len(__SCREAMING_SNAKE_CASE )}: {model_type}''' ) print("""=""" * 1_0_0 ) if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case , __snake_case : Optional[int] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: __snake_case : int = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: __snake_case : Union[str, Any] = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , start=1 ): print("""-""" * 1_0_0 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(F''' Skipping finetuned checkpoint {model_shortcut_name}''' ) continue __snake_case : List[Any] = model_shortcut_name elif only_convert_finetuned_models: print(F''' Skipping not finetuned checkpoint {model_shortcut_name}''' ) continue print( F''' Converting checkpoint {i}/{len(__SCREAMING_SNAKE_CASE )}: {model_shortcut_name} - model_type {model_type}''' ) print("""-""" * 1_0_0 ) if config_shortcut_name in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : Dict = config_shortcut_name if model_shortcut_name in aws_model_maps: __snake_case : Union[str, Any] = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : List[Any] = model_shortcut_name if os.path.isfile(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = """converted_model""" convert_pt_checkpoint_to_tf( model_type=__SCREAMING_SNAKE_CASE , pytorch_checkpoint_path=__SCREAMING_SNAKE_CASE , config_file=__SCREAMING_SNAKE_CASE , tf_dump_path=os.path.join(__SCREAMING_SNAKE_CASE , model_shortcut_name + """-tf_model.h5""" ) , compare_with_pt_model=__SCREAMING_SNAKE_CASE , ) if remove_cached_files: os.remove(__SCREAMING_SNAKE_CASE ) os.remove(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--tf_dump_path", default=None, type=str, required=True, help="Path to the output Tensorflow dump file." ) parser.add_argument( "--model_type", default=None, type=str, help=( F'''Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ''' "convert all the models from AWS." ), ) parser.add_argument( "--pytorch_checkpoint_path", default=None, type=str, help=( "Path to the PyTorch checkpoint path or shortcut name to download from AWS. " "If not given, will download and convert all the checkpoints from AWS." ), ) parser.add_argument( "--config_file", default=None, type=str, help=( "The config json file corresponding to the pre-trained model. \n" "This specifies the model architecture. If not given and " "--pytorch_checkpoint_path is not given or is a shortcut name " "use the configuration associated to the shortcut name on the AWS" ), ) parser.add_argument( "--compare_with_pt_model", action="store_true", help="Compare Tensorflow and PyTorch model predictions." ) parser.add_argument( "--use_cached_models", action="store_true", help="Use cached models if possible instead of updating to latest checkpoint versions.", ) parser.add_argument( "--remove_cached_files", action="store_true", help="Remove pytorch models after conversion (save memory when converting in batches).", ) parser.add_argument("--only_convert_finetuned_models", action="store_true", help="Only convert finetuned models.") lowercase_ = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
20
1
import time import warnings from abc import ABC from copy import deepcopy from typing import Optional import torch from ..utils import add_start_docstrings, logging lowercase_ = logging.get_logger(__name__) lowercase_ = r"\n Args:\n input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):\n Indices of input sequence tokens in the vocabulary.\n\n Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n [`PreTrainedTokenizer.__call__`] for details.\n\n [What are input IDs?](../glossary#input-ids)\n scores (`torch.FloatTensor` of shape `(batch_size, config.vocab_size)`):\n Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax\n or scores for each vocabulary token after SoftMax.\n kwargs (`Dict[str, Any]`, *optional*):\n Additional stopping criteria specific kwargs.\n\n Return:\n `bool`. `False` indicates we should continue, `True` indicates we should stop.\n\n" class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @add_start_docstrings(_lowerCAmelCase ) def __call__( self : Optional[Any] , _lowerCAmelCase : torch.LongTensor , _lowerCAmelCase : torch.FloatTensor , **_lowerCAmelCase : str ): raise NotImplementedError("""StoppingCriteria needs to be subclassed""" ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : List[str] , _lowerCAmelCase : int , _lowerCAmelCase : Optional[int] = None ): __snake_case : str = max_length __snake_case : Any = max_position_embeddings @add_start_docstrings(_lowerCAmelCase ) def __call__( self : Tuple , _lowerCAmelCase : torch.LongTensor , _lowerCAmelCase : torch.FloatTensor , **_lowerCAmelCase : Union[str, Any] ): __snake_case : int = input_ids.shape[-1] __snake_case : Tuple = cur_len >= self.max_length if self.max_position_embeddings is not None and not is_done and cur_len >= self.max_position_embeddings: logger.warning_once( """This is a friendly reminder - the current text generation call will exceed the model's predefined """ f'''maximum length ({self.max_position_embeddings}). Depending on the model, you may observe ''' """exceptions, performance degradation, or nothing at all.""" ) return is_done class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : List[str] , _lowerCAmelCase : int , _lowerCAmelCase : int ): warnings.warn( """The class `MaxNewTokensCriteria` is deprecated. """ f'''Please use `MaxLengthCriteria(max_length={start_length + max_new_tokens})` ''' """with `max_length = start_length + max_new_tokens` instead.""" , _lowerCAmelCase , ) __snake_case : Tuple = start_length __snake_case : Dict = max_new_tokens __snake_case : Any = start_length + max_new_tokens @add_start_docstrings(_lowerCAmelCase ) def __call__( self : Tuple , _lowerCAmelCase : torch.LongTensor , _lowerCAmelCase : torch.FloatTensor , **_lowerCAmelCase : List[Any] ): return input_ids.shape[-1] >= self.max_length class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : List[str] , _lowerCAmelCase : float , _lowerCAmelCase : Optional[float] = None ): __snake_case : Union[str, Any] = max_time __snake_case : List[Any] = time.time() if initial_timestamp is None else initial_timestamp @add_start_docstrings(_lowerCAmelCase ) def __call__( self : int , _lowerCAmelCase : torch.LongTensor , _lowerCAmelCase : torch.FloatTensor , **_lowerCAmelCase : str ): return time.time() - self.initial_timestamp > self.max_time class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @add_start_docstrings(_lowerCAmelCase ) def __call__( self : str , _lowerCAmelCase : torch.LongTensor , _lowerCAmelCase : torch.FloatTensor , **_lowerCAmelCase : List[str] ): return any(criteria(_lowerCAmelCase , _lowerCAmelCase ) for criteria in self ) @property def snake_case__ ( self : Union[str, Any] ): for stopping_criterium in self: if isinstance(_lowerCAmelCase , _lowerCAmelCase ): return stopping_criterium.max_length elif isinstance(_lowerCAmelCase , _lowerCAmelCase ): return stopping_criterium.max_length return None def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : StoppingCriteriaList , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : List[Any] = stopping_criteria.max_length __snake_case : Optional[Any] = deepcopy(__SCREAMING_SNAKE_CASE ) if stopping_max_length is not None and stopping_max_length != max_length: warnings.warn("""You set different `max_length` for stopping criteria and `max_length` parameter""" , __SCREAMING_SNAKE_CASE ) elif stopping_max_length is None: new_stopping_criteria.append(MaxLengthCriteria(max_length=__SCREAMING_SNAKE_CASE ) ) return new_stopping_criteria
20
import random def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case , __snake_case , __snake_case : Tuple = [], [], [] for element in data: if element < pivot: less.append(__SCREAMING_SNAKE_CASE ) elif element > pivot: greater.append(__SCREAMING_SNAKE_CASE ) else: equal.append(__SCREAMING_SNAKE_CASE ) return less, equal, greater def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' # index = len(items) // 2 when trying to find the median # (value of index when items is sorted) # invalid input if index >= len(__SCREAMING_SNAKE_CASE ) or index < 0: return None __snake_case : int = items[random.randint(0 , len(__SCREAMING_SNAKE_CASE ) - 1 )] __snake_case : Tuple = 0 __snake_case , __snake_case , __snake_case : List[str] = _partition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = len(__SCREAMING_SNAKE_CASE ) __snake_case : int = len(__SCREAMING_SNAKE_CASE ) # index is the pivot if m <= index < m + count: return pivot # must be in smaller elif m > index: return quick_select(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # must be in larger else: return quick_select(__SCREAMING_SNAKE_CASE , index - (m + count) )
20
1
import numpy as np from matplotlib import pyplot as plt from sklearn.datasets import load_iris from sklearn.metrics import ConfusionMatrixDisplay from sklearn.model_selection import train_test_split from xgboost import XGBClassifier def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : dict ): '''simple docstring''' return (data["data"], data["target"]) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : np.ndarray , __SCREAMING_SNAKE_CASE : np.ndarray ): '''simple docstring''' __snake_case : Optional[Any] = XGBClassifier() classifier.fit(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) return classifier def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Any = load_iris() __snake_case , __snake_case : Union[str, Any] = data_handling(__SCREAMING_SNAKE_CASE ) __snake_case , __snake_case , __snake_case , __snake_case : int = train_test_split( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , test_size=0.25 ) __snake_case : Optional[Any] = iris["""target_names"""] # Create an XGBoost Classifier from the training data __snake_case : List[Any] = xgboost(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # Display the confusion matrix of the classifier with both training and test sets ConfusionMatrixDisplay.from_estimator( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , display_labels=__SCREAMING_SNAKE_CASE , cmap="""Blues""" , normalize="""true""" , ) plt.title("""Normalized Confusion Matrix - IRIS Dataset""" ) plt.show() if __name__ == "__main__": import doctest doctest.testmod(verbose=True) main()
20
import json from typing import List, Optional, Tuple from tokenizers import normalizers from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_roformer import RoFormerTokenizer from .tokenization_utils import JiebaPreTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": { "junnyu/roformer_chinese_small": "https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt", "junnyu/roformer_chinese_base": "https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt", "junnyu/roformer_chinese_char_small": ( "https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt" ), "junnyu/roformer_chinese_char_base": ( "https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt" ), "junnyu/roformer_small_discriminator": ( "https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt" ), "junnyu/roformer_small_generator": ( "https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt" ), } } lowercase_ = { "junnyu/roformer_chinese_small": 15_36, "junnyu/roformer_chinese_base": 15_36, "junnyu/roformer_chinese_char_small": 5_12, "junnyu/roformer_chinese_char_base": 5_12, "junnyu/roformer_small_discriminator": 1_28, "junnyu/roformer_small_generator": 1_28, } lowercase_ = { "junnyu/roformer_chinese_small": {"do_lower_case": True}, "junnyu/roformer_chinese_base": {"do_lower_case": True}, "junnyu/roformer_chinese_char_small": {"do_lower_case": True}, "junnyu/roformer_chinese_char_base": {"do_lower_case": True}, "junnyu/roformer_small_discriminator": {"do_lower_case": True}, "junnyu/roformer_small_generator": {"do_lower_case": True}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = VOCAB_FILES_NAMES A : Optional[int] = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : int = PRETRAINED_INIT_CONFIGURATION A : List[str] = RoFormerTokenizer def __init__( self : Optional[Any] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any="[UNK]" , _lowerCAmelCase : int="[SEP]" , _lowerCAmelCase : Optional[int]="[PAD]" , _lowerCAmelCase : Optional[int]="[CLS]" , _lowerCAmelCase : Optional[Any]="[MASK]" , _lowerCAmelCase : Optional[Any]=True , _lowerCAmelCase : Optional[Any]=None , **_lowerCAmelCase : Dict , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Dict = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( pre_tok_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or pre_tok_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents ): __snake_case : Tuple = getattr(_lowerCAmelCase , pre_tok_state.pop("""type""" ) ) __snake_case : List[Any] = do_lower_case __snake_case : Optional[Any] = strip_accents __snake_case : List[str] = pre_tok_class(**_lowerCAmelCase ) __snake_case : Optional[Any] = do_lower_case def __getstate__( self : Optional[Any] ): __snake_case : Optional[int] = self.__dict__.copy() __snake_case : Optional[Any] = BertPreTokenizer() return state def __setstate__( self : str , _lowerCAmelCase : Dict ): __snake_case : str = d __snake_case : int = self.__dict__["""_tokenizer"""].get_vocab() __snake_case : List[str] = PreTokenizer.custom(JiebaPreTokenizer(_lowerCAmelCase ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int]=None ): __snake_case : Dict = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : Optional[int] = [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : int = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase ) def snake_case__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Tuple=None , _lowerCAmelCase : Union[str, Any]=False , **_lowerCAmelCase : Tuple , ): __snake_case : Tuple = BertPreTokenizer() return super().save_pretrained(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase )
20
1
import os import sys import unittest lowercase_ = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, "utils")) import get_test_info # noqa: E402 from get_test_info import ( # noqa: E402 get_model_to_test_mapping, get_model_to_tester_mapping, get_test_to_tester_mapping, ) lowercase_ = os.path.join("tests", "models", "bert", "test_modeling_bert.py") lowercase_ = os.path.join("tests", "models", "blip", "test_modeling_blip.py") class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Optional[Any] ): __snake_case : List[str] = get_test_to_tester_mapping(_lowerCAmelCase ) __snake_case : Optional[Any] = get_test_to_tester_mapping(_lowerCAmelCase ) __snake_case : Optional[int] = {"""BertModelTest""": """BertModelTester"""} __snake_case : Dict = { """BlipModelTest""": """BlipModelTester""", """BlipTextImageModelTest""": """BlipTextImageModelsModelTester""", """BlipTextModelTest""": """BlipTextModelTester""", """BlipTextRetrievalModelTest""": """BlipTextRetrievalModelTester""", """BlipVQAModelTest""": """BlipVQAModelTester""", """BlipVisionModelTest""": """BlipVisionModelTester""", } self.assertEqual(get_test_info.to_json(_lowerCAmelCase ) , _lowerCAmelCase ) self.assertEqual(get_test_info.to_json(_lowerCAmelCase ) , _lowerCAmelCase ) def snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = get_model_to_test_mapping(_lowerCAmelCase ) __snake_case : Optional[Any] = get_model_to_test_mapping(_lowerCAmelCase ) __snake_case : List[str] = { """BertForMaskedLM""": ["""BertModelTest"""], """BertForMultipleChoice""": ["""BertModelTest"""], """BertForNextSentencePrediction""": ["""BertModelTest"""], """BertForPreTraining""": ["""BertModelTest"""], """BertForQuestionAnswering""": ["""BertModelTest"""], """BertForSequenceClassification""": ["""BertModelTest"""], """BertForTokenClassification""": ["""BertModelTest"""], """BertLMHeadModel""": ["""BertModelTest"""], """BertModel""": ["""BertModelTest"""], } __snake_case : str = { """BlipForConditionalGeneration""": ["""BlipTextImageModelTest"""], """BlipForImageTextRetrieval""": ["""BlipTextRetrievalModelTest"""], """BlipForQuestionAnswering""": ["""BlipVQAModelTest"""], """BlipModel""": ["""BlipModelTest"""], """BlipTextModel""": ["""BlipTextModelTest"""], """BlipVisionModel""": ["""BlipVisionModelTest"""], } self.assertEqual(get_test_info.to_json(_lowerCAmelCase ) , _lowerCAmelCase ) self.assertEqual(get_test_info.to_json(_lowerCAmelCase ) , _lowerCAmelCase ) def snake_case__ ( self : List[str] ): __snake_case : Any = get_model_to_tester_mapping(_lowerCAmelCase ) __snake_case : Any = get_model_to_tester_mapping(_lowerCAmelCase ) __snake_case : Dict = { """BertForMaskedLM""": ["""BertModelTester"""], """BertForMultipleChoice""": ["""BertModelTester"""], """BertForNextSentencePrediction""": ["""BertModelTester"""], """BertForPreTraining""": ["""BertModelTester"""], """BertForQuestionAnswering""": ["""BertModelTester"""], """BertForSequenceClassification""": ["""BertModelTester"""], """BertForTokenClassification""": ["""BertModelTester"""], """BertLMHeadModel""": ["""BertModelTester"""], """BertModel""": ["""BertModelTester"""], } __snake_case : str = { """BlipForConditionalGeneration""": ["""BlipTextImageModelsModelTester"""], """BlipForImageTextRetrieval""": ["""BlipTextRetrievalModelTester"""], """BlipForQuestionAnswering""": ["""BlipVQAModelTester"""], """BlipModel""": ["""BlipModelTester"""], """BlipTextModel""": ["""BlipTextModelTester"""], """BlipVisionModel""": ["""BlipVisionModelTester"""], } self.assertEqual(get_test_info.to_json(_lowerCAmelCase ) , _lowerCAmelCase ) self.assertEqual(get_test_info.to_json(_lowerCAmelCase ) , _lowerCAmelCase )
20
from __future__ import annotations import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if depth < 0: raise ValueError("""Depth cannot be less than 0""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: raise ValueError("""Scores cannot be empty""" ) if depth == height: return scores[node_index] if is_max: return max( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) return min( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : str = [9_0, 2_3, 6, 3_3, 2_1, 6_5, 1_2_3, 3_4_4_2_3] __snake_case : Optional[Any] = math.log(len(__SCREAMING_SNAKE_CASE ) , 2 ) print("""Optimal value : """ , end="""""" ) print(minimax(0 , 0 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
20
1
import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType lowercase_ = None lowercase_ = "<" if sys.byteorder == "little" else ">" # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image lowercase_ = [ np.dtype("|b1"), np.dtype("|u1"), np.dtype("<u2"), np.dtype(">u2"), np.dtype("<i2"), np.dtype(">i2"), np.dtype("<u4"), np.dtype(">u4"), np.dtype("<i4"), np.dtype(">i4"), np.dtype("<f4"), np.dtype(">f4"), np.dtype("<f8"), np.dtype(">f8"), ] @dataclass class SCREAMING_SNAKE_CASE__ : A : bool = True A : Optional[str] = None # Automatically constructed A : ClassVar[str] = "PIL.Image.Image" A : ClassVar[Any] = pa.struct({"bytes": pa.binary(), "path": pa.string()} ) A : str = field(default="Image" , init=__UpperCamelCase , repr=__UpperCamelCase ) def __call__( self : Any ): return self.pa_type def snake_case__ ( self : List[Any] , _lowerCAmelCase : Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] ): if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : str = np.array(_lowerCAmelCase ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": value, "bytes": None} elif isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": None, "bytes": value} elif isinstance(_lowerCAmelCase , np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(_lowerCAmelCase ) elif isinstance(_lowerCAmelCase , PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(_lowerCAmelCase ) elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("""path""" )} elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )} else: raise ValueError( f'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''' ) def snake_case__ ( self : List[str] , _lowerCAmelCase : dict , _lowerCAmelCase : Dict=None ): if not self.decode: raise RuntimeError("""Decoding is disabled for this feature. Please use Image(decode=True) instead.""" ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support decoding images, please install 'Pillow'.""" ) if token_per_repo_id is None: __snake_case : Tuple = {} __snake_case , __snake_case : str = value["""path"""], value["""bytes"""] if bytes_ is None: if path is None: raise ValueError(f'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.''' ) else: if is_local_path(_lowerCAmelCase ): __snake_case : str = PIL.Image.open(_lowerCAmelCase ) else: __snake_case : List[str] = path.split("""::""" )[-1] try: __snake_case : Dict = string_to_dict(_lowerCAmelCase , config.HUB_DATASETS_URL )["""repo_id"""] __snake_case : int = token_per_repo_id.get(_lowerCAmelCase ) except ValueError: __snake_case : List[Any] = None with xopen(_lowerCAmelCase , """rb""" , use_auth_token=_lowerCAmelCase ) as f: __snake_case : Union[str, Any] = BytesIO(f.read() ) __snake_case : Dict = PIL.Image.open(bytes_ ) else: __snake_case : Optional[Any] = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def snake_case__ ( self : Union[str, Any] ): from .features import Value return ( self if self.decode else { "bytes": Value("""binary""" ), "path": Value("""string""" ), } ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Union[pa.StringArray, pa.StructArray, pa.ListArray] ): if pa.types.is_string(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, storage] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays([storage, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("""bytes""" ) >= 0: __snake_case : List[str] = storage.field("""bytes""" ) else: __snake_case : List[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) if storage.type.get_field_index("""path""" ) >= 0: __snake_case : Optional[int] = storage.field("""path""" ) else: __snake_case : int = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : Tuple = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_list(storage.type ): __snake_case : Optional[Any] = pa.array( [encode_np_array(np.array(_lowerCAmelCase ) )["""bytes"""] if arr is not None else None for arr in storage.to_pylist()] , type=pa.binary() , ) __snake_case : Optional[int] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays( [bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : pa.StructArray ): @no_op_if_value_is_null def path_to_bytes(_lowerCAmelCase : Tuple ): with xopen(_lowerCAmelCase , """rb""" ) as f: __snake_case : Optional[int] = f.read() return bytes_ __snake_case : Tuple = pa.array( [ (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) __snake_case : Optional[Any] = pa.array( [os.path.basename(_lowerCAmelCase ) if path is not None else None for path in storage.field("""path""" ).to_pylist()] , type=pa.string() , ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def __lowerCAmelCase ( ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() __snake_case : Optional[Any] = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' __snake_case : List[Any] = BytesIO() if image.format in list_image_compression_formats(): __snake_case : Union[str, Any] = image.format else: __snake_case : List[Any] = """PNG""" if image.mode in ["""1""", """L""", """LA""", """RGB""", """RGBA"""] else """TIFF""" image.save(__SCREAMING_SNAKE_CASE , format=__SCREAMING_SNAKE_CASE ) return buffer.getvalue() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' if hasattr(__SCREAMING_SNAKE_CASE , """filename""" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : np.ndarray ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) __snake_case : List[Any] = array.dtype __snake_case : List[Any] = dtype.byteorder if dtype.byteorder != """=""" else _NATIVE_BYTEORDER __snake_case : Dict = dtype.kind __snake_case : Union[str, Any] = dtype.itemsize __snake_case : Tuple = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: __snake_case : int = np.dtype("""|u1""" ) if dtype_kind not in ["u", "i"]: raise TypeError( F'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.''' ) if dtype is not dest_dtype: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: __snake_case : List[str] = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: __snake_case : int = dtype_byteorder + dtype_kind + str(__SCREAMING_SNAKE_CASE ) __snake_case : Any = np.dtype(__SCREAMING_SNAKE_CASE ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( F'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}''' ) __snake_case : Optional[int] = PIL.Image.fromarray(array.astype(__SCREAMING_SNAKE_CASE ) ) return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]] ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if objs: __snake_case , __snake_case : Any = first_non_null_value(__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(__SCREAMING_SNAKE_CASE , np.ndarray ): __snake_case : int = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] elif isinstance(__SCREAMING_SNAKE_CASE , PIL.Image.Image ): __snake_case : List[str] = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] else: return objs else: return objs
20
import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType lowercase_ = None lowercase_ = "<" if sys.byteorder == "little" else ">" # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image lowercase_ = [ np.dtype("|b1"), np.dtype("|u1"), np.dtype("<u2"), np.dtype(">u2"), np.dtype("<i2"), np.dtype(">i2"), np.dtype("<u4"), np.dtype(">u4"), np.dtype("<i4"), np.dtype(">i4"), np.dtype("<f4"), np.dtype(">f4"), np.dtype("<f8"), np.dtype(">f8"), ] @dataclass class SCREAMING_SNAKE_CASE__ : A : bool = True A : Optional[str] = None # Automatically constructed A : ClassVar[str] = "PIL.Image.Image" A : ClassVar[Any] = pa.struct({"bytes": pa.binary(), "path": pa.string()} ) A : str = field(default="Image" , init=__UpperCamelCase , repr=__UpperCamelCase ) def __call__( self : Any ): return self.pa_type def snake_case__ ( self : List[Any] , _lowerCAmelCase : Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] ): if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : str = np.array(_lowerCAmelCase ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": value, "bytes": None} elif isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": None, "bytes": value} elif isinstance(_lowerCAmelCase , np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(_lowerCAmelCase ) elif isinstance(_lowerCAmelCase , PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(_lowerCAmelCase ) elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("""path""" )} elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )} else: raise ValueError( f'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''' ) def snake_case__ ( self : List[str] , _lowerCAmelCase : dict , _lowerCAmelCase : Dict=None ): if not self.decode: raise RuntimeError("""Decoding is disabled for this feature. Please use Image(decode=True) instead.""" ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support decoding images, please install 'Pillow'.""" ) if token_per_repo_id is None: __snake_case : Tuple = {} __snake_case , __snake_case : str = value["""path"""], value["""bytes"""] if bytes_ is None: if path is None: raise ValueError(f'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.''' ) else: if is_local_path(_lowerCAmelCase ): __snake_case : str = PIL.Image.open(_lowerCAmelCase ) else: __snake_case : List[str] = path.split("""::""" )[-1] try: __snake_case : Dict = string_to_dict(_lowerCAmelCase , config.HUB_DATASETS_URL )["""repo_id"""] __snake_case : int = token_per_repo_id.get(_lowerCAmelCase ) except ValueError: __snake_case : List[Any] = None with xopen(_lowerCAmelCase , """rb""" , use_auth_token=_lowerCAmelCase ) as f: __snake_case : Union[str, Any] = BytesIO(f.read() ) __snake_case : Dict = PIL.Image.open(bytes_ ) else: __snake_case : Optional[Any] = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def snake_case__ ( self : Union[str, Any] ): from .features import Value return ( self if self.decode else { "bytes": Value("""binary""" ), "path": Value("""string""" ), } ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Union[pa.StringArray, pa.StructArray, pa.ListArray] ): if pa.types.is_string(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, storage] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays([storage, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("""bytes""" ) >= 0: __snake_case : List[str] = storage.field("""bytes""" ) else: __snake_case : List[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) if storage.type.get_field_index("""path""" ) >= 0: __snake_case : Optional[int] = storage.field("""path""" ) else: __snake_case : int = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : Tuple = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_list(storage.type ): __snake_case : Optional[Any] = pa.array( [encode_np_array(np.array(_lowerCAmelCase ) )["""bytes"""] if arr is not None else None for arr in storage.to_pylist()] , type=pa.binary() , ) __snake_case : Optional[int] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays( [bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : pa.StructArray ): @no_op_if_value_is_null def path_to_bytes(_lowerCAmelCase : Tuple ): with xopen(_lowerCAmelCase , """rb""" ) as f: __snake_case : Optional[int] = f.read() return bytes_ __snake_case : Tuple = pa.array( [ (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) __snake_case : Optional[Any] = pa.array( [os.path.basename(_lowerCAmelCase ) if path is not None else None for path in storage.field("""path""" ).to_pylist()] , type=pa.string() , ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def __lowerCAmelCase ( ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() __snake_case : Optional[Any] = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' __snake_case : List[Any] = BytesIO() if image.format in list_image_compression_formats(): __snake_case : Union[str, Any] = image.format else: __snake_case : List[Any] = """PNG""" if image.mode in ["""1""", """L""", """LA""", """RGB""", """RGBA"""] else """TIFF""" image.save(__SCREAMING_SNAKE_CASE , format=__SCREAMING_SNAKE_CASE ) return buffer.getvalue() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' if hasattr(__SCREAMING_SNAKE_CASE , """filename""" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : np.ndarray ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) __snake_case : List[Any] = array.dtype __snake_case : List[Any] = dtype.byteorder if dtype.byteorder != """=""" else _NATIVE_BYTEORDER __snake_case : Dict = dtype.kind __snake_case : Union[str, Any] = dtype.itemsize __snake_case : Tuple = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: __snake_case : int = np.dtype("""|u1""" ) if dtype_kind not in ["u", "i"]: raise TypeError( F'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.''' ) if dtype is not dest_dtype: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: __snake_case : List[str] = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: __snake_case : int = dtype_byteorder + dtype_kind + str(__SCREAMING_SNAKE_CASE ) __snake_case : Any = np.dtype(__SCREAMING_SNAKE_CASE ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( F'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}''' ) __snake_case : Optional[int] = PIL.Image.fromarray(array.astype(__SCREAMING_SNAKE_CASE ) ) return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]] ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if objs: __snake_case , __snake_case : Any = first_non_null_value(__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(__SCREAMING_SNAKE_CASE , np.ndarray ): __snake_case : int = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] elif isinstance(__SCREAMING_SNAKE_CASE , PIL.Image.Image ): __snake_case : List[str] = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] else: return objs else: return objs
20
1
import argparse import re import requests import torch # git clone https://github.com/salesforce/BLIP.git from models.blip import blip_decoder from models.blip_itm import blip_itm from models.blip_vqa import blip_vqa from PIL import Image from torchvision import transforms from torchvision.transforms.functional import InterpolationMode from transformers import ( BertTokenizer, BlipConfig, BlipForConditionalGeneration, BlipForImageTextRetrieval, BlipForQuestionAnswering, ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : List[str] ): '''simple docstring''' __snake_case : Any = """https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg""" __snake_case : str = Image.open(requests.get(__SCREAMING_SNAKE_CASE , stream=__SCREAMING_SNAKE_CASE ).raw ).convert("""RGB""" ) __snake_case : str = transforms.Compose( [ transforms.Resize((image_size, image_size) , interpolation=InterpolationMode.BICUBIC ), transforms.ToTensor(), transforms.Normalize((0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73) , (0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11) ), ] ) __snake_case : Any = transform(__SCREAMING_SNAKE_CASE ).unsqueeze(0 ).to(__SCREAMING_SNAKE_CASE ) return image def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' if "visual_encoder" in key: __snake_case : Tuple = re.sub("""visual_encoder*""" , """vision_model.encoder""" , __SCREAMING_SNAKE_CASE ) if "blocks" in key: __snake_case : int = re.sub(R"""blocks""" , """layers""" , __SCREAMING_SNAKE_CASE ) if "attn" in key: __snake_case : Tuple = re.sub(R"""attn""" , """self_attn""" , __SCREAMING_SNAKE_CASE ) if "norm1" in key: __snake_case : Tuple = re.sub(R"""norm1""" , """layer_norm1""" , __SCREAMING_SNAKE_CASE ) if "norm2" in key: __snake_case : Tuple = re.sub(R"""norm2""" , """layer_norm2""" , __SCREAMING_SNAKE_CASE ) if "encoder.norm" in key: __snake_case : Dict = re.sub(R"""encoder.norm""" , """post_layernorm""" , __SCREAMING_SNAKE_CASE ) if "encoder.patch_embed.proj" in key: __snake_case : List[Any] = re.sub(R"""encoder.patch_embed.proj""" , """embeddings.patch_embedding""" , __SCREAMING_SNAKE_CASE ) if "encoder.pos_embed" in key: __snake_case : Tuple = re.sub(R"""encoder.pos_embed""" , """embeddings.position_embedding""" , __SCREAMING_SNAKE_CASE ) if "encoder.cls_token" in key: __snake_case : int = re.sub(R"""encoder.cls_token""" , """embeddings.class_embedding""" , __SCREAMING_SNAKE_CASE ) if "self_attn" in key: __snake_case : List[str] = re.sub(R"""self_attn.proj""" , """self_attn.projection""" , __SCREAMING_SNAKE_CASE ) return key @torch.no_grad() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any]=None ): '''simple docstring''' if config_path is not None: __snake_case : Any = BlipConfig.from_pretrained(__SCREAMING_SNAKE_CASE ) else: __snake_case : Tuple = BlipConfig(projection_dim=5_1_2 , text_config={} , vision_config={} ) __snake_case : Tuple = BlipForConditionalGeneration(__SCREAMING_SNAKE_CASE ).eval() __snake_case : Tuple = """https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_capfilt_large.pth""" __snake_case : str = blip_decoder(pretrained=__SCREAMING_SNAKE_CASE , image_size=3_8_4 , vit="""base""" ) __snake_case : List[str] = pt_model.eval() __snake_case : Tuple = pt_model.state_dict() for key in modified_state_dict.copy(): __snake_case : List[str] = modified_state_dict.pop(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = rename_key(__SCREAMING_SNAKE_CASE ) __snake_case : Any = value hf_model.load_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : int = 3_8_4 __snake_case : Optional[int] = load_demo_image(image_size=__SCREAMING_SNAKE_CASE , device="""cpu""" ) __snake_case : Optional[Any] = BertTokenizer.from_pretrained("""bert-base-uncased""" ) __snake_case : Optional[int] = tokenizer(["""a picture of"""] ).input_ids __snake_case : Any = hf_model.generate(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) assert out[0].tolist() == [3_0_5_2_2, 1_0_3_7, 3_8_6_1, 1_9_9_7, 1_0_3_7, 2_4_5_0, 3_5_6_4, 2_0_0_6, 1_9_9_6, 3_5_0_9, 2_0_0_7, 2_0_1_4, 3_8_9_9, 1_0_2] __snake_case : Union[str, Any] = hf_model.generate(__SCREAMING_SNAKE_CASE ) assert out[0].tolist() == [3_0_5_2_2, 1_0_3_7, 2_4_5_0, 3_5_6_4, 2_0_0_6, 1_9_9_6, 3_5_0_9, 2_0_0_7, 2_0_1_4, 3_8_9_9, 1_0_2] if pytorch_dump_folder_path is not None: hf_model.save_pretrained(__SCREAMING_SNAKE_CASE ) # model_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_vqa.pth' __snake_case : List[str] = ( """https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_vqa_capfilt_large.pth""" ) __snake_case : Dict = blip_vqa(pretrained=__SCREAMING_SNAKE_CASE , image_size=__SCREAMING_SNAKE_CASE , vit="""base""" ) vqa_model.eval() __snake_case : int = vqa_model.state_dict() for key in modified_state_dict.copy(): __snake_case : int = modified_state_dict.pop(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = rename_key(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = value __snake_case : Any = BlipForQuestionAnswering(__SCREAMING_SNAKE_CASE ) hf_vqa_model.load_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = ["""How many dogs are in this image?"""] __snake_case : List[Any] = tokenizer(__SCREAMING_SNAKE_CASE , return_tensors="""pt""" ).input_ids __snake_case : List[str] = hf_vqa_model.generate(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) print(tokenizer.decode(answer[0] ) ) assert tokenizer.decode(answer[0] ) == "[UNK] 1 [SEP]" if pytorch_dump_folder_path is not None: hf_vqa_model.save_pretrained(pytorch_dump_folder_path + """_vqa""" ) __snake_case : int = """https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_retrieval_coco.pth""" __snake_case : int = blip_itm(pretrained=__SCREAMING_SNAKE_CASE , image_size=__SCREAMING_SNAKE_CASE , vit="""base""" ) itm_model.eval() __snake_case : List[Any] = itm_model.state_dict() for key in modified_state_dict.copy(): __snake_case : Optional[Any] = modified_state_dict.pop(__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = rename_key(__SCREAMING_SNAKE_CASE ) __snake_case : Union[str, Any] = value __snake_case : Union[str, Any] = BlipForImageTextRetrieval(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = ["""A picture of a woman with a dog sitting in a beach"""] __snake_case : str = tokenizer( __SCREAMING_SNAKE_CASE , return_tensors="""pt""" , padding="""max_length""" , truncation=__SCREAMING_SNAKE_CASE , max_length=3_5 , ).input_ids hf_itm_model.load_state_dict(__SCREAMING_SNAKE_CASE ) hf_itm_model.eval() __snake_case : Tuple = hf_itm_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , use_itm_head=__SCREAMING_SNAKE_CASE ) __snake_case : Dict = hf_itm_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , use_itm_head=__SCREAMING_SNAKE_CASE ) assert out[0].item() == 0.21_10_68_74_94_27_79_54 assert torch.nn.functional.softmax(out_itm[0] , dim=1 )[:, 1].item() == 0.4_56_98_84_53_86_50_51_27 if pytorch_dump_folder_path is not None: hf_itm_model.save_pretrained(pytorch_dump_folder_path + """_itm""" ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") lowercase_ = parser.parse_args() convert_blip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING lowercase_ = logging.get_logger(__name__) @add_end_docstrings(__UpperCamelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : Dict , *_lowerCAmelCase : Dict , **_lowerCAmelCase : int ): super().__init__(*_lowerCAmelCase , **_lowerCAmelCase ) requires_backends(self , """vision""" ) self.check_model_type( TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING ) def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[str]=None , _lowerCAmelCase : Any=None , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = {} __snake_case : int = {} if prompt is not None: __snake_case : Dict = prompt if generate_kwargs is not None: __snake_case : List[Any] = generate_kwargs if max_new_tokens is not None: if "generate_kwargs" not in forward_kwargs: __snake_case : Optional[int] = {} if "max_new_tokens" in forward_kwargs["generate_kwargs"]: raise ValueError( """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,""" """ please use only one""" ) __snake_case : Any = max_new_tokens return preprocess_params, forward_kwargs, {} def __call__( self : Optional[Any] , _lowerCAmelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] , **_lowerCAmelCase : Union[str, Any] ): return super().__call__(_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = load_image(_lowerCAmelCase ) if prompt is not None: if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): raise ValueError( f'''Received an invalid text input, got - {type(_lowerCAmelCase )} - but expected a single string. ''' """Note also that one single text can be provided for conditional image to text generation.""" ) __snake_case : Tuple = self.model.config.model_type if model_type == "git": __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Any = self.tokenizer(text=_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ).input_ids __snake_case : Tuple = [self.tokenizer.cls_token_id] + input_ids __snake_case : int = torch.tensor(_lowerCAmelCase ).unsqueeze(0 ) model_inputs.update({"""input_ids""": input_ids} ) elif model_type == "pix2struct": __snake_case : Dict = self.image_processor(images=_lowerCAmelCase , header_text=_lowerCAmelCase , return_tensors=self.framework ) elif model_type != "vision-encoder-decoder": # vision-encoder-decoder does not support conditional generation __snake_case : int = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Optional[Any] = self.tokenizer(_lowerCAmelCase , return_tensors=self.framework ) model_inputs.update(_lowerCAmelCase ) else: raise ValueError(f'''Model type {model_type} does not support conditional text generation''' ) else: __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) if self.model.config.model_type == "git" and prompt is None: __snake_case : int = None return model_inputs def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : str=None ): # Git model sets `model_inputs["input_ids"] = None` in `preprocess` (when `prompt=None`). In batch model, the # pipeline will group them into a list of `None`, which fail `_forward`. Avoid this by checking it first. if ( "input_ids" in model_inputs and isinstance(model_inputs["""input_ids"""] , _lowerCAmelCase ) and all(x is None for x in model_inputs["""input_ids"""] ) ): __snake_case : List[Any] = None if generate_kwargs is None: __snake_case : Dict = {} # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py` # parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas # the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name` # in the `_prepare_model_inputs` method. __snake_case : Dict = model_inputs.pop(self.model.main_input_name ) __snake_case : Optional[int] = self.model.generate(_lowerCAmelCase , **_lowerCAmelCase , **_lowerCAmelCase ) return model_outputs def snake_case__ ( self : List[Any] , _lowerCAmelCase : str ): __snake_case : Union[str, Any] = [] for output_ids in model_outputs: __snake_case : Union[str, Any] = { """generated_text""": self.tokenizer.decode( _lowerCAmelCase , skip_special_tokens=_lowerCAmelCase , ) } records.append(_lowerCAmelCase ) return records
20
1
from math import factorial class SCREAMING_SNAKE_CASE__ : def __init__( self : str , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : int ): __snake_case : List[str] = real if isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : Tuple = [1] * rank else: __snake_case : Optional[int] = rank def __repr__( self : Optional[Any] ): return ( f'''{self.real}+''' f'''{'+'.join(str(_lowerCAmelCase )+'E'+str(n+1 )for n,dual in enumerate(self.duals ) )}''' ) def snake_case__ ( self : List[Any] ): __snake_case : Optional[Any] = self.duals.copy() while cur[-1] == 0: cur.pop(-1 ) return Dual(self.real , _lowerCAmelCase ) def __add__( self : Optional[int] , _lowerCAmelCase : Optional[int] ): if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): return Dual(self.real + other , self.duals ) __snake_case : Dict = self.duals.copy() __snake_case : int = other.duals.copy() if len(_lowerCAmelCase ) > len(_lowerCAmelCase ): o_dual.extend([1] * (len(_lowerCAmelCase ) - len(_lowerCAmelCase )) ) elif len(_lowerCAmelCase ) < len(_lowerCAmelCase ): s_dual.extend([1] * (len(_lowerCAmelCase ) - len(_lowerCAmelCase )) ) __snake_case : List[Any] = [] for i in range(len(_lowerCAmelCase ) ): new_duals.append(s_dual[i] + o_dual[i] ) return Dual(self.real + other.real , _lowerCAmelCase ) A : List[Any] = __add__ def __sub__( self : Dict , _lowerCAmelCase : List[Any] ): return self + other * -1 def __mul__( self : List[str] , _lowerCAmelCase : Any ): if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : Optional[int] = [] for i in self.duals: new_duals.append(i * other ) return Dual(self.real * other , _lowerCAmelCase ) __snake_case : Optional[int] = [0] * (len(self.duals ) + len(other.duals ) + 1) for i, item in enumerate(self.duals ): for j, jtem in enumerate(other.duals ): new_duals[i + j + 1] += item * jtem for k in range(len(self.duals ) ): new_duals[k] += self.duals[k] * other.real for index in range(len(other.duals ) ): new_duals[index] += other.duals[index] * self.real return Dual(self.real * other.real , _lowerCAmelCase ) A : Optional[Any] = __mul__ def __truediv__( self : Tuple , _lowerCAmelCase : Optional[int] ): if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : Tuple = [] for i in self.duals: new_duals.append(i / other ) return Dual(self.real / other , _lowerCAmelCase ) raise ValueError def __floordiv__( self : Union[str, Any] , _lowerCAmelCase : Optional[Any] ): if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : Tuple = [] for i in self.duals: new_duals.append(i // other ) return Dual(self.real // other , _lowerCAmelCase ) raise ValueError def __pow__( self : List[str] , _lowerCAmelCase : Optional[Any] ): if n < 0 or isinstance(_lowerCAmelCase , _lowerCAmelCase ): raise ValueError("""power must be a positive integer""" ) if n == 0: return 1 if n == 1: return self __snake_case : Dict = self for _ in range(n - 1 ): x *= self return x def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' if not callable(__SCREAMING_SNAKE_CASE ): raise ValueError("""differentiate() requires a function as input for func""" ) if not isinstance(__SCREAMING_SNAKE_CASE , (float, int) ): raise ValueError("""differentiate() requires a float as input for position""" ) if not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): raise ValueError("""differentiate() requires an int as input for order""" ) __snake_case : Any = Dual(__SCREAMING_SNAKE_CASE , 1 ) __snake_case : List[Any] = func(__SCREAMING_SNAKE_CASE ) if order == 0: return result.real return result.duals[order - 1] * factorial(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": import doctest doctest.testmod() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] ): '''simple docstring''' return y**2 * y**4 print(differentiate(f, 9, 2))
20
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowercase_ = {"configuration_yolos": ["YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP", "YolosConfig", "YolosOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["YolosFeatureExtractor"] lowercase_ = ["YolosImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST", "YolosForObjectDetection", "YolosModel", "YolosPreTrainedModel", ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
import os import unittest from transformers import BatchEncoding from transformers.models.bert.tokenization_bert import ( BasicTokenizer, WordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.models.prophetnet.tokenization_prophetnet import VOCAB_FILES_NAMES, ProphetNetTokenizer from transformers.testing_utils import require_torch, slow from ...test_tokenization_common import TokenizerTesterMixin class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , unittest.TestCase ): A : Optional[int] = ProphetNetTokenizer A : Union[str, Any] = False def snake_case__ ( self : Union[str, Any] ): super().setUp() __snake_case : Any = [ """[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest""", ] __snake_case : int = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Optional[int] ): __snake_case : Union[str, Any] = """UNwant\u00E9d,running""" __snake_case : Optional[int] = """unwanted, running""" return input_text, output_text def snake_case__ ( self : List[Any] ): __snake_case : Optional[Any] = self.tokenizer_class(self.vocab_file ) __snake_case : int = tokenizer.tokenize("""UNwant\u00E9d,running""" ) self.assertListEqual(_lowerCAmelCase , ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCAmelCase ) , [9, 6, 7, 12, 10, 11] ) def snake_case__ ( self : Tuple ): __snake_case : str = BasicTokenizer() self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz""" ) , ["""ah""", """\u535A""", """\u63A8""", """zz"""] ) def snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = BasicTokenizer(do_lower_case=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) , ["""hello""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = BasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hällo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""h\u00E9llo"""] ) def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = BasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def snake_case__ ( self : Optional[int] ): __snake_case : Any = BasicTokenizer(do_lower_case=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Any = BasicTokenizer(do_lower_case=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) , ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def snake_case__ ( self : int ): __snake_case : Optional[Any] = BasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def snake_case__ ( self : int ): __snake_case : Optional[Any] = BasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def snake_case__ ( self : Any ): __snake_case : Union[str, Any] = BasicTokenizer(do_lower_case=_lowerCAmelCase , never_split=["""[UNK]"""] ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? [UNK]""" ) , ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""] ) def snake_case__ ( self : str ): __snake_case : Union[str, Any] = ["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""] __snake_case : List[str] = {} for i, token in enumerate(_lowerCAmelCase ): __snake_case : int = i __snake_case : Any = WordpieceTokenizer(vocab=_lowerCAmelCase , unk_token="""[UNK]""" ) self.assertListEqual(tokenizer.tokenize("""""" ) , [] ) self.assertListEqual(tokenizer.tokenize("""unwanted running""" ) , ["""un""", """##want""", """##ed""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.tokenize("""unwantedX running""" ) , ["""[UNK]""", """runn""", """##ing"""] ) @require_torch def snake_case__ ( self : List[str] ): __snake_case : int = self.tokenizer_class.from_pretrained("""microsoft/prophetnet-large-uncased""" ) __snake_case : Dict = ["""A long paragraph for summarization.""", """Another paragraph for summarization."""] __snake_case : Optional[Any] = [10_37, 21_46, 2_04_23, 20_05, 76_80, 78_49, 39_89, 10_12, 1_02] __snake_case : str = tokenizer(_lowerCAmelCase , padding=_lowerCAmelCase , return_tensors="""pt""" ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = list(batch.input_ids.numpy()[0] ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) self.assertEqual((2, 9) , batch.input_ids.shape ) self.assertEqual((2, 9) , batch.attention_mask.shape ) def snake_case__ ( self : int ): self.assertTrue(_is_whitespace(""" """ ) ) self.assertTrue(_is_whitespace("""\t""" ) ) self.assertTrue(_is_whitespace("""\r""" ) ) self.assertTrue(_is_whitespace("""\n""" ) ) self.assertTrue(_is_whitespace("""\u00A0""" ) ) self.assertFalse(_is_whitespace("""A""" ) ) self.assertFalse(_is_whitespace("""-""" ) ) def snake_case__ ( self : Any ): self.assertTrue(_is_control("""\u0005""" ) ) self.assertFalse(_is_control("""A""" ) ) self.assertFalse(_is_control(""" """ ) ) self.assertFalse(_is_control("""\t""" ) ) self.assertFalse(_is_control("""\r""" ) ) def snake_case__ ( self : int ): self.assertTrue(_is_punctuation("""-""" ) ) self.assertTrue(_is_punctuation("""$""" ) ) self.assertTrue(_is_punctuation("""`""" ) ) self.assertTrue(_is_punctuation(""".""" ) ) self.assertFalse(_is_punctuation("""A""" ) ) self.assertFalse(_is_punctuation(""" """ ) ) @slow def snake_case__ ( self : Dict ): __snake_case : Union[str, Any] = self.tokenizer_class.from_pretrained("""microsoft/prophetnet-large-uncased""" ) __snake_case : Union[str, Any] = tokenizer.encode("""sequence builders""" , add_special_tokens=_lowerCAmelCase ) __snake_case : Union[str, Any] = tokenizer.encode("""multi-sequence build""" , add_special_tokens=_lowerCAmelCase ) __snake_case : str = tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase ) __snake_case : List[str] = tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase , _lowerCAmelCase ) assert encoded_sentence == text + [1_02] assert encoded_pair == text + [1_02] + text_a + [1_02]
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = "microsoft/speecht5_tts" A : List[Any] = ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) A : str = "text_reader" A : Optional[Any] = SpeechTaProcessor A : Any = SpeechTaForTextToSpeech A : Optional[Any] = SpeechTaHifiGan A : str = ["text"] A : Union[str, Any] = ["audio"] def snake_case__ ( self : List[Any] ): if self.post_processor is None: __snake_case : Tuple = """microsoft/speecht5_hifigan""" super().setup() def snake_case__ ( self : Any , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Tuple=None ): __snake_case : str = self.pre_processor(text=_lowerCAmelCase , return_tensors="""pt""" , truncation=_lowerCAmelCase ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) __snake_case : List[Any] = load_dataset("""Matthijs/cmu-arctic-xvectors""" , split="""validation""" ) __snake_case : str = torch.tensor(embeddings_dataset[73_05]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def snake_case__ ( self : List[Any] , _lowerCAmelCase : Dict ): with torch.no_grad(): return self.model.generate_speech(**_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): with torch.no_grad(): return self.post_processor(_lowerCAmelCase ).cpu().detach()
20
1
import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int = 1_0_0 ): '''simple docstring''' __snake_case : Tuple = sum(i * i for i in range(1 , n + 1 ) ) __snake_case : Dict = int(math.pow(sum(range(1 , n + 1 ) ) , 2 ) ) return square_of_sum - sum_of_squares if __name__ == "__main__": print(F'''{solution() = }''')
20
import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * power_factor def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * math.sqrt(1 - power_factor**2 ) if __name__ == "__main__": import doctest doctest.testmod()
20
1
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy as np import tensorflow as tf from transformers import ( TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST, FlaubertConfig, TFFlaubertForMultipleChoice, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForSequenceClassification, TFFlaubertForTokenClassification, TFFlaubertModel, TFFlaubertWithLMHeadModel, ) class SCREAMING_SNAKE_CASE__ : def __init__( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , ): __snake_case : Dict = parent __snake_case : str = 13 __snake_case : Any = 7 __snake_case : int = True __snake_case : List[str] = True __snake_case : List[str] = True __snake_case : Dict = True __snake_case : Optional[int] = True __snake_case : Union[str, Any] = False __snake_case : Dict = False __snake_case : Optional[int] = False __snake_case : Optional[int] = 2 __snake_case : Tuple = 99 __snake_case : Any = 0 __snake_case : Union[str, Any] = 32 __snake_case : str = 2 __snake_case : Dict = 4 __snake_case : Union[str, Any] = 0.1 __snake_case : Union[str, Any] = 0.1 __snake_case : Any = 5_12 __snake_case : List[Any] = 16 __snake_case : int = 2 __snake_case : str = 0.02 __snake_case : Optional[int] = 3 __snake_case : Tuple = 4 __snake_case : Optional[int] = """last""" __snake_case : str = True __snake_case : List[str] = None __snake_case : str = 0 def snake_case__ ( self : Dict ): __snake_case : Union[str, Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) __snake_case : Dict = random_attention_mask([self.batch_size, self.seq_length] , dtype=tf.floataa ) __snake_case : List[str] = None if self.use_input_lengths: __snake_case : List[str] = ( ids_tensor([self.batch_size] , vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length __snake_case : Union[str, Any] = None if self.use_token_type_ids: __snake_case : Optional[int] = ids_tensor([self.batch_size, self.seq_length] , self.n_langs ) __snake_case : Dict = None __snake_case : List[Any] = None __snake_case : Union[str, Any] = None if self.use_labels: __snake_case : Dict = ids_tensor([self.batch_size] , self.type_sequence_label_size ) __snake_case : str = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) __snake_case : List[Any] = ids_tensor([self.batch_size] , 2 , dtype=tf.floataa ) __snake_case : int = ids_tensor([self.batch_size] , self.num_choices ) __snake_case : Tuple = FlaubertConfig( vocab_size=self.vocab_size , n_special=self.n_special , emb_dim=self.hidden_size , n_layers=self.num_hidden_layers , n_heads=self.num_attention_heads , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , gelu_activation=self.gelu_activation , sinusoidal_embeddings=self.sinusoidal_embeddings , asm=self.asm , causal=self.causal , n_langs=self.n_langs , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , summary_type=self.summary_type , use_proj=self.use_proj , bos_token_id=self.bos_token_id , ) return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Any , _lowerCAmelCase : Tuple , _lowerCAmelCase : List[str] , _lowerCAmelCase : List[str] , _lowerCAmelCase : Optional[int] , ): __snake_case : Union[str, Any] = TFFlaubertModel(config=_lowerCAmelCase ) __snake_case : List[str] = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} __snake_case : Optional[Any] = model(_lowerCAmelCase ) __snake_case : Optional[Any] = [input_ids, input_mask] __snake_case : int = model(_lowerCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def snake_case__ ( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : Dict , _lowerCAmelCase : Dict , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : str , ): __snake_case : str = TFFlaubertWithLMHeadModel(_lowerCAmelCase ) __snake_case : int = {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids} __snake_case : Optional[int] = model(_lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def snake_case__ ( self : Any , _lowerCAmelCase : str , _lowerCAmelCase : str , _lowerCAmelCase : Dict , _lowerCAmelCase : List[Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Dict , _lowerCAmelCase : Tuple , ): __snake_case : List[str] = TFFlaubertForQuestionAnsweringSimple(_lowerCAmelCase ) __snake_case : Optional[Any] = {"""input_ids""": input_ids, """lengths""": input_lengths} __snake_case : List[Any] = model(_lowerCAmelCase ) 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 snake_case__ ( self : List[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Any , _lowerCAmelCase : int , _lowerCAmelCase : Any , _lowerCAmelCase : str , _lowerCAmelCase : str , ): __snake_case : Tuple = TFFlaubertForSequenceClassification(_lowerCAmelCase ) __snake_case : List[str] = {"""input_ids""": input_ids, """lengths""": input_lengths} __snake_case : str = model(_lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def snake_case__ ( self : str , _lowerCAmelCase : List[str] , _lowerCAmelCase : Tuple , _lowerCAmelCase : Any , _lowerCAmelCase : Dict , _lowerCAmelCase : Any , _lowerCAmelCase : List[Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : Dict , _lowerCAmelCase : List[Any] , ): __snake_case : Any = self.num_labels __snake_case : Tuple = TFFlaubertForTokenClassification(config=_lowerCAmelCase ) __snake_case : Optional[int] = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} __snake_case : Optional[int] = model(_lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Any , _lowerCAmelCase : str , _lowerCAmelCase : List[Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : str , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Dict , _lowerCAmelCase : List[str] , ): __snake_case : List[str] = self.num_choices __snake_case : Union[str, Any] = TFFlaubertForMultipleChoice(config=_lowerCAmelCase ) __snake_case : Tuple = tf.tile(tf.expand_dims(_lowerCAmelCase , 1 ) , (1, self.num_choices, 1) ) __snake_case : List[Any] = tf.tile(tf.expand_dims(_lowerCAmelCase , 1 ) , (1, self.num_choices, 1) ) __snake_case : Union[str, Any] = tf.tile(tf.expand_dims(_lowerCAmelCase , 1 ) , (1, self.num_choices, 1) ) __snake_case : Optional[Any] = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } __snake_case : str = model(_lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def snake_case__ ( self : int ): __snake_case : Any = self.prepare_config_and_inputs() ( ( __snake_case ) , ( __snake_case ) , ( __snake_case ) , ( __snake_case ) , ( __snake_case ) , ( __snake_case ) , ( __snake_case ) , ( __snake_case ) , ( __snake_case ) , ) : Tuple = config_and_inputs __snake_case : Optional[Any] = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """langs""": token_type_ids, """lengths""": input_lengths, } return config, inputs_dict @require_tf class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , __UpperCamelCase , unittest.TestCase ): A : Dict = ( ( TFFlaubertModel, TFFlaubertWithLMHeadModel, TFFlaubertForSequenceClassification, TFFlaubertForQuestionAnsweringSimple, TFFlaubertForTokenClassification, TFFlaubertForMultipleChoice, ) if is_tf_available() else () ) A : str = ( (TFFlaubertWithLMHeadModel,) if is_tf_available() else () ) # TODO (PVP): Check other models whether language generation is also applicable A : Optional[int] = ( { "feature-extraction": TFFlaubertModel, "fill-mask": TFFlaubertWithLMHeadModel, "question-answering": TFFlaubertForQuestionAnsweringSimple, "text-classification": TFFlaubertForSequenceClassification, "token-classification": TFFlaubertForTokenClassification, "zero-shot": TFFlaubertForSequenceClassification, } if is_tf_available() else {} ) A : Optional[int] = False A : List[Any] = False def snake_case__ ( self : Tuple , _lowerCAmelCase : Dict , _lowerCAmelCase : str , _lowerCAmelCase : List[str] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[Any] ): if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def snake_case__ ( self : Dict ): __snake_case : Any = TFFlaubertModelTester(self ) __snake_case : int = ConfigTester(self , config_class=_lowerCAmelCase , emb_dim=37 ) def snake_case__ ( self : int ): self.config_tester.run_common_tests() def snake_case__ ( self : List[str] ): __snake_case : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*_lowerCAmelCase ) def snake_case__ ( self : List[str] ): __snake_case : str = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*_lowerCAmelCase ) def snake_case__ ( self : str ): __snake_case : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*_lowerCAmelCase ) def snake_case__ ( self : List[str] ): __snake_case : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_token_classification(*_lowerCAmelCase ) def snake_case__ ( self : str ): __snake_case : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_for_multiple_choice(*_lowerCAmelCase ) @slow def snake_case__ ( self : List[Any] ): for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __snake_case : Optional[Any] = TFFlaubertModel.from_pretrained(_lowerCAmelCase ) self.assertIsNotNone(_lowerCAmelCase ) @require_tf @require_sentencepiece @require_tokenizers class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): @slow def snake_case__ ( self : List[Any] ): __snake_case : Union[str, Any] = TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased""" ) __snake_case : Any = tf.convert_to_tensor( [[0, 1_58, 7_35, 25_92, 14_24, 67_27, 82, 1]] , dtype=tf.intaa , ) # "J'aime flaubert !" __snake_case : List[Any] = model(_lowerCAmelCase )[0] __snake_case : Union[str, Any] = tf.TensorShape((1, 8, 5_12) ) self.assertEqual(output.shape , _lowerCAmelCase ) # compare the actual values for a slice. __snake_case : List[str] = tf.convert_to_tensor( [ [ [-1.8768773, -1.566555, 0.27072418], [-1.6920038, -0.5873505, 1.9329599], [-2.9563985, -1.6993835, 1.7972052], ] ] , dtype=tf.floataa , ) self.assertTrue(np.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
20
from .constants import ( MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SCALER_NAME, SCHEDULER_NAME, TORCH_LAUNCH_PARAMS, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ) from .dataclasses import ( BnbQuantizationConfig, ComputeEnvironment, CustomDtype, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FPaRecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProjectConfiguration, RNGType, SageMakerDistributedType, TensorInformation, TorchDynamoPlugin, ) from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env from .imports import ( get_ccl_version, is_abit_bnb_available, is_abit_bnb_available, is_aim_available, is_bfaa_available, is_bnb_available, is_botoa_available, is_ccl_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_fpa_available, is_ipex_available, is_megatron_lm_available, is_mlflow_available, is_mps_available, is_npu_available, is_rich_available, is_safetensors_available, is_sagemaker_available, is_tensorboard_available, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) from .modeling import ( check_device_map, check_tied_parameters_in_config, check_tied_parameters_on_same_device, compute_module_sizes, convert_file_size_to_int, dtype_byte_size, find_tied_parameters, get_balanced_memory, get_max_layer_size, get_max_memory, get_mixed_precision_context_manager, id_tensor_storage, infer_auto_device_map, load_checkpoint_in_model, load_offloaded_weights, load_state_dict, named_module_tensors, retie_parameters, set_module_tensor_to_device, shard_checkpoint, ) from .offload import ( OffloadedWeightsLoader, PrefixedDataset, extract_submodules_state_dict, load_offloaded_weight, offload_state_dict, offload_weight, save_offload_index, ) from .operations import ( broadcast, broadcast_object_list, concatenate, convert_outputs_to_fpaa, convert_to_fpaa, find_batch_size, find_device, gather, gather_object, get_data_structure, honor_type, initialize_tensors, is_namedtuple, is_tensor_information, is_torch_tensor, listify, pad_across_processes, recursively_apply, reduce, send_to_device, slice_tensors, ) from .versions import compare_versions, is_torch_version if is_deepspeed_available(): from .deepspeed import ( DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler, HfDeepSpeedConfig, ) from .bnb import has_abit_bnb_layers, load_and_quantize_model from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer from .launch import ( PrepareForLaunch, _filter_args, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, ) from .megatron_lm import ( AbstractTrainStep, BertTrainStep, GPTTrainStep, MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, TaTrainStep, avg_losses_across_data_parallel_group, gather_across_data_parallel_groups, ) from .megatron_lm import initialize as megatron_lm_initialize from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader from .megatron_lm import prepare_model as megatron_lm_prepare_model from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler from .memory import find_executable_batch_size, release_memory from .other import ( extract_model_from_parallel, get_pretty_name, is_port_in_use, merge_dicts, patch_environment, save, wait_for_everyone, write_basic_config, ) from .random import set_seed, synchronize_rng_state, synchronize_rng_states from .torch_xla import install_xla from .tqdm import tqdm from .transformer_engine import convert_model, has_transformer_engine_layers
20
1
class SCREAMING_SNAKE_CASE__ : def __init__( self : str ): __snake_case : int = """""" __snake_case : Tuple = """""" __snake_case : List[str] = [] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : int , _lowerCAmelCase : int ): if m == -1: return n + 1 elif n == -1: return m + 1 elif self.dp[m][n] > -1: return self.dp[m][n] else: if self.worda[m] == self.worda[n]: __snake_case : str = self.__min_dist_top_down_dp(m - 1 , n - 1 ) else: __snake_case : Tuple = self.__min_dist_top_down_dp(_lowerCAmelCase , n - 1 ) __snake_case : List[Any] = self.__min_dist_top_down_dp(m - 1 , _lowerCAmelCase ) __snake_case : Any = self.__min_dist_top_down_dp(m - 1 , n - 1 ) __snake_case : List[Any] = 1 + min(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) return self.dp[m][n] def snake_case__ ( self : Any , _lowerCAmelCase : str , _lowerCAmelCase : str ): __snake_case : Union[str, Any] = worda __snake_case : Dict = worda __snake_case : Optional[int] = [[-1 for _ in range(len(_lowerCAmelCase ) )] for _ in range(len(_lowerCAmelCase ) )] return self.__min_dist_top_down_dp(len(_lowerCAmelCase ) - 1 , len(_lowerCAmelCase ) - 1 ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : str ): __snake_case : Optional[int] = worda __snake_case : List[Any] = worda __snake_case : Optional[int] = len(_lowerCAmelCase ) __snake_case : str = len(_lowerCAmelCase ) __snake_case : Tuple = [[0 for _ in range(n + 1 )] for _ in range(m + 1 )] for i in range(m + 1 ): for j in range(n + 1 ): if i == 0: # first string is empty __snake_case : List[Any] = j elif j == 0: # second string is empty __snake_case : Any = i elif worda[i - 1] == worda[j - 1]: # last characters are equal __snake_case : List[Any] = self.dp[i - 1][j - 1] else: __snake_case : Optional[int] = self.dp[i][j - 1] __snake_case : Union[str, Any] = self.dp[i - 1][j] __snake_case : Dict = self.dp[i - 1][j - 1] __snake_case : int = 1 + min(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) return self.dp[m][n] if __name__ == "__main__": lowercase_ = EditDistance() print("****************** Testing Edit Distance DP Algorithm ******************") print() lowercase_ = input("Enter the first string: ").strip() lowercase_ = input("Enter the second string: ").strip() print() print(F'''The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}''') print(F'''The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}''') print() print("*************** End of Testing Edit Distance DP Algorithm ***************")
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase_ = { "configuration_blenderbot_small": [ "BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "BlenderbotSmallConfig", "BlenderbotSmallOnnxConfig", ], "tokenization_blenderbot_small": ["BlenderbotSmallTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["BlenderbotSmallTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST", "BlenderbotSmallForCausalLM", "BlenderbotSmallForConditionalGeneration", "BlenderbotSmallModel", "BlenderbotSmallPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFBlenderbotSmallForConditionalGeneration", "TFBlenderbotSmallModel", "TFBlenderbotSmallPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxBlenderbotSmallForConditionalGeneration", "FlaxBlenderbotSmallModel", "FlaxBlenderbotSmallPreTrainedModel", ] if TYPE_CHECKING: from .configuration_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotSmallConfig, BlenderbotSmallOnnxConfig, ) from .tokenization_blenderbot_small import BlenderbotSmallTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_small_fast import BlenderbotSmallTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotSmallForCausalLM, BlenderbotSmallForConditionalGeneration, BlenderbotSmallModel, BlenderbotSmallPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot_small import ( TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel, TFBlenderbotSmallPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot_small import ( FlaxBlenderbotSmallForConditionalGeneration, FlaxBlenderbotSmallModel, FlaxBlenderbotSmallPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
from __future__ import annotations from math import pow, sqrt def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if (resistance, reactance, impedance).count(0 ) != 1: raise ValueError("""One and only one argument must be 0""" ) if resistance == 0: return {"resistance": sqrt(pow(__SCREAMING_SNAKE_CASE , 2 ) - pow(__SCREAMING_SNAKE_CASE , 2 ) )} elif reactance == 0: return {"reactance": sqrt(pow(__SCREAMING_SNAKE_CASE , 2 ) - pow(__SCREAMING_SNAKE_CASE , 2 ) )} elif impedance == 0: return {"impedance": sqrt(pow(__SCREAMING_SNAKE_CASE , 2 ) + pow(__SCREAMING_SNAKE_CASE , 2 ) )} else: raise ValueError("""Exactly one argument must be 0""" ) if __name__ == "__main__": import doctest doctest.testmod()
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) lowercase_ = {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["ViTFeatureExtractor"] lowercase_ = ["ViTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "VIT_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTForImageClassification", "ViTForMaskedImageModeling", "ViTModel", "ViTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFViTForImageClassification", "TFViTModel", "TFViTPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxViTForImageClassification", "FlaxViTModel", "FlaxViTPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() lowercase_ = { "bart": ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), "bert": ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-uncased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-cased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-base-cased-finetuned-mrpc": ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "dpr": ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), "gpt2": ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlnet": ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm": ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm-roberta": ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "transfo-xl": ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "openai-gpt": ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "roberta": ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "layoutlm": ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), "roberta-large-mnli": ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "camembert": ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "flaubert": ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert": ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert-base-distilled-squad": ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert": ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert-visual-feature-encoder": ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "ctrl": ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "albert": ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "t5": ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "electra": ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "wav2vec2": ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str]=False , __SCREAMING_SNAKE_CASE : List[Any]=True ): '''simple docstring''' if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case : Any = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) __snake_case : Dict = config_class.from_json_file(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = True __snake_case : Union[str, Any] = True print(F'''Building TensorFlow model from configuration: {config}''' ) __snake_case : List[Any] = model_class(__SCREAMING_SNAKE_CASE ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): __snake_case : Optional[Any] = cached_file( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: __snake_case : List[Any] = load_pytorch_checkpoint_in_tfa_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if compare_with_pt_model: __snake_case : Tuple = tf_model(tf_model.dummy_inputs , training=__SCREAMING_SNAKE_CASE ) # build the network __snake_case : List[str] = torch.load(__SCREAMING_SNAKE_CASE , map_location="""cpu""" ) __snake_case : Any = pt_model_class.from_pretrained( pretrained_model_name_or_path=__SCREAMING_SNAKE_CASE , config=__SCREAMING_SNAKE_CASE , state_dict=__SCREAMING_SNAKE_CASE ) with torch.no_grad(): __snake_case : Union[str, Any] = pt_model(**pt_model.dummy_inputs ) __snake_case : Any = pto[0].numpy() __snake_case : Optional[int] = tfo[0].numpy() __snake_case : Optional[int] = np.amax(np.abs(np_pt - np_tf ) ) print(F'''Max absolute difference between models outputs {diff}''' ) assert diff <= 2E-2, F'''Error, model absolute difference is >2e-2: {diff}''' # Save pytorch-model print(F'''Save TensorFlow model to {tf_dump_path}''' ) tf_model.save_weights(__SCREAMING_SNAKE_CASE , save_format="""h5""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : List[str]=None , __SCREAMING_SNAKE_CASE : Any=None , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : List[Any]=False , __SCREAMING_SNAKE_CASE : Any=False , ): '''simple docstring''' if args_model_type is None: __snake_case : Tuple = list(MODEL_CLASSES.keys() ) else: __snake_case : Union[str, Any] = [args_model_type] for j, model_type in enumerate(__SCREAMING_SNAKE_CASE , start=1 ): print("""=""" * 1_0_0 ) print(F''' Converting model type {j}/{len(__SCREAMING_SNAKE_CASE )}: {model_type}''' ) print("""=""" * 1_0_0 ) if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case , __snake_case : Optional[int] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: __snake_case : int = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: __snake_case : Union[str, Any] = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , start=1 ): print("""-""" * 1_0_0 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(F''' Skipping finetuned checkpoint {model_shortcut_name}''' ) continue __snake_case : List[Any] = model_shortcut_name elif only_convert_finetuned_models: print(F''' Skipping not finetuned checkpoint {model_shortcut_name}''' ) continue print( F''' Converting checkpoint {i}/{len(__SCREAMING_SNAKE_CASE )}: {model_shortcut_name} - model_type {model_type}''' ) print("""-""" * 1_0_0 ) if config_shortcut_name in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : Dict = config_shortcut_name if model_shortcut_name in aws_model_maps: __snake_case : Union[str, Any] = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : List[Any] = model_shortcut_name if os.path.isfile(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = """converted_model""" convert_pt_checkpoint_to_tf( model_type=__SCREAMING_SNAKE_CASE , pytorch_checkpoint_path=__SCREAMING_SNAKE_CASE , config_file=__SCREAMING_SNAKE_CASE , tf_dump_path=os.path.join(__SCREAMING_SNAKE_CASE , model_shortcut_name + """-tf_model.h5""" ) , compare_with_pt_model=__SCREAMING_SNAKE_CASE , ) if remove_cached_files: os.remove(__SCREAMING_SNAKE_CASE ) os.remove(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--tf_dump_path", default=None, type=str, required=True, help="Path to the output Tensorflow dump file." ) parser.add_argument( "--model_type", default=None, type=str, help=( F'''Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ''' "convert all the models from AWS." ), ) parser.add_argument( "--pytorch_checkpoint_path", default=None, type=str, help=( "Path to the PyTorch checkpoint path or shortcut name to download from AWS. " "If not given, will download and convert all the checkpoints from AWS." ), ) parser.add_argument( "--config_file", default=None, type=str, help=( "The config json file corresponding to the pre-trained model. \n" "This specifies the model architecture. If not given and " "--pytorch_checkpoint_path is not given or is a shortcut name " "use the configuration associated to the shortcut name on the AWS" ), ) parser.add_argument( "--compare_with_pt_model", action="store_true", help="Compare Tensorflow and PyTorch model predictions." ) parser.add_argument( "--use_cached_models", action="store_true", help="Use cached models if possible instead of updating to latest checkpoint versions.", ) parser.add_argument( "--remove_cached_files", action="store_true", help="Remove pytorch models after conversion (save memory when converting in batches).", ) parser.add_argument("--only_convert_finetuned_models", action="store_true", help="Only convert finetuned models.") lowercase_ = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if (direction == 1 and array[indexa] > array[indexa]) or ( direction == 0 and array[indexa] < array[indexa] ): __snake_case , __snake_case : str = array[indexa], array[indexa] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Tuple = int(length / 2 ) for i in range(__SCREAMING_SNAKE_CASE , low + middle ): comp_and_swap(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , i + middle , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Optional[Any] = int(length / 2 ) bitonic_sort(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , 1 ) bitonic_sort(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , 0 ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() lowercase_ = [int(item.strip()) for item in user_input.split(",")] bitonic_sort(unsorted, 0, len(unsorted), 1) print("\nSorted array in ascending order is: ", end="") print(*unsorted, sep=", ") bitonic_merge(unsorted, 0, len(unsorted), 0) print("Sorted array in descending order is: ", end="") print(*unsorted, sep=", ")
20
1
from __future__ import annotations lowercase_ = 8.9_8_8E9 # units = N * m^s * C^-2 def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' __snake_case : Optional[Any] = abs(chargea * chargea ) if (force, chargea, chargea, distance).count(0 ) != 1: raise ValueError("""One and only one argument must be 0""" ) if distance < 0: raise ValueError("""Distance cannot be negative""" ) if force == 0: __snake_case : Optional[Any] = COULOMBS_CONSTANT * charge_product / (distance**2) return {"force": force} elif chargea == 0: __snake_case : Any = abs(__SCREAMING_SNAKE_CASE ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge1": chargea} elif chargea == 0: __snake_case : List[str] = abs(__SCREAMING_SNAKE_CASE ) * (distance**2) / (COULOMBS_CONSTANT * chargea) return {"charge2": chargea} elif distance == 0: __snake_case : Optional[Any] = (COULOMBS_CONSTANT * charge_product / abs(__SCREAMING_SNAKE_CASE )) ** 0.5 return {"distance": distance} raise ValueError("""Exactly one argument must be 0""" ) if __name__ == "__main__": import doctest doctest.testmod()
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , ): '''simple docstring''' __snake_case : Optional[int] = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } __snake_case , __snake_case : Tuple = input_paths_and_base_extractors[compression_format] if input_path is None: __snake_case : Tuple = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) assert base_extractor.is_extractable(__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : List[str] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : int = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any] , ): '''simple docstring''' __snake_case : Union[str, Any] = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } __snake_case : int = input_paths[compression_format] if input_path is None: __snake_case : int = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) __snake_case : Any = Extractor.infer_extractor_format(__SCREAMING_SNAKE_CASE ) assert extractor_format is not None __snake_case : Tuple = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : Union[str, Any] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Union[str, Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' import tarfile __snake_case : List[str] = tmp_path / """data_dot_dot""" directory.mkdir() __snake_case : Optional[Any] = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(__SCREAMING_SNAKE_CASE , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' import tarfile __snake_case : Dict = tmp_path / """data_sym_link""" directory.mkdir() __snake_case : Tuple = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=__SCREAMING_SNAKE_CASE ) with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' __snake_case : Any = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } __snake_case : int = insecure_tar_files[insecure_tar_file] __snake_case : Optional[int] = tmp_path / """extracted""" TarExtractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number __snake_case : Optional[Any] = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 __snake_case : List[str] = ( b"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" b"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" b"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" b"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(__SCREAMING_SNAKE_CASE ) assert zipfile.is_zipfile(str(__SCREAMING_SNAKE_CASE ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(__SCREAMING_SNAKE_CASE ) # but we're right
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase_ = { "configuration_funnel": ["FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP", "FunnelConfig"], "convert_funnel_original_tf_checkpoint_to_pytorch": [], "tokenization_funnel": ["FunnelTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["FunnelTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST", "FunnelBaseModel", "FunnelForMaskedLM", "FunnelForMultipleChoice", "FunnelForPreTraining", "FunnelForQuestionAnswering", "FunnelForSequenceClassification", "FunnelForTokenClassification", "FunnelModel", "FunnelPreTrainedModel", "load_tf_weights_in_funnel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST", "TFFunnelBaseModel", "TFFunnelForMaskedLM", "TFFunnelForMultipleChoice", "TFFunnelForPreTraining", "TFFunnelForQuestionAnswering", "TFFunnelForSequenceClassification", "TFFunnelForTokenClassification", "TFFunnelModel", "TFFunnelPreTrainedModel", ] if TYPE_CHECKING: from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig from .tokenization_funnel import FunnelTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_funnel_fast import FunnelTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_funnel import ( FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, FunnelBaseModel, FunnelForMaskedLM, FunnelForMultipleChoice, FunnelForPreTraining, FunnelForQuestionAnswering, FunnelForSequenceClassification, FunnelForTokenClassification, FunnelModel, FunnelPreTrainedModel, load_tf_weights_in_funnel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_funnel import ( TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST, TFFunnelBaseModel, TFFunnelForMaskedLM, TFFunnelForMultipleChoice, TFFunnelForPreTraining, TFFunnelForQuestionAnswering, TFFunnelForSequenceClassification, TFFunnelForTokenClassification, TFFunnelModel, TFFunnelPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
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 SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Any ): __snake_case : Dict = """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split() __snake_case : str = dict(zip(_lowerCAmelCase , range(len(_lowerCAmelCase ) ) ) ) __snake_case : List[str] = { """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>""", } __snake_case : str = { """feature_size""": 1, """padding_value""": 0.0, """sampling_rate""": 1_60_00, """return_attention_mask""": False, """do_normalize""": True, } __snake_case : Optional[Any] = tempfile.mkdtemp() __snake_case : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Any = 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 __snake_case : Optional[int] = """hf-internal-testing/ngram-beam-search-decoder""" def snake_case__ ( self : Optional[Any] , **_lowerCAmelCase : Tuple ): __snake_case : int = self.add_kwargs_tokens_map.copy() kwargs.update(_lowerCAmelCase ) return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , **_lowerCAmelCase : Optional[int] ): return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : Tuple ): return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name , **_lowerCAmelCase ) def snake_case__ ( self : List[str] ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Tuple = self.get_feature_extractor() __snake_case : Dict = self.get_decoder() __snake_case : List[str] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) __snake_case : Dict = 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 snake_case__ ( self : Tuple ): __snake_case : Tuple = 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 __snake_case : Optional[Any] = 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 snake_case__ ( self : int ): __snake_case : Tuple = 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 snake_case__ ( self : Dict ): __snake_case : int = self.get_feature_extractor() __snake_case : str = self.get_tokenizer() __snake_case : Dict = self.get_decoder() __snake_case : Any = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : List[Any] = floats_list((3, 10_00) ) __snake_case : Optional[Any] = feature_extractor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Tuple = 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 snake_case__ ( self : Optional[int] ): __snake_case : Any = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = """This is a test string""" __snake_case : Union[str, Any] = processor(text=_lowerCAmelCase ) __snake_case : Dict = tokenizer(_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : List[str] , _lowerCAmelCase : List[Any]=(2, 10, 16) , _lowerCAmelCase : str=77 ): np.random.seed(_lowerCAmelCase ) return np.random.rand(*_lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : List[str] = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : List[str] = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = self._get_dummy_logits(shape=(10, 16) , seed=13 ) __snake_case : int = processor.decode(_lowerCAmelCase ) __snake_case : Optional[int] = 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 snake_case__ ( self : List[str] , _lowerCAmelCase : List[str] ): __snake_case : int = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = 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: __snake_case : Tuple = processor.batch_decode(_lowerCAmelCase ) else: with get_context(_lowerCAmelCase ).Pool() as pool: __snake_case : int = processor.batch_decode(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as p: __snake_case : Tuple = decoder.decode_beams_batch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case , __snake_case , __snake_case : List[Any] = [], [], [] 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 snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = self.get_feature_extractor() __snake_case : int = self.get_tokenizer() __snake_case : str = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = self._get_dummy_logits() __snake_case : List[str] = 15 __snake_case : Optional[Any] = -20.0 __snake_case : Tuple = -4.0 __snake_case : List[Any] = processor.batch_decode( _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : List[str] = decoded_processor_out.text __snake_case : str = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as pool: __snake_case : Dict = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : int = [d[0][0] for d in decoded_decoder_out] __snake_case : List[Any] = [d[0][2] for d in decoded_decoder_out] __snake_case : List[Any] = [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([-20.054, -18.447] , _lowerCAmelCase , atol=1e-3 ) ) self.assertTrue(np.array_equal(_lowerCAmelCase , decoded_processor_out.lm_score ) ) self.assertTrue(np.allclose([-15.554, -13.9474] , _lowerCAmelCase , atol=1e-3 ) ) def snake_case__ ( self : Any ): __snake_case : List[Any] = self.get_feature_extractor() __snake_case : Any = self.get_tokenizer() __snake_case : Union[str, Any] = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Any = self._get_dummy_logits() __snake_case : Any = 2.0 __snake_case : int = 5.0 __snake_case : Optional[int] = -20.0 __snake_case : Optional[int] = True __snake_case : Any = processor.batch_decode( _lowerCAmelCase , alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) __snake_case : str = decoded_processor_out.text __snake_case : int = list(_lowerCAmelCase ) decoder.reset_params( alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) with get_context("""fork""" ).Pool() as pool: __snake_case : Tuple = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , ) __snake_case : int = [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 ) __snake_case : List[str] = 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 , -20.0 ) self.assertEqual(lm_model.score_boundary , _lowerCAmelCase ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Union[str, Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : Union[str, Any] = os.listdir(_lowerCAmelCase ) __snake_case : List[str] = ["""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 snake_case__ ( self : Optional[Any] ): __snake_case : Union[str, Any] = snapshot_download("""hf-internal-testing/processor_with_lm""" ) __snake_case : Dict = WavaVecaProcessorWithLM.from_pretrained(_lowerCAmelCase ) __snake_case : Optional[Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : List[str] = os.listdir(_lowerCAmelCase ) __snake_case : List[Any] = 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 snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : str = AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = floats_list((3, 10_00) ) __snake_case : Union[str, Any] = processor_wavaveca(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Union[str, Any] = 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 ) __snake_case : Dict = self._get_dummy_logits() __snake_case : List[Any] = processor_wavaveca.batch_decode(_lowerCAmelCase ) __snake_case : List[Any] = processor_auto.batch_decode(_lowerCAmelCase ) self.assertListEqual(decoded_wavaveca.text , decoded_auto.text ) def snake_case__ ( self : str ): __snake_case : int = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : Optional[Any] = self.get_decoder() __snake_case : Union[str, Any] = 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 snake_case__ ( _lowerCAmelCase : Any , _lowerCAmelCase : Tuple ): __snake_case : Union[str, Any] = [d[key] for d in offsets] return retrieved_list def snake_case__ ( self : Dict ): __snake_case : int = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : List[str] = self._get_dummy_logits()[0] __snake_case : str = 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 snake_case__ ( self : List[str] ): __snake_case : Any = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = self._get_dummy_logits() __snake_case : int = 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 snake_case__ ( self : Optional[Any] ): import torch __snake_case : Optional[Any] = load_dataset("""common_voice""" , """en""" , split="""train""" , streaming=_lowerCAmelCase ) __snake_case : Any = ds.cast_column("""audio""" , datasets.Audio(sampling_rate=1_60_00 ) ) __snake_case : List[Any] = iter(_lowerCAmelCase ) __snake_case : Optional[int] = next(_lowerCAmelCase ) __snake_case : str = AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) __snake_case : str = 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 __snake_case : List[str] = processor(sample["""audio"""]["""array"""] , return_tensors="""pt""" ).input_values with torch.no_grad(): __snake_case : Dict = model(_lowerCAmelCase ).logits.cpu().numpy() __snake_case : Any = processor.decode(logits[0] , output_word_offsets=_lowerCAmelCase ) __snake_case : Optional[Any] = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate __snake_case : Dict = [ { """start_time""": d["""start_offset"""] * time_offset, """end_time""": d["""end_offset"""] * time_offset, """word""": d["""word"""], } for d in output["""word_offsets"""] ] __snake_case : Dict = """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 __snake_case : Dict = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """start_time""" ) ) __snake_case : Optional[Any] = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """end_time""" ) ) # fmt: off __snake_case : Optional[Any] = torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599] ) __snake_case : Optional[int] = torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94] ) # fmt: on self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) ) self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) )
20
1
class SCREAMING_SNAKE_CASE__ : def __init__( self : Any , _lowerCAmelCase : Dict ): # we need a list not a string, so do something to change the type __snake_case : Any = arr.split(""",""" ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Optional[Any] = [int(self.array[0] )] * len(self.array ) __snake_case : Union[str, Any] = [int(self.array[0] )] * len(self.array ) for i in range(1 , len(self.array ) ): __snake_case : Optional[int] = max( int(self.array[i] ) + sum_value[i - 1] , int(self.array[i] ) ) __snake_case : int = max(sum_value[i] , rear[i - 1] ) return rear[len(self.array ) - 1] if __name__ == "__main__": lowercase_ = input("please input some numbers:") lowercase_ = SubArray(whole_array) lowercase_ = array.solve_sub_array() print(("the results is:", re))
20
import argparse import re import torch from CLAP import create_model from transformers import AutoFeatureExtractor, ClapConfig, ClapModel lowercase_ = { "text_branch": "text_model", "audio_branch": "audio_model.audio_encoder", "attn": "attention.self", "self.proj": "output.dense", "attention.self_mask": "attn_mask", "mlp.fc1": "intermediate.dense", "mlp.fc2": "output.dense", "norm1": "layernorm_before", "norm2": "layernorm_after", "bn0": "batch_norm", } lowercase_ = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc") def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any]=False ): '''simple docstring''' __snake_case , __snake_case : str = create_model( """HTSAT-tiny""" , """roberta""" , __SCREAMING_SNAKE_CASE , precision="""fp32""" , device="""cuda:0""" if torch.cuda.is_available() else """cpu""" , enable_fusion=__SCREAMING_SNAKE_CASE , fusion_type="""aff_2d""" if enable_fusion else None , ) return model, model_cfg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Union[str, Any] = {} __snake_case : List[Any] = R""".*sequential.(\d+).*""" __snake_case : Union[str, Any] = R""".*_projection.(\d+).*""" for key, value in state_dict.items(): # check if any key needs to be modified for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items(): if key_to_modify in key: __snake_case : Optional[Any] = key.replace(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): # replace sequential layers with list __snake_case : Optional[Any] = re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) __snake_case : Dict = key.replace(F'''sequential.{sequential_layer}.''' , F'''layers.{int(__SCREAMING_SNAKE_CASE )//3}.linear.''' ) elif re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : str = int(re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) ) # Because in CLAP they use `nn.Sequential`... __snake_case : List[Any] = 1 if projecton_layer == 0 else 2 __snake_case : Tuple = key.replace(F'''_projection.{projecton_layer}.''' , F'''_projection.linear{transformers_projection_layer}.''' ) if "audio" and "qkv" in key: # split qkv into query key and value __snake_case : Optional[int] = value __snake_case : Any = mixed_qkv.size(0 ) // 3 __snake_case : List[Any] = mixed_qkv[:qkv_dim] __snake_case : Tuple = mixed_qkv[qkv_dim : qkv_dim * 2] __snake_case : List[Any] = mixed_qkv[qkv_dim * 2 :] __snake_case : Any = query_layer __snake_case : Dict = key_layer __snake_case : Optional[Any] = value_layer else: __snake_case : List[str] = value return model_state_dict def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Optional[Any]=False ): '''simple docstring''' __snake_case , __snake_case : List[str] = init_clap(__SCREAMING_SNAKE_CASE , enable_fusion=__SCREAMING_SNAKE_CASE ) clap_model.eval() __snake_case : Tuple = clap_model.state_dict() __snake_case : Union[str, Any] = rename_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = ClapConfig() __snake_case : Tuple = enable_fusion __snake_case : Any = ClapModel(__SCREAMING_SNAKE_CASE ) # ignore the spectrogram embedding layer model.load_state_dict(__SCREAMING_SNAKE_CASE , strict=__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) transformers_config.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not") lowercase_ = parser.parse_args() convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
20
1
import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BlipaProcessor, BlipImageProcessor, GPTaTokenizer, PreTrainedTokenizerFast @require_vision class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Union[str, Any] ): __snake_case : Tuple = tempfile.mkdtemp() __snake_case : Any = BlipImageProcessor() __snake_case : Optional[Any] = GPTaTokenizer.from_pretrained("""hf-internal-testing/tiny-random-GPT2Model""" ) __snake_case : str = BlipaProcessor(_lowerCAmelCase , _lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) def snake_case__ ( self : List[Any] , **_lowerCAmelCase : Optional[int] ): return AutoProcessor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ).tokenizer def snake_case__ ( self : Any , **_lowerCAmelCase : Dict ): return AutoProcessor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ).image_processor def snake_case__ ( self : Any ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Dict ): __snake_case : Tuple = [np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta )] __snake_case : Optional[Any] = [Image.fromarray(np.moveaxis(_lowerCAmelCase , 0 , -1 ) ) for x in image_inputs] return image_inputs def snake_case__ ( self : Dict ): __snake_case : Union[str, Any] = BlipaProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) __snake_case : str = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) __snake_case : List[str] = self.get_image_processor(do_normalize=_lowerCAmelCase , padding_value=1.0 ) __snake_case : Tuple = BlipaProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=_lowerCAmelCase , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , _lowerCAmelCase ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , _lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : Union[str, Any] = self.get_image_processor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : List[str] = BlipaProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : List[Any] = self.prepare_image_inputs() __snake_case : str = image_processor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Optional[Any] = processor(images=_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 snake_case__ ( self : Dict ): __snake_case : Optional[Any] = self.get_image_processor() __snake_case : Dict = self.get_tokenizer() __snake_case : Optional[Any] = BlipaProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : Optional[int] = """lower newer""" __snake_case : str = processor(text=_lowerCAmelCase ) __snake_case : List[Any] = tokenizer(_lowerCAmelCase , return_token_type_ids=_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : int ): __snake_case : Tuple = self.get_image_processor() __snake_case : List[str] = self.get_tokenizer() __snake_case : Dict = BlipaProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : List[str] = """lower newer""" __snake_case : Union[str, Any] = self.prepare_image_inputs() __snake_case : Union[str, Any] = processor(text=_lowerCAmelCase , images=_lowerCAmelCase ) self.assertListEqual(list(inputs.keys() ) , ["""pixel_values""", """input_ids""", """attention_mask"""] ) # test if it raises when no input is passed with pytest.raises(_lowerCAmelCase ): processor() def snake_case__ ( self : Any ): __snake_case : List[str] = self.get_image_processor() __snake_case : Tuple = self.get_tokenizer() __snake_case : Dict = BlipaProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : Any = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] __snake_case : int = processor.batch_decode(_lowerCAmelCase ) __snake_case : Dict = tokenizer.batch_decode(_lowerCAmelCase ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Optional[int] ): __snake_case : str = self.get_image_processor() __snake_case : Optional[Any] = self.get_tokenizer() __snake_case : Optional[int] = BlipaProcessor(tokenizer=_lowerCAmelCase , image_processor=_lowerCAmelCase ) __snake_case : Optional[Any] = """lower newer""" __snake_case : str = self.prepare_image_inputs() __snake_case : List[Any] = processor(text=_lowerCAmelCase , images=_lowerCAmelCase ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ) , ["""pixel_values""", """input_ids""", """attention_mask"""] )
20
import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = "▁" lowercase_ = {"vocab_file": "vocab.txt", "sentencepiece_model_ckpt": "sentencepiece.bpe.model"} lowercase_ = { "sentencepiece_model_file": "sentencepiece.bpe.model", "vocab_file": "vocab.txt", } lowercase_ = { "vocab_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", }, "sentencepiece_model_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", }, } lowercase_ = { "ernie-m-base": 5_14, "ernie-m-large": 5_14, } lowercase_ = { "ernie-m-base": {"do_lower_case": False}, "ernie-m-large": {"do_lower_case": False}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = ["input_ids"] A : Tuple = VOCAB_FILES_NAMES A : List[Any] = PRETRAINED_INIT_CONFIGURATION A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP A : Optional[Any] = RESOURCE_FILES_NAMES def __init__( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : Dict=False , _lowerCAmelCase : List[Any]="utf8" , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : Optional[int]="[SEP]" , _lowerCAmelCase : List[str]="[PAD]" , _lowerCAmelCase : Dict="[CLS]" , _lowerCAmelCase : List[Any]="[MASK]" , _lowerCAmelCase : Optional[Dict[str, Any]] = None , **_lowerCAmelCase : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. __snake_case : List[Any] = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , vocab_file=_lowerCAmelCase , encoding=_lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCAmelCase , ) __snake_case : List[Any] = do_lower_case __snake_case : Any = sentencepiece_model_ckpt __snake_case : int = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCAmelCase ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: __snake_case : int = self.load_vocab(filepath=_lowerCAmelCase ) else: __snake_case : Tuple = {self.sp_model.id_to_piece(_lowerCAmelCase ): id for id in range(self.sp_model.get_piece_size() )} __snake_case : str = {v: k for k, v in self.vocab.items()} def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[Any] ): if text is None: return None __snake_case : List[Any] = self.tokenize(_lowerCAmelCase ) __snake_case , __snake_case : Optional[Any] = """""", [] for i, ch in enumerate(_lowerCAmelCase ): if ch in self.SP_CHAR_MAPPING: __snake_case : Any = self.SP_CHAR_MAPPING.get(_lowerCAmelCase ) else: __snake_case : Dict = unicodedata.normalize("""NFKC""" , _lowerCAmelCase ) if self.is_whitespace(_lowerCAmelCase ): continue normalized_text += ch char_mapping.extend([i] * len(_lowerCAmelCase ) ) __snake_case , __snake_case , __snake_case : str = normalized_text, [], 0 if self.do_lower_case: __snake_case : int = text.lower() for token in split_tokens: if token[:1] == "▁": __snake_case : int = token[1:] __snake_case : Optional[int] = text[offset:].index(_lowerCAmelCase ) + offset __snake_case : int = start + len(_lowerCAmelCase ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) __snake_case : str = end return token_mapping @property def snake_case__ ( self : Tuple ): return len(self.vocab ) def snake_case__ ( self : Dict ): return dict(self.vocab , **self.added_tokens_encoder ) def __getstate__( self : int ): __snake_case : str = self.__dict__.copy() __snake_case : Union[str, Any] = None return state def __setstate__( self : Optional[Any] , _lowerCAmelCase : List[str] ): __snake_case : Union[str, Any] = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): __snake_case : Optional[Any] = {} __snake_case : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def snake_case__ ( self : str , _lowerCAmelCase : Optional[int] ): return "".join((self.SP_CHAR_MAPPING.get(_lowerCAmelCase , _lowerCAmelCase ) for c in text) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Optional[Any]=64 , _lowerCAmelCase : Optional[int]=0.1 ): if self.sp_model_kwargs.get("""enable_sampling""" ) is True: __snake_case : List[str] = True if self.sp_model_kwargs.get("""alpha""" ) is not None: __snake_case : Dict = self.sp_model_kwargs.get("""alpha""" ) if self.sp_model_kwargs.get("""nbest_size""" ) is not None: __snake_case : List[Any] = self.sp_model_kwargs.get("""nbest_size""" ) if not enable_sampling: __snake_case : str = self.sp_model.EncodeAsPieces(_lowerCAmelCase ) else: __snake_case : Tuple = self.sp_model.SampleEncodeAsPieces(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = [] for pi, piece in enumerate(_lowerCAmelCase ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(_lowerCAmelCase ) and pi != 0: new_pieces.append(_lowerCAmelCase ) continue else: continue __snake_case : Optional[int] = 0 for i, chunk in enumerate(_lowerCAmelCase ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(_lowerCAmelCase ) or self.is_punct(_lowerCAmelCase ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(_lowerCAmelCase ) __snake_case : Tuple = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : List[str] = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : Tuple = i if len(_lowerCAmelCase ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): __snake_case : int = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): __snake_case : int = self.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : Any = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): return self.vocab.get(_lowerCAmelCase , self.vocab.get(self.unk_token ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Dict ): return self.reverse_vocab.get(_lowerCAmelCase , self.unk_token ) def snake_case__ ( self : Any , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any]=None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] __snake_case : Optional[Any] = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None ): if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Optional[Any]=False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( """You should not supply a second sequence if the provided sequence of """ """ids is already formatted with special tokens for the model.""" ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] + ([0] * len(_lowerCAmelCase )) + [1] return [1] + ([0] * len(_lowerCAmelCase )) + [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method if token_ids_a is None: # [CLS] X [SEP] return (len(_lowerCAmelCase ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(_lowerCAmelCase ) + 1) + [1] * (len(_lowerCAmelCase ) + 3) def snake_case__ ( self : Tuple , _lowerCAmelCase : List[str] ): if "\u4e00" <= char <= "\u9fff": return True return False def snake_case__ ( self : List[str] , _lowerCAmelCase : Any ): if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def snake_case__ ( self : int , _lowerCAmelCase : List[Any] ): if char in ",;:.?!~,;:。?!《》【】": return True return False def snake_case__ ( self : str , _lowerCAmelCase : Optional[Any] ): if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(_lowerCAmelCase ) == 1: __snake_case : Dict = unicodedata.category(_lowerCAmelCase ) if cat == "Zs": return True return False def snake_case__ ( self : str , _lowerCAmelCase : List[Any] ): __snake_case : Dict = {} with io.open(_lowerCAmelCase , """r""" , encoding="""utf-8""" ) as f: for index, line in enumerate(_lowerCAmelCase ): __snake_case : Tuple = line.rstrip("""\n""" ) __snake_case : List[str] = int(_lowerCAmelCase ) return token_to_idx def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : Optional[int] = 0 if os.path.isdir(_lowerCAmelCase ): __snake_case : int = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) else: __snake_case : Optional[Any] = (filename_prefix + """-""" if filename_prefix else """""") + save_directory with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as writer: for token, token_index in sorted(self.vocab.items() , key=lambda _lowerCAmelCase : kv[1] ): if index != token_index: logger.warning( f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.''' """ Please check that the vocabulary is not corrupted!""" ) __snake_case : Union[str, Any] = token_index writer.write(token + """\n""" ) index += 1 __snake_case : List[Any] = os.path.join(_lowerCAmelCase , """sentencepiece.bpe.model""" ) with open(_lowerCAmelCase , """wb""" ) as fi: __snake_case : List[Any] = self.sp_model.serialized_model_proto() fi.write(_lowerCAmelCase ) return (vocab_file,)
20
1
import os def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' __snake_case : List[str] = len(grid[0] ) __snake_case : int = len(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[int] = 0 __snake_case : Dict = 0 __snake_case : List[Any] = 0 # Check vertically, horizontally, diagonally at the same time (only works # for nxn grid) for i in range(__SCREAMING_SNAKE_CASE ): for j in range(n_rows - 3 ): __snake_case : Any = grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i] __snake_case : Union[str, Any] = grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3] # Left-to-right diagonal (\) product if i < n_columns - 3: __snake_case : Tuple = ( grid[i][j] * grid[i + 1][j + 1] * grid[i + 2][j + 2] * grid[i + 3][j + 3] ) # Right-to-left diagonal(/) product if i > 2: __snake_case : Union[str, Any] = ( grid[i][j] * grid[i - 1][j + 1] * grid[i - 2][j + 2] * grid[i - 3][j + 3] ) __snake_case : str = max( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if max_product > largest: __snake_case : List[Any] = max_product return largest def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Tuple = [] with open(os.path.dirname(__SCREAMING_SNAKE_CASE ) + """/grid.txt""" ) as file: for line in file: grid.append(line.strip("""\n""" ).split(""" """ ) ) __snake_case : Optional[int] = [[int(__SCREAMING_SNAKE_CASE ) for i in grid[j]] for j in range(len(__SCREAMING_SNAKE_CASE ) )] return largest_product(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": print(solution())
20
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "xlm-mlm-en-2048": "https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json", "xlm-mlm-ende-1024": "https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json", "xlm-mlm-enfr-1024": "https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json", "xlm-mlm-enro-1024": "https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json", "xlm-mlm-tlm-xnli15-1024": "https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json", "xlm-mlm-xnli15-1024": "https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json", "xlm-clm-enfr-1024": "https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json", "xlm-clm-ende-1024": "https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json", "xlm-mlm-17-1280": "https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json", "xlm-mlm-100-1280": "https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = "xlm" A : List[str] = { "hidden_size": "emb_dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", "n_words": "vocab_size", # For backward compatibility } def __init__( self : List[Any] , _lowerCAmelCase : Optional[Any]=3_01_45 , _lowerCAmelCase : Optional[Any]=20_48 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : int=16 , _lowerCAmelCase : Tuple=0.1 , _lowerCAmelCase : List[Any]=0.1 , _lowerCAmelCase : str=True , _lowerCAmelCase : List[str]=False , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Dict=False , _lowerCAmelCase : Dict=1 , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Optional[Any]=5_12 , _lowerCAmelCase : List[Any]=20_48**-0.5 , _lowerCAmelCase : List[str]=1e-12 , _lowerCAmelCase : List[Any]=0.02 , _lowerCAmelCase : List[str]=0 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Dict=2 , _lowerCAmelCase : List[str]=3 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : Optional[int]=True , _lowerCAmelCase : Tuple="first" , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any=0.1 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : List[str]=5 , _lowerCAmelCase : Optional[Any]=0 , _lowerCAmelCase : Tuple=0 , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Union[str, Any]=0 , **_lowerCAmelCase : Tuple , ): __snake_case : Optional[Any] = vocab_size __snake_case : Tuple = emb_dim __snake_case : int = n_layers __snake_case : List[str] = n_heads __snake_case : Union[str, Any] = dropout __snake_case : Optional[int] = attention_dropout __snake_case : Optional[Any] = gelu_activation __snake_case : Tuple = sinusoidal_embeddings __snake_case : List[Any] = causal __snake_case : Dict = asm __snake_case : int = n_langs __snake_case : str = use_lang_emb __snake_case : Dict = layer_norm_eps __snake_case : List[Any] = bos_index __snake_case : Union[str, Any] = eos_index __snake_case : Dict = pad_index __snake_case : Any = unk_index __snake_case : Dict = mask_index __snake_case : Any = is_encoder __snake_case : Dict = max_position_embeddings __snake_case : Optional[Any] = embed_init_std __snake_case : List[Any] = init_std __snake_case : str = summary_type __snake_case : Optional[Any] = summary_use_proj __snake_case : str = summary_activation __snake_case : Optional[int] = summary_proj_to_labels __snake_case : Dict = summary_first_dropout __snake_case : Dict = start_n_top __snake_case : int = end_n_top __snake_case : str = mask_token_id __snake_case : int = lang_id if "n_words" in kwargs: __snake_case : Dict = kwargs["""n_words"""] super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Dict ): if self.task == "multiple-choice": __snake_case : Optional[int] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : Tuple = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis), ] )
20
1
import os import unittest from transformers import LxmertTokenizer, LxmertTokenizerFast from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , unittest.TestCase ): A : List[Any] = LxmertTokenizer A : Optional[Any] = LxmertTokenizerFast A : Dict = True A : Union[str, Any] = True def snake_case__ ( self : int ): super().setUp() __snake_case : Optional[int] = [ """[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest""", ] __snake_case : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] ): __snake_case : Union[str, Any] = """UNwant\u00E9d,running""" __snake_case : List[Any] = """unwanted, running""" return input_text, output_text def snake_case__ ( self : Any ): __snake_case : Optional[int] = self.tokenizer_class(self.vocab_file ) __snake_case : str = tokenizer.tokenize("""UNwant\u00E9d,running""" ) self.assertListEqual(_lowerCAmelCase , ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCAmelCase ) , [7, 4, 5, 10, 8, 9] ) def snake_case__ ( self : Union[str, Any] ): if not self.test_rust_tokenizer: return __snake_case : Optional[Any] = self.get_tokenizer() __snake_case : int = self.get_rust_tokenizer() __snake_case : List[Any] = """I was born in 92000, and this is falsé.""" __snake_case : int = tokenizer.tokenize(_lowerCAmelCase ) __snake_case : Dict = rust_tokenizer.tokenize(_lowerCAmelCase ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : List[Any] = tokenizer.encode(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) __snake_case : Dict = rust_tokenizer.encode(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = self.get_rust_tokenizer() __snake_case : int = tokenizer.encode(_lowerCAmelCase ) __snake_case : Optional[Any] = rust_tokenizer.encode(_lowerCAmelCase ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase )
20
import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "facebook/encodec_24khz": "https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json", "facebook/encodec_48khz": "https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[Any] = "encodec" def __init__( self : Tuple , _lowerCAmelCase : Union[str, Any]=[1.5, 3.0, 6.0, 12.0, 24.0] , _lowerCAmelCase : Tuple=2_40_00 , _lowerCAmelCase : List[Any]=1 , _lowerCAmelCase : Optional[int]=False , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : int=1_28 , _lowerCAmelCase : List[Any]=32 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Union[str, Any]=[8, 5, 4, 2] , _lowerCAmelCase : str="weight_norm" , _lowerCAmelCase : Tuple=7 , _lowerCAmelCase : str=7 , _lowerCAmelCase : Any=3 , _lowerCAmelCase : int=2 , _lowerCAmelCase : str=True , _lowerCAmelCase : Dict="reflect" , _lowerCAmelCase : Tuple=2 , _lowerCAmelCase : List[Any]=2 , _lowerCAmelCase : int=1.0 , _lowerCAmelCase : Optional[int]=10_24 , _lowerCAmelCase : int=None , _lowerCAmelCase : List[str]=True , **_lowerCAmelCase : List[Any] , ): __snake_case : Optional[int] = target_bandwidths __snake_case : int = sampling_rate __snake_case : List[Any] = audio_channels __snake_case : str = normalize __snake_case : Union[str, Any] = chunk_length_s __snake_case : Union[str, Any] = overlap __snake_case : Union[str, Any] = hidden_size __snake_case : Union[str, Any] = num_filters __snake_case : Optional[Any] = num_residual_layers __snake_case : List[Any] = upsampling_ratios __snake_case : List[str] = norm_type __snake_case : Union[str, Any] = kernel_size __snake_case : Optional[int] = last_kernel_size __snake_case : Optional[Any] = residual_kernel_size __snake_case : Dict = dilation_growth_rate __snake_case : int = use_causal_conv __snake_case : Tuple = pad_mode __snake_case : str = compress __snake_case : Optional[Any] = num_lstm_layers __snake_case : List[Any] = trim_right_ratio __snake_case : Any = codebook_size __snake_case : int = codebook_dim if codebook_dim is not None else hidden_size __snake_case : int = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( f'''self.norm_type must be one of `"weight_norm"`, `"time_group_norm"`), got {self.norm_type}''' ) super().__init__(**_lowerCAmelCase ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def snake_case__ ( self : Tuple ): return int(10_00 * self.target_bandwidths[-1] // (self.frame_rate * 10) )
20
1
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_mobilebert import MobileBertTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": {"mobilebert-uncased": "https://huggingface.co/google/mobilebert-uncased/resolve/main/vocab.txt"}, "tokenizer_file": { "mobilebert-uncased": "https://huggingface.co/google/mobilebert-uncased/resolve/main/tokenizer.json" }, } lowercase_ = {"mobilebert-uncased": 5_12} lowercase_ = {} class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : int = VOCAB_FILES_NAMES A : Optional[Any] = PRETRAINED_VOCAB_FILES_MAP A : Dict = PRETRAINED_INIT_CONFIGURATION A : List[Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : List[Any] = MobileBertTokenizer def __init__( self : Any , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Optional[int]=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : List[Any]="[SEP]" , _lowerCAmelCase : List[Any]="[PAD]" , _lowerCAmelCase : Union[str, Any]="[CLS]" , _lowerCAmelCase : Union[str, Any]="[MASK]" , _lowerCAmelCase : Optional[int]=True , _lowerCAmelCase : Dict=None , **_lowerCAmelCase : List[str] , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Union[str, Any] = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or normalizer_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents or normalizer_state.get("""handle_chinese_chars""" , _lowerCAmelCase ) != tokenize_chinese_chars ): __snake_case : Any = getattr(_lowerCAmelCase , normalizer_state.pop("""type""" ) ) __snake_case : List[str] = do_lower_case __snake_case : Optional[int] = strip_accents __snake_case : Union[str, Any] = tokenize_chinese_chars __snake_case : int = normalizer_class(**_lowerCAmelCase ) __snake_case : Any = do_lower_case def snake_case__ ( self : Tuple , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Union[str, Any]=None ): __snake_case : Optional[Any] = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : str , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : Optional[Any] = [self.sep_token_id] __snake_case : List[str] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : str = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase )
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : str = [] __snake_case , __snake_case : List[str] = input_list[low:mid], input_list[mid : high + 1] while left and right: result.append((left if left[0] <= right[0] else right).pop(0 ) ) __snake_case : List[Any] = result + left + right return input_list def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if len(__SCREAMING_SNAKE_CASE ) <= 1: return input_list __snake_case : Union[str, Any] = list(__SCREAMING_SNAKE_CASE ) # iteration for two-way merging __snake_case : Tuple = 2 while p <= len(__SCREAMING_SNAKE_CASE ): # getting low, high and middle value for merge-sort of single list for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = i + p - 1 __snake_case : Optional[Any] = (low + high + 1) // 2 __snake_case : str = merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # final merge of last two parts if p * 2 >= len(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = merge(__SCREAMING_SNAKE_CASE , 0 , __SCREAMING_SNAKE_CASE , len(__SCREAMING_SNAKE_CASE ) - 1 ) break p *= 2 return input_list if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() if user_input == "": lowercase_ = [] else: lowercase_ = [int(item.strip()) for item in user_input.split(",")] print(iter_merge_sort(unsorted))
20
1
import math_equivalence # From: git+https://github.com/hendrycks/math.git import datasets lowercase_ = "\\n@article{hendrycksmath2021,\n title={Measuring Mathematical Problem Solving With the MATH Dataset},\n author={Dan Hendrycks\n and Collin Burns\n and Saurav Kadavath\n and Akul Arora\n and Steven Basart\n and Eric Tang\n and Dawn Song\n and Jacob Steinhardt},\n journal={arXiv preprint arXiv:2103.03874},\n year={2021}\n}\n" lowercase_ = "\\nThis metric is used to assess performance on the Mathematics Aptitude Test of Heuristics (MATH) dataset.\nIt first canonicalizes the inputs (e.g., converting \"1/2\" to \"\\frac{1}{2}\") and then computes accuracy.\n" lowercase_ = r"\nCalculates accuracy after canonicalizing inputs.\n\nArgs:\n predictions: list of predictions to score. Each prediction\n is a string that contains natural language and LaTex.\n references: list of reference for each prediction. Each\n reference is a string that contains natural language\n and LaTex.\nReturns:\n accuracy: accuracy after canonicalizing inputs\n (e.g., converting \"1/2\" to \"\\frac{1}{2}\")\n\nExamples:\n >>> metric = datasets.load_metric(\"competition_math\")\n >>> results = metric.compute(references=[\"\\frac{1}{2}\"], predictions=[\"1/2\"])\n >>> print(results)\n {'accuracy': 1.0}\n" @datasets.utils.file_utils.add_end_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class SCREAMING_SNAKE_CASE__ ( datasets.Metric ): def snake_case__ ( self : List[Any] ): return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Value("""string""" ), """references""": datasets.Value("""string""" ), } ) , homepage="""https://github.com/hendrycks/math""" , codebase_urls=["""https://github.com/hendrycks/math"""] , ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : Tuple ): __snake_case : Optional[int] = 0.0 for i, j in zip(_lowerCAmelCase , _lowerCAmelCase ): n_correct += 1.0 if math_equivalence.is_equiv(_lowerCAmelCase , _lowerCAmelCase ) else 0.0 __snake_case : Optional[int] = n_correct / len(_lowerCAmelCase ) return { "accuracy": accuracy, }
20
import random import sys import numpy as np from matplotlib import pyplot as plt from matplotlib.colors import ListedColormap lowercase_ = "Usage of script: script_name <size_of_canvas:int>" lowercase_ = [0] * 1_00 + [1] * 10 random.shuffle(choice) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : List[str] = [[False for i in range(__SCREAMING_SNAKE_CASE )] for j in range(__SCREAMING_SNAKE_CASE )] return canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' for i, row in enumerate(__SCREAMING_SNAKE_CASE ): for j, _ in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : int = bool(random.getrandbits(1 ) ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Union[str, Any] = np.array(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = np.array(create_canvas(current_canvas.shape[0] ) ) for r, row in enumerate(__SCREAMING_SNAKE_CASE ): for c, pt in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : Optional[Any] = __judge_point( __SCREAMING_SNAKE_CASE , current_canvas[r - 1 : r + 2, c - 1 : c + 2] ) __snake_case : List[str] = next_gen_canvas del next_gen_canvas # cleaning memory as we move on. __snake_case : list[list[bool]] = current_canvas.tolist() return return_canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Any = 0 __snake_case : Dict = 0 # finding dead or alive neighbours count. for i in neighbours: for status in i: if status: alive += 1 else: dead += 1 # handling duplicate entry for focus pt. if pt: alive -= 1 else: dead -= 1 # running the rules of game here. __snake_case : str = pt if pt: if alive < 2: __snake_case : Optional[Any] = False elif alive == 2 or alive == 3: __snake_case : Union[str, Any] = True elif alive > 3: __snake_case : Optional[int] = False else: if alive == 3: __snake_case : List[Any] = True return state if __name__ == "__main__": if len(sys.argv) != 2: raise Exception(usage_doc) lowercase_ = int(sys.argv[1]) # main working structure of this module. lowercase_ = create_canvas(canvas_size) seed(c) lowercase_ , lowercase_ = plt.subplots() fig.show() lowercase_ = ListedColormap(["w", "k"]) try: while True: lowercase_ = run(c) ax.matshow(c, cmap=cmap) fig.canvas.draw() ax.cla() except KeyboardInterrupt: # do nothing. pass
20
1
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "camembert-base": "https://huggingface.co/camembert-base/resolve/main/config.json", "umberto-commoncrawl-cased-v1": ( "https://huggingface.co/Musixmatch/umberto-commoncrawl-cased-v1/resolve/main/config.json" ), "umberto-wikipedia-uncased-v1": ( "https://huggingface.co/Musixmatch/umberto-wikipedia-uncased-v1/resolve/main/config.json" ), } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Union[str, Any] = "camembert" def __init__( self : str , _lowerCAmelCase : int=3_05_22 , _lowerCAmelCase : Dict=7_68 , _lowerCAmelCase : Tuple=12 , _lowerCAmelCase : Union[str, Any]=12 , _lowerCAmelCase : str=30_72 , _lowerCAmelCase : Tuple="gelu" , _lowerCAmelCase : int=0.1 , _lowerCAmelCase : int=0.1 , _lowerCAmelCase : Optional[Any]=5_12 , _lowerCAmelCase : str=2 , _lowerCAmelCase : Tuple=0.02 , _lowerCAmelCase : Tuple=1e-12 , _lowerCAmelCase : List[str]=1 , _lowerCAmelCase : Union[str, Any]=0 , _lowerCAmelCase : Dict=2 , _lowerCAmelCase : str="absolute" , _lowerCAmelCase : Any=True , _lowerCAmelCase : int=None , **_lowerCAmelCase : Optional[Any] , ): super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , eos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Optional[int] = vocab_size __snake_case : Dict = hidden_size __snake_case : Any = num_hidden_layers __snake_case : Union[str, Any] = num_attention_heads __snake_case : Any = hidden_act __snake_case : List[str] = intermediate_size __snake_case : List[str] = hidden_dropout_prob __snake_case : List[str] = attention_probs_dropout_prob __snake_case : Tuple = max_position_embeddings __snake_case : str = type_vocab_size __snake_case : str = initializer_range __snake_case : Optional[Any] = layer_norm_eps __snake_case : Tuple = position_embedding_type __snake_case : Dict = use_cache __snake_case : List[Any] = classifier_dropout class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Dict ): if self.task == "multiple-choice": __snake_case : Dict = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : List[Any] = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ] )
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def __lowerCAmelCase ( *__SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Optional[Union[Dict, Any]] = None , __SCREAMING_SNAKE_CASE : Any=True , __SCREAMING_SNAKE_CASE : int=2 ): '''simple docstring''' from .. import __version__ __snake_case : List[Any] = take_from __snake_case : List[Any] = () if not isinstance(args[0] , __SCREAMING_SNAKE_CASE ): __snake_case : str = (args,) for attribute, version_name, message in args: if version.parse(version.parse(__SCREAMING_SNAKE_CASE ).base_version ) >= version.parse(__SCREAMING_SNAKE_CASE ): raise ValueError( F'''The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers\'''' F''' version {__version__} is >= {version_name}''' ) __snake_case : Optional[Any] = None if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(__SCREAMING_SNAKE_CASE ),) __snake_case : Optional[Any] = F'''The `{attribute}` argument is deprecated and will be removed in version {version_name}.''' elif hasattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): values += (getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ),) __snake_case : Any = F'''The `{attribute}` attribute is deprecated and will be removed in version {version_name}.''' elif deprecated_kwargs is None: __snake_case : Tuple = F'''`{attribute}` is deprecated and will be removed in version {version_name}.''' if warning is not None: __snake_case : Optional[Any] = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , __SCREAMING_SNAKE_CASE , stacklevel=__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and len(__SCREAMING_SNAKE_CASE ) > 0: __snake_case : Dict = inspect.getouterframes(inspect.currentframe() )[1] __snake_case : int = call_frame.filename __snake_case : int = call_frame.lineno __snake_case : List[str] = call_frame.function __snake_case , __snake_case : List[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(F'''{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`''' ) if len(__SCREAMING_SNAKE_CASE ) == 0: return elif len(__SCREAMING_SNAKE_CASE ) == 1: return values[0] return values
20
1
from collections import OrderedDict from typing import Any, Mapping, Optional from ... import PreTrainedTokenizer, TensorType, is_torch_available from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfigWithPast from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "EleutherAI/gpt-neo-1.3B": "https://huggingface.co/EleutherAI/gpt-neo-1.3B/resolve/main/config.json", # See all GPTNeo models at https://huggingface.co/models?filter=gpt_neo } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : int = "gpt_neo" A : List[Any] = ["past_key_values"] A : Dict = {"num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"} def __init__( self : Any , _lowerCAmelCase : Optional[Any]=5_02_57 , _lowerCAmelCase : Any=20_48 , _lowerCAmelCase : Tuple=20_48 , _lowerCAmelCase : Dict=24 , _lowerCAmelCase : Any=[[["global", "local"], 12]] , _lowerCAmelCase : int=16 , _lowerCAmelCase : str=None , _lowerCAmelCase : List[str]=2_56 , _lowerCAmelCase : Union[str, Any]="gelu_new" , _lowerCAmelCase : Dict=0.0 , _lowerCAmelCase : int=0.0 , _lowerCAmelCase : Optional[int]=0.0 , _lowerCAmelCase : Optional[Any]=0.1 , _lowerCAmelCase : Tuple=1e-5 , _lowerCAmelCase : List[str]=0.02 , _lowerCAmelCase : Dict=True , _lowerCAmelCase : Any=5_02_56 , _lowerCAmelCase : Union[str, Any]=5_02_56 , **_lowerCAmelCase : Optional[int] , ): __snake_case : Optional[Any] = vocab_size __snake_case : Optional[Any] = max_position_embeddings __snake_case : Optional[Any] = hidden_size __snake_case : Optional[int] = num_layers __snake_case : Tuple = num_heads __snake_case : Tuple = intermediate_size __snake_case : str = window_size __snake_case : Dict = activation_function __snake_case : Union[str, Any] = resid_dropout __snake_case : Union[str, Any] = embed_dropout __snake_case : Optional[int] = attention_dropout __snake_case : Optional[Any] = classifier_dropout __snake_case : str = layer_norm_epsilon __snake_case : Dict = initializer_range __snake_case : Optional[Any] = use_cache __snake_case : Any = bos_token_id __snake_case : Tuple = eos_token_id __snake_case : Dict = attention_types __snake_case : Union[str, Any] = self.expand_attention_types_params(_lowerCAmelCase ) if len(self.attention_layers ) != self.num_layers: raise ValueError( """Configuration for convolutional module is incorrect. """ """It is required that `len(config.attention_layers)` == `config.num_layers` """ f'''but is `len(config.attention_layers) = {len(self.attention_layers )}`, ''' f'''`config.num_layers = {self.num_layers}`. ''' """`config.attention_layers` is prepared using `config.attention_types`. """ """Please verify the value of `config.attention_types` argument.""" ) super().__init__(bos_token_id=_lowerCAmelCase , eos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) @staticmethod def snake_case__ ( _lowerCAmelCase : Optional[Any] ): __snake_case : Union[str, Any] = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' import torch __snake_case : Optional[int] = input.size() __snake_case : Optional[int] = len(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[int] = shape[dimension] __snake_case : Optional[Any] = torch.arange(0 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : int = torch.div(sizedim - size , __SCREAMING_SNAKE_CASE , rounding_mode="""floor""" ) + 1 __snake_case : Optional[Any] = torch.arange(__SCREAMING_SNAKE_CASE ) + low_indices[:min_length][:, None] __snake_case : List[str] = [slice(__SCREAMING_SNAKE_CASE )] * rank __snake_case : Optional[int] = indices __snake_case : Any = input[s] __snake_case : Any = list(range(0 , rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' import torch __snake_case : Optional[int] = torch.arange(1 , __SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = torch.remainder(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : str = remainders == 0 __snake_case : int = candidates[divisor_indices] __snake_case : List[Any] = torch.max(__SCREAMING_SNAKE_CASE ) return largest_divisor, torch.div(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , rounding_mode="""floor""" ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Optional[Any] ): __snake_case : Union[str, Any] = OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}} ) if self.use_past: self.fill_with_past_key_values_(_lowerCAmelCase , direction="""inputs""" ) __snake_case : Tuple = {0: """batch""", 1: """past_sequence + sequence"""} else: __snake_case : Dict = {0: """batch""", 1: """sequence"""} return common_inputs @property def snake_case__ ( self : List[str] ): return self._config.num_heads def snake_case__ ( self : Any , _lowerCAmelCase : PreTrainedTokenizer , _lowerCAmelCase : int = -1 , _lowerCAmelCase : int = -1 , _lowerCAmelCase : bool = False , _lowerCAmelCase : Optional[TensorType] = None , ): __snake_case : Optional[int] = super(_lowerCAmelCase , self ).generate_dummy_inputs( _lowerCAmelCase , batch_size=_lowerCAmelCase , seq_length=_lowerCAmelCase , is_pair=_lowerCAmelCase , framework=_lowerCAmelCase ) # We need to order the input in the way they appears in the forward() __snake_case : Optional[int] = OrderedDict({"""input_ids""": common_inputs["""input_ids"""]} ) # Need to add the past_keys if self.use_past: if not is_torch_available(): raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed.""" ) else: import torch __snake_case , __snake_case : Tuple = common_inputs["""input_ids"""].shape # Not using the same length for past_key_values __snake_case : Optional[Any] = seqlen + 2 __snake_case : List[str] = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) __snake_case : Optional[int] = [ (torch.zeros(_lowerCAmelCase ), torch.zeros(_lowerCAmelCase )) for _ in range(self.num_layers ) ] __snake_case : Optional[int] = common_inputs["""attention_mask"""] if self.use_past: __snake_case : List[str] = ordered_inputs["""attention_mask"""].dtype __snake_case : Optional[Any] = torch.cat( [ordered_inputs["""attention_mask"""], torch.ones(_lowerCAmelCase , _lowerCAmelCase , dtype=_lowerCAmelCase )] , dim=1 ) return ordered_inputs @property def snake_case__ ( self : List[Any] ): return 13
20
import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() lowercase_ = { "bart": ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), "bert": ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-uncased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-cased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-base-cased-finetuned-mrpc": ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "dpr": ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), "gpt2": ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlnet": ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm": ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm-roberta": ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "transfo-xl": ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "openai-gpt": ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "roberta": ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "layoutlm": ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), "roberta-large-mnli": ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "camembert": ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "flaubert": ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert": ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert-base-distilled-squad": ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert": ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert-visual-feature-encoder": ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "ctrl": ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "albert": ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "t5": ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "electra": ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "wav2vec2": ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str]=False , __SCREAMING_SNAKE_CASE : List[Any]=True ): '''simple docstring''' if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case : Any = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) __snake_case : Dict = config_class.from_json_file(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = True __snake_case : Union[str, Any] = True print(F'''Building TensorFlow model from configuration: {config}''' ) __snake_case : List[Any] = model_class(__SCREAMING_SNAKE_CASE ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): __snake_case : Optional[Any] = cached_file( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: __snake_case : List[Any] = load_pytorch_checkpoint_in_tfa_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if compare_with_pt_model: __snake_case : Tuple = tf_model(tf_model.dummy_inputs , training=__SCREAMING_SNAKE_CASE ) # build the network __snake_case : List[str] = torch.load(__SCREAMING_SNAKE_CASE , map_location="""cpu""" ) __snake_case : Any = pt_model_class.from_pretrained( pretrained_model_name_or_path=__SCREAMING_SNAKE_CASE , config=__SCREAMING_SNAKE_CASE , state_dict=__SCREAMING_SNAKE_CASE ) with torch.no_grad(): __snake_case : Union[str, Any] = pt_model(**pt_model.dummy_inputs ) __snake_case : Any = pto[0].numpy() __snake_case : Optional[int] = tfo[0].numpy() __snake_case : Optional[int] = np.amax(np.abs(np_pt - np_tf ) ) print(F'''Max absolute difference between models outputs {diff}''' ) assert diff <= 2E-2, F'''Error, model absolute difference is >2e-2: {diff}''' # Save pytorch-model print(F'''Save TensorFlow model to {tf_dump_path}''' ) tf_model.save_weights(__SCREAMING_SNAKE_CASE , save_format="""h5""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : List[str]=None , __SCREAMING_SNAKE_CASE : Any=None , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : List[Any]=False , __SCREAMING_SNAKE_CASE : Any=False , ): '''simple docstring''' if args_model_type is None: __snake_case : Tuple = list(MODEL_CLASSES.keys() ) else: __snake_case : Union[str, Any] = [args_model_type] for j, model_type in enumerate(__SCREAMING_SNAKE_CASE , start=1 ): print("""=""" * 1_0_0 ) print(F''' Converting model type {j}/{len(__SCREAMING_SNAKE_CASE )}: {model_type}''' ) print("""=""" * 1_0_0 ) if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case , __snake_case : Optional[int] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: __snake_case : int = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: __snake_case : Union[str, Any] = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , start=1 ): print("""-""" * 1_0_0 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(F''' Skipping finetuned checkpoint {model_shortcut_name}''' ) continue __snake_case : List[Any] = model_shortcut_name elif only_convert_finetuned_models: print(F''' Skipping not finetuned checkpoint {model_shortcut_name}''' ) continue print( F''' Converting checkpoint {i}/{len(__SCREAMING_SNAKE_CASE )}: {model_shortcut_name} - model_type {model_type}''' ) print("""-""" * 1_0_0 ) if config_shortcut_name in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : Dict = config_shortcut_name if model_shortcut_name in aws_model_maps: __snake_case : Union[str, Any] = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : List[Any] = model_shortcut_name if os.path.isfile(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = """converted_model""" convert_pt_checkpoint_to_tf( model_type=__SCREAMING_SNAKE_CASE , pytorch_checkpoint_path=__SCREAMING_SNAKE_CASE , config_file=__SCREAMING_SNAKE_CASE , tf_dump_path=os.path.join(__SCREAMING_SNAKE_CASE , model_shortcut_name + """-tf_model.h5""" ) , compare_with_pt_model=__SCREAMING_SNAKE_CASE , ) if remove_cached_files: os.remove(__SCREAMING_SNAKE_CASE ) os.remove(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--tf_dump_path", default=None, type=str, required=True, help="Path to the output Tensorflow dump file." ) parser.add_argument( "--model_type", default=None, type=str, help=( F'''Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ''' "convert all the models from AWS." ), ) parser.add_argument( "--pytorch_checkpoint_path", default=None, type=str, help=( "Path to the PyTorch checkpoint path or shortcut name to download from AWS. " "If not given, will download and convert all the checkpoints from AWS." ), ) parser.add_argument( "--config_file", default=None, type=str, help=( "The config json file corresponding to the pre-trained model. \n" "This specifies the model architecture. If not given and " "--pytorch_checkpoint_path is not given or is a shortcut name " "use the configuration associated to the shortcut name on the AWS" ), ) parser.add_argument( "--compare_with_pt_model", action="store_true", help="Compare Tensorflow and PyTorch model predictions." ) parser.add_argument( "--use_cached_models", action="store_true", help="Use cached models if possible instead of updating to latest checkpoint versions.", ) parser.add_argument( "--remove_cached_files", action="store_true", help="Remove pytorch models after conversion (save memory when converting in batches).", ) parser.add_argument("--only_convert_finetuned_models", action="store_true", help="Only convert finetuned models.") lowercase_ = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
20
1
import argparse import re import torch from CLAP import create_model from transformers import AutoFeatureExtractor, ClapConfig, ClapModel lowercase_ = { "text_branch": "text_model", "audio_branch": "audio_model.audio_encoder", "attn": "attention.self", "self.proj": "output.dense", "attention.self_mask": "attn_mask", "mlp.fc1": "intermediate.dense", "mlp.fc2": "output.dense", "norm1": "layernorm_before", "norm2": "layernorm_after", "bn0": "batch_norm", } lowercase_ = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc") def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any]=False ): '''simple docstring''' __snake_case , __snake_case : str = create_model( """HTSAT-tiny""" , """roberta""" , __SCREAMING_SNAKE_CASE , precision="""fp32""" , device="""cuda:0""" if torch.cuda.is_available() else """cpu""" , enable_fusion=__SCREAMING_SNAKE_CASE , fusion_type="""aff_2d""" if enable_fusion else None , ) return model, model_cfg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Union[str, Any] = {} __snake_case : List[Any] = R""".*sequential.(\d+).*""" __snake_case : Union[str, Any] = R""".*_projection.(\d+).*""" for key, value in state_dict.items(): # check if any key needs to be modified for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items(): if key_to_modify in key: __snake_case : Optional[Any] = key.replace(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): # replace sequential layers with list __snake_case : Optional[Any] = re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) __snake_case : Dict = key.replace(F'''sequential.{sequential_layer}.''' , F'''layers.{int(__SCREAMING_SNAKE_CASE )//3}.linear.''' ) elif re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : str = int(re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) ) # Because in CLAP they use `nn.Sequential`... __snake_case : List[Any] = 1 if projecton_layer == 0 else 2 __snake_case : Tuple = key.replace(F'''_projection.{projecton_layer}.''' , F'''_projection.linear{transformers_projection_layer}.''' ) if "audio" and "qkv" in key: # split qkv into query key and value __snake_case : Optional[int] = value __snake_case : Any = mixed_qkv.size(0 ) // 3 __snake_case : List[Any] = mixed_qkv[:qkv_dim] __snake_case : Tuple = mixed_qkv[qkv_dim : qkv_dim * 2] __snake_case : List[Any] = mixed_qkv[qkv_dim * 2 :] __snake_case : Any = query_layer __snake_case : Dict = key_layer __snake_case : Optional[Any] = value_layer else: __snake_case : List[str] = value return model_state_dict def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Optional[Any]=False ): '''simple docstring''' __snake_case , __snake_case : List[str] = init_clap(__SCREAMING_SNAKE_CASE , enable_fusion=__SCREAMING_SNAKE_CASE ) clap_model.eval() __snake_case : Tuple = clap_model.state_dict() __snake_case : Union[str, Any] = rename_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = ClapConfig() __snake_case : Tuple = enable_fusion __snake_case : Any = ClapModel(__SCREAMING_SNAKE_CASE ) # ignore the spectrogram embedding layer model.load_state_dict(__SCREAMING_SNAKE_CASE , strict=__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) transformers_config.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not") lowercase_ = parser.parse_args() convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
20
import random def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case , __snake_case , __snake_case : Tuple = [], [], [] for element in data: if element < pivot: less.append(__SCREAMING_SNAKE_CASE ) elif element > pivot: greater.append(__SCREAMING_SNAKE_CASE ) else: equal.append(__SCREAMING_SNAKE_CASE ) return less, equal, greater def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' # index = len(items) // 2 when trying to find the median # (value of index when items is sorted) # invalid input if index >= len(__SCREAMING_SNAKE_CASE ) or index < 0: return None __snake_case : int = items[random.randint(0 , len(__SCREAMING_SNAKE_CASE ) - 1 )] __snake_case : Tuple = 0 __snake_case , __snake_case , __snake_case : List[str] = _partition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = len(__SCREAMING_SNAKE_CASE ) __snake_case : int = len(__SCREAMING_SNAKE_CASE ) # index is the pivot if m <= index < m + count: return pivot # must be in smaller elif m > index: return quick_select(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # must be in larger else: return quick_select(__SCREAMING_SNAKE_CASE , index - (m + count) )
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' __snake_case : Tuple = hex_num.strip() if not hex_num: raise ValueError("""No value was passed to the function""" ) __snake_case : List[Any] = hex_num[0] == """-""" if is_negative: __snake_case : int = hex_num[1:] try: __snake_case : Any = int(__SCREAMING_SNAKE_CASE , 1_6 ) except ValueError: raise ValueError("""Invalid value was passed to the function""" ) __snake_case : Union[str, Any] = """""" while int_num > 0: __snake_case : int = str(int_num % 2 ) + bin_str int_num >>= 1 return int(("""-""" + bin_str) if is_negative else bin_str ) if __name__ == "__main__": import doctest doctest.testmod()
20
import json from typing import List, Optional, Tuple from tokenizers import normalizers from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_roformer import RoFormerTokenizer from .tokenization_utils import JiebaPreTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": { "junnyu/roformer_chinese_small": "https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt", "junnyu/roformer_chinese_base": "https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt", "junnyu/roformer_chinese_char_small": ( "https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt" ), "junnyu/roformer_chinese_char_base": ( "https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt" ), "junnyu/roformer_small_discriminator": ( "https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt" ), "junnyu/roformer_small_generator": ( "https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt" ), } } lowercase_ = { "junnyu/roformer_chinese_small": 15_36, "junnyu/roformer_chinese_base": 15_36, "junnyu/roformer_chinese_char_small": 5_12, "junnyu/roformer_chinese_char_base": 5_12, "junnyu/roformer_small_discriminator": 1_28, "junnyu/roformer_small_generator": 1_28, } lowercase_ = { "junnyu/roformer_chinese_small": {"do_lower_case": True}, "junnyu/roformer_chinese_base": {"do_lower_case": True}, "junnyu/roformer_chinese_char_small": {"do_lower_case": True}, "junnyu/roformer_chinese_char_base": {"do_lower_case": True}, "junnyu/roformer_small_discriminator": {"do_lower_case": True}, "junnyu/roformer_small_generator": {"do_lower_case": True}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = VOCAB_FILES_NAMES A : Optional[int] = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : int = PRETRAINED_INIT_CONFIGURATION A : List[str] = RoFormerTokenizer def __init__( self : Optional[Any] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any="[UNK]" , _lowerCAmelCase : int="[SEP]" , _lowerCAmelCase : Optional[int]="[PAD]" , _lowerCAmelCase : Optional[int]="[CLS]" , _lowerCAmelCase : Optional[Any]="[MASK]" , _lowerCAmelCase : Optional[Any]=True , _lowerCAmelCase : Optional[Any]=None , **_lowerCAmelCase : Dict , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Dict = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( pre_tok_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or pre_tok_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents ): __snake_case : Tuple = getattr(_lowerCAmelCase , pre_tok_state.pop("""type""" ) ) __snake_case : List[Any] = do_lower_case __snake_case : Optional[Any] = strip_accents __snake_case : List[str] = pre_tok_class(**_lowerCAmelCase ) __snake_case : Optional[Any] = do_lower_case def __getstate__( self : Optional[Any] ): __snake_case : Optional[int] = self.__dict__.copy() __snake_case : Optional[Any] = BertPreTokenizer() return state def __setstate__( self : str , _lowerCAmelCase : Dict ): __snake_case : str = d __snake_case : int = self.__dict__["""_tokenizer"""].get_vocab() __snake_case : List[str] = PreTokenizer.custom(JiebaPreTokenizer(_lowerCAmelCase ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int]=None ): __snake_case : Dict = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : Optional[int] = [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : int = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase ) def snake_case__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Tuple=None , _lowerCAmelCase : Union[str, Any]=False , **_lowerCAmelCase : Tuple , ): __snake_case : Tuple = BertPreTokenizer() return super().save_pretrained(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase )
20
1
import numpy as np from sklearn.datasets import fetch_california_housing from sklearn.metrics import mean_absolute_error, mean_squared_error from sklearn.model_selection import train_test_split from xgboost import XGBRegressor def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : dict ): '''simple docstring''' return (data["data"], data["target"]) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : np.ndarray , __SCREAMING_SNAKE_CASE : np.ndarray , __SCREAMING_SNAKE_CASE : np.ndarray ): '''simple docstring''' __snake_case : Tuple = XGBRegressor(verbosity=0 , random_state=4_2 ) xgb.fit(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # Predict target for test data __snake_case : Union[str, Any] = xgb.predict(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = predictions.reshape(len(__SCREAMING_SNAKE_CASE ) , 1 ) return predictions def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Union[str, Any] = fetch_california_housing() __snake_case , __snake_case : Any = data_handling(__SCREAMING_SNAKE_CASE ) __snake_case , __snake_case , __snake_case , __snake_case : int = train_test_split( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , test_size=0.25 , random_state=1 ) __snake_case : Union[str, Any] = xgboost(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # Error printing print(F'''Mean Absolute Error : {mean_absolute_error(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE )}''' ) print(F'''Mean Square Error : {mean_squared_error(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE )}''' ) if __name__ == "__main__": import doctest doctest.testmod(verbose=True) main()
20
from __future__ import annotations import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if depth < 0: raise ValueError("""Depth cannot be less than 0""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: raise ValueError("""Scores cannot be empty""" ) if depth == height: return scores[node_index] if is_max: return max( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) return min( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : str = [9_0, 2_3, 6, 3_3, 2_1, 6_5, 1_2_3, 3_4_4_2_3] __snake_case : Optional[Any] = math.log(len(__SCREAMING_SNAKE_CASE ) , 2 ) print("""Optimal value : """ , end="""""" ) print(minimax(0 , 0 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
20
1
from __future__ import annotations import time lowercase_ = list[tuple[int, int]] lowercase_ = [ [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], # 0 are free path whereas 1's are obstacles [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], ] lowercase_ = [[-1, 0], [0, -1], [1, 0], [0, 1]] # up, left, down, right class SCREAMING_SNAKE_CASE__ : def __init__( self : Optional[Any] , _lowerCAmelCase : int , _lowerCAmelCase : int , _lowerCAmelCase : int , _lowerCAmelCase : int , _lowerCAmelCase : Node | None ): __snake_case : Dict = pos_x __snake_case : Any = pos_y __snake_case : Any = (pos_y, pos_x) __snake_case : Any = goal_x __snake_case : Any = goal_y __snake_case : Tuple = parent class SCREAMING_SNAKE_CASE__ : def __init__( self : Dict , _lowerCAmelCase : tuple[int, int] , _lowerCAmelCase : tuple[int, int] ): __snake_case : List[Any] = Node(start[1] , start[0] , goal[1] , goal[0] , _lowerCAmelCase ) __snake_case : Any = Node(goal[1] , goal[0] , goal[1] , goal[0] , _lowerCAmelCase ) __snake_case : Optional[Any] = [self.start] __snake_case : List[Any] = False def snake_case__ ( self : Optional[Any] ): while self.node_queue: __snake_case : Optional[Any] = self.node_queue.pop(0 ) if current_node.pos == self.target.pos: __snake_case : List[Any] = True return self.retrace_path(_lowerCAmelCase ) __snake_case : List[str] = self.get_successors(_lowerCAmelCase ) for node in successors: self.node_queue.append(_lowerCAmelCase ) if not self.reached: return [self.start.pos] return None def snake_case__ ( self : List[str] , _lowerCAmelCase : Node ): __snake_case : Optional[int] = [] for action in delta: __snake_case : Optional[int] = parent.pos_x + action[1] __snake_case : Union[str, Any] = parent.pos_y + action[0] if not (0 <= pos_x <= len(grid[0] ) - 1 and 0 <= pos_y <= len(_lowerCAmelCase ) - 1): continue if grid[pos_y][pos_x] != 0: continue successors.append( Node(_lowerCAmelCase , _lowerCAmelCase , self.target.pos_y , self.target.pos_x , _lowerCAmelCase ) ) return successors def snake_case__ ( self : Tuple , _lowerCAmelCase : Node | None ): __snake_case : Union[str, Any] = node __snake_case : Any = [] while current_node is not None: path.append((current_node.pos_y, current_node.pos_x) ) __snake_case : int = current_node.parent path.reverse() return path class SCREAMING_SNAKE_CASE__ : def __init__( self : Dict , _lowerCAmelCase : List[str] , _lowerCAmelCase : List[Any] ): __snake_case : str = BreadthFirstSearch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : Any = BreadthFirstSearch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = False def snake_case__ ( self : Dict ): while self.fwd_bfs.node_queue or self.bwd_bfs.node_queue: __snake_case : Tuple = self.fwd_bfs.node_queue.pop(0 ) __snake_case : Optional[Any] = self.bwd_bfs.node_queue.pop(0 ) if current_bwd_node.pos == current_fwd_node.pos: __snake_case : Any = True return self.retrace_bidirectional_path( _lowerCAmelCase , _lowerCAmelCase ) __snake_case : Optional[Any] = current_bwd_node __snake_case : int = current_fwd_node __snake_case : Optional[Any] = { self.fwd_bfs: self.fwd_bfs.get_successors(_lowerCAmelCase ), self.bwd_bfs: self.bwd_bfs.get_successors(_lowerCAmelCase ), } for bfs in [self.fwd_bfs, self.bwd_bfs]: for node in successors[bfs]: bfs.node_queue.append(_lowerCAmelCase ) if not self.reached: return [self.fwd_bfs.start.pos] return None def snake_case__ ( self : int , _lowerCAmelCase : Node , _lowerCAmelCase : Node ): __snake_case : List[str] = self.fwd_bfs.retrace_path(_lowerCAmelCase ) __snake_case : Tuple = self.bwd_bfs.retrace_path(_lowerCAmelCase ) bwd_path.pop() bwd_path.reverse() __snake_case : Optional[int] = fwd_path + bwd_path return path if __name__ == "__main__": # all coordinates are given in format [y,x] import doctest doctest.testmod() lowercase_ = (0, 0) lowercase_ = (len(grid) - 1, len(grid[0]) - 1) for elem in grid: print(elem) lowercase_ = time.time() lowercase_ = BreadthFirstSearch(init, goal) lowercase_ = bfs.search() lowercase_ = time.time() - start_bfs_time print("Unidirectional BFS computation time : ", bfs_time) lowercase_ = time.time() lowercase_ = BidirectionalBreadthFirstSearch(init, goal) lowercase_ = bd_bfs.search() lowercase_ = time.time() - start_bd_bfs_time print("Bidirectional BFS computation time : ", bd_bfs_time)
20
import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType lowercase_ = None lowercase_ = "<" if sys.byteorder == "little" else ">" # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image lowercase_ = [ np.dtype("|b1"), np.dtype("|u1"), np.dtype("<u2"), np.dtype(">u2"), np.dtype("<i2"), np.dtype(">i2"), np.dtype("<u4"), np.dtype(">u4"), np.dtype("<i4"), np.dtype(">i4"), np.dtype("<f4"), np.dtype(">f4"), np.dtype("<f8"), np.dtype(">f8"), ] @dataclass class SCREAMING_SNAKE_CASE__ : A : bool = True A : Optional[str] = None # Automatically constructed A : ClassVar[str] = "PIL.Image.Image" A : ClassVar[Any] = pa.struct({"bytes": pa.binary(), "path": pa.string()} ) A : str = field(default="Image" , init=__UpperCamelCase , repr=__UpperCamelCase ) def __call__( self : Any ): return self.pa_type def snake_case__ ( self : List[Any] , _lowerCAmelCase : Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] ): if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : str = np.array(_lowerCAmelCase ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": value, "bytes": None} elif isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": None, "bytes": value} elif isinstance(_lowerCAmelCase , np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(_lowerCAmelCase ) elif isinstance(_lowerCAmelCase , PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(_lowerCAmelCase ) elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("""path""" )} elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )} else: raise ValueError( f'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''' ) def snake_case__ ( self : List[str] , _lowerCAmelCase : dict , _lowerCAmelCase : Dict=None ): if not self.decode: raise RuntimeError("""Decoding is disabled for this feature. Please use Image(decode=True) instead.""" ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support decoding images, please install 'Pillow'.""" ) if token_per_repo_id is None: __snake_case : Tuple = {} __snake_case , __snake_case : str = value["""path"""], value["""bytes"""] if bytes_ is None: if path is None: raise ValueError(f'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.''' ) else: if is_local_path(_lowerCAmelCase ): __snake_case : str = PIL.Image.open(_lowerCAmelCase ) else: __snake_case : List[str] = path.split("""::""" )[-1] try: __snake_case : Dict = string_to_dict(_lowerCAmelCase , config.HUB_DATASETS_URL )["""repo_id"""] __snake_case : int = token_per_repo_id.get(_lowerCAmelCase ) except ValueError: __snake_case : List[Any] = None with xopen(_lowerCAmelCase , """rb""" , use_auth_token=_lowerCAmelCase ) as f: __snake_case : Union[str, Any] = BytesIO(f.read() ) __snake_case : Dict = PIL.Image.open(bytes_ ) else: __snake_case : Optional[Any] = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def snake_case__ ( self : Union[str, Any] ): from .features import Value return ( self if self.decode else { "bytes": Value("""binary""" ), "path": Value("""string""" ), } ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Union[pa.StringArray, pa.StructArray, pa.ListArray] ): if pa.types.is_string(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, storage] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays([storage, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("""bytes""" ) >= 0: __snake_case : List[str] = storage.field("""bytes""" ) else: __snake_case : List[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) if storage.type.get_field_index("""path""" ) >= 0: __snake_case : Optional[int] = storage.field("""path""" ) else: __snake_case : int = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : Tuple = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_list(storage.type ): __snake_case : Optional[Any] = pa.array( [encode_np_array(np.array(_lowerCAmelCase ) )["""bytes"""] if arr is not None else None for arr in storage.to_pylist()] , type=pa.binary() , ) __snake_case : Optional[int] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays( [bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : pa.StructArray ): @no_op_if_value_is_null def path_to_bytes(_lowerCAmelCase : Tuple ): with xopen(_lowerCAmelCase , """rb""" ) as f: __snake_case : Optional[int] = f.read() return bytes_ __snake_case : Tuple = pa.array( [ (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) __snake_case : Optional[Any] = pa.array( [os.path.basename(_lowerCAmelCase ) if path is not None else None for path in storage.field("""path""" ).to_pylist()] , type=pa.string() , ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def __lowerCAmelCase ( ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() __snake_case : Optional[Any] = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' __snake_case : List[Any] = BytesIO() if image.format in list_image_compression_formats(): __snake_case : Union[str, Any] = image.format else: __snake_case : List[Any] = """PNG""" if image.mode in ["""1""", """L""", """LA""", """RGB""", """RGBA"""] else """TIFF""" image.save(__SCREAMING_SNAKE_CASE , format=__SCREAMING_SNAKE_CASE ) return buffer.getvalue() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' if hasattr(__SCREAMING_SNAKE_CASE , """filename""" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : np.ndarray ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) __snake_case : List[Any] = array.dtype __snake_case : List[Any] = dtype.byteorder if dtype.byteorder != """=""" else _NATIVE_BYTEORDER __snake_case : Dict = dtype.kind __snake_case : Union[str, Any] = dtype.itemsize __snake_case : Tuple = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: __snake_case : int = np.dtype("""|u1""" ) if dtype_kind not in ["u", "i"]: raise TypeError( F'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.''' ) if dtype is not dest_dtype: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: __snake_case : List[str] = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: __snake_case : int = dtype_byteorder + dtype_kind + str(__SCREAMING_SNAKE_CASE ) __snake_case : Any = np.dtype(__SCREAMING_SNAKE_CASE ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( F'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}''' ) __snake_case : Optional[int] = PIL.Image.fromarray(array.astype(__SCREAMING_SNAKE_CASE ) ) return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]] ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if objs: __snake_case , __snake_case : Any = first_non_null_value(__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(__SCREAMING_SNAKE_CASE , np.ndarray ): __snake_case : int = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] elif isinstance(__SCREAMING_SNAKE_CASE , PIL.Image.Image ): __snake_case : List[str] = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] else: return objs else: return objs
20
1
import json import os import unittest from transformers.models.roc_bert.tokenization_roc_bert import ( VOCAB_FILES_NAMES, RoCBertBasicTokenizer, RoCBertTokenizer, RoCBertWordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english @require_tokenizers class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , unittest.TestCase ): A : Any = RoCBertTokenizer A : str = None A : Union[str, Any] = False A : int = True A : str = filter_non_english def snake_case__ ( self : Tuple ): super().setUp() __snake_case : Any = ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """你""", """好""", """是""", """谁""", """a""", """b""", """c""", """d"""] __snake_case : List[Any] = {} __snake_case : List[Any] = {} for i, value in enumerate(_lowerCAmelCase ): __snake_case : Optional[Any] = i __snake_case : int = i __snake_case : Optional[int] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Optional[int] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""word_shape_file"""] ) __snake_case : List[str] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""word_pronunciation_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) with open(self.word_shape_file , """w""" , encoding="""utf-8""" ) as word_shape_writer: json.dump(_lowerCAmelCase , _lowerCAmelCase , ensure_ascii=_lowerCAmelCase ) with open(self.word_pronunciation_file , """w""" , encoding="""utf-8""" ) as word_pronunciation_writer: json.dump(_lowerCAmelCase , _lowerCAmelCase , ensure_ascii=_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Tuple = self.tokenizer_class(self.vocab_file , self.word_shape_file , self.word_pronunciation_file ) __snake_case : List[Any] = tokenizer.tokenize("""你好[SEP]你是谁""" ) self.assertListEqual(_lowerCAmelCase , ["""你""", """好""", """[SEP]""", """你""", """是""", """谁"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCAmelCase ) , [5, 6, 2, 5, 7, 8] ) self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(_lowerCAmelCase ) , [5, 6, 2, 5, 7, 8] ) self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(_lowerCAmelCase ) , [5, 6, 2, 5, 7, 8] ) def snake_case__ ( self : Any ): __snake_case : Any = RoCBertBasicTokenizer() self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz""" ) , ["""ah""", """\u535A""", """\u63A8""", """zz"""] ) def snake_case__ ( self : Tuple ): __snake_case : Tuple = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) , ["""hello""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def snake_case__ ( self : Tuple ): __snake_case : List[Any] = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hällo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""h\u00E9llo"""] ) def snake_case__ ( self : Tuple ): __snake_case : Optional[Any] = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def snake_case__ ( self : Dict ): __snake_case : Optional[int] = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def snake_case__ ( self : List[Any] ): __snake_case : str = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) , ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def snake_case__ ( self : Any ): __snake_case : Optional[Any] = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def snake_case__ ( self : str ): __snake_case : Dict = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase , strip_accents=_lowerCAmelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = RoCBertBasicTokenizer(do_lower_case=_lowerCAmelCase , never_split=["""[UNK]"""] ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? [UNK]""" ) , ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""] ) def snake_case__ ( self : Union[str, Any] ): __snake_case : str = ["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""] __snake_case : int = {} for i, token in enumerate(_lowerCAmelCase ): __snake_case : int = i __snake_case : Union[str, Any] = RoCBertWordpieceTokenizer(vocab=_lowerCAmelCase , unk_token="""[UNK]""" ) self.assertListEqual(tokenizer.tokenize("""""" ) , [] ) self.assertListEqual(tokenizer.tokenize("""unwanted running""" ) , ["""un""", """##want""", """##ed""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.tokenize("""unwantedX running""" ) , ["""[UNK]""", """runn""", """##ing"""] ) def snake_case__ ( self : List[Any] ): self.assertTrue(_is_whitespace(""" """ ) ) self.assertTrue(_is_whitespace("""\t""" ) ) self.assertTrue(_is_whitespace("""\r""" ) ) self.assertTrue(_is_whitespace("""\n""" ) ) self.assertTrue(_is_whitespace("""\u00A0""" ) ) self.assertFalse(_is_whitespace("""A""" ) ) self.assertFalse(_is_whitespace("""-""" ) ) def snake_case__ ( self : List[Any] ): self.assertTrue(_is_control("""\u0005""" ) ) self.assertFalse(_is_control("""A""" ) ) self.assertFalse(_is_control(""" """ ) ) self.assertFalse(_is_control("""\t""" ) ) self.assertFalse(_is_control("""\r""" ) ) def snake_case__ ( self : str ): self.assertTrue(_is_punctuation("""-""" ) ) self.assertTrue(_is_punctuation("""$""" ) ) self.assertTrue(_is_punctuation("""`""" ) ) self.assertTrue(_is_punctuation(""".""" ) ) self.assertFalse(_is_punctuation("""A""" ) ) self.assertFalse(_is_punctuation(""" """ ) ) def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = self.get_tokenizer() # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340 self.assertListEqual([tokenizer.tokenize(_lowerCAmelCase ) for t in ["""Test""", """\xad""", """test"""]] , [["""[UNK]"""], [], ["""[UNK]"""]] ) if self.test_rust_tokenizer: __snake_case : Any = self.get_rust_tokenizer() self.assertListEqual( [rust_tokenizer.tokenize(_lowerCAmelCase ) for t in ["""Test""", """\xad""", """test"""]] , [["""[UNK]"""], [], ["""[UNK]"""]] ) def snake_case__ ( self : int ): for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __snake_case : List[str] = self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Dict = f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.''' __snake_case : Union[str, Any] = tokenizer_r.encode_plus( _lowerCAmelCase , return_attention_mask=_lowerCAmelCase , return_token_type_ids=_lowerCAmelCase , return_offsets_mapping=_lowerCAmelCase , add_special_tokens=_lowerCAmelCase , ) __snake_case : Optional[int] = tokenizer_r.do_lower_case if hasattr(_lowerCAmelCase , """do_lower_case""" ) else False __snake_case : List[Any] = ( [ ((0, 0), tokenizer_r.cls_token), ((0, 1), """A"""), ((1, 2), ""","""), ((3, 5), """na"""), ((5, 6), """##ï"""), ((6, 8), """##ve"""), ((9, 15), tokenizer_r.mask_token), ((16, 21), """Allen"""), ((21, 23), """##NL"""), ((23, 24), """##P"""), ((25, 33), """sentence"""), ((33, 34), """."""), ((0, 0), tokenizer_r.sep_token), ] if not do_lower_case else [ ((0, 0), tokenizer_r.cls_token), ((0, 1), """a"""), ((1, 2), ""","""), ((3, 8), """naive"""), ((9, 15), tokenizer_r.mask_token), ((16, 21), """allen"""), ((21, 23), """##nl"""), ((23, 24), """##p"""), ((25, 33), """sentence"""), ((33, 34), """."""), ((0, 0), tokenizer_r.sep_token), ] ) self.assertEqual( [e[1] for e in expected_results] , tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""] ) ) self.assertEqual([e[0] for e in expected_results] , tokens["""offset_mapping"""] ) def snake_case__ ( self : int ): __snake_case : Any = ["""的""", """人""", """有"""] __snake_case : Tuple = """""".join(_lowerCAmelCase ) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})''' ): __snake_case : List[Any] = True __snake_case : Optional[int] = self.tokenizer_class.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Dict = self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : List[Any] = tokenizer_p.encode(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) __snake_case : Optional[int] = tokenizer_r.encode(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) __snake_case : Union[str, Any] = tokenizer_r.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : Optional[int] = tokenizer_p.convert_ids_to_tokens(_lowerCAmelCase ) # it is expected that each Chinese character is not preceded by "##" self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : Any = False __snake_case : List[str] = self.rust_tokenizer_class.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Union[str, Any] = self.tokenizer_class.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : List[str] = tokenizer_r.encode(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) __snake_case : Dict = tokenizer_p.encode(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) __snake_case : Any = tokenizer_r.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : List[str] = tokenizer_p.convert_ids_to_tokens(_lowerCAmelCase ) # it is expected that only the first Chinese character is not preceded by "##". __snake_case : Tuple = [ f'''##{token}''' if idx != 0 else token for idx, token in enumerate(_lowerCAmelCase ) ] self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) self.assertListEqual(_lowerCAmelCase , _lowerCAmelCase ) @slow def snake_case__ ( self : Optional[int] ): __snake_case : List[str] = self.tokenizer_class(self.vocab_file , self.word_shape_file , self.word_pronunciation_file ) __snake_case : Tuple = tokenizer.encode("""你好""" , add_special_tokens=_lowerCAmelCase ) __snake_case : Optional[int] = tokenizer.encode("""你是谁""" , add_special_tokens=_lowerCAmelCase ) __snake_case : Optional[Any] = tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase ) __snake_case : Dict = tokenizer.build_inputs_with_special_tokens(_lowerCAmelCase , _lowerCAmelCase ) assert encoded_sentence == [1] + text + [2] assert encoded_pair == [1] + text + [2] + text_a + [2] def snake_case__ ( self : Dict ): __snake_case : Optional[int] = self.get_tokenizers(do_lower_case=_lowerCAmelCase ) for tokenizer in tokenizers: with self.subTest(f'''{tokenizer.__class__.__name__}''' ): __snake_case : List[Any] = """你好,你是谁""" __snake_case : List[str] = tokenizer.tokenize(_lowerCAmelCase ) __snake_case : List[Any] = tokenizer.convert_tokens_to_ids(_lowerCAmelCase ) __snake_case : List[str] = tokenizer.convert_tokens_to_shape_ids(_lowerCAmelCase ) __snake_case : Union[str, Any] = tokenizer.convert_tokens_to_pronunciation_ids(_lowerCAmelCase ) __snake_case : Any = tokenizer.prepare_for_model( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) __snake_case : Any = tokenizer.encode_plus(_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ) self.assertEqual(_lowerCAmelCase , _lowerCAmelCase )
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING lowercase_ = logging.get_logger(__name__) @add_end_docstrings(__UpperCamelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : Dict , *_lowerCAmelCase : Dict , **_lowerCAmelCase : int ): super().__init__(*_lowerCAmelCase , **_lowerCAmelCase ) requires_backends(self , """vision""" ) self.check_model_type( TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING ) def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[str]=None , _lowerCAmelCase : Any=None , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = {} __snake_case : int = {} if prompt is not None: __snake_case : Dict = prompt if generate_kwargs is not None: __snake_case : List[Any] = generate_kwargs if max_new_tokens is not None: if "generate_kwargs" not in forward_kwargs: __snake_case : Optional[int] = {} if "max_new_tokens" in forward_kwargs["generate_kwargs"]: raise ValueError( """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,""" """ please use only one""" ) __snake_case : Any = max_new_tokens return preprocess_params, forward_kwargs, {} def __call__( self : Optional[Any] , _lowerCAmelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] , **_lowerCAmelCase : Union[str, Any] ): return super().__call__(_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = load_image(_lowerCAmelCase ) if prompt is not None: if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): raise ValueError( f'''Received an invalid text input, got - {type(_lowerCAmelCase )} - but expected a single string. ''' """Note also that one single text can be provided for conditional image to text generation.""" ) __snake_case : Tuple = self.model.config.model_type if model_type == "git": __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Any = self.tokenizer(text=_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ).input_ids __snake_case : Tuple = [self.tokenizer.cls_token_id] + input_ids __snake_case : int = torch.tensor(_lowerCAmelCase ).unsqueeze(0 ) model_inputs.update({"""input_ids""": input_ids} ) elif model_type == "pix2struct": __snake_case : Dict = self.image_processor(images=_lowerCAmelCase , header_text=_lowerCAmelCase , return_tensors=self.framework ) elif model_type != "vision-encoder-decoder": # vision-encoder-decoder does not support conditional generation __snake_case : int = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Optional[Any] = self.tokenizer(_lowerCAmelCase , return_tensors=self.framework ) model_inputs.update(_lowerCAmelCase ) else: raise ValueError(f'''Model type {model_type} does not support conditional text generation''' ) else: __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) if self.model.config.model_type == "git" and prompt is None: __snake_case : int = None return model_inputs def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : str=None ): # Git model sets `model_inputs["input_ids"] = None` in `preprocess` (when `prompt=None`). In batch model, the # pipeline will group them into a list of `None`, which fail `_forward`. Avoid this by checking it first. if ( "input_ids" in model_inputs and isinstance(model_inputs["""input_ids"""] , _lowerCAmelCase ) and all(x is None for x in model_inputs["""input_ids"""] ) ): __snake_case : List[Any] = None if generate_kwargs is None: __snake_case : Dict = {} # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py` # parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas # the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name` # in the `_prepare_model_inputs` method. __snake_case : Dict = model_inputs.pop(self.model.main_input_name ) __snake_case : Optional[int] = self.model.generate(_lowerCAmelCase , **_lowerCAmelCase , **_lowerCAmelCase ) return model_outputs def snake_case__ ( self : List[Any] , _lowerCAmelCase : str ): __snake_case : Union[str, Any] = [] for output_ids in model_outputs: __snake_case : Union[str, Any] = { """generated_text""": self.tokenizer.decode( _lowerCAmelCase , skip_special_tokens=_lowerCAmelCase , ) } records.append(_lowerCAmelCase ) return records
20
1
import multiprocessing import os from typing import BinaryIO, Optional, Union import fsspec from .. import Dataset, Features, NamedSplit, config from ..formatting import query_table from ..packaged_modules.json.json import Json from ..utils import logging from ..utils.typing import NestedDataStructureLike, PathLike from .abc import AbstractDatasetReader class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : List[Any] , _lowerCAmelCase : NestedDataStructureLike[PathLike] , _lowerCAmelCase : Optional[NamedSplit] = None , _lowerCAmelCase : Optional[Features] = None , _lowerCAmelCase : str = None , _lowerCAmelCase : bool = False , _lowerCAmelCase : bool = False , _lowerCAmelCase : Optional[str] = None , _lowerCAmelCase : Optional[int] = None , **_lowerCAmelCase : List[Any] , ): super().__init__( _lowerCAmelCase , split=_lowerCAmelCase , features=_lowerCAmelCase , cache_dir=_lowerCAmelCase , keep_in_memory=_lowerCAmelCase , streaming=_lowerCAmelCase , num_proc=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : List[Any] = field __snake_case : Union[str, Any] = path_or_paths if isinstance(_lowerCAmelCase , _lowerCAmelCase ) else {self.split: path_or_paths} __snake_case : List[str] = Json( cache_dir=_lowerCAmelCase , data_files=_lowerCAmelCase , features=_lowerCAmelCase , field=_lowerCAmelCase , **_lowerCAmelCase , ) def snake_case__ ( self : Optional[int] ): # Build iterable dataset if self.streaming: __snake_case : Optional[Any] = self.builder.as_streaming_dataset(split=self.split ) # Build regular (map-style) dataset else: __snake_case : Union[str, Any] = None __snake_case : Optional[int] = None __snake_case : List[Any] = None __snake_case : List[Any] = None self.builder.download_and_prepare( download_config=_lowerCAmelCase , download_mode=_lowerCAmelCase , verification_mode=_lowerCAmelCase , base_path=_lowerCAmelCase , num_proc=self.num_proc , ) __snake_case : Optional[Any] = self.builder.as_dataset( split=self.split , verification_mode=_lowerCAmelCase , in_memory=self.keep_in_memory ) return dataset class SCREAMING_SNAKE_CASE__ : def __init__( self : Dict , _lowerCAmelCase : Dataset , _lowerCAmelCase : Union[PathLike, BinaryIO] , _lowerCAmelCase : Optional[int] = None , _lowerCAmelCase : Optional[int] = None , **_lowerCAmelCase : List[str] , ): if num_proc is not None and num_proc <= 0: raise ValueError(f'''num_proc {num_proc} must be an integer > 0.''' ) __snake_case : List[str] = dataset __snake_case : Optional[Any] = path_or_buf __snake_case : Tuple = batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE __snake_case : Union[str, Any] = num_proc __snake_case : Any = """utf-8""" __snake_case : List[Any] = to_json_kwargs def snake_case__ ( self : Union[str, Any] ): __snake_case : int = self.to_json_kwargs.pop("""path_or_buf""" , _lowerCAmelCase ) __snake_case : Tuple = self.to_json_kwargs.pop("""orient""" , """records""" ) __snake_case : List[Any] = self.to_json_kwargs.pop("""lines""" , True if orient == """records""" else False ) __snake_case : List[str] = self.to_json_kwargs.pop("""index""" , False if orient in ["""split""", """table"""] else True ) __snake_case : Dict = self.to_json_kwargs.pop("""compression""" , _lowerCAmelCase ) if compression not in [None, "infer", "gzip", "bz2", "xz"]: raise NotImplementedError(f'''`datasets` currently does not support {compression} compression''' ) if isinstance(self.path_or_buf , (str, bytes, os.PathLike) ): with fsspec.open(self.path_or_buf , """wb""" , compression=_lowerCAmelCase ) as buffer: __snake_case : str = self._write(file_obj=_lowerCAmelCase , orient=_lowerCAmelCase , lines=_lowerCAmelCase , index=_lowerCAmelCase , **self.to_json_kwargs ) else: if compression: raise NotImplementedError( f'''The compression parameter is not supported when writing to a buffer, but compression={compression}''' """ was passed. Please provide a local path instead.""" ) __snake_case : Union[str, Any] = self._write( file_obj=self.path_or_buf , orient=_lowerCAmelCase , lines=_lowerCAmelCase , index=_lowerCAmelCase , **self.to_json_kwargs ) return written def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[Any] ): __snake_case , __snake_case , __snake_case , __snake_case , __snake_case : List[str] = args __snake_case : Tuple = query_table( table=self.dataset.data , key=slice(_lowerCAmelCase , offset + self.batch_size ) , indices=self.dataset._indices , ) __snake_case : Optional[int] = batch.to_pandas().to_json( path_or_buf=_lowerCAmelCase , orient=_lowerCAmelCase , lines=_lowerCAmelCase , index=_lowerCAmelCase , **_lowerCAmelCase ) if not json_str.endswith("""\n""" ): json_str += "\n" return json_str.encode(self.encoding ) def snake_case__ ( self : int , _lowerCAmelCase : BinaryIO , _lowerCAmelCase : Any , _lowerCAmelCase : Tuple , _lowerCAmelCase : List[str] , **_lowerCAmelCase : List[str] , ): __snake_case : List[Any] = 0 if self.num_proc is None or self.num_proc == 1: for offset in logging.tqdm( range(0 , len(self.dataset ) , self.batch_size ) , unit="""ba""" , disable=not logging.is_progress_bar_enabled() , desc="""Creating json from Arrow format""" , ): __snake_case : Any = self._batch_json((offset, orient, lines, index, to_json_kwargs) ) written += file_obj.write(_lowerCAmelCase ) else: __snake_case , __snake_case : str = len(self.dataset ), self.batch_size with multiprocessing.Pool(self.num_proc ) as pool: for json_str in logging.tqdm( pool.imap( self._batch_json , [(offset, orient, lines, index, to_json_kwargs) for offset in range(0 , _lowerCAmelCase , _lowerCAmelCase )] , ) , total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size , unit="""ba""" , disable=not logging.is_progress_bar_enabled() , desc="""Creating json from Arrow format""" , ): written += file_obj.write(_lowerCAmelCase ) return written
20
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowercase_ = {"configuration_yolos": ["YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP", "YolosConfig", "YolosOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["YolosFeatureExtractor"] lowercase_ = ["YolosImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST", "YolosForObjectDetection", "YolosModel", "YolosPreTrainedModel", ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
from __future__ import annotations from typing import TypedDict class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : str A : int def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' if not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): raise TypeError("""The parameter s type must be str.""" ) return [s[i:] + s[:i] for i in range(len(__SCREAMING_SNAKE_CASE ) )] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' if not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): raise TypeError("""The parameter s type must be str.""" ) if not s: raise ValueError("""The parameter s must not be empty.""" ) __snake_case : Dict = all_rotations(__SCREAMING_SNAKE_CASE ) rotations.sort() # sort the list of rotations in alphabetically order # make a string composed of the last char of each rotation __snake_case : BWTTransformDict = { "bwt_string": "".join([word[-1] for word in rotations] ), "idx_original_string": rotations.index(__SCREAMING_SNAKE_CASE ), } return response def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): raise TypeError("""The parameter bwt_string type must be str.""" ) if not bwt_string: raise ValueError("""The parameter bwt_string must not be empty.""" ) try: __snake_case : int = int(__SCREAMING_SNAKE_CASE ) except ValueError: raise TypeError( """The parameter idx_original_string type must be int or passive""" """ of cast to int.""" ) if idx_original_string < 0: raise ValueError("""The parameter idx_original_string must not be lower than 0.""" ) if idx_original_string >= len(__SCREAMING_SNAKE_CASE ): raise ValueError( """The parameter idx_original_string must be lower than""" """ len(bwt_string).""" ) __snake_case : str = [""""""] * len(__SCREAMING_SNAKE_CASE ) for _ in range(len(__SCREAMING_SNAKE_CASE ) ): for i in range(len(__SCREAMING_SNAKE_CASE ) ): __snake_case : Any = bwt_string[i] + ordered_rotations[i] ordered_rotations.sort() return ordered_rotations[idx_original_string] if __name__ == "__main__": lowercase_ = "Provide a string that I will generate its BWT transform: " lowercase_ = input(entry_msg).strip() lowercase_ = bwt_transform(s) print( F'''Burrows Wheeler transform for string \'{s}\' results ''' F'''in \'{result["bwt_string"]}\'''' ) lowercase_ = reverse_bwt(result["bwt_string"], result["idx_original_string"]) print( F'''Reversing Burrows Wheeler transform for entry \'{result["bwt_string"]}\' ''' F'''we get original string \'{original_string}\'''' )
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = "microsoft/speecht5_tts" A : List[Any] = ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) A : str = "text_reader" A : Optional[Any] = SpeechTaProcessor A : Any = SpeechTaForTextToSpeech A : Optional[Any] = SpeechTaHifiGan A : str = ["text"] A : Union[str, Any] = ["audio"] def snake_case__ ( self : List[Any] ): if self.post_processor is None: __snake_case : Tuple = """microsoft/speecht5_hifigan""" super().setup() def snake_case__ ( self : Any , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Tuple=None ): __snake_case : str = self.pre_processor(text=_lowerCAmelCase , return_tensors="""pt""" , truncation=_lowerCAmelCase ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) __snake_case : List[Any] = load_dataset("""Matthijs/cmu-arctic-xvectors""" , split="""validation""" ) __snake_case : str = torch.tensor(embeddings_dataset[73_05]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def snake_case__ ( self : List[Any] , _lowerCAmelCase : Dict ): with torch.no_grad(): return self.model.generate_speech(**_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): with torch.no_grad(): return self.post_processor(_lowerCAmelCase ).cpu().detach()
20
1
import json import os import tempfile import datasets from utils import generate_example_dataset, get_duration lowercase_ = 5_00_00 lowercase_ = 50_00 lowercase_ , lowercase_ = os.path.split(__file__) lowercase_ = os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json")) @get_duration def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : datasets.Dataset , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' for i in range(__SCREAMING_SNAKE_CASE ): __snake_case : str = dataset[i] @get_duration def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : datasets.Dataset , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ): __snake_case : Any = dataset[i : i + batch_size] @get_duration def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : datasets.Dataset , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' with dataset.formatted_as(type=__SCREAMING_SNAKE_CASE ): for i in range(__SCREAMING_SNAKE_CASE ): __snake_case : Optional[Any] = dataset[i] @get_duration def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : datasets.Dataset , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' with dataset.formatted_as(type=__SCREAMING_SNAKE_CASE ): for i in range(0 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : List[str] = dataset[i : i + batch_size] def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : List[Any] = {"""num examples""": SPEED_TEST_N_EXAMPLES} __snake_case : Tuple = [ (read, {"""length""": SMALL_TEST}), (read, {"""length""": SPEED_TEST_N_EXAMPLES}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_0}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_0_0}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_0_0_0}), (read_formatted, {"""type""": """numpy""", """length""": SMALL_TEST}), (read_formatted, {"""type""": """pandas""", """length""": SMALL_TEST}), (read_formatted, {"""type""": """torch""", """length""": SMALL_TEST}), (read_formatted, {"""type""": """tensorflow""", """length""": SMALL_TEST}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_0}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_0_0_0}), ] __snake_case : List[str] = [ (read, {"""length""": SMALL_TEST}), (read, {"""length""": SPEED_TEST_N_EXAMPLES}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_0}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_0_0}), (read_batch, {"""length""": SPEED_TEST_N_EXAMPLES, """batch_size""": 1_0_0_0}), (read_formatted, {"""type""": """numpy""", """length""": SMALL_TEST}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_0}), (read_formatted_batch, {"""type""": """numpy""", """length""": SMALL_TEST, """batch_size""": 1_0_0_0}), ] with tempfile.TemporaryDirectory() as tmp_dir: print("""generating dataset""" ) __snake_case : Dict = datasets.Features( {"""list""": datasets.Sequence(datasets.Value("""float32""" ) ), """numbers""": datasets.Value("""float32""" )} ) __snake_case : Any = generate_example_dataset( os.path.join(__SCREAMING_SNAKE_CASE , """dataset.arrow""" ) , __SCREAMING_SNAKE_CASE , num_examples=__SCREAMING_SNAKE_CASE , seq_shapes={"""list""": (1_0_0,)} , ) print("""first set of iterations""" ) for func, kwargs in functions: print(func.__name__ , str(__SCREAMING_SNAKE_CASE ) ) __snake_case : int = func(__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ) print("""shuffling dataset""" ) __snake_case : Dict = dataset.shuffle() print("""Second set of iterations (after shuffling""" ) for func, kwargs in functions_shuffled: print("""shuffled """ , func.__name__ , str(__SCREAMING_SNAKE_CASE ) ) __snake_case : List[str] = func( __SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ) with open(__SCREAMING_SNAKE_CASE , """wb""" ) as f: f.write(json.dumps(__SCREAMING_SNAKE_CASE ).encode("""utf-8""" ) ) if __name__ == "__main__": # useful to run the profiler benchmark_iterating()
20
import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * power_factor def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * math.sqrt(1 - power_factor**2 ) if __name__ == "__main__": import doctest doctest.testmod()
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): raise ValueError("""Input series is not valid, valid series - [2, 4, 6]""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: raise ValueError("""Input list must be a non empty list""" ) if len(__SCREAMING_SNAKE_CASE ) == 1: return True __snake_case : Union[str, Any] = series[1] - series[0] for index in range(len(__SCREAMING_SNAKE_CASE ) - 1 ): if series[index + 1] - series[index] != common_diff: return False return True def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): raise ValueError("""Input series is not valid, valid series - [2, 4, 6]""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: raise ValueError("""Input list must be a non empty list""" ) __snake_case : Tuple = 0 for val in series: answer += val return answer / len(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": import doctest doctest.testmod()
20
from .constants import ( MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SCALER_NAME, SCHEDULER_NAME, TORCH_LAUNCH_PARAMS, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ) from .dataclasses import ( BnbQuantizationConfig, ComputeEnvironment, CustomDtype, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FPaRecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProjectConfiguration, RNGType, SageMakerDistributedType, TensorInformation, TorchDynamoPlugin, ) from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env from .imports import ( get_ccl_version, is_abit_bnb_available, is_abit_bnb_available, is_aim_available, is_bfaa_available, is_bnb_available, is_botoa_available, is_ccl_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_fpa_available, is_ipex_available, is_megatron_lm_available, is_mlflow_available, is_mps_available, is_npu_available, is_rich_available, is_safetensors_available, is_sagemaker_available, is_tensorboard_available, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) from .modeling import ( check_device_map, check_tied_parameters_in_config, check_tied_parameters_on_same_device, compute_module_sizes, convert_file_size_to_int, dtype_byte_size, find_tied_parameters, get_balanced_memory, get_max_layer_size, get_max_memory, get_mixed_precision_context_manager, id_tensor_storage, infer_auto_device_map, load_checkpoint_in_model, load_offloaded_weights, load_state_dict, named_module_tensors, retie_parameters, set_module_tensor_to_device, shard_checkpoint, ) from .offload import ( OffloadedWeightsLoader, PrefixedDataset, extract_submodules_state_dict, load_offloaded_weight, offload_state_dict, offload_weight, save_offload_index, ) from .operations import ( broadcast, broadcast_object_list, concatenate, convert_outputs_to_fpaa, convert_to_fpaa, find_batch_size, find_device, gather, gather_object, get_data_structure, honor_type, initialize_tensors, is_namedtuple, is_tensor_information, is_torch_tensor, listify, pad_across_processes, recursively_apply, reduce, send_to_device, slice_tensors, ) from .versions import compare_versions, is_torch_version if is_deepspeed_available(): from .deepspeed import ( DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler, HfDeepSpeedConfig, ) from .bnb import has_abit_bnb_layers, load_and_quantize_model from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer from .launch import ( PrepareForLaunch, _filter_args, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, ) from .megatron_lm import ( AbstractTrainStep, BertTrainStep, GPTTrainStep, MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, TaTrainStep, avg_losses_across_data_parallel_group, gather_across_data_parallel_groups, ) from .megatron_lm import initialize as megatron_lm_initialize from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader from .megatron_lm import prepare_model as megatron_lm_prepare_model from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler from .memory import find_executable_batch_size, release_memory from .other import ( extract_model_from_parallel, get_pretty_name, is_port_in_use, merge_dicts, patch_environment, save, wait_for_everyone, write_basic_config, ) from .random import set_seed, synchronize_rng_state, synchronize_rng_states from .torch_xla import install_xla from .tqdm import tqdm from .transformer_engine import convert_model, has_transformer_engine_layers
20
1
import argparse import os import gluonnlp as nlp import mxnet as mx import numpy as np import torch from gluonnlp.base import get_home_dir from gluonnlp.model.bert import BERTEncoder from gluonnlp.model.utils import _load_vocab from gluonnlp.vocab import Vocab from packaging import version from torch import nn from transformers import BertConfig, BertForMaskedLM, BertModel, RobertaTokenizer from transformers.models.bert.modeling_bert import ( BertIntermediate, BertLayer, BertOutput, BertSelfAttention, BertSelfOutput, ) from transformers.utils import logging if version.parse(nlp.__version__) != version.parse("0.8.3"): raise Exception("requires gluonnlp == 0.8.3") if version.parse(mx.__version__) != version.parse("1.5.0"): raise Exception("requires mxnet == 1.5.0") logging.set_verbosity_info() lowercase_ = logging.get_logger(__name__) lowercase_ = "The Nymphenburg Palace is a beautiful palace in Munich!" def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' __snake_case : Optional[int] = { """attention_cell""": """multi_head""", """num_layers""": 4, """units""": 1_0_2_4, """hidden_size""": 7_6_8, """max_length""": 5_1_2, """num_heads""": 8, """scaled""": True, """dropout""": 0.1, """use_residual""": True, """embed_size""": 1_0_2_4, """embed_dropout""": 0.1, """word_embed""": None, """layer_norm_eps""": 1E-5, """token_type_vocab_size""": 2, } __snake_case : Any = bort_4_8_768_1024_hparams # Let's construct the original Bort model here # Taken from official BERT implementation, see: # https://github.com/alexa/bort/blob/master/bort/bort.py __snake_case : Any = BERTEncoder( attention_cell=predefined_args["""attention_cell"""] , num_layers=predefined_args["""num_layers"""] , units=predefined_args["""units"""] , hidden_size=predefined_args["""hidden_size"""] , max_length=predefined_args["""max_length"""] , num_heads=predefined_args["""num_heads"""] , scaled=predefined_args["""scaled"""] , dropout=predefined_args["""dropout"""] , output_attention=__SCREAMING_SNAKE_CASE , output_all_encodings=__SCREAMING_SNAKE_CASE , use_residual=predefined_args["""use_residual"""] , activation=predefined_args.get("""activation""" , """gelu""" ) , layer_norm_eps=predefined_args.get("""layer_norm_eps""" , __SCREAMING_SNAKE_CASE ) , ) # Vocab information needs to be fetched first # It's the same as RoBERTa, so RobertaTokenizer can be used later __snake_case : Optional[Any] = """openwebtext_ccnews_stories_books_cased""" # Specify download folder to Gluonnlp's vocab __snake_case : List[Any] = os.path.join(get_home_dir() , """models""" ) __snake_case : Optional[Any] = _load_vocab(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , cls=__SCREAMING_SNAKE_CASE ) __snake_case : Dict = nlp.model.BERTModel( __SCREAMING_SNAKE_CASE , len(__SCREAMING_SNAKE_CASE ) , units=predefined_args["""units"""] , embed_size=predefined_args["""embed_size"""] , embed_dropout=predefined_args["""embed_dropout"""] , word_embed=predefined_args["""word_embed"""] , use_pooler=__SCREAMING_SNAKE_CASE , use_token_type_embed=__SCREAMING_SNAKE_CASE , token_type_vocab_size=predefined_args["""token_type_vocab_size"""] , use_classifier=__SCREAMING_SNAKE_CASE , use_decoder=__SCREAMING_SNAKE_CASE , ) original_bort.load_parameters(__SCREAMING_SNAKE_CASE , cast_dtype=__SCREAMING_SNAKE_CASE , ignore_extra=__SCREAMING_SNAKE_CASE ) __snake_case : Union[str, Any] = original_bort._collect_params_with_prefix() # Build our config 🤗 __snake_case : Union[str, Any] = { """architectures""": ["""BertForMaskedLM"""], """attention_probs_dropout_prob""": predefined_args["""dropout"""], """hidden_act""": """gelu""", """hidden_dropout_prob""": predefined_args["""dropout"""], """hidden_size""": predefined_args["""embed_size"""], """initializer_range""": 0.02, """intermediate_size""": predefined_args["""hidden_size"""], """layer_norm_eps""": predefined_args["""layer_norm_eps"""], """max_position_embeddings""": predefined_args["""max_length"""], """model_type""": """bort""", """num_attention_heads""": predefined_args["""num_heads"""], """num_hidden_layers""": predefined_args["""num_layers"""], """pad_token_id""": 1, # 2 = BERT, 1 = RoBERTa """type_vocab_size""": 1, # 2 = BERT, 1 = RoBERTa """vocab_size""": len(__SCREAMING_SNAKE_CASE ), } __snake_case : str = BertConfig.from_dict(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = BertForMaskedLM(__SCREAMING_SNAKE_CASE ) hf_bort_model.eval() # Parameter mapping table (Gluonnlp to Transformers) # * denotes layer index # # | Gluon Parameter | Transformers Parameter # | -------------------------------------------------------------- | ---------------------- # | `encoder.layer_norm.beta` | `bert.embeddings.LayerNorm.bias` # | `encoder.layer_norm.gamma` | `bert.embeddings.LayerNorm.weight` # | `encoder.position_weight` | `bert.embeddings.position_embeddings.weight` # | `word_embed.0.weight` | `bert.embeddings.word_embeddings.weight` # | `encoder.transformer_cells.*.attention_cell.proj_key.bias` | `bert.encoder.layer.*.attention.self.key.bias` # | `encoder.transformer_cells.*.attention_cell.proj_key.weight` | `bert.encoder.layer.*.attention.self.key.weight` # | `encoder.transformer_cells.*.attention_cell.proj_query.bias` | `bert.encoder.layer.*.attention.self.query.bias` # | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight` # | `encoder.transformer_cells.*.attention_cell.proj_value.bias` | `bert.encoder.layer.*.attention.self.value.bias` # | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight` # | `encoder.transformer_cells.*.ffn.ffn_2.bias` | `bert.encoder.layer.*.attention.output.dense.bias` # | `encoder.transformer_cells.*.ffn.ffn_2.weight` | `bert.encoder.layer.*.attention.output.dense.weight` # | `encoder.transformer_cells.*.layer_norm.beta` | `bert.encoder.layer.*.attention.output.LayerNorm.bias` # | `encoder.transformer_cells.*.layer_norm.gamma` | `bert.encoder.layer.*.attention.output.LayerNorm.weight` # | `encoder.transformer_cells.*.ffn.ffn_1.bias` | `bert.encoder.layer.*.intermediate.dense.bias` # | `encoder.transformer_cells.*.ffn.ffn_1.weight` | `bert.encoder.layer.*.intermediate.dense.weight` # | `encoder.transformer_cells.*.ffn.layer_norm.beta` | `bert.encoder.layer.*.output.LayerNorm.bias` # | `encoder.transformer_cells.*.ffn.layer_norm.gamma` | `bert.encoder.layer.*.output.LayerNorm.weight` # | `encoder.transformer_cells.*.proj.bias` | `bert.encoder.layer.*.output.dense.bias` # | `encoder.transformer_cells.*.proj.weight` | `bert.encoder.layer.*.output.dense.weight` # Helper function to convert MXNET Arrays to PyTorch def to_torch(__SCREAMING_SNAKE_CASE : Union[str, Any] ) -> nn.Parameter: return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy() ) ) # Check param shapes and map new HF param back def check_and_map_params(__SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Optional[Any] ): __snake_case : int = hf_param.shape __snake_case : Any = to_torch(params[gluon_param] ) __snake_case : List[Any] = gluon_param.shape assert ( shape_hf == shape_gluon ), F'''The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers''' return gluon_param __snake_case : Tuple = check_and_map_params( hf_bort_model.bert.embeddings.word_embeddings.weight , """word_embed.0.weight""" ) __snake_case : int = check_and_map_params( hf_bort_model.bert.embeddings.position_embeddings.weight , """encoder.position_weight""" ) __snake_case : int = check_and_map_params( hf_bort_model.bert.embeddings.LayerNorm.bias , """encoder.layer_norm.beta""" ) __snake_case : str = check_and_map_params( hf_bort_model.bert.embeddings.LayerNorm.weight , """encoder.layer_norm.gamma""" ) # Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them) __snake_case : str = torch.zeros_like( hf_bort_model.bert.embeddings.token_type_embeddings.weight.data ) for i in range(hf_bort_config.num_hidden_layers ): __snake_case : BertLayer = hf_bort_model.bert.encoder.layer[i] # self attention __snake_case : BertSelfAttention = layer.attention.self __snake_case : str = check_and_map_params( self_attn.key.bias.data , F'''encoder.transformer_cells.{i}.attention_cell.proj_key.bias''' ) __snake_case : Optional[Any] = check_and_map_params( self_attn.key.weight.data , F'''encoder.transformer_cells.{i}.attention_cell.proj_key.weight''' ) __snake_case : List[str] = check_and_map_params( self_attn.query.bias.data , F'''encoder.transformer_cells.{i}.attention_cell.proj_query.bias''' ) __snake_case : List[str] = check_and_map_params( self_attn.query.weight.data , F'''encoder.transformer_cells.{i}.attention_cell.proj_query.weight''' ) __snake_case : Tuple = check_and_map_params( self_attn.value.bias.data , F'''encoder.transformer_cells.{i}.attention_cell.proj_value.bias''' ) __snake_case : List[Any] = check_and_map_params( self_attn.value.weight.data , F'''encoder.transformer_cells.{i}.attention_cell.proj_value.weight''' ) # self attention output __snake_case : BertSelfOutput = layer.attention.output __snake_case : Optional[Any] = check_and_map_params( self_output.dense.bias , F'''encoder.transformer_cells.{i}.proj.bias''' ) __snake_case : str = check_and_map_params( self_output.dense.weight , F'''encoder.transformer_cells.{i}.proj.weight''' ) __snake_case : Dict = check_and_map_params( self_output.LayerNorm.bias , F'''encoder.transformer_cells.{i}.layer_norm.beta''' ) __snake_case : Tuple = check_and_map_params( self_output.LayerNorm.weight , F'''encoder.transformer_cells.{i}.layer_norm.gamma''' ) # intermediate __snake_case : BertIntermediate = layer.intermediate __snake_case : List[Any] = check_and_map_params( intermediate.dense.bias , F'''encoder.transformer_cells.{i}.ffn.ffn_1.bias''' ) __snake_case : Union[str, Any] = check_and_map_params( intermediate.dense.weight , F'''encoder.transformer_cells.{i}.ffn.ffn_1.weight''' ) # output __snake_case : BertOutput = layer.output __snake_case : str = check_and_map_params( bert_output.dense.bias , F'''encoder.transformer_cells.{i}.ffn.ffn_2.bias''' ) __snake_case : Optional[int] = check_and_map_params( bert_output.dense.weight , F'''encoder.transformer_cells.{i}.ffn.ffn_2.weight''' ) __snake_case : Optional[int] = check_and_map_params( bert_output.LayerNorm.bias , F'''encoder.transformer_cells.{i}.ffn.layer_norm.beta''' ) __snake_case : Union[str, Any] = check_and_map_params( bert_output.LayerNorm.weight , F'''encoder.transformer_cells.{i}.ffn.layer_norm.gamma''' ) # Save space and energy 🎄 hf_bort_model.half() # Compare output of both models __snake_case : Optional[Any] = RobertaTokenizer.from_pretrained("""roberta-base""" ) __snake_case : Dict = tokenizer.encode_plus(__SCREAMING_SNAKE_CASE )["""input_ids"""] # Get gluon output __snake_case : str = mx.nd.array([input_ids] ) __snake_case : Any = original_bort(inputs=__SCREAMING_SNAKE_CASE , token_types=[] ) # Get Transformer output (save and reload model again) hf_bort_model.save_pretrained(__SCREAMING_SNAKE_CASE ) __snake_case : Union[str, Any] = BertModel.from_pretrained(__SCREAMING_SNAKE_CASE ) hf_bort_model.eval() __snake_case : Any = tokenizer.encode_plus(__SCREAMING_SNAKE_CASE , return_tensors="""pt""" ) __snake_case : Any = hf_bort_model(**__SCREAMING_SNAKE_CASE )[0] __snake_case : Dict = output_gluon[0].asnumpy() __snake_case : Optional[int] = output_hf[0].detach().numpy() __snake_case : int = np.max(np.abs(hf_layer - gluon_layer ) ).item() __snake_case : Optional[Any] = np.allclose(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , atol=1E-3 ) if success: print("""✔️ Both model do output the same tensors""" ) else: print("""❌ Both model do **NOT** output the same tensors""" ) print("""Absolute difference is:""" , __SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--bort_checkpoint_path", default=None, type=str, required=True, help="Path the official Bort params file." ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) lowercase_ = parser.parse_args() convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase_ = { "configuration_blenderbot_small": [ "BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "BlenderbotSmallConfig", "BlenderbotSmallOnnxConfig", ], "tokenization_blenderbot_small": ["BlenderbotSmallTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["BlenderbotSmallTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST", "BlenderbotSmallForCausalLM", "BlenderbotSmallForConditionalGeneration", "BlenderbotSmallModel", "BlenderbotSmallPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFBlenderbotSmallForConditionalGeneration", "TFBlenderbotSmallModel", "TFBlenderbotSmallPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxBlenderbotSmallForConditionalGeneration", "FlaxBlenderbotSmallModel", "FlaxBlenderbotSmallPreTrainedModel", ] if TYPE_CHECKING: from .configuration_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotSmallConfig, BlenderbotSmallOnnxConfig, ) from .tokenization_blenderbot_small import BlenderbotSmallTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_small_fast import BlenderbotSmallTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotSmallForCausalLM, BlenderbotSmallForConditionalGeneration, BlenderbotSmallModel, BlenderbotSmallPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot_small import ( TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel, TFBlenderbotSmallPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot_small import ( FlaxBlenderbotSmallForConditionalGeneration, FlaxBlenderbotSmallModel, FlaxBlenderbotSmallPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available lowercase_ = {"configuration_vit_msn": ["VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTMSNConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTMSNModel", "ViTMSNForImageClassification", "ViTMSNPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit_msn import VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMSNConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit_msn import ( VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST, ViTMSNForImageClassification, ViTMSNModel, ViTMSNPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) lowercase_ = {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["ViTFeatureExtractor"] lowercase_ = ["ViTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "VIT_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTForImageClassification", "ViTForMaskedImageModeling", "ViTModel", "ViTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFViTForImageClassification", "TFViTModel", "TFViTPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxViTForImageClassification", "FlaxViTModel", "FlaxViTPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
import torch from diffusers import DDPMParallelScheduler from .test_schedulers import SchedulerCommonTest class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : str = (DDPMParallelScheduler,) def snake_case__ ( self : Optional[int] , **_lowerCAmelCase : Tuple ): __snake_case : Any = { """num_train_timesteps""": 10_00, """beta_start""": 0.0001, """beta_end""": 0.02, """beta_schedule""": """linear""", """variance_type""": """fixed_small""", """clip_sample""": True, } config.update(**_lowerCAmelCase ) return config def snake_case__ ( self : Tuple ): for timesteps in [1, 5, 1_00, 10_00]: self.check_over_configs(num_train_timesteps=_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] ): for beta_start, beta_end in zip([0.0001, 0.001, 0.01, 0.1] , [0.002, 0.02, 0.2, 2] ): self.check_over_configs(beta_start=_lowerCAmelCase , beta_end=_lowerCAmelCase ) def snake_case__ ( self : Any ): for schedule in ["linear", "squaredcos_cap_v2"]: self.check_over_configs(beta_schedule=_lowerCAmelCase ) def snake_case__ ( self : Tuple ): for variance in ["fixed_small", "fixed_large", "other"]: self.check_over_configs(variance_type=_lowerCAmelCase ) def snake_case__ ( self : str ): for clip_sample in [True, False]: self.check_over_configs(clip_sample=_lowerCAmelCase ) def snake_case__ ( self : List[Any] ): self.check_over_configs(thresholding=_lowerCAmelCase ) for threshold in [0.5, 1.0, 2.0]: for prediction_type in ["epsilon", "sample", "v_prediction"]: self.check_over_configs( thresholding=_lowerCAmelCase , prediction_type=_lowerCAmelCase , sample_max_value=_lowerCAmelCase , ) def snake_case__ ( self : Any ): for prediction_type in ["epsilon", "sample", "v_prediction"]: self.check_over_configs(prediction_type=_lowerCAmelCase ) def snake_case__ ( self : Any ): for t in [0, 5_00, 9_99]: self.check_over_forward(time_step=_lowerCAmelCase ) def snake_case__ ( self : Optional[int] ): __snake_case : Optional[int] = self.scheduler_classes[0] __snake_case : int = self.get_scheduler_config() __snake_case : str = scheduler_class(**_lowerCAmelCase ) assert torch.sum(torch.abs(scheduler._get_variance(0 ) - 0.0 ) ) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(4_87 ) - 0.00979 ) ) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(9_99 ) - 0.02 ) ) < 1e-5 def snake_case__ ( self : int ): __snake_case : Optional[Any] = self.scheduler_classes[0] __snake_case : Optional[Any] = self.get_scheduler_config() __snake_case : Optional[int] = scheduler_class(**_lowerCAmelCase ) __snake_case : Optional[Any] = len(_lowerCAmelCase ) __snake_case : Any = self.dummy_model() __snake_case : List[Any] = self.dummy_sample_deter __snake_case : Tuple = self.dummy_sample_deter + 0.1 __snake_case : int = self.dummy_sample_deter - 0.1 __snake_case : Optional[Any] = samplea.shape[0] __snake_case : Dict = torch.stack([samplea, samplea, samplea] , dim=0 ) __snake_case : Optional[Any] = torch.arange(_lowerCAmelCase )[0:3, None].repeat(1 , _lowerCAmelCase ) __snake_case : str = model(samples.flatten(0 , 1 ) , timesteps.flatten(0 , 1 ) ) __snake_case : Dict = scheduler.batch_step_no_noise(_lowerCAmelCase , timesteps.flatten(0 , 1 ) , samples.flatten(0 , 1 ) ) __snake_case : Tuple = torch.sum(torch.abs(_lowerCAmelCase ) ) __snake_case : Optional[Any] = torch.mean(torch.abs(_lowerCAmelCase ) ) assert abs(result_sum.item() - 1153.1833 ) < 1e-2 assert abs(result_mean.item() - 0.5005 ) < 1e-3 def snake_case__ ( self : Optional[int] ): __snake_case : List[Any] = self.scheduler_classes[0] __snake_case : Optional[int] = self.get_scheduler_config() __snake_case : Optional[int] = scheduler_class(**_lowerCAmelCase ) __snake_case : Optional[int] = len(_lowerCAmelCase ) __snake_case : List[Any] = self.dummy_model() __snake_case : str = self.dummy_sample_deter __snake_case : Optional[Any] = torch.manual_seed(0 ) for t in reversed(range(_lowerCAmelCase ) ): # 1. predict noise residual __snake_case : str = model(_lowerCAmelCase , _lowerCAmelCase ) # 2. predict previous mean of sample x_t-1 __snake_case : int = scheduler.step(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , generator=_lowerCAmelCase ).prev_sample __snake_case : str = pred_prev_sample __snake_case : str = torch.sum(torch.abs(_lowerCAmelCase ) ) __snake_case : Optional[Any] = torch.mean(torch.abs(_lowerCAmelCase ) ) assert abs(result_sum.item() - 258.9606 ) < 1e-2 assert abs(result_mean.item() - 0.3372 ) < 1e-3 def snake_case__ ( self : Union[str, Any] ): __snake_case : Dict = self.scheduler_classes[0] __snake_case : Dict = self.get_scheduler_config(prediction_type="""v_prediction""" ) __snake_case : str = scheduler_class(**_lowerCAmelCase ) __snake_case : Optional[int] = len(_lowerCAmelCase ) __snake_case : Dict = self.dummy_model() __snake_case : List[Any] = self.dummy_sample_deter __snake_case : Any = torch.manual_seed(0 ) for t in reversed(range(_lowerCAmelCase ) ): # 1. predict noise residual __snake_case : Optional[Any] = model(_lowerCAmelCase , _lowerCAmelCase ) # 2. predict previous mean of sample x_t-1 __snake_case : List[Any] = scheduler.step(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , generator=_lowerCAmelCase ).prev_sample __snake_case : Union[str, Any] = pred_prev_sample __snake_case : List[str] = torch.sum(torch.abs(_lowerCAmelCase ) ) __snake_case : List[Any] = torch.mean(torch.abs(_lowerCAmelCase ) ) assert abs(result_sum.item() - 202.0296 ) < 1e-2 assert abs(result_mean.item() - 0.2631 ) < 1e-3 def snake_case__ ( self : Optional[int] ): __snake_case : str = self.scheduler_classes[0] __snake_case : List[str] = self.get_scheduler_config() __snake_case : Any = scheduler_class(**_lowerCAmelCase ) __snake_case : str = [1_00, 87, 50, 1, 0] scheduler.set_timesteps(timesteps=_lowerCAmelCase ) __snake_case : str = scheduler.timesteps for i, timestep in enumerate(_lowerCAmelCase ): if i == len(_lowerCAmelCase ) - 1: __snake_case : Optional[Any] = -1 else: __snake_case : List[str] = timesteps[i + 1] __snake_case : Dict = scheduler.previous_timestep(_lowerCAmelCase ) __snake_case : Union[str, Any] = prev_t.item() self.assertEqual(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : int ): __snake_case : Any = self.scheduler_classes[0] __snake_case : List[str] = self.get_scheduler_config() __snake_case : List[str] = scheduler_class(**_lowerCAmelCase ) __snake_case : Union[str, Any] = [1_00, 87, 50, 51, 0] with self.assertRaises(_lowerCAmelCase , msg="""`custom_timesteps` must be in descending order.""" ): scheduler.set_timesteps(timesteps=_lowerCAmelCase ) def snake_case__ ( self : List[Any] ): __snake_case : Dict = self.scheduler_classes[0] __snake_case : Any = self.get_scheduler_config() __snake_case : List[Any] = scheduler_class(**_lowerCAmelCase ) __snake_case : Optional[int] = [1_00, 87, 50, 1, 0] __snake_case : Tuple = len(_lowerCAmelCase ) with self.assertRaises(_lowerCAmelCase , msg="""Can only pass one of `num_inference_steps` or `custom_timesteps`.""" ): scheduler.set_timesteps(num_inference_steps=_lowerCAmelCase , timesteps=_lowerCAmelCase ) def snake_case__ ( self : Dict ): __snake_case : Optional[int] = self.scheduler_classes[0] __snake_case : List[str] = self.get_scheduler_config() __snake_case : Any = scheduler_class(**_lowerCAmelCase ) __snake_case : Dict = [scheduler.config.num_train_timesteps] with self.assertRaises( _lowerCAmelCase , msg="""`timesteps` must start before `self.config.train_timesteps`: {scheduler.config.num_train_timesteps}}""" , ): scheduler.set_timesteps(timesteps=_lowerCAmelCase )
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if (direction == 1 and array[indexa] > array[indexa]) or ( direction == 0 and array[indexa] < array[indexa] ): __snake_case , __snake_case : str = array[indexa], array[indexa] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Tuple = int(length / 2 ) for i in range(__SCREAMING_SNAKE_CASE , low + middle ): comp_and_swap(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , i + middle , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Optional[Any] = int(length / 2 ) bitonic_sort(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , 1 ) bitonic_sort(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , 0 ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() lowercase_ = [int(item.strip()) for item in user_input.split(",")] bitonic_sort(unsorted, 0, len(unsorted), 1) print("\nSorted array in ascending order is: ", end="") print(*unsorted, sep=", ") bitonic_merge(unsorted, 0, len(unsorted), 0) print("Sorted array in descending order is: ", end="") print(*unsorted, sep=", ")
20
1
from __future__ import annotations lowercase_ = "Muhammad Umer Farooq" lowercase_ = "MIT" lowercase_ = "1.0.0" lowercase_ = "Muhammad Umer Farooq" lowercase_ = "[email protected]" lowercase_ = "Alpha" import re from html.parser import HTMLParser from urllib import parse import requests class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : Any , _lowerCAmelCase : str ): super().__init__() __snake_case : list[str] = [] __snake_case : Tuple = domain def snake_case__ ( self : int , _lowerCAmelCase : str , _lowerCAmelCase : list[tuple[str, str | None]] ): # Only parse the 'anchor' tag. if tag == "a": # Check the list of defined attributes. for name, value in attrs: # If href is defined, and not empty nor # print it. if name == "href" and value != "#" and value != "": # If not already in urls. if value not in self.urls: __snake_case : Any = parse.urljoin(self.domain , _lowerCAmelCase ) self.urls.append(_lowerCAmelCase ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' return ".".join(get_sub_domain_name(__SCREAMING_SNAKE_CASE ).split(""".""" )[-2:] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' return parse.urlparse(__SCREAMING_SNAKE_CASE ).netloc def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str = "https://github.com" ): '''simple docstring''' __snake_case : int = get_domain_name(__SCREAMING_SNAKE_CASE ) # Initialize the parser __snake_case : int = Parser(__SCREAMING_SNAKE_CASE ) try: # Open URL __snake_case : str = requests.get(__SCREAMING_SNAKE_CASE ) # pass the raw HTML to the parser to get links parser.feed(r.text ) # Get links and loop through __snake_case : Optional[int] = set() for link in parser.urls: # open URL. # read = requests.get(link) try: __snake_case : Dict = requests.get(__SCREAMING_SNAKE_CASE ) # Get the valid email. __snake_case : str = re.findall("""[a-zA-Z0-9]+@""" + domain , read.text ) # If not in list then append it. for email in emails: valid_emails.add(__SCREAMING_SNAKE_CASE ) except ValueError: pass except ValueError: raise SystemExit(1 ) # Finally return a sorted list of email addresses with no duplicates. return sorted(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = emails_from_url("https://github.com") print(F'''{len(emails)} emails found:''') print("\n".join(sorted(emails)))
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , ): '''simple docstring''' __snake_case : Optional[int] = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } __snake_case , __snake_case : Tuple = input_paths_and_base_extractors[compression_format] if input_path is None: __snake_case : Tuple = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) assert base_extractor.is_extractable(__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : List[str] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : int = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any] , ): '''simple docstring''' __snake_case : Union[str, Any] = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } __snake_case : int = input_paths[compression_format] if input_path is None: __snake_case : int = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) __snake_case : Any = Extractor.infer_extractor_format(__SCREAMING_SNAKE_CASE ) assert extractor_format is not None __snake_case : Tuple = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : Union[str, Any] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Union[str, Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' import tarfile __snake_case : List[str] = tmp_path / """data_dot_dot""" directory.mkdir() __snake_case : Optional[Any] = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(__SCREAMING_SNAKE_CASE , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' import tarfile __snake_case : Dict = tmp_path / """data_sym_link""" directory.mkdir() __snake_case : Tuple = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=__SCREAMING_SNAKE_CASE ) with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' __snake_case : Any = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } __snake_case : int = insecure_tar_files[insecure_tar_file] __snake_case : Optional[int] = tmp_path / """extracted""" TarExtractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number __snake_case : Optional[Any] = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 __snake_case : List[str] = ( b"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" b"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" b"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" b"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(__SCREAMING_SNAKE_CASE ) assert zipfile.is_zipfile(str(__SCREAMING_SNAKE_CASE ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(__SCREAMING_SNAKE_CASE ) # but we're right
20
1
import importlib import json import os from collections import OrderedDict from typing import Dict, Optional, Union # Build the list of all image processors from ...configuration_utils import PretrainedConfig from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code from ...image_processing_utils import ImageProcessingMixin from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging from .auto_factory import _LazyAutoMapping from .configuration_auto import ( CONFIG_MAPPING_NAMES, AutoConfig, model_type_to_module_name, replace_list_option_in_docstrings, ) lowercase_ = logging.get_logger(__name__) lowercase_ = OrderedDict( [ ("align", "EfficientNetImageProcessor"), ("beit", "BeitImageProcessor"), ("bit", "BitImageProcessor"), ("blip", "BlipImageProcessor"), ("blip-2", "BlipImageProcessor"), ("bridgetower", "BridgeTowerImageProcessor"), ("chinese_clip", "ChineseCLIPImageProcessor"), ("clip", "CLIPImageProcessor"), ("clipseg", "ViTImageProcessor"), ("conditional_detr", "ConditionalDetrImageProcessor"), ("convnext", "ConvNextImageProcessor"), ("convnextv2", "ConvNextImageProcessor"), ("cvt", "ConvNextImageProcessor"), ("data2vec-vision", "BeitImageProcessor"), ("deformable_detr", "DeformableDetrImageProcessor"), ("deit", "DeiTImageProcessor"), ("deta", "DetaImageProcessor"), ("detr", "DetrImageProcessor"), ("dinat", "ViTImageProcessor"), ("donut-swin", "DonutImageProcessor"), ("dpt", "DPTImageProcessor"), ("efficientformer", "EfficientFormerImageProcessor"), ("efficientnet", "EfficientNetImageProcessor"), ("flava", "FlavaImageProcessor"), ("focalnet", "BitImageProcessor"), ("git", "CLIPImageProcessor"), ("glpn", "GLPNImageProcessor"), ("groupvit", "CLIPImageProcessor"), ("imagegpt", "ImageGPTImageProcessor"), ("instructblip", "BlipImageProcessor"), ("layoutlmv2", "LayoutLMv2ImageProcessor"), ("layoutlmv3", "LayoutLMv3ImageProcessor"), ("levit", "LevitImageProcessor"), ("mask2former", "Mask2FormerImageProcessor"), ("maskformer", "MaskFormerImageProcessor"), ("mgp-str", "ViTImageProcessor"), ("mobilenet_v1", "MobileNetV1ImageProcessor"), ("mobilenet_v2", "MobileNetV2ImageProcessor"), ("mobilevit", "MobileViTImageProcessor"), ("mobilevit", "MobileViTImageProcessor"), ("mobilevitv2", "MobileViTImageProcessor"), ("nat", "ViTImageProcessor"), ("oneformer", "OneFormerImageProcessor"), ("owlvit", "OwlViTImageProcessor"), ("perceiver", "PerceiverImageProcessor"), ("pix2struct", "Pix2StructImageProcessor"), ("poolformer", "PoolFormerImageProcessor"), ("regnet", "ConvNextImageProcessor"), ("resnet", "ConvNextImageProcessor"), ("sam", "SamImageProcessor"), ("segformer", "SegformerImageProcessor"), ("swiftformer", "ViTImageProcessor"), ("swin", "ViTImageProcessor"), ("swin2sr", "Swin2SRImageProcessor"), ("swinv2", "ViTImageProcessor"), ("table-transformer", "DetrImageProcessor"), ("timesformer", "VideoMAEImageProcessor"), ("tvlt", "TvltImageProcessor"), ("upernet", "SegformerImageProcessor"), ("van", "ConvNextImageProcessor"), ("videomae", "VideoMAEImageProcessor"), ("vilt", "ViltImageProcessor"), ("vit", "ViTImageProcessor"), ("vit_hybrid", "ViTHybridImageProcessor"), ("vit_mae", "ViTImageProcessor"), ("vit_msn", "ViTImageProcessor"), ("xclip", "CLIPImageProcessor"), ("yolos", "YolosImageProcessor"), ] ) lowercase_ = _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items(): if class_name in extractors: __snake_case : Any = model_type_to_module_name(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[int] = importlib.import_module(F'''.{module_name}''' , """transformers.models""" ) try: return getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) except AttributeError: continue for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items(): if getattr(__SCREAMING_SNAKE_CASE , """__name__""" , __SCREAMING_SNAKE_CASE ) == class_name: return extractor # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main # init and we return the proper dummy to get an appropriate error message. __snake_case : str = importlib.import_module("""transformers""" ) if hasattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): return getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) return None def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, os.PathLike] , __SCREAMING_SNAKE_CASE : Optional[Union[str, os.PathLike]] = None , __SCREAMING_SNAKE_CASE : bool = False , __SCREAMING_SNAKE_CASE : bool = False , __SCREAMING_SNAKE_CASE : Optional[Dict[str, str]] = None , __SCREAMING_SNAKE_CASE : Optional[Union[bool, str]] = None , __SCREAMING_SNAKE_CASE : Optional[str] = None , __SCREAMING_SNAKE_CASE : bool = False , **__SCREAMING_SNAKE_CASE : Optional[Any] , ): '''simple docstring''' __snake_case : Optional[int] = get_file_from_repo( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , cache_dir=__SCREAMING_SNAKE_CASE , force_download=__SCREAMING_SNAKE_CASE , resume_download=__SCREAMING_SNAKE_CASE , proxies=__SCREAMING_SNAKE_CASE , use_auth_token=__SCREAMING_SNAKE_CASE , revision=__SCREAMING_SNAKE_CASE , local_files_only=__SCREAMING_SNAKE_CASE , ) if resolved_config_file is None: logger.info( """Could not locate the image processor configuration file, will try to use the model config instead.""" ) return {} with open(__SCREAMING_SNAKE_CASE , encoding="""utf-8""" ) as reader: return json.load(__SCREAMING_SNAKE_CASE ) class SCREAMING_SNAKE_CASE__ : def __init__( self : str ): raise EnvironmentError( """AutoImageProcessor is designed to be instantiated """ """using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.""" ) @classmethod @replace_list_option_in_docstrings(_lowerCAmelCase ) def snake_case__ ( cls : Optional[Any] , _lowerCAmelCase : List[Any] , **_lowerCAmelCase : str ): __snake_case : int = kwargs.pop("""config""" , _lowerCAmelCase ) __snake_case : str = kwargs.pop("""trust_remote_code""" , _lowerCAmelCase ) __snake_case : Any = True __snake_case , __snake_case : Optional[Any] = ImageProcessingMixin.get_image_processor_dict(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : List[str] = config_dict.get("""image_processor_type""" , _lowerCAmelCase ) __snake_case : Union[str, Any] = None if "AutoImageProcessor" in config_dict.get("""auto_map""" , {} ): __snake_case : List[str] = config_dict["""auto_map"""]["""AutoImageProcessor"""] # If we still don't have the image processor class, check if we're loading from a previous feature extractor config # and if so, infer the image processor class from there. if image_processor_class is None and image_processor_auto_map is None: __snake_case : int = config_dict.pop("""feature_extractor_type""" , _lowerCAmelCase ) if feature_extractor_class is not None: logger.warning( """Could not find image processor class in the image processor config or the model config. Loading""" """ based on pattern matching with the model's feature extractor configuration.""" ) __snake_case : List[Any] = feature_extractor_class.replace("""FeatureExtractor""" , """ImageProcessor""" ) if "AutoFeatureExtractor" in config_dict.get("""auto_map""" , {} ): __snake_case : Tuple = config_dict["""auto_map"""]["""AutoFeatureExtractor"""] __snake_case : Optional[Any] = feature_extractor_auto_map.replace("""FeatureExtractor""" , """ImageProcessor""" ) logger.warning( """Could not find image processor auto map in the image processor config or the model config.""" """ Loading based on pattern matching with the model's feature extractor configuration.""" ) # If we don't find the image processor class in the image processor config, let's try the model config. if image_processor_class is None and image_processor_auto_map is None: if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : List[Any] = AutoConfig.from_pretrained(_lowerCAmelCase , **_lowerCAmelCase ) # It could be in `config.image_processor_type`` __snake_case : Dict = getattr(_lowerCAmelCase , """image_processor_type""" , _lowerCAmelCase ) if hasattr(_lowerCAmelCase , """auto_map""" ) and "AutoImageProcessor" in config.auto_map: __snake_case : Tuple = config.auto_map["""AutoImageProcessor"""] if image_processor_class is not None: __snake_case : Optional[int] = image_processor_class_from_name(_lowerCAmelCase ) __snake_case : Optional[Any] = image_processor_auto_map is not None __snake_case : Optional[Any] = image_processor_class is not None or type(_lowerCAmelCase ) in IMAGE_PROCESSOR_MAPPING __snake_case : List[str] = resolve_trust_remote_code( _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) if has_remote_code and trust_remote_code: __snake_case : Any = get_class_from_dynamic_module( _lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Union[str, Any] = kwargs.pop("""code_revision""" , _lowerCAmelCase ) if os.path.isdir(_lowerCAmelCase ): image_processor_class.register_for_auto_class() return image_processor_class.from_dict(_lowerCAmelCase , **_lowerCAmelCase ) elif image_processor_class is not None: return image_processor_class.from_dict(_lowerCAmelCase , **_lowerCAmelCase ) # Last try: we use the IMAGE_PROCESSOR_MAPPING. elif type(_lowerCAmelCase ) in IMAGE_PROCESSOR_MAPPING: __snake_case : Optional[Any] = IMAGE_PROCESSOR_MAPPING[type(_lowerCAmelCase )] return image_processor_class.from_dict(_lowerCAmelCase , **_lowerCAmelCase ) raise ValueError( f'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a ''' f'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following ''' f'''`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys() )}''' ) @staticmethod def snake_case__ ( _lowerCAmelCase : Tuple , _lowerCAmelCase : Tuple ): IMAGE_PROCESSOR_MAPPING.register(_lowerCAmelCase , _lowerCAmelCase )
20
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 SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Any ): __snake_case : Dict = """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split() __snake_case : str = dict(zip(_lowerCAmelCase , range(len(_lowerCAmelCase ) ) ) ) __snake_case : List[str] = { """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>""", } __snake_case : str = { """feature_size""": 1, """padding_value""": 0.0, """sampling_rate""": 1_60_00, """return_attention_mask""": False, """do_normalize""": True, } __snake_case : Optional[Any] = tempfile.mkdtemp() __snake_case : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Any = 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 __snake_case : Optional[int] = """hf-internal-testing/ngram-beam-search-decoder""" def snake_case__ ( self : Optional[Any] , **_lowerCAmelCase : Tuple ): __snake_case : int = self.add_kwargs_tokens_map.copy() kwargs.update(_lowerCAmelCase ) return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , **_lowerCAmelCase : Optional[int] ): return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : Tuple ): return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name , **_lowerCAmelCase ) def snake_case__ ( self : List[str] ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Tuple = self.get_feature_extractor() __snake_case : Dict = self.get_decoder() __snake_case : List[str] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) __snake_case : Dict = 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 snake_case__ ( self : Tuple ): __snake_case : Tuple = 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 __snake_case : Optional[Any] = 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 snake_case__ ( self : int ): __snake_case : Tuple = 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 snake_case__ ( self : Dict ): __snake_case : int = self.get_feature_extractor() __snake_case : str = self.get_tokenizer() __snake_case : Dict = self.get_decoder() __snake_case : Any = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : List[Any] = floats_list((3, 10_00) ) __snake_case : Optional[Any] = feature_extractor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Tuple = 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 snake_case__ ( self : Optional[int] ): __snake_case : Any = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = """This is a test string""" __snake_case : Union[str, Any] = processor(text=_lowerCAmelCase ) __snake_case : Dict = tokenizer(_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : List[str] , _lowerCAmelCase : List[Any]=(2, 10, 16) , _lowerCAmelCase : str=77 ): np.random.seed(_lowerCAmelCase ) return np.random.rand(*_lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : List[str] = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : List[str] = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = self._get_dummy_logits(shape=(10, 16) , seed=13 ) __snake_case : int = processor.decode(_lowerCAmelCase ) __snake_case : Optional[int] = 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 snake_case__ ( self : List[str] , _lowerCAmelCase : List[str] ): __snake_case : int = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = 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: __snake_case : Tuple = processor.batch_decode(_lowerCAmelCase ) else: with get_context(_lowerCAmelCase ).Pool() as pool: __snake_case : int = processor.batch_decode(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as p: __snake_case : Tuple = decoder.decode_beams_batch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case , __snake_case , __snake_case : List[Any] = [], [], [] 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 snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = self.get_feature_extractor() __snake_case : int = self.get_tokenizer() __snake_case : str = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = self._get_dummy_logits() __snake_case : List[str] = 15 __snake_case : Optional[Any] = -20.0 __snake_case : Tuple = -4.0 __snake_case : List[Any] = processor.batch_decode( _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : List[str] = decoded_processor_out.text __snake_case : str = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as pool: __snake_case : Dict = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : int = [d[0][0] for d in decoded_decoder_out] __snake_case : List[Any] = [d[0][2] for d in decoded_decoder_out] __snake_case : List[Any] = [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([-20.054, -18.447] , _lowerCAmelCase , atol=1e-3 ) ) self.assertTrue(np.array_equal(_lowerCAmelCase , decoded_processor_out.lm_score ) ) self.assertTrue(np.allclose([-15.554, -13.9474] , _lowerCAmelCase , atol=1e-3 ) ) def snake_case__ ( self : Any ): __snake_case : List[Any] = self.get_feature_extractor() __snake_case : Any = self.get_tokenizer() __snake_case : Union[str, Any] = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Any = self._get_dummy_logits() __snake_case : Any = 2.0 __snake_case : int = 5.0 __snake_case : Optional[int] = -20.0 __snake_case : Optional[int] = True __snake_case : Any = processor.batch_decode( _lowerCAmelCase , alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) __snake_case : str = decoded_processor_out.text __snake_case : int = list(_lowerCAmelCase ) decoder.reset_params( alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) with get_context("""fork""" ).Pool() as pool: __snake_case : Tuple = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , ) __snake_case : int = [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 ) __snake_case : List[str] = 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 , -20.0 ) self.assertEqual(lm_model.score_boundary , _lowerCAmelCase ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Union[str, Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : Union[str, Any] = os.listdir(_lowerCAmelCase ) __snake_case : List[str] = ["""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 snake_case__ ( self : Optional[Any] ): __snake_case : Union[str, Any] = snapshot_download("""hf-internal-testing/processor_with_lm""" ) __snake_case : Dict = WavaVecaProcessorWithLM.from_pretrained(_lowerCAmelCase ) __snake_case : Optional[Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : List[str] = os.listdir(_lowerCAmelCase ) __snake_case : List[Any] = 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 snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : str = AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = floats_list((3, 10_00) ) __snake_case : Union[str, Any] = processor_wavaveca(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Union[str, Any] = 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 ) __snake_case : Dict = self._get_dummy_logits() __snake_case : List[Any] = processor_wavaveca.batch_decode(_lowerCAmelCase ) __snake_case : List[Any] = processor_auto.batch_decode(_lowerCAmelCase ) self.assertListEqual(decoded_wavaveca.text , decoded_auto.text ) def snake_case__ ( self : str ): __snake_case : int = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : Optional[Any] = self.get_decoder() __snake_case : Union[str, Any] = 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 snake_case__ ( _lowerCAmelCase : Any , _lowerCAmelCase : Tuple ): __snake_case : Union[str, Any] = [d[key] for d in offsets] return retrieved_list def snake_case__ ( self : Dict ): __snake_case : int = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : List[str] = self._get_dummy_logits()[0] __snake_case : str = 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 snake_case__ ( self : List[str] ): __snake_case : Any = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = self._get_dummy_logits() __snake_case : int = 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 snake_case__ ( self : Optional[Any] ): import torch __snake_case : Optional[Any] = load_dataset("""common_voice""" , """en""" , split="""train""" , streaming=_lowerCAmelCase ) __snake_case : Any = ds.cast_column("""audio""" , datasets.Audio(sampling_rate=1_60_00 ) ) __snake_case : List[Any] = iter(_lowerCAmelCase ) __snake_case : Optional[int] = next(_lowerCAmelCase ) __snake_case : str = AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) __snake_case : str = 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 __snake_case : List[str] = processor(sample["""audio"""]["""array"""] , return_tensors="""pt""" ).input_values with torch.no_grad(): __snake_case : Dict = model(_lowerCAmelCase ).logits.cpu().numpy() __snake_case : Any = processor.decode(logits[0] , output_word_offsets=_lowerCAmelCase ) __snake_case : Optional[Any] = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate __snake_case : Dict = [ { """start_time""": d["""start_offset"""] * time_offset, """end_time""": d["""end_offset"""] * time_offset, """word""": d["""word"""], } for d in output["""word_offsets"""] ] __snake_case : Dict = """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 __snake_case : Dict = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """start_time""" ) ) __snake_case : Optional[Any] = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """end_time""" ) ) # fmt: off __snake_case : Optional[Any] = torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599] ) __snake_case : Optional[int] = torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94] ) # fmt: on self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) ) self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) )
20
1
import contextlib import os import sqlitea import pytest from datasets import Dataset, Features, Value from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' assert isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @require_sqlalchemy @pytest.mark.parametrize("""keep_in_memory""" , [False, True] ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' __snake_case : Optional[Any] = tmp_path / """cache""" __snake_case : Tuple = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): __snake_case : List[Any] = SqlDatasetReader( """dataset""" , """sqlite:///""" + sqlite_path , cache_dir=__SCREAMING_SNAKE_CASE , keep_in_memory=__SCREAMING_SNAKE_CASE ).read() _check_sql_dataset(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) @require_sqlalchemy @pytest.mark.parametrize( """features""" , [ None, {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}, {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""}, {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""}, {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""}, ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' __snake_case : Dict = tmp_path / """cache""" __snake_case : Union[str, Any] = {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""} __snake_case : Tuple = features.copy() if features else default_expected_features __snake_case : Optional[int] = ( Features({feature: Value(__SCREAMING_SNAKE_CASE ) for feature, dtype in features.items()} ) if features is not None else None ) __snake_case : Any = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , features=__SCREAMING_SNAKE_CASE , cache_dir=__SCREAMING_SNAKE_CASE ).read() _check_sql_dataset(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[Any] ): '''simple docstring''' with contextlib.closing(sqlitea.connect(__SCREAMING_SNAKE_CASE ) ) as con: __snake_case : List[str] = con.cursor() cur.execute("""SELECT * FROM dataset""" ) for row in cur: yield row @require_sqlalchemy def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any] ): '''simple docstring''' __snake_case : str = tmp_path / """cache""" __snake_case : int = os.path.join(__SCREAMING_SNAKE_CASE , """tmp.sql""" ) __snake_case : Tuple = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=__SCREAMING_SNAKE_CASE ).read() SqlDatasetWriter(__SCREAMING_SNAKE_CASE , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=1 ).write() __snake_case : int = iter_sql_file(__SCREAMING_SNAKE_CASE ) __snake_case : int = iter_sql_file(__SCREAMING_SNAKE_CASE ) for rowa, rowa in zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): assert rowa == rowa @require_sqlalchemy def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' __snake_case : int = tmp_path / """cache""" __snake_case : Optional[Any] = os.path.join(__SCREAMING_SNAKE_CASE , """tmp.sql""" ) __snake_case : Optional[int] = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=__SCREAMING_SNAKE_CASE ).read() SqlDatasetWriter(__SCREAMING_SNAKE_CASE , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=2 ).write() __snake_case : List[str] = iter_sql_file(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = iter_sql_file(__SCREAMING_SNAKE_CASE ) for rowa, rowa in zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): assert rowa == rowa @require_sqlalchemy def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' __snake_case : List[str] = tmp_path / """cache""" __snake_case : Union[str, Any] = os.path.join(__SCREAMING_SNAKE_CASE , """tmp.sql""" ) __snake_case : Any = SqlDatasetReader("""dataset""" , """sqlite:///""" + sqlite_path , cache_dir=__SCREAMING_SNAKE_CASE ).read() with pytest.raises(__SCREAMING_SNAKE_CASE ): SqlDatasetWriter(__SCREAMING_SNAKE_CASE , """dataset""" , """sqlite:///""" + output_sqlite_path , num_proc=0 ).write()
20
import argparse import re import torch from CLAP import create_model from transformers import AutoFeatureExtractor, ClapConfig, ClapModel lowercase_ = { "text_branch": "text_model", "audio_branch": "audio_model.audio_encoder", "attn": "attention.self", "self.proj": "output.dense", "attention.self_mask": "attn_mask", "mlp.fc1": "intermediate.dense", "mlp.fc2": "output.dense", "norm1": "layernorm_before", "norm2": "layernorm_after", "bn0": "batch_norm", } lowercase_ = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc") def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any]=False ): '''simple docstring''' __snake_case , __snake_case : str = create_model( """HTSAT-tiny""" , """roberta""" , __SCREAMING_SNAKE_CASE , precision="""fp32""" , device="""cuda:0""" if torch.cuda.is_available() else """cpu""" , enable_fusion=__SCREAMING_SNAKE_CASE , fusion_type="""aff_2d""" if enable_fusion else None , ) return model, model_cfg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Union[str, Any] = {} __snake_case : List[Any] = R""".*sequential.(\d+).*""" __snake_case : Union[str, Any] = R""".*_projection.(\d+).*""" for key, value in state_dict.items(): # check if any key needs to be modified for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items(): if key_to_modify in key: __snake_case : Optional[Any] = key.replace(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): # replace sequential layers with list __snake_case : Optional[Any] = re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) __snake_case : Dict = key.replace(F'''sequential.{sequential_layer}.''' , F'''layers.{int(__SCREAMING_SNAKE_CASE )//3}.linear.''' ) elif re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : str = int(re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) ) # Because in CLAP they use `nn.Sequential`... __snake_case : List[Any] = 1 if projecton_layer == 0 else 2 __snake_case : Tuple = key.replace(F'''_projection.{projecton_layer}.''' , F'''_projection.linear{transformers_projection_layer}.''' ) if "audio" and "qkv" in key: # split qkv into query key and value __snake_case : Optional[int] = value __snake_case : Any = mixed_qkv.size(0 ) // 3 __snake_case : List[Any] = mixed_qkv[:qkv_dim] __snake_case : Tuple = mixed_qkv[qkv_dim : qkv_dim * 2] __snake_case : List[Any] = mixed_qkv[qkv_dim * 2 :] __snake_case : Any = query_layer __snake_case : Dict = key_layer __snake_case : Optional[Any] = value_layer else: __snake_case : List[str] = value return model_state_dict def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Optional[Any]=False ): '''simple docstring''' __snake_case , __snake_case : List[str] = init_clap(__SCREAMING_SNAKE_CASE , enable_fusion=__SCREAMING_SNAKE_CASE ) clap_model.eval() __snake_case : Tuple = clap_model.state_dict() __snake_case : Union[str, Any] = rename_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = ClapConfig() __snake_case : Tuple = enable_fusion __snake_case : Any = ClapModel(__SCREAMING_SNAKE_CASE ) # ignore the spectrogram embedding layer model.load_state_dict(__SCREAMING_SNAKE_CASE , strict=__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) transformers_config.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not") lowercase_ = parser.parse_args() convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
20
1
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_distilbert import DistilBertTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": { "distilbert-base-uncased": "https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt", "distilbert-base-uncased-distilled-squad": ( "https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt" ), "distilbert-base-cased": "https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt", "distilbert-base-cased-distilled-squad": ( "https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt" ), "distilbert-base-german-cased": "https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt", "distilbert-base-multilingual-cased": ( "https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt" ), }, "tokenizer_file": { "distilbert-base-uncased": "https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json", "distilbert-base-uncased-distilled-squad": ( "https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json" ), "distilbert-base-cased": "https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json", "distilbert-base-cased-distilled-squad": ( "https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json" ), "distilbert-base-german-cased": ( "https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json" ), "distilbert-base-multilingual-cased": ( "https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json" ), }, } lowercase_ = { "distilbert-base-uncased": 5_12, "distilbert-base-uncased-distilled-squad": 5_12, "distilbert-base-cased": 5_12, "distilbert-base-cased-distilled-squad": 5_12, "distilbert-base-german-cased": 5_12, "distilbert-base-multilingual-cased": 5_12, } lowercase_ = { "distilbert-base-uncased": {"do_lower_case": True}, "distilbert-base-uncased-distilled-squad": {"do_lower_case": True}, "distilbert-base-cased": {"do_lower_case": False}, "distilbert-base-cased-distilled-squad": {"do_lower_case": False}, "distilbert-base-german-cased": {"do_lower_case": False}, "distilbert-base-multilingual-cased": {"do_lower_case": False}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : int = VOCAB_FILES_NAMES A : Dict = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : Union[str, Any] = PRETRAINED_INIT_CONFIGURATION A : List[Any] = ["input_ids", "attention_mask"] A : Optional[int] = DistilBertTokenizer def __init__( self : Optional[int] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : str=None , _lowerCAmelCase : Any=True , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : Tuple="[SEP]" , _lowerCAmelCase : Any="[PAD]" , _lowerCAmelCase : int="[CLS]" , _lowerCAmelCase : Dict="[MASK]" , _lowerCAmelCase : str=True , _lowerCAmelCase : str=None , **_lowerCAmelCase : Dict , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Optional[Any] = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or normalizer_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents or normalizer_state.get("""handle_chinese_chars""" , _lowerCAmelCase ) != tokenize_chinese_chars ): __snake_case : List[Any] = getattr(_lowerCAmelCase , normalizer_state.pop("""type""" ) ) __snake_case : Union[str, Any] = do_lower_case __snake_case : Optional[int] = strip_accents __snake_case : Union[str, Any] = tokenize_chinese_chars __snake_case : Tuple = normalizer_class(**_lowerCAmelCase ) __snake_case : Optional[int] = do_lower_case def snake_case__ ( self : str , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Tuple=None ): __snake_case : int = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : Tuple , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : List[Any] = [self.sep_token_id] __snake_case : Any = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : List[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : int = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase )
20
import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = "▁" lowercase_ = {"vocab_file": "vocab.txt", "sentencepiece_model_ckpt": "sentencepiece.bpe.model"} lowercase_ = { "sentencepiece_model_file": "sentencepiece.bpe.model", "vocab_file": "vocab.txt", } lowercase_ = { "vocab_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", }, "sentencepiece_model_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", }, } lowercase_ = { "ernie-m-base": 5_14, "ernie-m-large": 5_14, } lowercase_ = { "ernie-m-base": {"do_lower_case": False}, "ernie-m-large": {"do_lower_case": False}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = ["input_ids"] A : Tuple = VOCAB_FILES_NAMES A : List[Any] = PRETRAINED_INIT_CONFIGURATION A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP A : Optional[Any] = RESOURCE_FILES_NAMES def __init__( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : Dict=False , _lowerCAmelCase : List[Any]="utf8" , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : Optional[int]="[SEP]" , _lowerCAmelCase : List[str]="[PAD]" , _lowerCAmelCase : Dict="[CLS]" , _lowerCAmelCase : List[Any]="[MASK]" , _lowerCAmelCase : Optional[Dict[str, Any]] = None , **_lowerCAmelCase : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. __snake_case : List[Any] = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , vocab_file=_lowerCAmelCase , encoding=_lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCAmelCase , ) __snake_case : List[Any] = do_lower_case __snake_case : Any = sentencepiece_model_ckpt __snake_case : int = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCAmelCase ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: __snake_case : int = self.load_vocab(filepath=_lowerCAmelCase ) else: __snake_case : Tuple = {self.sp_model.id_to_piece(_lowerCAmelCase ): id for id in range(self.sp_model.get_piece_size() )} __snake_case : str = {v: k for k, v in self.vocab.items()} def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[Any] ): if text is None: return None __snake_case : List[Any] = self.tokenize(_lowerCAmelCase ) __snake_case , __snake_case : Optional[Any] = """""", [] for i, ch in enumerate(_lowerCAmelCase ): if ch in self.SP_CHAR_MAPPING: __snake_case : Any = self.SP_CHAR_MAPPING.get(_lowerCAmelCase ) else: __snake_case : Dict = unicodedata.normalize("""NFKC""" , _lowerCAmelCase ) if self.is_whitespace(_lowerCAmelCase ): continue normalized_text += ch char_mapping.extend([i] * len(_lowerCAmelCase ) ) __snake_case , __snake_case , __snake_case : str = normalized_text, [], 0 if self.do_lower_case: __snake_case : int = text.lower() for token in split_tokens: if token[:1] == "▁": __snake_case : int = token[1:] __snake_case : Optional[int] = text[offset:].index(_lowerCAmelCase ) + offset __snake_case : int = start + len(_lowerCAmelCase ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) __snake_case : str = end return token_mapping @property def snake_case__ ( self : Tuple ): return len(self.vocab ) def snake_case__ ( self : Dict ): return dict(self.vocab , **self.added_tokens_encoder ) def __getstate__( self : int ): __snake_case : str = self.__dict__.copy() __snake_case : Union[str, Any] = None return state def __setstate__( self : Optional[Any] , _lowerCAmelCase : List[str] ): __snake_case : Union[str, Any] = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): __snake_case : Optional[Any] = {} __snake_case : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def snake_case__ ( self : str , _lowerCAmelCase : Optional[int] ): return "".join((self.SP_CHAR_MAPPING.get(_lowerCAmelCase , _lowerCAmelCase ) for c in text) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Optional[Any]=64 , _lowerCAmelCase : Optional[int]=0.1 ): if self.sp_model_kwargs.get("""enable_sampling""" ) is True: __snake_case : List[str] = True if self.sp_model_kwargs.get("""alpha""" ) is not None: __snake_case : Dict = self.sp_model_kwargs.get("""alpha""" ) if self.sp_model_kwargs.get("""nbest_size""" ) is not None: __snake_case : List[Any] = self.sp_model_kwargs.get("""nbest_size""" ) if not enable_sampling: __snake_case : str = self.sp_model.EncodeAsPieces(_lowerCAmelCase ) else: __snake_case : Tuple = self.sp_model.SampleEncodeAsPieces(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = [] for pi, piece in enumerate(_lowerCAmelCase ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(_lowerCAmelCase ) and pi != 0: new_pieces.append(_lowerCAmelCase ) continue else: continue __snake_case : Optional[int] = 0 for i, chunk in enumerate(_lowerCAmelCase ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(_lowerCAmelCase ) or self.is_punct(_lowerCAmelCase ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(_lowerCAmelCase ) __snake_case : Tuple = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : List[str] = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : Tuple = i if len(_lowerCAmelCase ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): __snake_case : int = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): __snake_case : int = self.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : Any = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): return self.vocab.get(_lowerCAmelCase , self.vocab.get(self.unk_token ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Dict ): return self.reverse_vocab.get(_lowerCAmelCase , self.unk_token ) def snake_case__ ( self : Any , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any]=None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] __snake_case : Optional[Any] = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None ): if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Optional[Any]=False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( """You should not supply a second sequence if the provided sequence of """ """ids is already formatted with special tokens for the model.""" ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] + ([0] * len(_lowerCAmelCase )) + [1] return [1] + ([0] * len(_lowerCAmelCase )) + [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method if token_ids_a is None: # [CLS] X [SEP] return (len(_lowerCAmelCase ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(_lowerCAmelCase ) + 1) + [1] * (len(_lowerCAmelCase ) + 3) def snake_case__ ( self : Tuple , _lowerCAmelCase : List[str] ): if "\u4e00" <= char <= "\u9fff": return True return False def snake_case__ ( self : List[str] , _lowerCAmelCase : Any ): if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def snake_case__ ( self : int , _lowerCAmelCase : List[Any] ): if char in ",;:.?!~,;:。?!《》【】": return True return False def snake_case__ ( self : str , _lowerCAmelCase : Optional[Any] ): if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(_lowerCAmelCase ) == 1: __snake_case : Dict = unicodedata.category(_lowerCAmelCase ) if cat == "Zs": return True return False def snake_case__ ( self : str , _lowerCAmelCase : List[Any] ): __snake_case : Dict = {} with io.open(_lowerCAmelCase , """r""" , encoding="""utf-8""" ) as f: for index, line in enumerate(_lowerCAmelCase ): __snake_case : Tuple = line.rstrip("""\n""" ) __snake_case : List[str] = int(_lowerCAmelCase ) return token_to_idx def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : Optional[int] = 0 if os.path.isdir(_lowerCAmelCase ): __snake_case : int = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) else: __snake_case : Optional[Any] = (filename_prefix + """-""" if filename_prefix else """""") + save_directory with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as writer: for token, token_index in sorted(self.vocab.items() , key=lambda _lowerCAmelCase : kv[1] ): if index != token_index: logger.warning( f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.''' """ Please check that the vocabulary is not corrupted!""" ) __snake_case : Union[str, Any] = token_index writer.write(token + """\n""" ) index += 1 __snake_case : List[Any] = os.path.join(_lowerCAmelCase , """sentencepiece.bpe.model""" ) with open(_lowerCAmelCase , """wb""" ) as fi: __snake_case : List[Any] = self.sp_model.serialized_model_proto() fi.write(_lowerCAmelCase ) return (vocab_file,)
20
1
import json import os from typing import Optional, Tuple from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.json"} lowercase_ = { "vocab_file": { "mgp-str": "https://huggingface.co/alibaba-damo/mgp-str-base/blob/main/vocab.json", } } lowercase_ = {"mgp-str": 27} class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[Any] = VOCAB_FILES_NAMES A : str = PRETRAINED_VOCAB_FILES_MAP A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self : Dict , _lowerCAmelCase : Any , _lowerCAmelCase : str="[GO]" , _lowerCAmelCase : str="[GO]" , _lowerCAmelCase : Dict="[s]" , _lowerCAmelCase : Tuple="[GO]" , **_lowerCAmelCase : Union[str, Any] ): super().__init__( unk_token=_lowerCAmelCase , bos_token=_lowerCAmelCase , eos_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , **_lowerCAmelCase , ) with open(_lowerCAmelCase , encoding="""utf-8""" ) as vocab_handle: __snake_case : str = json.load(_lowerCAmelCase ) __snake_case : Dict = {v: k for k, v in self.vocab.items()} @property def snake_case__ ( self : Any ): return len(self.vocab ) def snake_case__ ( self : Dict ): return dict(self.vocab , **self.added_tokens_encoder ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : List[str] ): __snake_case : List[Any] = [] for s in text: char_tokens.extend(_lowerCAmelCase ) return char_tokens def snake_case__ ( self : Dict , _lowerCAmelCase : Optional[int] ): return self.vocab.get(_lowerCAmelCase , self.vocab.get(self.unk_token ) ) def snake_case__ ( self : List[str] , _lowerCAmelCase : Any ): return self.decoder.get(_lowerCAmelCase ) def snake_case__ ( self : Tuple , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): if not os.path.isdir(_lowerCAmelCase ): logger.error("""Vocabulary path ({}) should be a directory""".format(_lowerCAmelCase ) ) return __snake_case : Union[str, Any] = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as f: f.write(json.dumps(self.vocab , indent=2 , sort_keys=_lowerCAmelCase , ensure_ascii=_lowerCAmelCase ) + """\n""" ) return (vocab_file,)
20
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "xlm-mlm-en-2048": "https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json", "xlm-mlm-ende-1024": "https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json", "xlm-mlm-enfr-1024": "https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json", "xlm-mlm-enro-1024": "https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json", "xlm-mlm-tlm-xnli15-1024": "https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json", "xlm-mlm-xnli15-1024": "https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json", "xlm-clm-enfr-1024": "https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json", "xlm-clm-ende-1024": "https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json", "xlm-mlm-17-1280": "https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json", "xlm-mlm-100-1280": "https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = "xlm" A : List[str] = { "hidden_size": "emb_dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", "n_words": "vocab_size", # For backward compatibility } def __init__( self : List[Any] , _lowerCAmelCase : Optional[Any]=3_01_45 , _lowerCAmelCase : Optional[Any]=20_48 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : int=16 , _lowerCAmelCase : Tuple=0.1 , _lowerCAmelCase : List[Any]=0.1 , _lowerCAmelCase : str=True , _lowerCAmelCase : List[str]=False , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Dict=False , _lowerCAmelCase : Dict=1 , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Optional[Any]=5_12 , _lowerCAmelCase : List[Any]=20_48**-0.5 , _lowerCAmelCase : List[str]=1e-12 , _lowerCAmelCase : List[Any]=0.02 , _lowerCAmelCase : List[str]=0 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Dict=2 , _lowerCAmelCase : List[str]=3 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : Optional[int]=True , _lowerCAmelCase : Tuple="first" , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any=0.1 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : List[str]=5 , _lowerCAmelCase : Optional[Any]=0 , _lowerCAmelCase : Tuple=0 , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Union[str, Any]=0 , **_lowerCAmelCase : Tuple , ): __snake_case : Optional[Any] = vocab_size __snake_case : Tuple = emb_dim __snake_case : int = n_layers __snake_case : List[str] = n_heads __snake_case : Union[str, Any] = dropout __snake_case : Optional[int] = attention_dropout __snake_case : Optional[Any] = gelu_activation __snake_case : Tuple = sinusoidal_embeddings __snake_case : List[Any] = causal __snake_case : Dict = asm __snake_case : int = n_langs __snake_case : str = use_lang_emb __snake_case : Dict = layer_norm_eps __snake_case : List[Any] = bos_index __snake_case : Union[str, Any] = eos_index __snake_case : Dict = pad_index __snake_case : Any = unk_index __snake_case : Dict = mask_index __snake_case : Any = is_encoder __snake_case : Dict = max_position_embeddings __snake_case : Optional[Any] = embed_init_std __snake_case : List[Any] = init_std __snake_case : str = summary_type __snake_case : Optional[Any] = summary_use_proj __snake_case : str = summary_activation __snake_case : Optional[int] = summary_proj_to_labels __snake_case : Dict = summary_first_dropout __snake_case : Dict = start_n_top __snake_case : int = end_n_top __snake_case : str = mask_token_id __snake_case : int = lang_id if "n_words" in kwargs: __snake_case : Dict = kwargs["""n_words"""] super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Dict ): if self.task == "multiple-choice": __snake_case : Optional[int] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : Tuple = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis), ] )
20
1
from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "uclanlp/visualbert-vqa": "https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json", "uclanlp/visualbert-vqa-pre": "https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json", "uclanlp/visualbert-vqa-coco-pre": ( "https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json" ), "uclanlp/visualbert-vcr": "https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json", "uclanlp/visualbert-vcr-pre": "https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json", "uclanlp/visualbert-vcr-coco-pre": ( "https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json" ), "uclanlp/visualbert-nlvr2": "https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json", "uclanlp/visualbert-nlvr2-pre": "https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json", "uclanlp/visualbert-nlvr2-coco-pre": ( "https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json" ) # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Tuple = "visual_bert" def __init__( self : List[str] , _lowerCAmelCase : Dict=3_05_22 , _lowerCAmelCase : Any=7_68 , _lowerCAmelCase : int=5_12 , _lowerCAmelCase : Union[str, Any]=12 , _lowerCAmelCase : Tuple=12 , _lowerCAmelCase : Tuple=30_72 , _lowerCAmelCase : str="gelu" , _lowerCAmelCase : Dict=0.1 , _lowerCAmelCase : str=0.1 , _lowerCAmelCase : Dict=5_12 , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Optional[int]=0.02 , _lowerCAmelCase : Union[str, Any]=1e-12 , _lowerCAmelCase : int=False , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Union[str, Any]=1 , _lowerCAmelCase : str=0 , _lowerCAmelCase : Tuple=2 , **_lowerCAmelCase : Any , ): super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , eos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Optional[Any] = vocab_size __snake_case : List[str] = max_position_embeddings __snake_case : str = hidden_size __snake_case : int = visual_embedding_dim __snake_case : Any = num_hidden_layers __snake_case : Union[str, Any] = num_attention_heads __snake_case : Dict = intermediate_size __snake_case : Any = hidden_act __snake_case : Optional[int] = hidden_dropout_prob __snake_case : Optional[Any] = attention_probs_dropout_prob __snake_case : Optional[Any] = initializer_range __snake_case : Tuple = type_vocab_size __snake_case : int = layer_norm_eps __snake_case : List[str] = bypass_transformer __snake_case : Union[str, Any] = special_visual_initialize
20
import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "facebook/encodec_24khz": "https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json", "facebook/encodec_48khz": "https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[Any] = "encodec" def __init__( self : Tuple , _lowerCAmelCase : Union[str, Any]=[1.5, 3.0, 6.0, 12.0, 24.0] , _lowerCAmelCase : Tuple=2_40_00 , _lowerCAmelCase : List[Any]=1 , _lowerCAmelCase : Optional[int]=False , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : int=1_28 , _lowerCAmelCase : List[Any]=32 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Union[str, Any]=[8, 5, 4, 2] , _lowerCAmelCase : str="weight_norm" , _lowerCAmelCase : Tuple=7 , _lowerCAmelCase : str=7 , _lowerCAmelCase : Any=3 , _lowerCAmelCase : int=2 , _lowerCAmelCase : str=True , _lowerCAmelCase : Dict="reflect" , _lowerCAmelCase : Tuple=2 , _lowerCAmelCase : List[Any]=2 , _lowerCAmelCase : int=1.0 , _lowerCAmelCase : Optional[int]=10_24 , _lowerCAmelCase : int=None , _lowerCAmelCase : List[str]=True , **_lowerCAmelCase : List[Any] , ): __snake_case : Optional[int] = target_bandwidths __snake_case : int = sampling_rate __snake_case : List[Any] = audio_channels __snake_case : str = normalize __snake_case : Union[str, Any] = chunk_length_s __snake_case : Union[str, Any] = overlap __snake_case : Union[str, Any] = hidden_size __snake_case : Union[str, Any] = num_filters __snake_case : Optional[Any] = num_residual_layers __snake_case : List[Any] = upsampling_ratios __snake_case : List[str] = norm_type __snake_case : Union[str, Any] = kernel_size __snake_case : Optional[int] = last_kernel_size __snake_case : Optional[Any] = residual_kernel_size __snake_case : Dict = dilation_growth_rate __snake_case : int = use_causal_conv __snake_case : Tuple = pad_mode __snake_case : str = compress __snake_case : Optional[Any] = num_lstm_layers __snake_case : List[Any] = trim_right_ratio __snake_case : Any = codebook_size __snake_case : int = codebook_dim if codebook_dim is not None else hidden_size __snake_case : int = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( f'''self.norm_type must be one of `"weight_norm"`, `"time_group_norm"`), got {self.norm_type}''' ) super().__init__(**_lowerCAmelCase ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def snake_case__ ( self : Tuple ): return int(10_00 * self.target_bandwidths[-1] // (self.frame_rate * 10) )
20
1
import copy import os from typing import Union from ...configuration_utils import PretrainedConfig from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES from ...utils import logging from ..auto import CONFIG_MAPPING lowercase_ = logging.get_logger(__name__) lowercase_ = { "salesforce/blip2-opt-2.7b": "https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : int = "blip_2_vision_model" def __init__( self : Tuple , _lowerCAmelCase : Optional[int]=14_08 , _lowerCAmelCase : Any=61_44 , _lowerCAmelCase : Any=39 , _lowerCAmelCase : int=16 , _lowerCAmelCase : int=2_24 , _lowerCAmelCase : str=14 , _lowerCAmelCase : Any="gelu" , _lowerCAmelCase : Any=0.00001 , _lowerCAmelCase : int=0.0 , _lowerCAmelCase : Optional[int]=1e-10 , _lowerCAmelCase : List[str]=True , **_lowerCAmelCase : Dict , ): super().__init__(**_lowerCAmelCase ) __snake_case : int = hidden_size __snake_case : List[str] = intermediate_size __snake_case : Tuple = num_hidden_layers __snake_case : Optional[Any] = num_attention_heads __snake_case : str = patch_size __snake_case : Optional[Any] = image_size __snake_case : List[str] = initializer_range __snake_case : Dict = attention_dropout __snake_case : str = layer_norm_eps __snake_case : Tuple = hidden_act __snake_case : List[str] = qkv_bias @classmethod def snake_case__ ( cls : Union[str, Any] , _lowerCAmelCase : Union[str, os.PathLike] , **_lowerCAmelCase : Optional[int] ): cls._set_token_in_kwargs(_lowerCAmelCase ) __snake_case , __snake_case : str = cls.get_config_dict(_lowerCAmelCase , **_lowerCAmelCase ) # get the vision config dict if we are loading from Blip2Config if config_dict.get("""model_type""" ) == "blip-2": __snake_case : Any = config_dict["""vision_config"""] if "model_type" in config_dict and hasattr(cls , """model_type""" ) and config_dict["model_type"] != cls.model_type: logger.warning( f'''You are using a model of type {config_dict['model_type']} to instantiate a model of type ''' f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' ) return cls.from_dict(_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Dict = "blip_2_qformer" def __init__( self : Any , _lowerCAmelCase : Tuple=3_05_22 , _lowerCAmelCase : Union[str, Any]=7_68 , _lowerCAmelCase : int=12 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : Tuple=30_72 , _lowerCAmelCase : List[str]="gelu" , _lowerCAmelCase : List[Any]=0.1 , _lowerCAmelCase : str=0.1 , _lowerCAmelCase : Union[str, Any]=5_12 , _lowerCAmelCase : List[Any]=0.02 , _lowerCAmelCase : Any=1e-12 , _lowerCAmelCase : List[Any]=0 , _lowerCAmelCase : List[str]="absolute" , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Dict=14_08 , **_lowerCAmelCase : Optional[int] , ): super().__init__(pad_token_id=_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Union[str, Any] = vocab_size __snake_case : Tuple = hidden_size __snake_case : Any = num_hidden_layers __snake_case : str = num_attention_heads __snake_case : Optional[int] = hidden_act __snake_case : Any = intermediate_size __snake_case : Tuple = hidden_dropout_prob __snake_case : Union[str, Any] = attention_probs_dropout_prob __snake_case : List[Any] = max_position_embeddings __snake_case : str = initializer_range __snake_case : Optional[Any] = layer_norm_eps __snake_case : List[str] = position_embedding_type __snake_case : List[str] = cross_attention_frequency __snake_case : Optional[int] = encoder_hidden_size @classmethod def snake_case__ ( cls : Dict , _lowerCAmelCase : Union[str, os.PathLike] , **_lowerCAmelCase : Union[str, Any] ): cls._set_token_in_kwargs(_lowerCAmelCase ) __snake_case , __snake_case : List[Any] = cls.get_config_dict(_lowerCAmelCase , **_lowerCAmelCase ) # get the qformer config dict if we are loading from Blip2Config if config_dict.get("""model_type""" ) == "blip-2": __snake_case : List[Any] = config_dict["""qformer_config"""] if "model_type" in config_dict and hasattr(cls , """model_type""" ) and config_dict["model_type"] != cls.model_type: logger.warning( f'''You are using a model of type {config_dict['model_type']} to instantiate a model of type ''' f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' ) return cls.from_dict(_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : int = "blip-2" A : Union[str, Any] = True def __init__( self : Any , _lowerCAmelCase : List[str]=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Any=None , _lowerCAmelCase : Optional[Any]=32 , **_lowerCAmelCase : Tuple ): super().__init__(**_lowerCAmelCase ) if vision_config is None: __snake_case : Any = {} logger.info("""vision_config is None. initializing the Blip2VisionConfig with default values.""" ) if qformer_config is None: __snake_case : int = {} logger.info("""qformer_config is None. Initializing the Blip2QFormerConfig with default values.""" ) if text_config is None: __snake_case : Dict = {} logger.info("""text_config is None. Initializing the text config with default values (`OPTConfig`).""" ) __snake_case : Any = BlipaVisionConfig(**_lowerCAmelCase ) __snake_case : Optional[int] = BlipaQFormerConfig(**_lowerCAmelCase ) __snake_case : str = text_config["""model_type"""] if """model_type""" in text_config else """opt""" __snake_case : List[str] = CONFIG_MAPPING[text_model_type](**_lowerCAmelCase ) __snake_case : int = self.text_config.tie_word_embeddings __snake_case : List[str] = self.text_config.is_encoder_decoder __snake_case : Union[str, Any] = num_query_tokens __snake_case : Union[str, Any] = self.vision_config.hidden_size __snake_case : Optional[Any] = self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES __snake_case : List[Any] = 1.0 __snake_case : str = 0.02 @classmethod def snake_case__ ( cls : Union[str, Any] , _lowerCAmelCase : BlipaVisionConfig , _lowerCAmelCase : BlipaQFormerConfig , _lowerCAmelCase : PretrainedConfig , **_lowerCAmelCase : int , ): return cls( vision_config=vision_config.to_dict() , qformer_config=qformer_config.to_dict() , text_config=text_config.to_dict() , **_lowerCAmelCase , ) def snake_case__ ( self : Dict ): __snake_case : Union[str, Any] = copy.deepcopy(self.__dict__ ) __snake_case : Tuple = self.vision_config.to_dict() __snake_case : Optional[Any] = self.qformer_config.to_dict() __snake_case : Union[str, Any] = self.text_config.to_dict() __snake_case : int = self.__class__.model_type return output
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : str = [] __snake_case , __snake_case : List[str] = input_list[low:mid], input_list[mid : high + 1] while left and right: result.append((left if left[0] <= right[0] else right).pop(0 ) ) __snake_case : List[Any] = result + left + right return input_list def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if len(__SCREAMING_SNAKE_CASE ) <= 1: return input_list __snake_case : Union[str, Any] = list(__SCREAMING_SNAKE_CASE ) # iteration for two-way merging __snake_case : Tuple = 2 while p <= len(__SCREAMING_SNAKE_CASE ): # getting low, high and middle value for merge-sort of single list for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = i + p - 1 __snake_case : Optional[Any] = (low + high + 1) // 2 __snake_case : str = merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # final merge of last two parts if p * 2 >= len(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = merge(__SCREAMING_SNAKE_CASE , 0 , __SCREAMING_SNAKE_CASE , len(__SCREAMING_SNAKE_CASE ) - 1 ) break p *= 2 return input_list if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() if user_input == "": lowercase_ = [] else: lowercase_ = [int(item.strip()) for item in user_input.split(",")] print(iter_merge_sort(unsorted))
20
1
import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = "▁" lowercase_ = {"vocab_file": "vocab.txt", "sentencepiece_model_ckpt": "sentencepiece.bpe.model"} lowercase_ = { "sentencepiece_model_file": "sentencepiece.bpe.model", "vocab_file": "vocab.txt", } lowercase_ = { "vocab_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", }, "sentencepiece_model_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", }, } lowercase_ = { "ernie-m-base": 5_14, "ernie-m-large": 5_14, } lowercase_ = { "ernie-m-base": {"do_lower_case": False}, "ernie-m-large": {"do_lower_case": False}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = ["input_ids"] A : Tuple = VOCAB_FILES_NAMES A : List[Any] = PRETRAINED_INIT_CONFIGURATION A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP A : Optional[Any] = RESOURCE_FILES_NAMES def __init__( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : Dict=False , _lowerCAmelCase : List[Any]="utf8" , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : Optional[int]="[SEP]" , _lowerCAmelCase : List[str]="[PAD]" , _lowerCAmelCase : Dict="[CLS]" , _lowerCAmelCase : List[Any]="[MASK]" , _lowerCAmelCase : Optional[Dict[str, Any]] = None , **_lowerCAmelCase : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. __snake_case : List[Any] = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , vocab_file=_lowerCAmelCase , encoding=_lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCAmelCase , ) __snake_case : List[Any] = do_lower_case __snake_case : Any = sentencepiece_model_ckpt __snake_case : int = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCAmelCase ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: __snake_case : int = self.load_vocab(filepath=_lowerCAmelCase ) else: __snake_case : Tuple = {self.sp_model.id_to_piece(_lowerCAmelCase ): id for id in range(self.sp_model.get_piece_size() )} __snake_case : str = {v: k for k, v in self.vocab.items()} def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[Any] ): if text is None: return None __snake_case : List[Any] = self.tokenize(_lowerCAmelCase ) __snake_case , __snake_case : Optional[Any] = """""", [] for i, ch in enumerate(_lowerCAmelCase ): if ch in self.SP_CHAR_MAPPING: __snake_case : Any = self.SP_CHAR_MAPPING.get(_lowerCAmelCase ) else: __snake_case : Dict = unicodedata.normalize("""NFKC""" , _lowerCAmelCase ) if self.is_whitespace(_lowerCAmelCase ): continue normalized_text += ch char_mapping.extend([i] * len(_lowerCAmelCase ) ) __snake_case , __snake_case , __snake_case : str = normalized_text, [], 0 if self.do_lower_case: __snake_case : int = text.lower() for token in split_tokens: if token[:1] == "▁": __snake_case : int = token[1:] __snake_case : Optional[int] = text[offset:].index(_lowerCAmelCase ) + offset __snake_case : int = start + len(_lowerCAmelCase ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) __snake_case : str = end return token_mapping @property def snake_case__ ( self : Tuple ): return len(self.vocab ) def snake_case__ ( self : Dict ): return dict(self.vocab , **self.added_tokens_encoder ) def __getstate__( self : int ): __snake_case : str = self.__dict__.copy() __snake_case : Union[str, Any] = None return state def __setstate__( self : Optional[Any] , _lowerCAmelCase : List[str] ): __snake_case : Union[str, Any] = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): __snake_case : Optional[Any] = {} __snake_case : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def snake_case__ ( self : str , _lowerCAmelCase : Optional[int] ): return "".join((self.SP_CHAR_MAPPING.get(_lowerCAmelCase , _lowerCAmelCase ) for c in text) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Optional[Any]=64 , _lowerCAmelCase : Optional[int]=0.1 ): if self.sp_model_kwargs.get("""enable_sampling""" ) is True: __snake_case : List[str] = True if self.sp_model_kwargs.get("""alpha""" ) is not None: __snake_case : Dict = self.sp_model_kwargs.get("""alpha""" ) if self.sp_model_kwargs.get("""nbest_size""" ) is not None: __snake_case : List[Any] = self.sp_model_kwargs.get("""nbest_size""" ) if not enable_sampling: __snake_case : str = self.sp_model.EncodeAsPieces(_lowerCAmelCase ) else: __snake_case : Tuple = self.sp_model.SampleEncodeAsPieces(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = [] for pi, piece in enumerate(_lowerCAmelCase ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(_lowerCAmelCase ) and pi != 0: new_pieces.append(_lowerCAmelCase ) continue else: continue __snake_case : Optional[int] = 0 for i, chunk in enumerate(_lowerCAmelCase ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(_lowerCAmelCase ) or self.is_punct(_lowerCAmelCase ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(_lowerCAmelCase ) __snake_case : Tuple = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : List[str] = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : Tuple = i if len(_lowerCAmelCase ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): __snake_case : int = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): __snake_case : int = self.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : Any = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): return self.vocab.get(_lowerCAmelCase , self.vocab.get(self.unk_token ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Dict ): return self.reverse_vocab.get(_lowerCAmelCase , self.unk_token ) def snake_case__ ( self : Any , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any]=None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] __snake_case : Optional[Any] = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None ): if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Optional[Any]=False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( """You should not supply a second sequence if the provided sequence of """ """ids is already formatted with special tokens for the model.""" ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] + ([0] * len(_lowerCAmelCase )) + [1] return [1] + ([0] * len(_lowerCAmelCase )) + [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method if token_ids_a is None: # [CLS] X [SEP] return (len(_lowerCAmelCase ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(_lowerCAmelCase ) + 1) + [1] * (len(_lowerCAmelCase ) + 3) def snake_case__ ( self : Tuple , _lowerCAmelCase : List[str] ): if "\u4e00" <= char <= "\u9fff": return True return False def snake_case__ ( self : List[str] , _lowerCAmelCase : Any ): if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def snake_case__ ( self : int , _lowerCAmelCase : List[Any] ): if char in ",;:.?!~,;:。?!《》【】": return True return False def snake_case__ ( self : str , _lowerCAmelCase : Optional[Any] ): if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(_lowerCAmelCase ) == 1: __snake_case : Dict = unicodedata.category(_lowerCAmelCase ) if cat == "Zs": return True return False def snake_case__ ( self : str , _lowerCAmelCase : List[Any] ): __snake_case : Dict = {} with io.open(_lowerCAmelCase , """r""" , encoding="""utf-8""" ) as f: for index, line in enumerate(_lowerCAmelCase ): __snake_case : Tuple = line.rstrip("""\n""" ) __snake_case : List[str] = int(_lowerCAmelCase ) return token_to_idx def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : Optional[int] = 0 if os.path.isdir(_lowerCAmelCase ): __snake_case : int = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) else: __snake_case : Optional[Any] = (filename_prefix + """-""" if filename_prefix else """""") + save_directory with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as writer: for token, token_index in sorted(self.vocab.items() , key=lambda _lowerCAmelCase : kv[1] ): if index != token_index: logger.warning( f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.''' """ Please check that the vocabulary is not corrupted!""" ) __snake_case : Union[str, Any] = token_index writer.write(token + """\n""" ) index += 1 __snake_case : List[Any] = os.path.join(_lowerCAmelCase , """sentencepiece.bpe.model""" ) with open(_lowerCAmelCase , """wb""" ) as fi: __snake_case : List[Any] = self.sp_model.serialized_model_proto() fi.write(_lowerCAmelCase ) return (vocab_file,)
20
import random import sys import numpy as np from matplotlib import pyplot as plt from matplotlib.colors import ListedColormap lowercase_ = "Usage of script: script_name <size_of_canvas:int>" lowercase_ = [0] * 1_00 + [1] * 10 random.shuffle(choice) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : List[str] = [[False for i in range(__SCREAMING_SNAKE_CASE )] for j in range(__SCREAMING_SNAKE_CASE )] return canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' for i, row in enumerate(__SCREAMING_SNAKE_CASE ): for j, _ in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : int = bool(random.getrandbits(1 ) ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Union[str, Any] = np.array(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = np.array(create_canvas(current_canvas.shape[0] ) ) for r, row in enumerate(__SCREAMING_SNAKE_CASE ): for c, pt in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : Optional[Any] = __judge_point( __SCREAMING_SNAKE_CASE , current_canvas[r - 1 : r + 2, c - 1 : c + 2] ) __snake_case : List[str] = next_gen_canvas del next_gen_canvas # cleaning memory as we move on. __snake_case : list[list[bool]] = current_canvas.tolist() return return_canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Any = 0 __snake_case : Dict = 0 # finding dead or alive neighbours count. for i in neighbours: for status in i: if status: alive += 1 else: dead += 1 # handling duplicate entry for focus pt. if pt: alive -= 1 else: dead -= 1 # running the rules of game here. __snake_case : str = pt if pt: if alive < 2: __snake_case : Optional[Any] = False elif alive == 2 or alive == 3: __snake_case : Union[str, Any] = True elif alive > 3: __snake_case : Optional[int] = False else: if alive == 3: __snake_case : List[Any] = True return state if __name__ == "__main__": if len(sys.argv) != 2: raise Exception(usage_doc) lowercase_ = int(sys.argv[1]) # main working structure of this module. lowercase_ = create_canvas(canvas_size) seed(c) lowercase_ , lowercase_ = plt.subplots() fig.show() lowercase_ = ListedColormap(["w", "k"]) try: while True: lowercase_ = run(c) ax.matshow(c, cmap=cmap) fig.canvas.draw() ax.cla() except KeyboardInterrupt: # do nothing. pass
20
1
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "xlm-mlm-en-2048": "https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json", "xlm-mlm-ende-1024": "https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json", "xlm-mlm-enfr-1024": "https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json", "xlm-mlm-enro-1024": "https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json", "xlm-mlm-tlm-xnli15-1024": "https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json", "xlm-mlm-xnli15-1024": "https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json", "xlm-clm-enfr-1024": "https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json", "xlm-clm-ende-1024": "https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json", "xlm-mlm-17-1280": "https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json", "xlm-mlm-100-1280": "https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = "xlm" A : List[str] = { "hidden_size": "emb_dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", "n_words": "vocab_size", # For backward compatibility } def __init__( self : List[Any] , _lowerCAmelCase : Optional[Any]=3_01_45 , _lowerCAmelCase : Optional[Any]=20_48 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : int=16 , _lowerCAmelCase : Tuple=0.1 , _lowerCAmelCase : List[Any]=0.1 , _lowerCAmelCase : str=True , _lowerCAmelCase : List[str]=False , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Dict=False , _lowerCAmelCase : Dict=1 , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Optional[Any]=5_12 , _lowerCAmelCase : List[Any]=20_48**-0.5 , _lowerCAmelCase : List[str]=1e-12 , _lowerCAmelCase : List[Any]=0.02 , _lowerCAmelCase : List[str]=0 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Dict=2 , _lowerCAmelCase : List[str]=3 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : Optional[int]=True , _lowerCAmelCase : Tuple="first" , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any=0.1 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : List[str]=5 , _lowerCAmelCase : Optional[Any]=0 , _lowerCAmelCase : Tuple=0 , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Union[str, Any]=0 , **_lowerCAmelCase : Tuple , ): __snake_case : Optional[Any] = vocab_size __snake_case : Tuple = emb_dim __snake_case : int = n_layers __snake_case : List[str] = n_heads __snake_case : Union[str, Any] = dropout __snake_case : Optional[int] = attention_dropout __snake_case : Optional[Any] = gelu_activation __snake_case : Tuple = sinusoidal_embeddings __snake_case : List[Any] = causal __snake_case : Dict = asm __snake_case : int = n_langs __snake_case : str = use_lang_emb __snake_case : Dict = layer_norm_eps __snake_case : List[Any] = bos_index __snake_case : Union[str, Any] = eos_index __snake_case : Dict = pad_index __snake_case : Any = unk_index __snake_case : Dict = mask_index __snake_case : Any = is_encoder __snake_case : Dict = max_position_embeddings __snake_case : Optional[Any] = embed_init_std __snake_case : List[Any] = init_std __snake_case : str = summary_type __snake_case : Optional[Any] = summary_use_proj __snake_case : str = summary_activation __snake_case : Optional[int] = summary_proj_to_labels __snake_case : Dict = summary_first_dropout __snake_case : Dict = start_n_top __snake_case : int = end_n_top __snake_case : str = mask_token_id __snake_case : int = lang_id if "n_words" in kwargs: __snake_case : Dict = kwargs["""n_words"""] super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Dict ): if self.task == "multiple-choice": __snake_case : Optional[int] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : Tuple = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis), ] )
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def __lowerCAmelCase ( *__SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Optional[Union[Dict, Any]] = None , __SCREAMING_SNAKE_CASE : Any=True , __SCREAMING_SNAKE_CASE : int=2 ): '''simple docstring''' from .. import __version__ __snake_case : List[Any] = take_from __snake_case : List[Any] = () if not isinstance(args[0] , __SCREAMING_SNAKE_CASE ): __snake_case : str = (args,) for attribute, version_name, message in args: if version.parse(version.parse(__SCREAMING_SNAKE_CASE ).base_version ) >= version.parse(__SCREAMING_SNAKE_CASE ): raise ValueError( F'''The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers\'''' F''' version {__version__} is >= {version_name}''' ) __snake_case : Optional[Any] = None if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(__SCREAMING_SNAKE_CASE ),) __snake_case : Optional[Any] = F'''The `{attribute}` argument is deprecated and will be removed in version {version_name}.''' elif hasattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): values += (getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ),) __snake_case : Any = F'''The `{attribute}` attribute is deprecated and will be removed in version {version_name}.''' elif deprecated_kwargs is None: __snake_case : Tuple = F'''`{attribute}` is deprecated and will be removed in version {version_name}.''' if warning is not None: __snake_case : Optional[Any] = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , __SCREAMING_SNAKE_CASE , stacklevel=__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and len(__SCREAMING_SNAKE_CASE ) > 0: __snake_case : Dict = inspect.getouterframes(inspect.currentframe() )[1] __snake_case : int = call_frame.filename __snake_case : int = call_frame.lineno __snake_case : List[str] = call_frame.function __snake_case , __snake_case : List[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(F'''{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`''' ) if len(__SCREAMING_SNAKE_CASE ) == 0: return elif len(__SCREAMING_SNAKE_CASE ) == 1: return values[0] return values
20
1
from typing import Dict, List, Optional, Union import numpy as np from transformers.utils import is_vision_available from transformers.utils.generic import TensorType from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, is_valid_image, to_numpy_array, valid_images, ) from ...utils import logging if is_vision_available(): import PIL lowercase_ = logging.get_logger(__name__) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' if isinstance(__SCREAMING_SNAKE_CASE , (list, tuple) ) and isinstance(videos[0] , (list, tuple) ) and is_valid_image(videos[0][0] ): return videos elif isinstance(__SCREAMING_SNAKE_CASE , (list, tuple) ) and is_valid_image(videos[0] ): return [videos] elif is_valid_image(__SCREAMING_SNAKE_CASE ): return [[videos]] raise ValueError(F'''Could not make batched video from {videos}''' ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[Any] = ["pixel_values"] def __init__( self : Any , _lowerCAmelCase : bool = True , _lowerCAmelCase : Dict[str, int] = None , _lowerCAmelCase : PILImageResampling = PILImageResampling.BILINEAR , _lowerCAmelCase : bool = True , _lowerCAmelCase : Dict[str, int] = None , _lowerCAmelCase : bool = True , _lowerCAmelCase : Union[int, float] = 1 / 2_55 , _lowerCAmelCase : bool = True , _lowerCAmelCase : bool = True , _lowerCAmelCase : Optional[Union[float, List[float]]] = None , _lowerCAmelCase : Optional[Union[float, List[float]]] = None , **_lowerCAmelCase : Dict , ): super().__init__(**_lowerCAmelCase ) __snake_case : Dict = size if size is not None else {"""shortest_edge""": 2_56} __snake_case : List[str] = get_size_dict(_lowerCAmelCase , default_to_square=_lowerCAmelCase ) __snake_case : Optional[Any] = crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24} __snake_case : List[Any] = get_size_dict(_lowerCAmelCase , param_name="""crop_size""" ) __snake_case : List[str] = do_resize __snake_case : Union[str, Any] = size __snake_case : Tuple = do_center_crop __snake_case : Tuple = crop_size __snake_case : Union[str, Any] = resample __snake_case : Union[str, Any] = do_rescale __snake_case : str = rescale_factor __snake_case : int = offset __snake_case : str = do_normalize __snake_case : List[Any] = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN __snake_case : Tuple = image_std if image_std is not None else IMAGENET_STANDARD_STD def snake_case__ ( self : Optional[int] , _lowerCAmelCase : np.ndarray , _lowerCAmelCase : Dict[str, int] , _lowerCAmelCase : PILImageResampling = PILImageResampling.BILINEAR , _lowerCAmelCase : Optional[Union[str, ChannelDimension]] = None , **_lowerCAmelCase : Optional[Any] , ): __snake_case : Optional[Any] = get_size_dict(_lowerCAmelCase , default_to_square=_lowerCAmelCase ) if "shortest_edge" in size: __snake_case : Any = get_resize_output_image_size(_lowerCAmelCase , size["""shortest_edge"""] , default_to_square=_lowerCAmelCase ) elif "height" in size and "width" in size: __snake_case : Dict = (size["""height"""], size["""width"""]) else: raise ValueError(f'''Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}''' ) return resize(_lowerCAmelCase , size=_lowerCAmelCase , resample=_lowerCAmelCase , data_format=_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : np.ndarray , _lowerCAmelCase : Dict[str, int] , _lowerCAmelCase : Optional[Union[str, ChannelDimension]] = None , **_lowerCAmelCase : Dict , ): __snake_case : Optional[int] = get_size_dict(_lowerCAmelCase ) if "height" not in size or "width" not in size: raise ValueError(f'''Size must have \'height\' and \'width\' as keys. Got {size.keys()}''' ) return center_crop(_lowerCAmelCase , size=(size["""height"""], size["""width"""]) , data_format=_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Dict , _lowerCAmelCase : np.ndarray , _lowerCAmelCase : Union[int, float] , _lowerCAmelCase : bool = True , _lowerCAmelCase : Optional[Union[str, ChannelDimension]] = None , **_lowerCAmelCase : Optional[Any] , ): __snake_case : Dict = image.astype(np.floataa ) if offset: __snake_case : Tuple = image - (scale / 2) return rescale(_lowerCAmelCase , scale=_lowerCAmelCase , data_format=_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : int , _lowerCAmelCase : np.ndarray , _lowerCAmelCase : Union[float, List[float]] , _lowerCAmelCase : Union[float, List[float]] , _lowerCAmelCase : Optional[Union[str, ChannelDimension]] = None , **_lowerCAmelCase : int , ): return normalize(_lowerCAmelCase , mean=_lowerCAmelCase , std=_lowerCAmelCase , data_format=_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Dict , _lowerCAmelCase : ImageInput , _lowerCAmelCase : bool = None , _lowerCAmelCase : Dict[str, int] = None , _lowerCAmelCase : PILImageResampling = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : Dict[str, int] = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : float = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : Optional[Union[float, List[float]]] = None , _lowerCAmelCase : Optional[Union[float, List[float]]] = None , _lowerCAmelCase : Optional[ChannelDimension] = ChannelDimension.FIRST , ): if do_resize and size is None or resample is None: raise ValueError("""Size and resample must be specified if do_resize is True.""" ) if do_center_crop and crop_size is None: raise ValueError("""Crop size must be specified if do_center_crop is True.""" ) if do_rescale and rescale_factor is None: raise ValueError("""Rescale factor must be specified if do_rescale is True.""" ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("""Image mean and std must be specified if do_normalize is True.""" ) if offset and not do_rescale: raise ValueError("""For offset, do_rescale must also be set to True.""" ) # All transformations expect numpy arrays. __snake_case : Optional[int] = to_numpy_array(_lowerCAmelCase ) if do_resize: __snake_case : Tuple = self.resize(image=_lowerCAmelCase , size=_lowerCAmelCase , resample=_lowerCAmelCase ) if do_center_crop: __snake_case : Optional[int] = self.center_crop(_lowerCAmelCase , size=_lowerCAmelCase ) if do_rescale: __snake_case : Union[str, Any] = self.rescale(image=_lowerCAmelCase , scale=_lowerCAmelCase , offset=_lowerCAmelCase ) if do_normalize: __snake_case : Optional[Any] = self.normalize(image=_lowerCAmelCase , mean=_lowerCAmelCase , std=_lowerCAmelCase ) __snake_case : Any = to_channel_dimension_format(_lowerCAmelCase , _lowerCAmelCase ) return image def snake_case__ ( self : int , _lowerCAmelCase : ImageInput , _lowerCAmelCase : bool = None , _lowerCAmelCase : Dict[str, int] = None , _lowerCAmelCase : PILImageResampling = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : Dict[str, int] = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : float = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : bool = None , _lowerCAmelCase : Optional[Union[float, List[float]]] = None , _lowerCAmelCase : Optional[Union[float, List[float]]] = None , _lowerCAmelCase : Optional[Union[str, TensorType]] = None , _lowerCAmelCase : ChannelDimension = ChannelDimension.FIRST , **_lowerCAmelCase : Optional[int] , ): __snake_case : Dict = do_resize if do_resize is not None else self.do_resize __snake_case : Tuple = resample if resample is not None else self.resample __snake_case : List[Any] = do_center_crop if do_center_crop is not None else self.do_center_crop __snake_case : Optional[int] = do_rescale if do_rescale is not None else self.do_rescale __snake_case : List[Any] = rescale_factor if rescale_factor is not None else self.rescale_factor __snake_case : Optional[Any] = offset if offset is not None else self.offset __snake_case : Optional[int] = do_normalize if do_normalize is not None else self.do_normalize __snake_case : Optional[Any] = image_mean if image_mean is not None else self.image_mean __snake_case : int = image_std if image_std is not None else self.image_std __snake_case : List[str] = size if size is not None else self.size __snake_case : Optional[Any] = get_size_dict(_lowerCAmelCase , default_to_square=_lowerCAmelCase ) __snake_case : List[Any] = crop_size if crop_size is not None else self.crop_size __snake_case : Union[str, Any] = get_size_dict(_lowerCAmelCase , param_name="""crop_size""" ) if not valid_images(_lowerCAmelCase ): raise ValueError( """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """ """torch.Tensor, tf.Tensor or jax.ndarray.""" ) __snake_case : Union[str, Any] = make_batched(_lowerCAmelCase ) __snake_case : Dict = [ [ self._preprocess_image( image=_lowerCAmelCase , do_resize=_lowerCAmelCase , size=_lowerCAmelCase , resample=_lowerCAmelCase , do_center_crop=_lowerCAmelCase , crop_size=_lowerCAmelCase , do_rescale=_lowerCAmelCase , rescale_factor=_lowerCAmelCase , offset=_lowerCAmelCase , do_normalize=_lowerCAmelCase , image_mean=_lowerCAmelCase , image_std=_lowerCAmelCase , data_format=_lowerCAmelCase , ) for img in video ] for video in videos ] __snake_case : Any = {"""pixel_values""": videos} return BatchFeature(data=_lowerCAmelCase , tensor_type=_lowerCAmelCase )
20
import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() lowercase_ = { "bart": ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), "bert": ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-uncased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-cased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-base-cased-finetuned-mrpc": ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "dpr": ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), "gpt2": ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlnet": ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm": ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm-roberta": ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "transfo-xl": ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "openai-gpt": ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "roberta": ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "layoutlm": ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), "roberta-large-mnli": ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "camembert": ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "flaubert": ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert": ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert-base-distilled-squad": ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert": ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert-visual-feature-encoder": ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "ctrl": ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "albert": ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "t5": ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "electra": ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "wav2vec2": ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str]=False , __SCREAMING_SNAKE_CASE : List[Any]=True ): '''simple docstring''' if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case : Any = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) __snake_case : Dict = config_class.from_json_file(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = True __snake_case : Union[str, Any] = True print(F'''Building TensorFlow model from configuration: {config}''' ) __snake_case : List[Any] = model_class(__SCREAMING_SNAKE_CASE ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): __snake_case : Optional[Any] = cached_file( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: __snake_case : List[Any] = load_pytorch_checkpoint_in_tfa_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if compare_with_pt_model: __snake_case : Tuple = tf_model(tf_model.dummy_inputs , training=__SCREAMING_SNAKE_CASE ) # build the network __snake_case : List[str] = torch.load(__SCREAMING_SNAKE_CASE , map_location="""cpu""" ) __snake_case : Any = pt_model_class.from_pretrained( pretrained_model_name_or_path=__SCREAMING_SNAKE_CASE , config=__SCREAMING_SNAKE_CASE , state_dict=__SCREAMING_SNAKE_CASE ) with torch.no_grad(): __snake_case : Union[str, Any] = pt_model(**pt_model.dummy_inputs ) __snake_case : Any = pto[0].numpy() __snake_case : Optional[int] = tfo[0].numpy() __snake_case : Optional[int] = np.amax(np.abs(np_pt - np_tf ) ) print(F'''Max absolute difference between models outputs {diff}''' ) assert diff <= 2E-2, F'''Error, model absolute difference is >2e-2: {diff}''' # Save pytorch-model print(F'''Save TensorFlow model to {tf_dump_path}''' ) tf_model.save_weights(__SCREAMING_SNAKE_CASE , save_format="""h5""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : List[str]=None , __SCREAMING_SNAKE_CASE : Any=None , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : List[Any]=False , __SCREAMING_SNAKE_CASE : Any=False , ): '''simple docstring''' if args_model_type is None: __snake_case : Tuple = list(MODEL_CLASSES.keys() ) else: __snake_case : Union[str, Any] = [args_model_type] for j, model_type in enumerate(__SCREAMING_SNAKE_CASE , start=1 ): print("""=""" * 1_0_0 ) print(F''' Converting model type {j}/{len(__SCREAMING_SNAKE_CASE )}: {model_type}''' ) print("""=""" * 1_0_0 ) if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case , __snake_case : Optional[int] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: __snake_case : int = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: __snake_case : Union[str, Any] = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , start=1 ): print("""-""" * 1_0_0 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(F''' Skipping finetuned checkpoint {model_shortcut_name}''' ) continue __snake_case : List[Any] = model_shortcut_name elif only_convert_finetuned_models: print(F''' Skipping not finetuned checkpoint {model_shortcut_name}''' ) continue print( F''' Converting checkpoint {i}/{len(__SCREAMING_SNAKE_CASE )}: {model_shortcut_name} - model_type {model_type}''' ) print("""-""" * 1_0_0 ) if config_shortcut_name in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : Dict = config_shortcut_name if model_shortcut_name in aws_model_maps: __snake_case : Union[str, Any] = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : List[Any] = model_shortcut_name if os.path.isfile(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = """converted_model""" convert_pt_checkpoint_to_tf( model_type=__SCREAMING_SNAKE_CASE , pytorch_checkpoint_path=__SCREAMING_SNAKE_CASE , config_file=__SCREAMING_SNAKE_CASE , tf_dump_path=os.path.join(__SCREAMING_SNAKE_CASE , model_shortcut_name + """-tf_model.h5""" ) , compare_with_pt_model=__SCREAMING_SNAKE_CASE , ) if remove_cached_files: os.remove(__SCREAMING_SNAKE_CASE ) os.remove(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--tf_dump_path", default=None, type=str, required=True, help="Path to the output Tensorflow dump file." ) parser.add_argument( "--model_type", default=None, type=str, help=( F'''Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ''' "convert all the models from AWS." ), ) parser.add_argument( "--pytorch_checkpoint_path", default=None, type=str, help=( "Path to the PyTorch checkpoint path or shortcut name to download from AWS. " "If not given, will download and convert all the checkpoints from AWS." ), ) parser.add_argument( "--config_file", default=None, type=str, help=( "The config json file corresponding to the pre-trained model. \n" "This specifies the model architecture. If not given and " "--pytorch_checkpoint_path is not given or is a shortcut name " "use the configuration associated to the shortcut name on the AWS" ), ) parser.add_argument( "--compare_with_pt_model", action="store_true", help="Compare Tensorflow and PyTorch model predictions." ) parser.add_argument( "--use_cached_models", action="store_true", help="Use cached models if possible instead of updating to latest checkpoint versions.", ) parser.add_argument( "--remove_cached_files", action="store_true", help="Remove pytorch models after conversion (save memory when converting in batches).", ) parser.add_argument("--only_convert_finetuned_models", action="store_true", help="Only convert finetuned models.") lowercase_ = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
20
1
import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class SCREAMING_SNAKE_CASE__ ( tf.keras.layers.Layer ): def __init__( self : Tuple , _lowerCAmelCase : Dict[str, int] , _lowerCAmelCase : List[str] , _lowerCAmelCase : int = None , _lowerCAmelCase : int = None ): super().__init__() __snake_case : List[str] = pad_token_id __snake_case : List[str] = max_length __snake_case : Optional[Any] = vocab __snake_case : List[str] = merges __snake_case : str = BytePairTokenizer(_lowerCAmelCase , _lowerCAmelCase , sequence_length=_lowerCAmelCase ) @classmethod def snake_case__ ( cls : Union[str, Any] , _lowerCAmelCase : GPTaTokenizer , *_lowerCAmelCase : Optional[int] , **_lowerCAmelCase : List[str] ): __snake_case : int = [""" """.join(_lowerCAmelCase ) for m in tokenizer.bpe_ranks.keys()] __snake_case : Tuple = tokenizer.get_vocab() return cls(_lowerCAmelCase , _lowerCAmelCase , *_lowerCAmelCase , **_lowerCAmelCase ) @classmethod def snake_case__ ( cls : str , _lowerCAmelCase : Union[str, os.PathLike] , *_lowerCAmelCase : Dict , **_lowerCAmelCase : str ): __snake_case : str = GPTaTokenizer.from_pretrained(_lowerCAmelCase , *_lowerCAmelCase , **_lowerCAmelCase ) return cls.from_tokenizer(_lowerCAmelCase , *_lowerCAmelCase , **_lowerCAmelCase ) @classmethod def snake_case__ ( cls : Optional[int] , _lowerCAmelCase : Tuple ): return cls(**_lowerCAmelCase ) def snake_case__ ( self : Optional[Any] ): return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def snake_case__ ( self : Dict , _lowerCAmelCase : str , _lowerCAmelCase : int = None ): __snake_case : Union[str, Any] = self.tf_tokenizer(_lowerCAmelCase ) __snake_case : List[Any] = tf.ones_like(_lowerCAmelCase ) if self.pad_token_id is not None: # pad the tokens up to max length __snake_case : Dict = max_length if max_length is not None else self.max_length if max_length is not None: __snake_case , __snake_case : str = pad_model_inputs( _lowerCAmelCase , max_seq_length=_lowerCAmelCase , pad_value=self.pad_token_id ) return {"attention_mask": attention_mask, "input_ids": input_ids}
20
import random def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case , __snake_case , __snake_case : Tuple = [], [], [] for element in data: if element < pivot: less.append(__SCREAMING_SNAKE_CASE ) elif element > pivot: greater.append(__SCREAMING_SNAKE_CASE ) else: equal.append(__SCREAMING_SNAKE_CASE ) return less, equal, greater def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' # index = len(items) // 2 when trying to find the median # (value of index when items is sorted) # invalid input if index >= len(__SCREAMING_SNAKE_CASE ) or index < 0: return None __snake_case : int = items[random.randint(0 , len(__SCREAMING_SNAKE_CASE ) - 1 )] __snake_case : Tuple = 0 __snake_case , __snake_case , __snake_case : List[str] = _partition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = len(__SCREAMING_SNAKE_CASE ) __snake_case : int = len(__SCREAMING_SNAKE_CASE ) # index is the pivot if m <= index < m + count: return pivot # must be in smaller elif m > index: return quick_select(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # must be in larger else: return quick_select(__SCREAMING_SNAKE_CASE , index - (m + count) )
20
1
import os import numpy import onnx def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case : List[Any] = a.name __snake_case : List[str] = b.name __snake_case : str = """""" __snake_case : int = """""" __snake_case : Tuple = a == b __snake_case : Tuple = name_a __snake_case : str = name_b return res def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Union[str, Any] ): '''simple docstring''' for i, input_name in enumerate(node_proto.input ): if input_name == name: node_proto.input.insert(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) node_proto.input.pop(i + 1 ) if node_proto.op_type == "If": _graph_replace_input_with(node_proto.attribute[0].g , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) _graph_replace_input_with(node_proto.attribute[1].g , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if node_proto.op_type == "Loop": _graph_replace_input_with(node_proto.attribute[0].g , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : List[Any] ): '''simple docstring''' for n in graph_proto.node: _node_replace_input_with(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case : Union[str, Any] = list(model.graph.initializer ) __snake_case : str = list(model_without_ext.graph.initializer ) for i, ref_i in ind_to_replace: assert inits_with_data[i].name == inits[i].name assert inits_with_data[ref_i].name == inits[ref_i].name assert i > ref_i __snake_case : Tuple = inits[i].name __snake_case : Dict = inits[ref_i].name model_without_ext.graph.initializer.remove(inits[i] ) # for n in model.graph.node: _graph_replace_input_with(model_without_ext.graph , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' __snake_case : Dict = os.path.dirname(__SCREAMING_SNAKE_CASE ) __snake_case : Any = os.path.basename(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[int] = onnx.load(os.path.join(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) __snake_case : Dict = list(model.graph.initializer ) __snake_case : List[Any] = set() __snake_case : Tuple = {} __snake_case : List[str] = [] __snake_case : Union[str, Any] = 0 for i in range(len(__SCREAMING_SNAKE_CASE ) ): if i in dup_set: continue for j in range(i + 1 , len(__SCREAMING_SNAKE_CASE ) ): if j in dup_set: continue if _is_equal_tensor_proto(inits[i] , inits[j] ): dup_set.add(__SCREAMING_SNAKE_CASE ) dup_set.add(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = inits[j].data_type __snake_case : int = numpy.prod(inits[j].dims ) if dtype == 1: mem_size *= 4 elif dtype == 6: mem_size *= 4 elif dtype == 7 or dtype == 1_1: mem_size *= 8 else: print("""unexpected data type: """ , __SCREAMING_SNAKE_CASE ) total_reduced_size += mem_size __snake_case : str = inits[i].name __snake_case : Dict = inits[j].name if name_i in dup_map: dup_map[name_i].append(__SCREAMING_SNAKE_CASE ) else: __snake_case : Optional[int] = [name_j] ind_to_replace.append((j, i) ) print("""total reduced size: """ , total_reduced_size / 1_0_2_4 / 1_0_2_4 / 1_0_2_4 , """GB""" ) __snake_case : Optional[Any] = sorted(__SCREAMING_SNAKE_CASE ) _remove_dup_initializers_from_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : List[str] = """optimized_""" + model_file_name __snake_case : List[str] = os.path.join(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) onnx.save(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) return new_model
20
import json from typing import List, Optional, Tuple from tokenizers import normalizers from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_roformer import RoFormerTokenizer from .tokenization_utils import JiebaPreTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": { "junnyu/roformer_chinese_small": "https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt", "junnyu/roformer_chinese_base": "https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt", "junnyu/roformer_chinese_char_small": ( "https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt" ), "junnyu/roformer_chinese_char_base": ( "https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt" ), "junnyu/roformer_small_discriminator": ( "https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt" ), "junnyu/roformer_small_generator": ( "https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt" ), } } lowercase_ = { "junnyu/roformer_chinese_small": 15_36, "junnyu/roformer_chinese_base": 15_36, "junnyu/roformer_chinese_char_small": 5_12, "junnyu/roformer_chinese_char_base": 5_12, "junnyu/roformer_small_discriminator": 1_28, "junnyu/roformer_small_generator": 1_28, } lowercase_ = { "junnyu/roformer_chinese_small": {"do_lower_case": True}, "junnyu/roformer_chinese_base": {"do_lower_case": True}, "junnyu/roformer_chinese_char_small": {"do_lower_case": True}, "junnyu/roformer_chinese_char_base": {"do_lower_case": True}, "junnyu/roformer_small_discriminator": {"do_lower_case": True}, "junnyu/roformer_small_generator": {"do_lower_case": True}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = VOCAB_FILES_NAMES A : Optional[int] = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : int = PRETRAINED_INIT_CONFIGURATION A : List[str] = RoFormerTokenizer def __init__( self : Optional[Any] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any="[UNK]" , _lowerCAmelCase : int="[SEP]" , _lowerCAmelCase : Optional[int]="[PAD]" , _lowerCAmelCase : Optional[int]="[CLS]" , _lowerCAmelCase : Optional[Any]="[MASK]" , _lowerCAmelCase : Optional[Any]=True , _lowerCAmelCase : Optional[Any]=None , **_lowerCAmelCase : Dict , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Dict = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( pre_tok_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or pre_tok_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents ): __snake_case : Tuple = getattr(_lowerCAmelCase , pre_tok_state.pop("""type""" ) ) __snake_case : List[Any] = do_lower_case __snake_case : Optional[Any] = strip_accents __snake_case : List[str] = pre_tok_class(**_lowerCAmelCase ) __snake_case : Optional[Any] = do_lower_case def __getstate__( self : Optional[Any] ): __snake_case : Optional[int] = self.__dict__.copy() __snake_case : Optional[Any] = BertPreTokenizer() return state def __setstate__( self : str , _lowerCAmelCase : Dict ): __snake_case : str = d __snake_case : int = self.__dict__["""_tokenizer"""].get_vocab() __snake_case : List[str] = PreTokenizer.custom(JiebaPreTokenizer(_lowerCAmelCase ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int]=None ): __snake_case : Dict = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : Optional[int] = [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : int = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase ) def snake_case__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Tuple=None , _lowerCAmelCase : Union[str, Any]=False , **_lowerCAmelCase : Tuple , ): __snake_case : Tuple = BertPreTokenizer() return super().save_pretrained(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase )
20
1
import json import os import sys import tempfile import unittest from pathlib import Path from shutil import copyfile from huggingface_hub import HfFolder, Repository, create_repo, delete_repo from requests.exceptions import HTTPError import transformers from transformers import ( CONFIG_MAPPING, FEATURE_EXTRACTOR_MAPPING, PROCESSOR_MAPPING, TOKENIZER_MAPPING, AutoConfig, AutoFeatureExtractor, AutoProcessor, AutoTokenizer, BertTokenizer, ProcessorMixin, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaProcessor, ) from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils")) from test_module.custom_configuration import CustomConfig # noqa E402 from test_module.custom_feature_extraction import CustomFeatureExtractor # noqa E402 from test_module.custom_processing import CustomProcessor # noqa E402 from test_module.custom_tokenization import CustomTokenizer # noqa E402 lowercase_ = get_tests_dir("fixtures/dummy_feature_extractor_config.json") lowercase_ = get_tests_dir("fixtures/vocab.json") lowercase_ = get_tests_dir("fixtures") class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): A : str = ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"] def snake_case__ ( self : Any ): __snake_case : Union[str, Any] = 0 def snake_case__ ( self : List[str] ): __snake_case : Optional[Any] = AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h""" ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Any ): with tempfile.TemporaryDirectory() as tmpdirname: __snake_case : int = WavaVecaConfig() __snake_case : Dict = AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h""" ) # save in new folder model_config.save_pretrained(_lowerCAmelCase ) processor.save_pretrained(_lowerCAmelCase ) __snake_case : int = AutoProcessor.from_pretrained(_lowerCAmelCase ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Optional[int] ): with tempfile.TemporaryDirectory() as tmpdirname: # copy relevant files copyfile(_lowerCAmelCase , os.path.join(_lowerCAmelCase , _lowerCAmelCase ) ) copyfile(_lowerCAmelCase , os.path.join(_lowerCAmelCase , """vocab.json""" ) ) __snake_case : str = AutoProcessor.from_pretrained(_lowerCAmelCase ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : int ): with tempfile.TemporaryDirectory() as tmpdirname: __snake_case : int = WavaVecaFeatureExtractor() __snake_case : List[Any] = AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h""" ) __snake_case : int = WavaVecaProcessor(_lowerCAmelCase , _lowerCAmelCase ) # save in new folder processor.save_pretrained(_lowerCAmelCase ) # drop `processor_class` in tokenizer with open(os.path.join(_lowerCAmelCase , _lowerCAmelCase ) , """r""" ) as f: __snake_case : List[Any] = json.load(_lowerCAmelCase ) config_dict.pop("""processor_class""" ) with open(os.path.join(_lowerCAmelCase , _lowerCAmelCase ) , """w""" ) as f: f.write(json.dumps(_lowerCAmelCase ) ) __snake_case : Optional[Any] = AutoProcessor.from_pretrained(_lowerCAmelCase ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Dict ): with tempfile.TemporaryDirectory() as tmpdirname: __snake_case : Union[str, Any] = WavaVecaFeatureExtractor() __snake_case : str = AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h""" ) __snake_case : Dict = WavaVecaProcessor(_lowerCAmelCase , _lowerCAmelCase ) # save in new folder processor.save_pretrained(_lowerCAmelCase ) # drop `processor_class` in feature extractor with open(os.path.join(_lowerCAmelCase , _lowerCAmelCase ) , """r""" ) as f: __snake_case : Tuple = json.load(_lowerCAmelCase ) config_dict.pop("""processor_class""" ) with open(os.path.join(_lowerCAmelCase , _lowerCAmelCase ) , """w""" ) as f: f.write(json.dumps(_lowerCAmelCase ) ) __snake_case : Tuple = AutoProcessor.from_pretrained(_lowerCAmelCase ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] ): with tempfile.TemporaryDirectory() as tmpdirname: __snake_case : str = WavaVecaConfig(processor_class="""Wav2Vec2Processor""" ) model_config.save_pretrained(_lowerCAmelCase ) # copy relevant files copyfile(_lowerCAmelCase , os.path.join(_lowerCAmelCase , """vocab.json""" ) ) # create emtpy sample processor with open(os.path.join(_lowerCAmelCase , _lowerCAmelCase ) , """w""" ) as f: f.write("""{}""" ) __snake_case : int = AutoProcessor.from_pretrained(_lowerCAmelCase ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] ): # If remote code is not set, we will time out when asking whether to load the model. with self.assertRaises(_lowerCAmelCase ): __snake_case : Optional[Any] = AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" ) # If remote code is disabled, we can't load this config. with self.assertRaises(_lowerCAmelCase ): __snake_case : Tuple = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=_lowerCAmelCase ) __snake_case : List[Any] = AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" , trust_remote_code=_lowerCAmelCase ) self.assertTrue(processor.special_attribute_present ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) __snake_case : Optional[Any] = processor.feature_extractor self.assertTrue(feature_extractor.special_attribute_present ) self.assertEqual(feature_extractor.__class__.__name__ , """NewFeatureExtractor""" ) __snake_case : Tuple = processor.tokenizer self.assertTrue(tokenizer.special_attribute_present ) if is_tokenizers_available(): self.assertEqual(tokenizer.__class__.__name__ , """NewTokenizerFast""" ) # Test we can also load the slow version __snake_case : int = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=_lowerCAmelCase , use_fast=_lowerCAmelCase ) __snake_case : str = new_processor.tokenizer self.assertTrue(new_tokenizer.special_attribute_present ) self.assertEqual(new_tokenizer.__class__.__name__ , """NewTokenizer""" ) else: self.assertEqual(tokenizer.__class__.__name__ , """NewTokenizer""" ) def snake_case__ ( self : Any ): try: AutoConfig.register("""custom""" , _lowerCAmelCase ) AutoFeatureExtractor.register(_lowerCAmelCase , _lowerCAmelCase ) AutoTokenizer.register(_lowerCAmelCase , slow_tokenizer_class=_lowerCAmelCase ) AutoProcessor.register(_lowerCAmelCase , _lowerCAmelCase ) # Trying to register something existing in the Transformers library will raise an error with self.assertRaises(_lowerCAmelCase ): AutoProcessor.register(_lowerCAmelCase , _lowerCAmelCase ) # Now that the config is registered, it can be used as any other config with the auto-API __snake_case : str = CustomFeatureExtractor.from_pretrained(_lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: __snake_case : Optional[int] = os.path.join(_lowerCAmelCase , """vocab.txt""" ) with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens] ) ) __snake_case : List[Any] = CustomTokenizer(_lowerCAmelCase ) __snake_case : Union[str, Any] = CustomProcessor(_lowerCAmelCase , _lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained(_lowerCAmelCase ) __snake_case : int = AutoProcessor.from_pretrained(_lowerCAmelCase ) self.assertIsInstance(_lowerCAmelCase , _lowerCAmelCase ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig] if CustomConfig in TOKENIZER_MAPPING._extra_content: del TOKENIZER_MAPPING._extra_content[CustomConfig] if CustomConfig in PROCESSOR_MAPPING._extra_content: del PROCESSOR_MAPPING._extra_content[CustomConfig] def snake_case__ ( self : Optional[int] ): class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Any = False class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Any = False class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Any = "AutoFeatureExtractor" A : List[str] = "AutoTokenizer" A : List[Any] = False try: AutoConfig.register("""custom""" , _lowerCAmelCase ) AutoFeatureExtractor.register(_lowerCAmelCase , _lowerCAmelCase ) AutoTokenizer.register(_lowerCAmelCase , slow_tokenizer_class=_lowerCAmelCase ) AutoProcessor.register(_lowerCAmelCase , _lowerCAmelCase ) # If remote code is not set, the default is to use local classes. __snake_case : Dict = AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor""" ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) self.assertFalse(processor.special_attribute_present ) self.assertFalse(processor.feature_extractor.special_attribute_present ) self.assertFalse(processor.tokenizer.special_attribute_present ) # If remote code is disabled, we load the local ones. __snake_case : List[str] = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=_lowerCAmelCase ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) self.assertFalse(processor.special_attribute_present ) self.assertFalse(processor.feature_extractor.special_attribute_present ) self.assertFalse(processor.tokenizer.special_attribute_present ) # If remote is enabled, we load from the Hub. __snake_case : Optional[int] = AutoProcessor.from_pretrained( """hf-internal-testing/test_dynamic_processor""" , trust_remote_code=_lowerCAmelCase ) self.assertEqual(processor.__class__.__name__ , """NewProcessor""" ) self.assertTrue(processor.special_attribute_present ) self.assertTrue(processor.feature_extractor.special_attribute_present ) self.assertTrue(processor.tokenizer.special_attribute_present ) finally: if "custom" in CONFIG_MAPPING._extra_content: del CONFIG_MAPPING._extra_content["custom"] if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content: del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig] if CustomConfig in TOKENIZER_MAPPING._extra_content: del TOKENIZER_MAPPING._extra_content[CustomConfig] if CustomConfig in PROCESSOR_MAPPING._extra_content: del PROCESSOR_MAPPING._extra_content[CustomConfig] def snake_case__ ( self : str ): __snake_case : Optional[int] = AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-bert""" ) self.assertEqual(processor.__class__.__name__ , """BertTokenizerFast""" ) def snake_case__ ( self : List[str] ): __snake_case : Dict = AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-convnext""" ) self.assertEqual(processor.__class__.__name__ , """ConvNextImageProcessor""" ) @is_staging_test class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): A : Dict = ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"] @classmethod def snake_case__ ( cls : Union[str, Any] ): __snake_case : Any = TOKEN HfFolder.save_token(_lowerCAmelCase ) @classmethod def snake_case__ ( cls : str ): try: delete_repo(token=cls._token , repo_id="""test-processor""" ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id="""valid_org/test-processor-org""" ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id="""test-dynamic-processor""" ) except HTTPError: pass def snake_case__ ( self : Optional[Any] ): __snake_case : List[str] = WavaVecaProcessor.from_pretrained(_lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained( os.path.join(_lowerCAmelCase , """test-processor""" ) , push_to_hub=_lowerCAmelCase , use_auth_token=self._token ) __snake_case : Optional[int] = WavaVecaProcessor.from_pretrained(f'''{USER}/test-processor''' ) for k, v in processor.feature_extractor.__dict__.items(): self.assertEqual(_lowerCAmelCase , getattr(new_processor.feature_extractor , _lowerCAmelCase ) ) self.assertDictEqual(new_processor.tokenizer.get_vocab() , processor.tokenizer.get_vocab() ) def snake_case__ ( self : Optional[Any] ): __snake_case : Tuple = WavaVecaProcessor.from_pretrained(_lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: processor.save_pretrained( os.path.join(_lowerCAmelCase , """test-processor-org""" ) , push_to_hub=_lowerCAmelCase , use_auth_token=self._token , organization="""valid_org""" , ) __snake_case : Any = WavaVecaProcessor.from_pretrained("""valid_org/test-processor-org""" ) for k, v in processor.feature_extractor.__dict__.items(): self.assertEqual(_lowerCAmelCase , getattr(new_processor.feature_extractor , _lowerCAmelCase ) ) self.assertDictEqual(new_processor.tokenizer.get_vocab() , processor.tokenizer.get_vocab() ) def snake_case__ ( self : Dict ): CustomFeatureExtractor.register_for_auto_class() CustomTokenizer.register_for_auto_class() CustomProcessor.register_for_auto_class() __snake_case : List[Any] = CustomFeatureExtractor.from_pretrained(_lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: __snake_case : int = os.path.join(_lowerCAmelCase , """vocab.txt""" ) with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens] ) ) __snake_case : Union[str, Any] = CustomTokenizer(_lowerCAmelCase ) __snake_case : List[Any] = CustomProcessor(_lowerCAmelCase , _lowerCAmelCase ) with tempfile.TemporaryDirectory() as tmp_dir: create_repo(f'''{USER}/test-dynamic-processor''' , token=self._token ) __snake_case : List[str] = Repository(_lowerCAmelCase , clone_from=f'''{USER}/test-dynamic-processor''' , token=self._token ) processor.save_pretrained(_lowerCAmelCase ) # This has added the proper auto_map field to the feature extractor config self.assertDictEqual( processor.feature_extractor.auto_map , { """AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor""", """AutoProcessor""": """custom_processing.CustomProcessor""", } , ) # This has added the proper auto_map field to the tokenizer config with open(os.path.join(_lowerCAmelCase , """tokenizer_config.json""" ) ) as f: __snake_case : Union[str, Any] = json.load(_lowerCAmelCase ) self.assertDictEqual( tokenizer_config["""auto_map"""] , { """AutoTokenizer""": ["""custom_tokenization.CustomTokenizer""", None], """AutoProcessor""": """custom_processing.CustomProcessor""", } , ) # The code has been copied from fixtures self.assertTrue(os.path.isfile(os.path.join(_lowerCAmelCase , """custom_feature_extraction.py""" ) ) ) self.assertTrue(os.path.isfile(os.path.join(_lowerCAmelCase , """custom_tokenization.py""" ) ) ) self.assertTrue(os.path.isfile(os.path.join(_lowerCAmelCase , """custom_processing.py""" ) ) ) repo.push_to_hub() __snake_case : Any = AutoProcessor.from_pretrained(f'''{USER}/test-dynamic-processor''' , trust_remote_code=_lowerCAmelCase ) # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module self.assertEqual(new_processor.__class__.__name__ , """CustomProcessor""" )
20
from __future__ import annotations import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if depth < 0: raise ValueError("""Depth cannot be less than 0""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: raise ValueError("""Scores cannot be empty""" ) if depth == height: return scores[node_index] if is_max: return max( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) return min( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : str = [9_0, 2_3, 6, 3_3, 2_1, 6_5, 1_2_3, 3_4_4_2_3] __snake_case : Optional[Any] = math.log(len(__SCREAMING_SNAKE_CASE ) , 2 ) print("""Optimal value : """ , end="""""" ) print(minimax(0 , 0 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
20
1
import json import os from typing import Optional, Tuple import regex as re from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "vocab_file": "vocab.json", "merges_file": "merges.txt", } lowercase_ = { "vocab_file": {"ctrl": "https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-vocab.json"}, "merges_file": {"ctrl": "https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-merges.txt"}, } lowercase_ = { "ctrl": 2_56, } lowercase_ = { "Pregnancy": 16_86_29, "Christianity": 76_75, "Explain": 10_64_23, "Fitness": 6_34_40, "Saving": 6_31_63, "Ask": 2_71_71, "Ass": 9_59_85, "Joke": 16_35_09, "Questions": 4_56_22, "Thoughts": 4_96_05, "Retail": 5_23_42, "Feminism": 16_43_38, "Writing": 1_19_92, "Atheism": 19_22_63, "Netflix": 4_86_16, "Computing": 3_96_39, "Opinion": 4_32_13, "Alone": 4_49_67, "Funny": 5_89_17, "Gaming": 4_03_58, "Human": 40_88, "India": 13_31, "Joker": 7_71_38, "Diet": 3_62_06, "Legal": 1_18_59, "Norman": 49_39, "Tip": 7_26_89, "Weight": 5_23_43, "Movies": 4_62_73, "Running": 2_34_25, "Science": 20_90, "Horror": 3_77_93, "Confession": 6_05_72, "Finance": 1_22_50, "Politics": 1_63_60, "Scary": 19_19_85, "Support": 1_26_54, "Technologies": 3_25_16, "Teenage": 6_61_60, "Event": 3_27_69, "Learned": 6_74_60, "Notion": 18_27_70, "Wikipedia": 3_75_83, "Books": 66_65, "Extract": 7_60_50, "Confessions": 10_27_01, "Conspiracy": 7_59_32, "Links": 6_36_74, "Narcissus": 15_04_25, "Relationship": 5_47_66, "Relationships": 13_47_96, "Reviews": 4_16_71, "News": 42_56, "Translation": 2_68_20, "multilingual": 12_84_06, } def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' __snake_case : Any = set() __snake_case : Any = word[0] for char in word[1:]: pairs.add((prev_char, char) ) __snake_case : int = char __snake_case : Any = set(__SCREAMING_SNAKE_CASE ) return pairs class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Union[str, Any] = VOCAB_FILES_NAMES A : Optional[Any] = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : str = CONTROL_CODES def __init__( self : str , _lowerCAmelCase : str , _lowerCAmelCase : Tuple , _lowerCAmelCase : int="<unk>" , **_lowerCAmelCase : str ): super().__init__(unk_token=_lowerCAmelCase , **_lowerCAmelCase ) with open(_lowerCAmelCase , encoding="""utf-8""" ) as vocab_handle: __snake_case : Optional[Any] = json.load(_lowerCAmelCase ) __snake_case : int = {v: k for k, v in self.encoder.items()} with open(_lowerCAmelCase , encoding="""utf-8""" ) as merges_handle: __snake_case : Union[str, Any] = merges_handle.read().split("""\n""" )[1:-1] __snake_case : Optional[Any] = [tuple(merge.split() ) for merge in merges] __snake_case : Any = dict(zip(_lowerCAmelCase , range(len(_lowerCAmelCase ) ) ) ) __snake_case : List[str] = {} @property def snake_case__ ( self : Dict ): return len(self.encoder ) def snake_case__ ( self : Any ): return dict(self.encoder , **self.added_tokens_encoder ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Tuple ): if token in self.cache: return self.cache[token] __snake_case : Tuple = tuple(_lowerCAmelCase ) __snake_case : Dict = tuple(list(word[:-1] ) + [word[-1] + """</w>"""] ) __snake_case : str = get_pairs(_lowerCAmelCase ) if not pairs: return token while True: __snake_case : Optional[int] = min(_lowerCAmelCase , key=lambda _lowerCAmelCase : self.bpe_ranks.get(_lowerCAmelCase , float("""inf""" ) ) ) if bigram not in self.bpe_ranks: break __snake_case , __snake_case : Union[str, Any] = bigram __snake_case : str = [] __snake_case : Tuple = 0 while i < len(_lowerCAmelCase ): try: __snake_case : List[Any] = word.index(_lowerCAmelCase , _lowerCAmelCase ) except ValueError: new_word.extend(word[i:] ) break else: new_word.extend(word[i:j] ) __snake_case : Any = j if word[i] == first and i < len(_lowerCAmelCase ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 __snake_case : int = tuple(_lowerCAmelCase ) __snake_case : List[str] = new_word if len(_lowerCAmelCase ) == 1: break else: __snake_case : List[Any] = get_pairs(_lowerCAmelCase ) __snake_case : Any = """@@ """.join(_lowerCAmelCase ) __snake_case : Optional[Any] = word[:-4] __snake_case : Optional[int] = word return word def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[int] ): __snake_case : int = [] __snake_case : Union[str, Any] = re.findall(r"""\S+\n?""" , _lowerCAmelCase ) for token in words: split_tokens.extend(list(self.bpe(_lowerCAmelCase ).split(""" """ ) ) ) return split_tokens def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] ): return self.encoder.get(_lowerCAmelCase , self.encoder.get(self.unk_token ) ) def snake_case__ ( self : int , _lowerCAmelCase : List[str] ): return self.decoder.get(_lowerCAmelCase , self.unk_token ) def snake_case__ ( self : str , _lowerCAmelCase : Tuple ): __snake_case : Optional[Any] = """ """.join(_lowerCAmelCase ).replace("""@@ """ , """""" ).strip() return out_string def snake_case__ ( self : List[str] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): if not os.path.isdir(_lowerCAmelCase ): logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' ) return __snake_case : Any = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Union[str, Any] = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""] ) with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=_lowerCAmelCase , ensure_ascii=_lowerCAmelCase ) + """\n""" ) __snake_case : Optional[Any] = 0 with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as writer: writer.write("""#version: 0.2\n""" ) for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda _lowerCAmelCase : kv[1] ): if index != token_index: logger.warning( f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.''' """ Please check that the tokenizer is not corrupted!""" ) __snake_case : Any = token_index writer.write(""" """.join(_lowerCAmelCase ) + """\n""" ) index += 1 return vocab_file, merge_file # def decode(self, token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=True): # filtered_tokens = ' '.join(self.convert_ids_to_tokens(token_ids, skip_special_tokens=skip_special_tokens)) # tokens_generated_so_far = re.sub('(@@ )', '', string=filtered_tokens) # tokens_generated_so_far = re.sub('(@@ ?$)', '', string=tokens_generated_so_far) # return ''.join(tokens_generated_so_far)
20
import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType lowercase_ = None lowercase_ = "<" if sys.byteorder == "little" else ">" # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image lowercase_ = [ np.dtype("|b1"), np.dtype("|u1"), np.dtype("<u2"), np.dtype(">u2"), np.dtype("<i2"), np.dtype(">i2"), np.dtype("<u4"), np.dtype(">u4"), np.dtype("<i4"), np.dtype(">i4"), np.dtype("<f4"), np.dtype(">f4"), np.dtype("<f8"), np.dtype(">f8"), ] @dataclass class SCREAMING_SNAKE_CASE__ : A : bool = True A : Optional[str] = None # Automatically constructed A : ClassVar[str] = "PIL.Image.Image" A : ClassVar[Any] = pa.struct({"bytes": pa.binary(), "path": pa.string()} ) A : str = field(default="Image" , init=__UpperCamelCase , repr=__UpperCamelCase ) def __call__( self : Any ): return self.pa_type def snake_case__ ( self : List[Any] , _lowerCAmelCase : Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] ): if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): __snake_case : str = np.array(_lowerCAmelCase ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": value, "bytes": None} elif isinstance(_lowerCAmelCase , _lowerCAmelCase ): return {"path": None, "bytes": value} elif isinstance(_lowerCAmelCase , np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(_lowerCAmelCase ) elif isinstance(_lowerCAmelCase , PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(_lowerCAmelCase ) elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("""path""" )} elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )} else: raise ValueError( f'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''' ) def snake_case__ ( self : List[str] , _lowerCAmelCase : dict , _lowerCAmelCase : Dict=None ): if not self.decode: raise RuntimeError("""Decoding is disabled for this feature. Please use Image(decode=True) instead.""" ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support decoding images, please install 'Pillow'.""" ) if token_per_repo_id is None: __snake_case : Tuple = {} __snake_case , __snake_case : str = value["""path"""], value["""bytes"""] if bytes_ is None: if path is None: raise ValueError(f'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.''' ) else: if is_local_path(_lowerCAmelCase ): __snake_case : str = PIL.Image.open(_lowerCAmelCase ) else: __snake_case : List[str] = path.split("""::""" )[-1] try: __snake_case : Dict = string_to_dict(_lowerCAmelCase , config.HUB_DATASETS_URL )["""repo_id"""] __snake_case : int = token_per_repo_id.get(_lowerCAmelCase ) except ValueError: __snake_case : List[Any] = None with xopen(_lowerCAmelCase , """rb""" , use_auth_token=_lowerCAmelCase ) as f: __snake_case : Union[str, Any] = BytesIO(f.read() ) __snake_case : Dict = PIL.Image.open(bytes_ ) else: __snake_case : Optional[Any] = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def snake_case__ ( self : Union[str, Any] ): from .features import Value return ( self if self.decode else { "bytes": Value("""binary""" ), "path": Value("""string""" ), } ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Union[pa.StringArray, pa.StructArray, pa.ListArray] ): if pa.types.is_string(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, storage] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): __snake_case : Optional[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays([storage, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("""bytes""" ) >= 0: __snake_case : List[str] = storage.field("""bytes""" ) else: __snake_case : List[Any] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.binary() ) if storage.type.get_field_index("""path""" ) >= 0: __snake_case : Optional[int] = storage.field("""path""" ) else: __snake_case : int = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : Tuple = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=storage.is_null() ) elif pa.types.is_list(storage.type ): __snake_case : Optional[Any] = pa.array( [encode_np_array(np.array(_lowerCAmelCase ) )["""bytes"""] if arr is not None else None for arr in storage.to_pylist()] , type=pa.binary() , ) __snake_case : Optional[int] = pa.array([None] * len(_lowerCAmelCase ) , type=pa.string() ) __snake_case : List[str] = pa.StructArray.from_arrays( [bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : pa.StructArray ): @no_op_if_value_is_null def path_to_bytes(_lowerCAmelCase : Tuple ): with xopen(_lowerCAmelCase , """rb""" ) as f: __snake_case : Optional[int] = f.read() return bytes_ __snake_case : Tuple = pa.array( [ (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) __snake_case : Optional[Any] = pa.array( [os.path.basename(_lowerCAmelCase ) if path is not None else None for path in storage.field("""path""" ).to_pylist()] , type=pa.string() , ) __snake_case : Any = pa.StructArray.from_arrays([bytes_array, path_array] , ["""bytes""", """path"""] , mask=bytes_array.is_null() ) return array_cast(_lowerCAmelCase , self.pa_type ) def __lowerCAmelCase ( ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() __snake_case : Optional[Any] = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' __snake_case : List[Any] = BytesIO() if image.format in list_image_compression_formats(): __snake_case : Union[str, Any] = image.format else: __snake_case : List[Any] = """PNG""" if image.mode in ["""1""", """L""", """LA""", """RGB""", """RGBA"""] else """TIFF""" image.save(__SCREAMING_SNAKE_CASE , format=__SCREAMING_SNAKE_CASE ) return buffer.getvalue() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : "PIL.Image.Image" ): '''simple docstring''' if hasattr(__SCREAMING_SNAKE_CASE , """filename""" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : np.ndarray ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) __snake_case : List[Any] = array.dtype __snake_case : List[Any] = dtype.byteorder if dtype.byteorder != """=""" else _NATIVE_BYTEORDER __snake_case : Dict = dtype.kind __snake_case : Union[str, Any] = dtype.itemsize __snake_case : Tuple = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: __snake_case : int = np.dtype("""|u1""" ) if dtype_kind not in ["u", "i"]: raise TypeError( F'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.''' ) if dtype is not dest_dtype: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: __snake_case : List[str] = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: __snake_case : int = dtype_byteorder + dtype_kind + str(__SCREAMING_SNAKE_CASE ) __snake_case : Any = np.dtype(__SCREAMING_SNAKE_CASE ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( F'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}''' ) __snake_case : Optional[int] = PIL.Image.fromarray(array.astype(__SCREAMING_SNAKE_CASE ) ) return {"path": None, "bytes": image_to_bytes(__SCREAMING_SNAKE_CASE )} def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]] ): '''simple docstring''' if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("""To support encoding images, please install 'Pillow'.""" ) if objs: __snake_case , __snake_case : Any = first_non_null_value(__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(__SCREAMING_SNAKE_CASE , np.ndarray ): __snake_case : int = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] elif isinstance(__SCREAMING_SNAKE_CASE , PIL.Image.Image ): __snake_case : List[str] = no_op_if_value_is_null(__SCREAMING_SNAKE_CASE ) return [obj_to_image_dict_func(__SCREAMING_SNAKE_CASE ) for obj in objs] else: return objs else: return objs
20
1
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING lowercase_ = logging.get_logger(__name__) @add_end_docstrings(__UpperCamelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : Dict , *_lowerCAmelCase : Dict , **_lowerCAmelCase : int ): super().__init__(*_lowerCAmelCase , **_lowerCAmelCase ) requires_backends(self , """vision""" ) self.check_model_type( TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING ) def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[str]=None , _lowerCAmelCase : Any=None , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = {} __snake_case : int = {} if prompt is not None: __snake_case : Dict = prompt if generate_kwargs is not None: __snake_case : List[Any] = generate_kwargs if max_new_tokens is not None: if "generate_kwargs" not in forward_kwargs: __snake_case : Optional[int] = {} if "max_new_tokens" in forward_kwargs["generate_kwargs"]: raise ValueError( """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,""" """ please use only one""" ) __snake_case : Any = max_new_tokens return preprocess_params, forward_kwargs, {} def __call__( self : Optional[Any] , _lowerCAmelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] , **_lowerCAmelCase : Union[str, Any] ): return super().__call__(_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = load_image(_lowerCAmelCase ) if prompt is not None: if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): raise ValueError( f'''Received an invalid text input, got - {type(_lowerCAmelCase )} - but expected a single string. ''' """Note also that one single text can be provided for conditional image to text generation.""" ) __snake_case : Tuple = self.model.config.model_type if model_type == "git": __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Any = self.tokenizer(text=_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ).input_ids __snake_case : Tuple = [self.tokenizer.cls_token_id] + input_ids __snake_case : int = torch.tensor(_lowerCAmelCase ).unsqueeze(0 ) model_inputs.update({"""input_ids""": input_ids} ) elif model_type == "pix2struct": __snake_case : Dict = self.image_processor(images=_lowerCAmelCase , header_text=_lowerCAmelCase , return_tensors=self.framework ) elif model_type != "vision-encoder-decoder": # vision-encoder-decoder does not support conditional generation __snake_case : int = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Optional[Any] = self.tokenizer(_lowerCAmelCase , return_tensors=self.framework ) model_inputs.update(_lowerCAmelCase ) else: raise ValueError(f'''Model type {model_type} does not support conditional text generation''' ) else: __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) if self.model.config.model_type == "git" and prompt is None: __snake_case : int = None return model_inputs def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : str=None ): # Git model sets `model_inputs["input_ids"] = None` in `preprocess` (when `prompt=None`). In batch model, the # pipeline will group them into a list of `None`, which fail `_forward`. Avoid this by checking it first. if ( "input_ids" in model_inputs and isinstance(model_inputs["""input_ids"""] , _lowerCAmelCase ) and all(x is None for x in model_inputs["""input_ids"""] ) ): __snake_case : List[Any] = None if generate_kwargs is None: __snake_case : Dict = {} # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py` # parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas # the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name` # in the `_prepare_model_inputs` method. __snake_case : Dict = model_inputs.pop(self.model.main_input_name ) __snake_case : Optional[int] = self.model.generate(_lowerCAmelCase , **_lowerCAmelCase , **_lowerCAmelCase ) return model_outputs def snake_case__ ( self : List[Any] , _lowerCAmelCase : str ): __snake_case : Union[str, Any] = [] for output_ids in model_outputs: __snake_case : Union[str, Any] = { """generated_text""": self.tokenizer.decode( _lowerCAmelCase , skip_special_tokens=_lowerCAmelCase , ) } records.append(_lowerCAmelCase ) return records
20
from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING lowercase_ = logging.get_logger(__name__) @add_end_docstrings(__UpperCamelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): def __init__( self : Dict , *_lowerCAmelCase : Dict , **_lowerCAmelCase : int ): super().__init__(*_lowerCAmelCase , **_lowerCAmelCase ) requires_backends(self , """vision""" ) self.check_model_type( TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == """tf""" else MODEL_FOR_VISION_2_SEQ_MAPPING ) def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[str]=None , _lowerCAmelCase : Any=None , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = {} __snake_case : int = {} if prompt is not None: __snake_case : Dict = prompt if generate_kwargs is not None: __snake_case : List[Any] = generate_kwargs if max_new_tokens is not None: if "generate_kwargs" not in forward_kwargs: __snake_case : Optional[int] = {} if "max_new_tokens" in forward_kwargs["generate_kwargs"]: raise ValueError( """'max_new_tokens' is defined twice, once in 'generate_kwargs' and once as a direct parameter,""" """ please use only one""" ) __snake_case : Any = max_new_tokens return preprocess_params, forward_kwargs, {} def __call__( self : Optional[Any] , _lowerCAmelCase : Union[str, List[str], "Image.Image", List["Image.Image"]] , **_lowerCAmelCase : Union[str, Any] ): return super().__call__(_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : List[str]=None ): __snake_case : Optional[Any] = load_image(_lowerCAmelCase ) if prompt is not None: if not isinstance(_lowerCAmelCase , _lowerCAmelCase ): raise ValueError( f'''Received an invalid text input, got - {type(_lowerCAmelCase )} - but expected a single string. ''' """Note also that one single text can be provided for conditional image to text generation.""" ) __snake_case : Tuple = self.model.config.model_type if model_type == "git": __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Any = self.tokenizer(text=_lowerCAmelCase , add_special_tokens=_lowerCAmelCase ).input_ids __snake_case : Tuple = [self.tokenizer.cls_token_id] + input_ids __snake_case : int = torch.tensor(_lowerCAmelCase ).unsqueeze(0 ) model_inputs.update({"""input_ids""": input_ids} ) elif model_type == "pix2struct": __snake_case : Dict = self.image_processor(images=_lowerCAmelCase , header_text=_lowerCAmelCase , return_tensors=self.framework ) elif model_type != "vision-encoder-decoder": # vision-encoder-decoder does not support conditional generation __snake_case : int = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) __snake_case : Optional[Any] = self.tokenizer(_lowerCAmelCase , return_tensors=self.framework ) model_inputs.update(_lowerCAmelCase ) else: raise ValueError(f'''Model type {model_type} does not support conditional text generation''' ) else: __snake_case : Tuple = self.image_processor(images=_lowerCAmelCase , return_tensors=self.framework ) if self.model.config.model_type == "git" and prompt is None: __snake_case : int = None return model_inputs def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : str=None ): # Git model sets `model_inputs["input_ids"] = None` in `preprocess` (when `prompt=None`). In batch model, the # pipeline will group them into a list of `None`, which fail `_forward`. Avoid this by checking it first. if ( "input_ids" in model_inputs and isinstance(model_inputs["""input_ids"""] , _lowerCAmelCase ) and all(x is None for x in model_inputs["""input_ids"""] ) ): __snake_case : List[Any] = None if generate_kwargs is None: __snake_case : Dict = {} # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py` # parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas # the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name` # in the `_prepare_model_inputs` method. __snake_case : Dict = model_inputs.pop(self.model.main_input_name ) __snake_case : Optional[int] = self.model.generate(_lowerCAmelCase , **_lowerCAmelCase , **_lowerCAmelCase ) return model_outputs def snake_case__ ( self : List[Any] , _lowerCAmelCase : str ): __snake_case : Union[str, Any] = [] for output_ids in model_outputs: __snake_case : Union[str, Any] = { """generated_text""": self.tokenizer.decode( _lowerCAmelCase , skip_special_tokens=_lowerCAmelCase , ) } records.append(_lowerCAmelCase ) return records
20
1
import unittest from huggingface_hub import hf_hub_download from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor from transformers.pipelines import VideoClassificationPipeline, pipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_decord, require_tf, require_torch, require_torch_or_tf, require_vision, ) from .test_pipelines_common import ANY @is_pipeline_test @require_torch_or_tf @require_vision @require_decord class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): A : Optional[Any] = MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING def snake_case__ ( self : List[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Any ): __snake_case : Tuple = hf_hub_download( repo_id="""nateraw/video-demo""" , filename="""archery.mp4""" , repo_type="""dataset""" ) __snake_case : Optional[Any] = VideoClassificationPipeline(model=_lowerCAmelCase , image_processor=_lowerCAmelCase , top_k=2 ) __snake_case : Any = [ example_video_filepath, """https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4""", ] return video_classifier, examples def snake_case__ ( self : int , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[Any] ): for example in examples: __snake_case : int = video_classifier(_lowerCAmelCase ) self.assertEqual( _lowerCAmelCase , [ {"""score""": ANY(_lowerCAmelCase ), """label""": ANY(_lowerCAmelCase )}, {"""score""": ANY(_lowerCAmelCase ), """label""": ANY(_lowerCAmelCase )}, ] , ) @require_torch def snake_case__ ( self : Optional[Any] ): __snake_case : Dict = """hf-internal-testing/tiny-random-VideoMAEForVideoClassification""" __snake_case : Optional[Any] = VideoMAEFeatureExtractor( size={"""shortest_edge""": 10} , crop_size={"""height""": 10, """width""": 10} ) __snake_case : List[Any] = pipeline( """video-classification""" , model=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , frame_sampling_rate=4 ) __snake_case : Tuple = hf_hub_download(repo_id="""nateraw/video-demo""" , filename="""archery.mp4""" , repo_type="""dataset""" ) __snake_case : Optional[Any] = video_classifier(_lowerCAmelCase , top_k=2 ) self.assertEqual( nested_simplify(_lowerCAmelCase , decimals=4 ) , [{"""score""": 0.5199, """label""": """LABEL_0"""}, {"""score""": 0.4801, """label""": """LABEL_1"""}] , ) __snake_case : Dict = video_classifier( [ video_file_path, video_file_path, ] , top_k=2 , ) self.assertEqual( nested_simplify(_lowerCAmelCase , decimals=4 ) , [ [{"""score""": 0.5199, """label""": """LABEL_0"""}, {"""score""": 0.4801, """label""": """LABEL_1"""}], [{"""score""": 0.5199, """label""": """LABEL_0"""}, {"""score""": 0.4801, """label""": """LABEL_1"""}], ] , ) @require_tf def snake_case__ ( self : int ): pass
20
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowercase_ = {"configuration_yolos": ["YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP", "YolosConfig", "YolosOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["YolosFeatureExtractor"] lowercase_ = ["YolosImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST", "YolosForObjectDetection", "YolosModel", "YolosPreTrainedModel", ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
from ..utils import DummyObject, requires_backends class SCREAMING_SNAKE_CASE__ ( metaclass=__UpperCamelCase ): A : List[Any] = ["flax", "transformers"] def __init__( self : List[str] , *_lowerCAmelCase : List[Any] , **_lowerCAmelCase : Dict ): requires_backends(self , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : int , *_lowerCAmelCase : str , **_lowerCAmelCase : int ): requires_backends(cls , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : int , *_lowerCAmelCase : Optional[int] , **_lowerCAmelCase : Optional[int] ): requires_backends(cls , ["""flax""", """transformers"""] ) class SCREAMING_SNAKE_CASE__ ( metaclass=__UpperCamelCase ): A : Any = ["flax", "transformers"] def __init__( self : int , *_lowerCAmelCase : Optional[int] , **_lowerCAmelCase : List[str] ): requires_backends(self , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : int , *_lowerCAmelCase : Any , **_lowerCAmelCase : Union[str, Any] ): requires_backends(cls , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : Tuple , *_lowerCAmelCase : List[Any] , **_lowerCAmelCase : List[str] ): requires_backends(cls , ["""flax""", """transformers"""] ) class SCREAMING_SNAKE_CASE__ ( metaclass=__UpperCamelCase ): A : Tuple = ["flax", "transformers"] def __init__( self : Dict , *_lowerCAmelCase : Tuple , **_lowerCAmelCase : Union[str, Any] ): requires_backends(self , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : int , *_lowerCAmelCase : int , **_lowerCAmelCase : Tuple ): requires_backends(cls , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : Any , *_lowerCAmelCase : int , **_lowerCAmelCase : int ): requires_backends(cls , ["""flax""", """transformers"""] ) class SCREAMING_SNAKE_CASE__ ( metaclass=__UpperCamelCase ): A : Optional[Any] = ["flax", "transformers"] def __init__( self : Any , *_lowerCAmelCase : Dict , **_lowerCAmelCase : int ): requires_backends(self , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : Optional[int] , *_lowerCAmelCase : str , **_lowerCAmelCase : List[Any] ): requires_backends(cls , ["""flax""", """transformers"""] ) @classmethod def snake_case__ ( cls : List[str] , *_lowerCAmelCase : Union[str, Any] , **_lowerCAmelCase : List[Any] ): requires_backends(cls , ["""flax""", """transformers"""] )
20
# Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import torch from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor from ..utils import is_datasets_available from .base import PipelineTool if is_datasets_available(): from datasets import load_dataset class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = "microsoft/speecht5_tts" A : List[Any] = ( "This is a tool that reads an English text out loud. It takes an input named `text` which should contain the " "text to read (in English) and returns a waveform object containing the sound." ) A : str = "text_reader" A : Optional[Any] = SpeechTaProcessor A : Any = SpeechTaForTextToSpeech A : Optional[Any] = SpeechTaHifiGan A : str = ["text"] A : Union[str, Any] = ["audio"] def snake_case__ ( self : List[Any] ): if self.post_processor is None: __snake_case : Tuple = """microsoft/speecht5_hifigan""" super().setup() def snake_case__ ( self : Any , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Tuple=None ): __snake_case : str = self.pre_processor(text=_lowerCAmelCase , return_tensors="""pt""" , truncation=_lowerCAmelCase ) if speaker_embeddings is None: if not is_datasets_available(): raise ImportError("""Datasets needs to be installed if not passing speaker embeddings.""" ) __snake_case : List[Any] = load_dataset("""Matthijs/cmu-arctic-xvectors""" , split="""validation""" ) __snake_case : str = torch.tensor(embeddings_dataset[73_05]["""xvector"""] ).unsqueeze(0 ) return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings} def snake_case__ ( self : List[Any] , _lowerCAmelCase : Dict ): with torch.no_grad(): return self.model.generate_speech(**_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): with torch.no_grad(): return self.post_processor(_lowerCAmelCase ).cpu().detach()
20
1
import argparse import fairseq import torch from torch import nn from transformers import ( MBartaaTokenizer, MBartConfig, MBartForCausalLM, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaModel, logging, ) logging.set_verbosity_info() lowercase_ = logging.get_logger(__name__) lowercase_ = { "post_extract_proj": "feature_projection.projection", "encoder.pos_conv.0": "encoder.pos_conv_embed.conv", "self_attn.k_proj": "encoder.layers.*.attention.k_proj", "self_attn.v_proj": "encoder.layers.*.attention.v_proj", "self_attn.q_proj": "encoder.layers.*.attention.q_proj", "self_attn.out_proj": "encoder.layers.*.attention.out_proj", "self_attn_layer_norm": "encoder.layers.*.layer_norm", "fc1": "encoder.layers.*.feed_forward.intermediate_dense", "fc2": "encoder.layers.*.feed_forward.output_dense", "final_layer_norm": "encoder.layers.*.final_layer_norm", "encoder.layer_norm": "encoder.layer_norm", "w2v_model.layer_norm": "feature_projection.layer_norm", "quantizer.weight_proj": "quantizer.weight_proj", "quantizer.vars": "quantizer.codevectors", "project_q": "project_q", "final_proj": "project_hid", "w2v_encoder.proj": "lm_head", "mask_emb": "masked_spec_embed", } lowercase_ = [ "lm_head", "quantizer.weight_proj", "quantizer.codevectors", "project_q", "project_hid", ] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' for attribute in key.split(""".""" ): __snake_case : Optional[Any] = getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if weight_type is not None: __snake_case : int = getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).shape else: __snake_case : Optional[int] = hf_pointer.shape assert hf_shape == value.shape, ( F'''Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be''' F''' {value.shape} for {full_name}''' ) if weight_type == "weight": __snake_case : Optional[int] = value elif weight_type == "weight_g": __snake_case : Optional[int] = value elif weight_type == "weight_v": __snake_case : List[str] = value elif weight_type == "bias": __snake_case : int = value else: __snake_case : Union[str, Any] = value logger.info(F'''{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.''' ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' __snake_case : Union[str, Any] = [] __snake_case : Optional[Any] = fairseq_model.state_dict() __snake_case : str = hf_model.feature_extractor __snake_case : Optional[int] = hf_model.adapter for name, value in fairseq_dict.items(): __snake_case : List[Any] = False if "conv_layers" in name: load_conv_layer( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , hf_model.config.feat_extract_norm == """group""" , ) __snake_case : str = True elif any(x in name for x in ["""adaptor""", """w2v_encoder.proj.""", """w2v_proj_ln."""] ): load_adapter(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Dict = True else: for key, mapped_key in MAPPING.items(): if key in name or key.split("""w2v_model.""" )[-1] == name.split(""".""" )[0]: __snake_case : Dict = True if "*" in mapped_key: __snake_case : List[Any] = name.split(__SCREAMING_SNAKE_CASE )[0].split(""".""" )[-2] __snake_case : List[str] = mapped_key.replace("""*""" , __SCREAMING_SNAKE_CASE ) if "weight_g" in name: __snake_case : Optional[Any] = """weight_g""" elif "weight_v" in name: __snake_case : Dict = """weight_v""" elif "bias" in name: __snake_case : Any = """bias""" elif "weight" in name: __snake_case : List[Any] = """weight""" else: __snake_case : Any = None set_recursively(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) continue if not is_used: unused_weights.append(__SCREAMING_SNAKE_CASE ) logger.warning(F'''Unused weights: {unused_weights}''' ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' __snake_case : Optional[Any] = full_name.split("""conv_layers.""" )[-1] __snake_case : Any = name.split(""".""" ) __snake_case : Optional[int] = int(items[0] ) __snake_case : Dict = int(items[1] ) if type_id == 0: if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, ( F'''{full_name} has size {value.shape}, but''' F''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.''' ) __snake_case : Optional[int] = value logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, ( F'''{full_name} has size {value.shape}, but''' F''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.''' ) __snake_case : Tuple = value logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, ( F'''{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was''' " found." ) __snake_case : List[str] = value logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, ( F'''{full_name} has size {value.shape}, but''' F''' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.''' ) __snake_case : int = value logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' ) else: unused_weights.append(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' __snake_case : Tuple = full_name.split("""adaptor.""" )[-1] __snake_case : Dict = name.split(""".""" ) if items[1].isdigit(): __snake_case : int = int(items[1] ) else: __snake_case : List[str] = None if "adaptor" not in full_name: if "proj_ln" in full_name: # has to be layer norm if "bias" in name: assert ( value.shape == adapter.proj_layer_norm.bias.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found.''' __snake_case : Dict = value logger.info(F'''Adapter proj layer norm bias was initialized from {full_name}.''' ) if "weight" in name: assert ( value.shape == adapter.proj_layer_norm.weight.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found.''' __snake_case : Any = value else: # has to be projection layer if "bias" in name: assert ( value.shape == adapter.proj.bias.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found.''' __snake_case : str = value logger.info(F'''Adapter proj layer bias was initialized from {full_name}.''' ) if "weight" in name: assert ( value.shape == adapter.proj.weight.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found.''' __snake_case : Optional[Any] = value logger.info(F'''Adapter proj layer weight was initialized from {full_name}.''' ) elif isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): if "bias" in name: assert ( value.shape == adapter.layers[layer_id].conv.bias.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found.''' __snake_case : int = value logger.info(F'''Adapter layer {layer_id} bias was initialized from {full_name}.''' ) elif "weight" in name: assert ( value.shape == adapter.layers[layer_id].conv.weight.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found.''' __snake_case : str = value logger.info(F'''Adapter layer {layer_id} bias was initialized from {full_name}.''' ) else: unused_weights.append(__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] ): '''simple docstring''' __snake_case , __snake_case : int = emb.weight.shape __snake_case : List[str] = nn.Linear(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , bias=__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = emb.weight.data return lin_layer @torch.no_grad() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Any , ): '''simple docstring''' __snake_case : Dict = WavaVecaConfig.from_pretrained( __SCREAMING_SNAKE_CASE , add_adapter=__SCREAMING_SNAKE_CASE , adapter_stride=__SCREAMING_SNAKE_CASE , adapter_kernel_size=__SCREAMING_SNAKE_CASE , use_auth_token=__SCREAMING_SNAKE_CASE , output_hidden_size=__SCREAMING_SNAKE_CASE , ) __snake_case : Dict = MBartConfig.from_pretrained(__SCREAMING_SNAKE_CASE ) # load model __snake_case , __snake_case , __snake_case : List[str] = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={ """config_yaml""": config_yaml_path, """data""": """/""".join(dict_path.split("""/""" )[:-1] ), """w2v_path""": checkpoint_path, """load_pretrained_decoder_from""": None, } , ) __snake_case : Dict = model[0].eval() # load feature extractor __snake_case : List[Any] = WavaVecaFeatureExtractor.from_pretrained(__SCREAMING_SNAKE_CASE , use_auth_token=__SCREAMING_SNAKE_CASE ) # set weights for wav2vec2 encoder __snake_case : List[Any] = WavaVecaModel(__SCREAMING_SNAKE_CASE ) recursively_load_weights_wavaveca(model.encoder , __SCREAMING_SNAKE_CASE ) # load decoder weights __snake_case : Optional[Any] = MBartForCausalLM(__SCREAMING_SNAKE_CASE ) __snake_case , __snake_case : List[str] = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() , strict=__SCREAMING_SNAKE_CASE ) logger.warning(F'''The following keys are missing when loading the decoder weights: {missing_keys}''' ) logger.warning(F'''The following keys are unexpected when loading the decoder weights: {unexpected_keys}''' ) __snake_case : str = SpeechEncoderDecoderModel(encoder=__SCREAMING_SNAKE_CASE , decoder=__SCREAMING_SNAKE_CASE ) __snake_case : int = False __snake_case : Optional[Any] = MBartaaTokenizer(__SCREAMING_SNAKE_CASE ) tokenizer.save_pretrained(__SCREAMING_SNAKE_CASE ) __snake_case : Any = hf_wavavec.config.to_dict() __snake_case : Optional[Any] = tokenizer.pad_token_id __snake_case : Optional[Any] = tokenizer.bos_token_id __snake_case : List[Any] = tokenizer.eos_token_id __snake_case : Dict = """mbart50""" __snake_case : int = """wav2vec2""" __snake_case : Dict = tokenizer.eos_token_id __snake_case : List[str] = 2_5_0_0_0_4 __snake_case : Union[str, Any] = tokenizer.eos_token_id __snake_case : Optional[int] = SpeechEncoderDecoderConfig.from_dict(__SCREAMING_SNAKE_CASE ) hf_wavavec.save_pretrained(__SCREAMING_SNAKE_CASE ) feature_extractor.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model") parser.add_argument("--config_yaml_path", default=None, type=str, help="Path to yaml file of fine-tuned model") parser.add_argument( "--encoder_config_path", default="facebook/wav2vec2-xls-r-1b", type=str, help="Path to hf encoder wav2vec2 checkpoint config", ) parser.add_argument( "--decoder_config_path", default="facebook/mbart-large-50-one-to-many-mmt", type=str, help="Path to hf decoder checkpoint config", ) parser.add_argument("--add_adapter", default=True, type=bool, help="whethere to add model adapter layers") parser.add_argument("--adapter_stride", default=2, type=int, help="stride of adapter layers") parser.add_argument("--adapter_kernel_size", default=3, type=int, help="kernel size of adapter layers") parser.add_argument("--encoder_output_dim", default=10_24, type=int, help="encoder output dim") parser.add_argument("--start_token_id", default=25_00_04, type=int, help="`decoder_start_token_id` of model config") lowercase_ = parser.parse_args() convert_wavaveca_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.dict_path, args.config_yaml_path, encoder_config_path=args.encoder_config_path, decoder_config_path=args.decoder_config_path, add_adapter=args.add_adapter, adapter_kernel_size=args.adapter_kernel_size, adapter_stride=args.adapter_stride, decoder_start_token_id=args.start_token_id, encoder_output_dim=args.encoder_output_dim, )
20
import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * power_factor def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : float , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if ( not isinstance(__SCREAMING_SNAKE_CASE , (int, float) ) or power_factor < -1 or power_factor > 1 ): raise ValueError("""power_factor must be a valid float value between -1 and 1.""" ) return apparent_power * math.sqrt(1 - power_factor**2 ) if __name__ == "__main__": import doctest doctest.testmod()
20
1
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 SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Any ): __snake_case : Dict = """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split() __snake_case : str = dict(zip(_lowerCAmelCase , range(len(_lowerCAmelCase ) ) ) ) __snake_case : List[str] = { """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>""", } __snake_case : str = { """feature_size""": 1, """padding_value""": 0.0, """sampling_rate""": 1_60_00, """return_attention_mask""": False, """do_normalize""": True, } __snake_case : Optional[Any] = tempfile.mkdtemp() __snake_case : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Any = 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 __snake_case : Optional[int] = """hf-internal-testing/ngram-beam-search-decoder""" def snake_case__ ( self : Optional[Any] , **_lowerCAmelCase : Tuple ): __snake_case : int = self.add_kwargs_tokens_map.copy() kwargs.update(_lowerCAmelCase ) return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , **_lowerCAmelCase : Optional[int] ): return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : Tuple ): return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name , **_lowerCAmelCase ) def snake_case__ ( self : List[str] ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Tuple = self.get_feature_extractor() __snake_case : Dict = self.get_decoder() __snake_case : List[str] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) __snake_case : Dict = 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 snake_case__ ( self : Tuple ): __snake_case : Tuple = 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 __snake_case : Optional[Any] = 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 snake_case__ ( self : int ): __snake_case : Tuple = 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 snake_case__ ( self : Dict ): __snake_case : int = self.get_feature_extractor() __snake_case : str = self.get_tokenizer() __snake_case : Dict = self.get_decoder() __snake_case : Any = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : List[Any] = floats_list((3, 10_00) ) __snake_case : Optional[Any] = feature_extractor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Tuple = 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 snake_case__ ( self : Optional[int] ): __snake_case : Any = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = """This is a test string""" __snake_case : Union[str, Any] = processor(text=_lowerCAmelCase ) __snake_case : Dict = tokenizer(_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : List[str] , _lowerCAmelCase : List[Any]=(2, 10, 16) , _lowerCAmelCase : str=77 ): np.random.seed(_lowerCAmelCase ) return np.random.rand(*_lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : List[str] = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : List[str] = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = self._get_dummy_logits(shape=(10, 16) , seed=13 ) __snake_case : int = processor.decode(_lowerCAmelCase ) __snake_case : Optional[int] = 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 snake_case__ ( self : List[str] , _lowerCAmelCase : List[str] ): __snake_case : int = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = 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: __snake_case : Tuple = processor.batch_decode(_lowerCAmelCase ) else: with get_context(_lowerCAmelCase ).Pool() as pool: __snake_case : int = processor.batch_decode(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as p: __snake_case : Tuple = decoder.decode_beams_batch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case , __snake_case , __snake_case : List[Any] = [], [], [] 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 snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = self.get_feature_extractor() __snake_case : int = self.get_tokenizer() __snake_case : str = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = self._get_dummy_logits() __snake_case : List[str] = 15 __snake_case : Optional[Any] = -20.0 __snake_case : Tuple = -4.0 __snake_case : List[Any] = processor.batch_decode( _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : List[str] = decoded_processor_out.text __snake_case : str = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as pool: __snake_case : Dict = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : int = [d[0][0] for d in decoded_decoder_out] __snake_case : List[Any] = [d[0][2] for d in decoded_decoder_out] __snake_case : List[Any] = [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([-20.054, -18.447] , _lowerCAmelCase , atol=1e-3 ) ) self.assertTrue(np.array_equal(_lowerCAmelCase , decoded_processor_out.lm_score ) ) self.assertTrue(np.allclose([-15.554, -13.9474] , _lowerCAmelCase , atol=1e-3 ) ) def snake_case__ ( self : Any ): __snake_case : List[Any] = self.get_feature_extractor() __snake_case : Any = self.get_tokenizer() __snake_case : Union[str, Any] = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Any = self._get_dummy_logits() __snake_case : Any = 2.0 __snake_case : int = 5.0 __snake_case : Optional[int] = -20.0 __snake_case : Optional[int] = True __snake_case : Any = processor.batch_decode( _lowerCAmelCase , alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) __snake_case : str = decoded_processor_out.text __snake_case : int = list(_lowerCAmelCase ) decoder.reset_params( alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) with get_context("""fork""" ).Pool() as pool: __snake_case : Tuple = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , ) __snake_case : int = [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 ) __snake_case : List[str] = 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 , -20.0 ) self.assertEqual(lm_model.score_boundary , _lowerCAmelCase ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Union[str, Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : Union[str, Any] = os.listdir(_lowerCAmelCase ) __snake_case : List[str] = ["""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 snake_case__ ( self : Optional[Any] ): __snake_case : Union[str, Any] = snapshot_download("""hf-internal-testing/processor_with_lm""" ) __snake_case : Dict = WavaVecaProcessorWithLM.from_pretrained(_lowerCAmelCase ) __snake_case : Optional[Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : List[str] = os.listdir(_lowerCAmelCase ) __snake_case : List[Any] = 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 snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : str = AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = floats_list((3, 10_00) ) __snake_case : Union[str, Any] = processor_wavaveca(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Union[str, Any] = 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 ) __snake_case : Dict = self._get_dummy_logits() __snake_case : List[Any] = processor_wavaveca.batch_decode(_lowerCAmelCase ) __snake_case : List[Any] = processor_auto.batch_decode(_lowerCAmelCase ) self.assertListEqual(decoded_wavaveca.text , decoded_auto.text ) def snake_case__ ( self : str ): __snake_case : int = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : Optional[Any] = self.get_decoder() __snake_case : Union[str, Any] = 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 snake_case__ ( _lowerCAmelCase : Any , _lowerCAmelCase : Tuple ): __snake_case : Union[str, Any] = [d[key] for d in offsets] return retrieved_list def snake_case__ ( self : Dict ): __snake_case : int = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : List[str] = self._get_dummy_logits()[0] __snake_case : str = 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 snake_case__ ( self : List[str] ): __snake_case : Any = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = self._get_dummy_logits() __snake_case : int = 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 snake_case__ ( self : Optional[Any] ): import torch __snake_case : Optional[Any] = load_dataset("""common_voice""" , """en""" , split="""train""" , streaming=_lowerCAmelCase ) __snake_case : Any = ds.cast_column("""audio""" , datasets.Audio(sampling_rate=1_60_00 ) ) __snake_case : List[Any] = iter(_lowerCAmelCase ) __snake_case : Optional[int] = next(_lowerCAmelCase ) __snake_case : str = AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) __snake_case : str = 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 __snake_case : List[str] = processor(sample["""audio"""]["""array"""] , return_tensors="""pt""" ).input_values with torch.no_grad(): __snake_case : Dict = model(_lowerCAmelCase ).logits.cpu().numpy() __snake_case : Any = processor.decode(logits[0] , output_word_offsets=_lowerCAmelCase ) __snake_case : Optional[Any] = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate __snake_case : Dict = [ { """start_time""": d["""start_offset"""] * time_offset, """end_time""": d["""end_offset"""] * time_offset, """word""": d["""word"""], } for d in output["""word_offsets"""] ] __snake_case : Dict = """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 __snake_case : Dict = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """start_time""" ) ) __snake_case : Optional[Any] = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """end_time""" ) ) # fmt: off __snake_case : Optional[Any] = torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599] ) __snake_case : Optional[int] = torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94] ) # fmt: on self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) ) self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) )
20
from .constants import ( MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SCALER_NAME, SCHEDULER_NAME, TORCH_LAUNCH_PARAMS, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ) from .dataclasses import ( BnbQuantizationConfig, ComputeEnvironment, CustomDtype, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FPaRecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProjectConfiguration, RNGType, SageMakerDistributedType, TensorInformation, TorchDynamoPlugin, ) from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env from .imports import ( get_ccl_version, is_abit_bnb_available, is_abit_bnb_available, is_aim_available, is_bfaa_available, is_bnb_available, is_botoa_available, is_ccl_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_fpa_available, is_ipex_available, is_megatron_lm_available, is_mlflow_available, is_mps_available, is_npu_available, is_rich_available, is_safetensors_available, is_sagemaker_available, is_tensorboard_available, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) from .modeling import ( check_device_map, check_tied_parameters_in_config, check_tied_parameters_on_same_device, compute_module_sizes, convert_file_size_to_int, dtype_byte_size, find_tied_parameters, get_balanced_memory, get_max_layer_size, get_max_memory, get_mixed_precision_context_manager, id_tensor_storage, infer_auto_device_map, load_checkpoint_in_model, load_offloaded_weights, load_state_dict, named_module_tensors, retie_parameters, set_module_tensor_to_device, shard_checkpoint, ) from .offload import ( OffloadedWeightsLoader, PrefixedDataset, extract_submodules_state_dict, load_offloaded_weight, offload_state_dict, offload_weight, save_offload_index, ) from .operations import ( broadcast, broadcast_object_list, concatenate, convert_outputs_to_fpaa, convert_to_fpaa, find_batch_size, find_device, gather, gather_object, get_data_structure, honor_type, initialize_tensors, is_namedtuple, is_tensor_information, is_torch_tensor, listify, pad_across_processes, recursively_apply, reduce, send_to_device, slice_tensors, ) from .versions import compare_versions, is_torch_version if is_deepspeed_available(): from .deepspeed import ( DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler, HfDeepSpeedConfig, ) from .bnb import has_abit_bnb_layers, load_and_quantize_model from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer from .launch import ( PrepareForLaunch, _filter_args, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, ) from .megatron_lm import ( AbstractTrainStep, BertTrainStep, GPTTrainStep, MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, TaTrainStep, avg_losses_across_data_parallel_group, gather_across_data_parallel_groups, ) from .megatron_lm import initialize as megatron_lm_initialize from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader from .megatron_lm import prepare_model as megatron_lm_prepare_model from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler from .memory import find_executable_batch_size, release_memory from .other import ( extract_model_from_parallel, get_pretty_name, is_port_in_use, merge_dicts, patch_environment, save, wait_for_everyone, write_basic_config, ) from .random import set_seed, synchronize_rng_state, synchronize_rng_states from .torch_xla import install_xla from .tqdm import tqdm from .transformer_engine import convert_model, has_transformer_engine_layers
20
1
from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "facebook/deit-base-distilled-patch16-224": ( "https://huggingface.co/facebook/deit-base-patch16-224/resolve/main/config.json" ), # See all DeiT models at https://huggingface.co/models?filter=deit } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : int = "deit" def __init__( self : Optional[int] , _lowerCAmelCase : Any=7_68 , _lowerCAmelCase : str=12 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : Tuple=30_72 , _lowerCAmelCase : Dict="gelu" , _lowerCAmelCase : Optional[int]=0.0 , _lowerCAmelCase : int=0.0 , _lowerCAmelCase : Optional[int]=0.02 , _lowerCAmelCase : str=1e-12 , _lowerCAmelCase : Union[str, Any]=2_24 , _lowerCAmelCase : int=16 , _lowerCAmelCase : str=3 , _lowerCAmelCase : str=True , _lowerCAmelCase : Dict=16 , **_lowerCAmelCase : List[str] , ): super().__init__(**_lowerCAmelCase ) __snake_case : int = hidden_size __snake_case : str = num_hidden_layers __snake_case : Dict = num_attention_heads __snake_case : Any = intermediate_size __snake_case : int = hidden_act __snake_case : str = hidden_dropout_prob __snake_case : Union[str, Any] = attention_probs_dropout_prob __snake_case : Optional[int] = initializer_range __snake_case : Dict = layer_norm_eps __snake_case : Optional[int] = image_size __snake_case : Optional[int] = patch_size __snake_case : List[str] = num_channels __snake_case : Tuple = qkv_bias __snake_case : int = encoder_stride class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Tuple = version.parse("1.11" ) @property def snake_case__ ( self : str ): return OrderedDict( [ ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}), ] ) @property def snake_case__ ( self : Any ): return 1e-4
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase_ = { "configuration_blenderbot_small": [ "BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "BlenderbotSmallConfig", "BlenderbotSmallOnnxConfig", ], "tokenization_blenderbot_small": ["BlenderbotSmallTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["BlenderbotSmallTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST", "BlenderbotSmallForCausalLM", "BlenderbotSmallForConditionalGeneration", "BlenderbotSmallModel", "BlenderbotSmallPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFBlenderbotSmallForConditionalGeneration", "TFBlenderbotSmallModel", "TFBlenderbotSmallPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxBlenderbotSmallForConditionalGeneration", "FlaxBlenderbotSmallModel", "FlaxBlenderbotSmallPreTrainedModel", ] if TYPE_CHECKING: from .configuration_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotSmallConfig, BlenderbotSmallOnnxConfig, ) from .tokenization_blenderbot_small import BlenderbotSmallTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_small_fast import BlenderbotSmallTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot_small import ( BLENDERBOT_SMALL_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotSmallForCausalLM, BlenderbotSmallForConditionalGeneration, BlenderbotSmallModel, BlenderbotSmallPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot_small import ( TFBlenderbotSmallForConditionalGeneration, TFBlenderbotSmallModel, TFBlenderbotSmallPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot_small import ( FlaxBlenderbotSmallForConditionalGeneration, FlaxBlenderbotSmallModel, FlaxBlenderbotSmallPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
import unittest from transformers import ( MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, Pipeline, ZeroShotClassificationPipeline, pipeline, ) from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow from .test_pipelines_common import ANY # These 2 model types require different inputs than those of the usual text models. lowercase_ = {"LayoutLMv2Config", "LayoutLMv3Config"} @is_pipeline_test class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): A : int = MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING A : Tuple = TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING if model_mapping is not None: A : str = {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP} if tf_model_mapping is not None: A : Dict = { config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP } def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : int ): __snake_case : List[str] = ZeroShotClassificationPipeline( model=_lowerCAmelCase , tokenizer=_lowerCAmelCase , candidate_labels=["""polics""", """health"""] ) return classifier, ["Who are you voting for in 2020?", "My stomach hurts."] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[Any] ): __snake_case : Any = classifier("""Who are you voting for in 2020?""" , candidate_labels="""politics""" ) self.assertEqual(_lowerCAmelCase , {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase )]} ) # No kwarg __snake_case : Union[str, Any] = classifier("""Who are you voting for in 2020?""" , ["""politics"""] ) self.assertEqual(_lowerCAmelCase , {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase )]} ) __snake_case : Optional[int] = classifier("""Who are you voting for in 2020?""" , candidate_labels=["""politics"""] ) self.assertEqual(_lowerCAmelCase , {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase )]} ) __snake_case : Optional[Any] = classifier("""Who are you voting for in 2020?""" , candidate_labels="""politics, public health""" ) self.assertEqual( _lowerCAmelCase , {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )]} ) self.assertAlmostEqual(sum(nested_simplify(outputs["""scores"""] ) ) , 1.0 ) __snake_case : List[Any] = classifier("""Who are you voting for in 2020?""" , candidate_labels=["""politics""", """public health"""] ) self.assertEqual( _lowerCAmelCase , {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )]} ) self.assertAlmostEqual(sum(nested_simplify(outputs["""scores"""] ) ) , 1.0 ) __snake_case : Tuple = classifier( """Who are you voting for in 2020?""" , candidate_labels="""politics""" , hypothesis_template="""This text is about {}""" ) self.assertEqual(_lowerCAmelCase , {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase )]} ) # https://github.com/huggingface/transformers/issues/13846 __snake_case : str = classifier(["""I am happy"""] , ["""positive""", """negative"""] ) self.assertEqual( _lowerCAmelCase , [ {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )]} for i in range(1 ) ] , ) __snake_case : Optional[int] = classifier(["""I am happy""", """I am sad"""] , ["""positive""", """negative"""] ) self.assertEqual( _lowerCAmelCase , [ {"""sequence""": ANY(_lowerCAmelCase ), """labels""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )], """scores""": [ANY(_lowerCAmelCase ), ANY(_lowerCAmelCase )]} for i in range(2 ) ] , ) with self.assertRaises(_lowerCAmelCase ): classifier("""""" , candidate_labels="""politics""" ) with self.assertRaises(_lowerCAmelCase ): classifier(_lowerCAmelCase , candidate_labels="""politics""" ) with self.assertRaises(_lowerCAmelCase ): classifier("""Who are you voting for in 2020?""" , candidate_labels="""""" ) with self.assertRaises(_lowerCAmelCase ): classifier("""Who are you voting for in 2020?""" , candidate_labels=_lowerCAmelCase ) with self.assertRaises(_lowerCAmelCase ): classifier( """Who are you voting for in 2020?""" , candidate_labels="""politics""" , hypothesis_template="""Not formatting template""" , ) with self.assertRaises(_lowerCAmelCase ): classifier( """Who are you voting for in 2020?""" , candidate_labels="""politics""" , hypothesis_template=_lowerCAmelCase , ) self.run_entailment_id(_lowerCAmelCase ) def snake_case__ ( self : Tuple , _lowerCAmelCase : Pipeline ): __snake_case : Tuple = zero_shot_classifier.model.config __snake_case : int = config.labelaid __snake_case : Any = zero_shot_classifier.entailment_id __snake_case : List[Any] = {"""LABEL_0""": 0, """LABEL_1""": 1, """LABEL_2""": 2} self.assertEqual(zero_shot_classifier.entailment_id , -1 ) __snake_case : Tuple = {"""entailment""": 0, """neutral""": 1, """contradiction""": 2} self.assertEqual(zero_shot_classifier.entailment_id , 0 ) __snake_case : Optional[int] = {"""ENTAIL""": 0, """NON-ENTAIL""": 1} self.assertEqual(zero_shot_classifier.entailment_id , 0 ) __snake_case : int = {"""ENTAIL""": 2, """NEUTRAL""": 1, """CONTR""": 0} self.assertEqual(zero_shot_classifier.entailment_id , 2 ) __snake_case : List[Any] = original_labelaid self.assertEqual(_lowerCAmelCase , zero_shot_classifier.entailment_id ) @require_torch def snake_case__ ( self : int ): __snake_case : Dict = pipeline( """zero-shot-classification""" , model="""sshleifer/tiny-distilbert-base-cased-distilled-squad""" , framework="""pt""" , ) # There was a regression in 4.10 for this # Adding a test so we don't make the mistake again. # https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499 zero_shot_classifier( """Who are you voting for in 2020?""" * 1_00 , candidate_labels=["""politics""", """public health""", """science"""] ) @require_torch def snake_case__ ( self : Optional[int] ): __snake_case : str = pipeline( """zero-shot-classification""" , model="""sshleifer/tiny-distilbert-base-cased-distilled-squad""" , framework="""pt""" , ) __snake_case : int = zero_shot_classifier( """Who are you voting for in 2020?""" , candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(_lowerCAmelCase ) , { """sequence""": """Who are you voting for in 2020?""", """labels""": ["""science""", """public health""", """politics"""], """scores""": [0.333, 0.333, 0.333], } , ) @require_tf def snake_case__ ( self : Optional[int] ): __snake_case : Tuple = pipeline( """zero-shot-classification""" , model="""sshleifer/tiny-distilbert-base-cased-distilled-squad""" , framework="""tf""" , ) __snake_case : List[str] = zero_shot_classifier( """Who are you voting for in 2020?""" , candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(_lowerCAmelCase ) , { """sequence""": """Who are you voting for in 2020?""", """labels""": ["""science""", """public health""", """politics"""], """scores""": [0.333, 0.333, 0.333], } , ) @slow @require_torch def snake_case__ ( self : Optional[Any] ): __snake_case : List[Any] = pipeline("""zero-shot-classification""" , model="""roberta-large-mnli""" , framework="""pt""" ) __snake_case : Any = zero_shot_classifier( """Who are you voting for in 2020?""" , candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(_lowerCAmelCase ) , { """sequence""": """Who are you voting for in 2020?""", """labels""": ["""politics""", """public health""", """science"""], """scores""": [0.976, 0.015, 0.009], } , ) __snake_case : List[Any] = zero_shot_classifier( """The dominant sequence transduction models are based on complex recurrent or convolutional neural networks""" """ in an encoder-decoder configuration. The best performing models also connect the encoder and decoder""" """ through an attention mechanism. We propose a new simple network architecture, the Transformer, based""" """ solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two""" """ machine translation tasks show these models to be superior in quality while being more parallelizable""" """ and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014""" """ English-to-German translation task, improving over the existing best results, including ensembles by""" """ over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new""" """ single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small""" """ fraction of the training costs of the best models from the literature. We show that the Transformer""" """ generalizes well to other tasks by applying it successfully to English constituency parsing both with""" """ large and limited training data.""" , candidate_labels=["""machine learning""", """statistics""", """translation""", """vision"""] , multi_label=_lowerCAmelCase , ) self.assertEqual( nested_simplify(_lowerCAmelCase ) , { """sequence""": ( """The dominant sequence transduction models are based on complex recurrent or convolutional neural""" """ networks in an encoder-decoder configuration. The best performing models also connect the""" """ encoder and decoder through an attention mechanism. We propose a new simple network""" """ architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence""" """ and convolutions entirely. Experiments on two machine translation tasks show these models to be""" """ superior in quality while being more parallelizable and requiring significantly less time to""" """ train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,""" """ improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014""" """ English-to-French translation task, our model establishes a new single-model state-of-the-art""" """ BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training""" """ costs of the best models from the literature. We show that the Transformer generalizes well to""" """ other tasks by applying it successfully to English constituency parsing both with large and""" """ limited training data.""" ), """labels""": ["""translation""", """machine learning""", """vision""", """statistics"""], """scores""": [0.817, 0.713, 0.018, 0.018], } , ) @slow @require_tf def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = pipeline("""zero-shot-classification""" , model="""roberta-large-mnli""" , framework="""tf""" ) __snake_case : Tuple = zero_shot_classifier( """Who are you voting for in 2020?""" , candidate_labels=["""politics""", """public health""", """science"""] ) self.assertEqual( nested_simplify(_lowerCAmelCase ) , { """sequence""": """Who are you voting for in 2020?""", """labels""": ["""politics""", """public health""", """science"""], """scores""": [0.976, 0.015, 0.009], } , ) __snake_case : int = zero_shot_classifier( """The dominant sequence transduction models are based on complex recurrent or convolutional neural networks""" """ in an encoder-decoder configuration. The best performing models also connect the encoder and decoder""" """ through an attention mechanism. We propose a new simple network architecture, the Transformer, based""" """ solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two""" """ machine translation tasks show these models to be superior in quality while being more parallelizable""" """ and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014""" """ English-to-German translation task, improving over the existing best results, including ensembles by""" """ over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new""" """ single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small""" """ fraction of the training costs of the best models from the literature. We show that the Transformer""" """ generalizes well to other tasks by applying it successfully to English constituency parsing both with""" """ large and limited training data.""" , candidate_labels=["""machine learning""", """statistics""", """translation""", """vision"""] , multi_label=_lowerCAmelCase , ) self.assertEqual( nested_simplify(_lowerCAmelCase ) , { """sequence""": ( """The dominant sequence transduction models are based on complex recurrent or convolutional neural""" """ networks in an encoder-decoder configuration. The best performing models also connect the""" """ encoder and decoder through an attention mechanism. We propose a new simple network""" """ architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence""" """ and convolutions entirely. Experiments on two machine translation tasks show these models to be""" """ superior in quality while being more parallelizable and requiring significantly less time to""" """ train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,""" """ improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014""" """ English-to-French translation task, our model establishes a new single-model state-of-the-art""" """ BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training""" """ costs of the best models from the literature. We show that the Transformer generalizes well to""" """ other tasks by applying it successfully to English constituency parsing both with large and""" """ limited training data.""" ), """labels""": ["""translation""", """machine learning""", """vision""", """statistics"""], """scores""": [0.817, 0.713, 0.018, 0.018], } , )
20
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, is_vision_available, ) lowercase_ = {"configuration_vit": ["VIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTConfig", "ViTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["ViTFeatureExtractor"] lowercase_ = ["ViTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "VIT_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTForImageClassification", "ViTForMaskedImageModeling", "ViTModel", "ViTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TFViTForImageClassification", "TFViTModel", "TFViTPreTrainedModel", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "FlaxViTForImageClassification", "FlaxViTModel", "FlaxViTPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_vit import ViTFeatureExtractor from .image_processing_vit import ViTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit import ( VIT_PRETRAINED_MODEL_ARCHIVE_LIST, ViTForImageClassification, ViTForMaskedImageModeling, ViTModel, ViTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[int]] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : set ): '''simple docstring''' __snake_case , __snake_case : Any = len(__SCREAMING_SNAKE_CASE ), len(grid[0] ) if ( min(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) < 0 or row == row_length or col == col_length or (row, col) in visit or grid[row][col] == 1 ): return 0 if row == row_length - 1 and col == col_length - 1: return 1 visit.add((row, col) ) __snake_case : List[Any] = 0 count += depth_first_search(__SCREAMING_SNAKE_CASE , row + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) count += depth_first_search(__SCREAMING_SNAKE_CASE , row - 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) count += depth_first_search(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , col + 1 , __SCREAMING_SNAKE_CASE ) count += depth_first_search(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , col - 1 , __SCREAMING_SNAKE_CASE ) visit.remove((row, col) ) return count if __name__ == "__main__": import doctest doctest.testmod()
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if (direction == 1 and array[indexa] > array[indexa]) or ( direction == 0 and array[indexa] < array[indexa] ): __snake_case , __snake_case : str = array[indexa], array[indexa] def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Tuple = int(length / 2 ) for i in range(__SCREAMING_SNAKE_CASE , low + middle ): comp_and_swap(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , i + middle , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) bitonic_merge(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' if length > 1: __snake_case : Optional[Any] = int(length / 2 ) bitonic_sort(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , 1 ) bitonic_sort(__SCREAMING_SNAKE_CASE , low + middle , __SCREAMING_SNAKE_CASE , 0 ) bitonic_merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() lowercase_ = [int(item.strip()) for item in user_input.split(",")] bitonic_sort(unsorted, 0, len(unsorted), 1) print("\nSorted array in ascending order is: ", end="") print(*unsorted, sep=", ") bitonic_merge(unsorted, 0, len(unsorted), 0) print("Sorted array in descending order is: ", end="") print(*unsorted, sep=", ")
20
1
import os import sys import tempfile import torch from .state import AcceleratorState from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple=() , __SCREAMING_SNAKE_CASE : Tuple=None , __SCREAMING_SNAKE_CASE : Union[str, Any]="no" , __SCREAMING_SNAKE_CASE : List[Any]="29500" ): '''simple docstring''' __snake_case : Any = False __snake_case : Optional[int] = False if any(key.startswith("""KAGGLE""" ) for key in os.environ.keys() ): __snake_case : Any = True elif "IPython" in sys.modules: __snake_case : Optional[int] = """google.colab""" in str(sys.modules["""IPython"""].get_ipython() ) try: __snake_case : str = PrecisionType(mixed_precision.lower() ) except ValueError: raise ValueError( F'''Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.''' ) if (in_colab or in_kaggle) and (os.environ.get("""TPU_NAME""" , __SCREAMING_SNAKE_CASE ) is not None): # TPU launch import torch_xla.distributed.xla_multiprocessing as xmp if len(AcceleratorState._shared_state ) > 0: raise ValueError( """To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside """ """your training function. Restart your notebook and make sure no cells initializes an """ """`Accelerator`.""" ) if num_processes is None: __snake_case : Optional[int] = 8 __snake_case : Optional[Any] = PrepareForLaunch(__SCREAMING_SNAKE_CASE , distributed_type="""TPU""" ) print(F'''Launching a training on {num_processes} TPU cores.''' ) xmp.spawn(__SCREAMING_SNAKE_CASE , args=__SCREAMING_SNAKE_CASE , nprocs=__SCREAMING_SNAKE_CASE , start_method="""fork""" ) elif in_colab: # No need for a distributed launch otherwise as it's either CPU or one GPU. if torch.cuda.is_available(): print("""Launching training on one GPU.""" ) else: print("""Launching training on one CPU.""" ) function(*__SCREAMING_SNAKE_CASE ) else: if num_processes is None: raise ValueError( """You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.""" ) if num_processes > 1: # Multi-GPU launch from torch.multiprocessing import start_processes from torch.multiprocessing.spawn import ProcessRaisedException if len(AcceleratorState._shared_state ) > 0: raise ValueError( """To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized """ """inside your training function. Restart your notebook and make sure no cells initializes an """ """`Accelerator`.""" ) if torch.cuda.is_initialized(): raise ValueError( """To launch a multi-GPU training from your notebook, you need to avoid running any instruction """ """using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA """ """function.""" ) # torch.distributed will expect a few environment variable to be here. We set the ones common to each # process here (the other ones will be set be the launcher). with patch_environment( world_size=__SCREAMING_SNAKE_CASE , master_addr="""127.0.01""" , master_port=__SCREAMING_SNAKE_CASE , mixed_precision=__SCREAMING_SNAKE_CASE ): __snake_case : Optional[int] = PrepareForLaunch(__SCREAMING_SNAKE_CASE , distributed_type="""MULTI_GPU""" ) print(F'''Launching training on {num_processes} GPUs.''' ) try: start_processes(__SCREAMING_SNAKE_CASE , args=__SCREAMING_SNAKE_CASE , nprocs=__SCREAMING_SNAKE_CASE , start_method="""fork""" ) except ProcessRaisedException as e: if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]: raise RuntimeError( """CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. """ """This likely stems from an outside import causing issues once the `notebook_launcher()` is called. """ """Please review your imports and test them when running the `notebook_launcher()` to identify """ """which one is problematic.""" ) from e else: # No need for a distributed launch otherwise as it's either CPU, GPU or MPS. if is_mps_available(): __snake_case : int = """1""" print("""Launching training on MPS.""" ) elif torch.cuda.is_available(): print("""Launching training on one GPU.""" ) else: print("""Launching training on CPU.""" ) function(*__SCREAMING_SNAKE_CASE ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : Dict=() , __SCREAMING_SNAKE_CASE : int=2 ): '''simple docstring''' from torch.multiprocessing import start_processes with tempfile.NamedTemporaryFile() as tmp_file: # torch.distributed will expect a few environment variable to be here. We set the ones common to each # process here (the other ones will be set be the launcher). with patch_environment( world_size=__SCREAMING_SNAKE_CASE , master_addr="""127.0.01""" , master_port="""29500""" , accelerate_mixed_precision="""no""" , accelerate_debug_rdv_file=tmp_file.name , accelerate_use_cpu="""yes""" , ): __snake_case : Dict = PrepareForLaunch(__SCREAMING_SNAKE_CASE , debug=__SCREAMING_SNAKE_CASE ) start_processes(__SCREAMING_SNAKE_CASE , args=__SCREAMING_SNAKE_CASE , nprocs=__SCREAMING_SNAKE_CASE , start_method="""fork""" )
20
import os import zipfile import pytest from datasets.utils.extract import ( BzipaExtractor, Extractor, GzipExtractor, LzaExtractor, SevenZipExtractor, TarExtractor, XzExtractor, ZipExtractor, ZstdExtractor, ) from .utils import require_lza, require_pyazr, require_zstandard @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , ): '''simple docstring''' __snake_case : Optional[int] = { """7z""": (seven_zip_file, SevenZipExtractor), """bz2""": (bza_file, BzipaExtractor), """gzip""": (gz_file, GzipExtractor), """lz4""": (lza_file, LzaExtractor), """tar""": (tar_file, TarExtractor), """xz""": (xz_file, XzExtractor), """zip""": (zip_file, ZipExtractor), """zstd""": (zstd_file, ZstdExtractor), } __snake_case , __snake_case : Tuple = input_paths_and_base_extractors[compression_format] if input_path is None: __snake_case : Tuple = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) assert base_extractor.is_extractable(__SCREAMING_SNAKE_CASE ) __snake_case : List[str] = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") base_extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : List[str] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Optional[Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : int = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.mark.parametrize( """compression_format, is_archive""" , [ ("""7z""", True), ("""bz2""", False), ("""gzip""", False), ("""lz4""", False), ("""tar""", True), ("""xz""", False), ("""zip""", True), ("""zstd""", False), ] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any] , ): '''simple docstring''' __snake_case : Union[str, Any] = { """7z""": seven_zip_file, """bz2""": bza_file, """gzip""": gz_file, """lz4""": lza_file, """tar""": tar_file, """xz""": xz_file, """zip""": zip_file, """zstd""": zstd_file, } __snake_case : int = input_paths[compression_format] if input_path is None: __snake_case : int = F'''for \'{compression_format}\' compression_format, ''' if compression_format == "7z": reason += require_pyazr.kwargs["reason"] elif compression_format == "lz4": reason += require_lza.kwargs["reason"] elif compression_format == "zstd": reason += require_zstandard.kwargs["reason"] pytest.skip(__SCREAMING_SNAKE_CASE ) __snake_case : Any = Extractor.infer_extractor_format(__SCREAMING_SNAKE_CASE ) assert extractor_format is not None __snake_case : Tuple = tmp_path / ("""extracted""" if is_archive else """extracted.txt""") Extractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if is_archive: assert output_path.is_dir() for file_path in output_path.iterdir(): assert file_path.name == text_file.name __snake_case : Union[str, Any] = file_path.read_text(encoding="""utf-8""" ) else: __snake_case : Union[str, Any] = output_path.read_text(encoding="""utf-8""" ) __snake_case : Optional[Any] = text_file.read_text(encoding="""utf-8""" ) assert extracted_file_content == expected_file_content @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any ): '''simple docstring''' import tarfile __snake_case : List[str] = tmp_path / """data_dot_dot""" directory.mkdir() __snake_case : Optional[Any] = directory / """tar_file_with_dot_dot.tar""" with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(__SCREAMING_SNAKE_CASE , arcname=os.path.join("""..""" , text_file.name ) ) return path @pytest.fixture def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' import tarfile __snake_case : Dict = tmp_path / """data_sym_link""" directory.mkdir() __snake_case : Tuple = directory / """tar_file_with_sym_link.tar""" os.symlink("""..""" , directory / """subdir""" , target_is_directory=__SCREAMING_SNAKE_CASE ) with tarfile.TarFile(__SCREAMING_SNAKE_CASE , """w""" ) as f: f.add(str(directory / """subdir""" ) , arcname="""subdir""" ) # str required by os.readlink on Windows and Python < 3.8 return path @pytest.mark.parametrize( """insecure_tar_file, error_log""" , [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")] , ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[Any] ): '''simple docstring''' __snake_case : Any = { """tar_file_with_dot_dot""": tar_file_with_dot_dot, """tar_file_with_sym_link""": tar_file_with_sym_link, } __snake_case : int = insecure_tar_files[insecure_tar_file] __snake_case : Optional[int] = tmp_path / """extracted""" TarExtractor.extract(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) assert caplog.text for record in caplog.records: assert record.levelname == "ERROR" assert error_log in record.msg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict ): '''simple docstring''' # We should have less false positives than zipfile.is_zipfile # We do that by checking only the magic number __snake_case : Optional[Any] = tmpdir / """not_a_zip_file""" # From: https://github.com/python/cpython/pull/5053 __snake_case : List[str] = ( b"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00""" b"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I""" b"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07""" b"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82""" ) with not_a_zip_file.open("""wb""" ) as f: f.write(__SCREAMING_SNAKE_CASE ) assert zipfile.is_zipfile(str(__SCREAMING_SNAKE_CASE ) ) # is a false positive for `zipfile` assert not ZipExtractor.is_extractable(__SCREAMING_SNAKE_CASE ) # but we're right
20
1
from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "google/vit-base-patch16-224": "https://huggingface.co/vit-base-patch16-224/resolve/main/config.json", # See all ViT models at https://huggingface.co/models?filter=vit } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : int = "vit" def __init__( self : Any , _lowerCAmelCase : Optional[int]=7_68 , _lowerCAmelCase : List[str]=12 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : int=30_72 , _lowerCAmelCase : Tuple="gelu" , _lowerCAmelCase : Any=0.0 , _lowerCAmelCase : Any=0.0 , _lowerCAmelCase : Dict=0.02 , _lowerCAmelCase : str=1e-12 , _lowerCAmelCase : int=2_24 , _lowerCAmelCase : int=16 , _lowerCAmelCase : List[str]=3 , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any=16 , **_lowerCAmelCase : Dict , ): super().__init__(**_lowerCAmelCase ) __snake_case : Optional[Any] = hidden_size __snake_case : Union[str, Any] = num_hidden_layers __snake_case : List[str] = num_attention_heads __snake_case : List[Any] = intermediate_size __snake_case : Tuple = hidden_act __snake_case : int = hidden_dropout_prob __snake_case : str = attention_probs_dropout_prob __snake_case : Dict = initializer_range __snake_case : Any = layer_norm_eps __snake_case : str = image_size __snake_case : str = patch_size __snake_case : Optional[Any] = num_channels __snake_case : List[Any] = qkv_bias __snake_case : Dict = encoder_stride class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : str = version.parse("1.11" ) @property def snake_case__ ( self : Optional[int] ): return OrderedDict( [ ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}), ] ) @property def snake_case__ ( self : Optional[Any] ): return 1e-4
20
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 SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): def snake_case__ ( self : Any ): __snake_case : Dict = """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split() __snake_case : str = dict(zip(_lowerCAmelCase , range(len(_lowerCAmelCase ) ) ) ) __snake_case : List[str] = { """unk_token""": """<unk>""", """bos_token""": """<s>""", """eos_token""": """</s>""", } __snake_case : str = { """feature_size""": 1, """padding_value""": 0.0, """sampling_rate""": 1_60_00, """return_attention_mask""": False, """do_normalize""": True, } __snake_case : Optional[Any] = tempfile.mkdtemp() __snake_case : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) __snake_case : Any = 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 __snake_case : Optional[int] = """hf-internal-testing/ngram-beam-search-decoder""" def snake_case__ ( self : Optional[Any] , **_lowerCAmelCase : Tuple ): __snake_case : int = self.add_kwargs_tokens_map.copy() kwargs.update(_lowerCAmelCase ) return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] , **_lowerCAmelCase : Optional[int] ): return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname , **_lowerCAmelCase ) def snake_case__ ( self : Dict , **_lowerCAmelCase : Tuple ): return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name , **_lowerCAmelCase ) def snake_case__ ( self : List[str] ): shutil.rmtree(self.tmpdirname ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : Tuple = self.get_feature_extractor() __snake_case : Dict = self.get_decoder() __snake_case : List[str] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) processor.save_pretrained(self.tmpdirname ) __snake_case : Dict = 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 snake_case__ ( self : Tuple ): __snake_case : Tuple = 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 __snake_case : Optional[Any] = 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 snake_case__ ( self : int ): __snake_case : Tuple = 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 snake_case__ ( self : Dict ): __snake_case : int = self.get_feature_extractor() __snake_case : str = self.get_tokenizer() __snake_case : Dict = self.get_decoder() __snake_case : Any = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : List[Any] = floats_list((3, 10_00) ) __snake_case : Optional[Any] = feature_extractor(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Tuple = 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 snake_case__ ( self : Optional[int] ): __snake_case : Any = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = """This is a test string""" __snake_case : Union[str, Any] = processor(text=_lowerCAmelCase ) __snake_case : Dict = tokenizer(_lowerCAmelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def snake_case__ ( self : List[str] , _lowerCAmelCase : List[Any]=(2, 10, 16) , _lowerCAmelCase : str=77 ): np.random.seed(_lowerCAmelCase ) return np.random.rand(*_lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case : List[str] = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : List[str] = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Optional[int] = self._get_dummy_logits(shape=(10, 16) , seed=13 ) __snake_case : int = processor.decode(_lowerCAmelCase ) __snake_case : Optional[int] = 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 snake_case__ ( self : List[str] , _lowerCAmelCase : List[str] ): __snake_case : int = self.get_feature_extractor() __snake_case : Union[str, Any] = self.get_tokenizer() __snake_case : int = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = 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: __snake_case : Tuple = processor.batch_decode(_lowerCAmelCase ) else: with get_context(_lowerCAmelCase ).Pool() as pool: __snake_case : int = processor.batch_decode(_lowerCAmelCase , _lowerCAmelCase ) __snake_case : int = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as p: __snake_case : Tuple = decoder.decode_beams_batch(_lowerCAmelCase , _lowerCAmelCase ) __snake_case , __snake_case , __snake_case : List[Any] = [], [], [] 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 snake_case__ ( self : Optional[int] ): __snake_case : Optional[Any] = self.get_feature_extractor() __snake_case : int = self.get_tokenizer() __snake_case : str = self.get_decoder() __snake_case : Optional[Any] = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : int = self._get_dummy_logits() __snake_case : List[str] = 15 __snake_case : Optional[Any] = -20.0 __snake_case : Tuple = -4.0 __snake_case : List[Any] = processor.batch_decode( _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : List[str] = decoded_processor_out.text __snake_case : str = list(_lowerCAmelCase ) with get_context("""fork""" ).Pool() as pool: __snake_case : Dict = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , beam_width=_lowerCAmelCase , beam_prune_logp=_lowerCAmelCase , token_min_logp=_lowerCAmelCase , ) __snake_case : int = [d[0][0] for d in decoded_decoder_out] __snake_case : List[Any] = [d[0][2] for d in decoded_decoder_out] __snake_case : List[Any] = [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([-20.054, -18.447] , _lowerCAmelCase , atol=1e-3 ) ) self.assertTrue(np.array_equal(_lowerCAmelCase , decoded_processor_out.lm_score ) ) self.assertTrue(np.allclose([-15.554, -13.9474] , _lowerCAmelCase , atol=1e-3 ) ) def snake_case__ ( self : Any ): __snake_case : List[Any] = self.get_feature_extractor() __snake_case : Any = self.get_tokenizer() __snake_case : Union[str, Any] = self.get_decoder() __snake_case : Dict = WavaVecaProcessorWithLM(tokenizer=_lowerCAmelCase , feature_extractor=_lowerCAmelCase , decoder=_lowerCAmelCase ) __snake_case : Any = self._get_dummy_logits() __snake_case : Any = 2.0 __snake_case : int = 5.0 __snake_case : Optional[int] = -20.0 __snake_case : Optional[int] = True __snake_case : Any = processor.batch_decode( _lowerCAmelCase , alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) __snake_case : str = decoded_processor_out.text __snake_case : int = list(_lowerCAmelCase ) decoder.reset_params( alpha=_lowerCAmelCase , beta=_lowerCAmelCase , unk_score_offset=_lowerCAmelCase , lm_score_boundary=_lowerCAmelCase , ) with get_context("""fork""" ).Pool() as pool: __snake_case : Tuple = decoder.decode_beams_batch( _lowerCAmelCase , _lowerCAmelCase , ) __snake_case : int = [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 ) __snake_case : List[str] = 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 , -20.0 ) self.assertEqual(lm_model.score_boundary , _lowerCAmelCase ) def snake_case__ ( self : Dict ): __snake_case : Optional[Any] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Union[str, Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : Union[str, Any] = os.listdir(_lowerCAmelCase ) __snake_case : List[str] = ["""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 snake_case__ ( self : Optional[Any] ): __snake_case : Union[str, Any] = snapshot_download("""hf-internal-testing/processor_with_lm""" ) __snake_case : Dict = WavaVecaProcessorWithLM.from_pretrained(_lowerCAmelCase ) __snake_case : Optional[Any] = processor.decoder.model_container[processor.decoder._model_key] __snake_case : Optional[int] = Path(language_model._kenlm_model.path.decode("""utf-8""" ) ).parent.parent.absolute() __snake_case : List[str] = os.listdir(_lowerCAmelCase ) __snake_case : List[Any] = 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 snake_case__ ( self : Optional[Any] ): __snake_case : Optional[int] = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : str = AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = floats_list((3, 10_00) ) __snake_case : Union[str, Any] = processor_wavaveca(_lowerCAmelCase , return_tensors="""np""" ) __snake_case : Union[str, Any] = 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 ) __snake_case : Dict = self._get_dummy_logits() __snake_case : List[Any] = processor_wavaveca.batch_decode(_lowerCAmelCase ) __snake_case : List[Any] = processor_auto.batch_decode(_lowerCAmelCase ) self.assertListEqual(decoded_wavaveca.text , decoded_auto.text ) def snake_case__ ( self : str ): __snake_case : int = self.get_feature_extractor() __snake_case : List[str] = self.get_tokenizer() __snake_case : Optional[Any] = self.get_decoder() __snake_case : Union[str, Any] = 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 snake_case__ ( _lowerCAmelCase : Any , _lowerCAmelCase : Tuple ): __snake_case : Union[str, Any] = [d[key] for d in offsets] return retrieved_list def snake_case__ ( self : Dict ): __snake_case : int = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : List[str] = self._get_dummy_logits()[0] __snake_case : str = 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 snake_case__ ( self : List[str] ): __snake_case : Any = WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm""" ) __snake_case : Optional[int] = self._get_dummy_logits() __snake_case : int = 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 snake_case__ ( self : Optional[Any] ): import torch __snake_case : Optional[Any] = load_dataset("""common_voice""" , """en""" , split="""train""" , streaming=_lowerCAmelCase ) __snake_case : Any = ds.cast_column("""audio""" , datasets.Audio(sampling_rate=1_60_00 ) ) __snake_case : List[Any] = iter(_lowerCAmelCase ) __snake_case : Optional[int] = next(_lowerCAmelCase ) __snake_case : str = AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm""" ) __snake_case : str = 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 __snake_case : List[str] = processor(sample["""audio"""]["""array"""] , return_tensors="""pt""" ).input_values with torch.no_grad(): __snake_case : Dict = model(_lowerCAmelCase ).logits.cpu().numpy() __snake_case : Any = processor.decode(logits[0] , output_word_offsets=_lowerCAmelCase ) __snake_case : Optional[Any] = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate __snake_case : Dict = [ { """start_time""": d["""start_offset"""] * time_offset, """end_time""": d["""end_offset"""] * time_offset, """word""": d["""word"""], } for d in output["""word_offsets"""] ] __snake_case : Dict = """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 __snake_case : Dict = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """start_time""" ) ) __snake_case : Optional[Any] = torch.tensor(self.get_from_offsets(_lowerCAmelCase , """end_time""" ) ) # fmt: off __snake_case : Optional[Any] = torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599] ) __snake_case : Optional[int] = torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94] ) # fmt: on self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) ) self.assertTrue(torch.allclose(_lowerCAmelCase , _lowerCAmelCase , atol=0.01 ) )
20
1
import argparse import json from collections import OrderedDict import torch from huggingface_hub import cached_download, hf_hub_url from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[Any] ): '''simple docstring''' __snake_case : int = [] embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight''', F'''stage{idx}.patch_embed.proj.weight''', ) ) embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias''', F'''stage{idx}.patch_embed.proj.bias''', ) ) embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight''', F'''stage{idx}.patch_embed.norm.weight''', ) ) embed.append( ( F'''cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias''', F'''stage{idx}.patch_embed.norm.bias''', ) ) return embed def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Any = [] attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.convolution.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.conv.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.bias''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_mean''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_mean''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_var''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_var''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.num_batches_tracked''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.num_batches_tracked''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.convolution.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.conv.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.bias''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_mean''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_mean''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_var''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_var''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.num_batches_tracked''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.num_batches_tracked''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.convolution.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.conv.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.weight''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.bias''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_mean''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_mean''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_var''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_var''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.num_batches_tracked''', F'''stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.num_batches_tracked''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj_q.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj_q.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj_k.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj_k.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj_v.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj_v.bias''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.weight''', F'''stage{idx}.blocks.{cnt}.attn.proj.weight''', ) ) attention_weights.append( ( F'''cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.bias''', F'''stage{idx}.blocks.{cnt}.attn.proj.bias''', ) ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.weight''', F'''stage{idx}.blocks.{cnt}.mlp.fc1.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.bias''', F'''stage{idx}.blocks.{cnt}.mlp.fc1.bias''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.weight''', F'''stage{idx}.blocks.{cnt}.mlp.fc2.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.bias''', F'''stage{idx}.blocks.{cnt}.mlp.fc2.bias''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.weight''', F'''stage{idx}.blocks.{cnt}.norm1.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.bias''', F'''stage{idx}.blocks.{cnt}.norm1.bias''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.weight''', F'''stage{idx}.blocks.{cnt}.norm2.weight''') ) attention_weights.append( (F'''cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.bias''', F'''stage{idx}.blocks.{cnt}.norm2.bias''') ) return attention_weights def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' __snake_case : Optional[Any] = [] token.append((F'''cvt.encoder.stages.{idx}.cls_token''', """stage2.cls_token""") ) return token def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : str = [] head.append(("""layernorm.weight""", """norm.weight""") ) head.append(("""layernorm.bias""", """norm.bias""") ) head.append(("""classifier.weight""", """head.weight""") ) head.append(("""classifier.bias""", """head.bias""") ) return head def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Dict , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' __snake_case : List[Any] = """imagenet-1k-id2label.json""" __snake_case : Optional[int] = 1_0_0_0 __snake_case : int = """huggingface/label-files""" __snake_case : Dict = num_labels __snake_case : str = json.load(open(cached_download(hf_hub_url(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , repo_type="""dataset""" ) ) , """r""" ) ) __snake_case : Union[str, Any] = {int(__SCREAMING_SNAKE_CASE ): v for k, v in idalabel.items()} __snake_case : Dict = idalabel __snake_case : int = {v: k for k, v in idalabel.items()} __snake_case : Optional[Any] = CvtConfig(num_labels=__SCREAMING_SNAKE_CASE , idalabel=__SCREAMING_SNAKE_CASE , labelaid=__SCREAMING_SNAKE_CASE ) # For depth size 13 (13 = 1+2+10) if cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "13": __snake_case : Any = [1, 2, 1_0] # For depth size 21 (21 = 1+4+16) elif cvt_model.rsplit("""/""" , 1 )[-1][4:6] == "21": __snake_case : int = [1, 4, 1_6] # For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20) else: __snake_case : List[str] = [2, 2, 2_0] __snake_case : Optional[int] = [3, 1_2, 1_6] __snake_case : Union[str, Any] = [1_9_2, 7_6_8, 1_0_2_4] __snake_case : int = CvtForImageClassification(__SCREAMING_SNAKE_CASE ) __snake_case : str = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k""" ) __snake_case : Tuple = image_size __snake_case : Optional[int] = torch.load(__SCREAMING_SNAKE_CASE , map_location=torch.device("""cpu""" ) ) __snake_case : int = OrderedDict() __snake_case : Tuple = [] for idx in range(len(config.depth ) ): if config.cls_token[idx]: __snake_case : Union[str, Any] = list_of_state_dict + cls_token(__SCREAMING_SNAKE_CASE ) __snake_case : Dict = list_of_state_dict + embeddings(__SCREAMING_SNAKE_CASE ) for cnt in range(config.depth[idx] ): __snake_case : Any = list_of_state_dict + attention(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Union[str, Any] = list_of_state_dict + final() for gg in list_of_state_dict: print(__SCREAMING_SNAKE_CASE ) for i in range(len(__SCREAMING_SNAKE_CASE ) ): __snake_case : Optional[Any] = original_weights[list_of_state_dict[i][1]] model.load_state_dict(__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) image_processor.save_pretrained(__SCREAMING_SNAKE_CASE ) # Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument( "--cvt_model", default="cvt-w24", type=str, help="Name of the cvt model you'd like to convert.", ) parser.add_argument( "--image_size", default=3_84, type=int, help="Input Image Size", ) parser.add_argument( "--cvt_file_name", default=r"cvtmodels\CvT-w24-384x384-IN-22k.pth", type=str, help="Input Image Size", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory." ) lowercase_ = parser.parse_args() convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)
20
import argparse import re import torch from CLAP import create_model from transformers import AutoFeatureExtractor, ClapConfig, ClapModel lowercase_ = { "text_branch": "text_model", "audio_branch": "audio_model.audio_encoder", "attn": "attention.self", "self.proj": "output.dense", "attention.self_mask": "attn_mask", "mlp.fc1": "intermediate.dense", "mlp.fc2": "output.dense", "norm1": "layernorm_before", "norm2": "layernorm_after", "bn0": "batch_norm", } lowercase_ = AutoFeatureExtractor.from_pretrained("laion/clap-htsat-unfused", truncation="rand_trunc") def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Union[str, Any]=False ): '''simple docstring''' __snake_case , __snake_case : str = create_model( """HTSAT-tiny""" , """roberta""" , __SCREAMING_SNAKE_CASE , precision="""fp32""" , device="""cuda:0""" if torch.cuda.is_available() else """cpu""" , enable_fusion=__SCREAMING_SNAKE_CASE , fusion_type="""aff_2d""" if enable_fusion else None , ) return model, model_cfg def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : Union[str, Any] = {} __snake_case : List[Any] = R""".*sequential.(\d+).*""" __snake_case : Union[str, Any] = R""".*_projection.(\d+).*""" for key, value in state_dict.items(): # check if any key needs to be modified for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items(): if key_to_modify in key: __snake_case : Optional[Any] = key.replace(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): # replace sequential layers with list __snake_case : Optional[Any] = re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) __snake_case : Dict = key.replace(F'''sequential.{sequential_layer}.''' , F'''layers.{int(__SCREAMING_SNAKE_CASE )//3}.linear.''' ) elif re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : str = int(re.match(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ).group(1 ) ) # Because in CLAP they use `nn.Sequential`... __snake_case : List[Any] = 1 if projecton_layer == 0 else 2 __snake_case : Tuple = key.replace(F'''_projection.{projecton_layer}.''' , F'''_projection.linear{transformers_projection_layer}.''' ) if "audio" and "qkv" in key: # split qkv into query key and value __snake_case : Optional[int] = value __snake_case : Any = mixed_qkv.size(0 ) // 3 __snake_case : List[Any] = mixed_qkv[:qkv_dim] __snake_case : Tuple = mixed_qkv[qkv_dim : qkv_dim * 2] __snake_case : List[Any] = mixed_qkv[qkv_dim * 2 :] __snake_case : Any = query_layer __snake_case : Dict = key_layer __snake_case : Optional[Any] = value_layer else: __snake_case : List[str] = value return model_state_dict def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : List[Any] , __SCREAMING_SNAKE_CASE : Optional[Any]=False ): '''simple docstring''' __snake_case , __snake_case : List[str] = init_clap(__SCREAMING_SNAKE_CASE , enable_fusion=__SCREAMING_SNAKE_CASE ) clap_model.eval() __snake_case : Tuple = clap_model.state_dict() __snake_case : Union[str, Any] = rename_state_dict(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = ClapConfig() __snake_case : Tuple = enable_fusion __snake_case : Any = ClapModel(__SCREAMING_SNAKE_CASE ) # ignore the spectrogram embedding layer model.load_state_dict(__SCREAMING_SNAKE_CASE , strict=__SCREAMING_SNAKE_CASE ) model.save_pretrained(__SCREAMING_SNAKE_CASE ) transformers_config.save_pretrained(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument("--enable_fusion", action="store_true", help="Whether to enable fusion or not") lowercase_ = parser.parse_args() convert_clap_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.enable_fusion)
20
1
import inspect import unittest from transformers import BitConfig from transformers.testing_utils import require_torch, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_backbone_common import BackboneTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import BitBackbone, BitForImageClassification, BitImageProcessor, BitModel from transformers.models.bit.modeling_bit import BIT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image class SCREAMING_SNAKE_CASE__ : def __init__( self : Tuple , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : str=3 , _lowerCAmelCase : int=32 , _lowerCAmelCase : Tuple=3 , _lowerCAmelCase : Any=10 , _lowerCAmelCase : List[Any]=[8, 16, 32, 64] , _lowerCAmelCase : List[Any]=[1, 1, 2, 1] , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Optional[Any]="relu" , _lowerCAmelCase : List[Any]=3 , _lowerCAmelCase : str=None , _lowerCAmelCase : str=["stage2", "stage3", "stage4"] , _lowerCAmelCase : Dict=[2, 3, 4] , _lowerCAmelCase : Union[str, Any]=1 , ): __snake_case : Optional[int] = parent __snake_case : Union[str, Any] = batch_size __snake_case : Dict = image_size __snake_case : List[Any] = num_channels __snake_case : List[str] = embeddings_size __snake_case : Optional[Any] = hidden_sizes __snake_case : Dict = depths __snake_case : Union[str, Any] = is_training __snake_case : Optional[int] = use_labels __snake_case : Optional[int] = hidden_act __snake_case : Union[str, Any] = num_labels __snake_case : List[str] = scope __snake_case : List[Any] = len(_lowerCAmelCase ) __snake_case : Union[str, Any] = out_features __snake_case : List[str] = out_indices __snake_case : Dict = num_groups def snake_case__ ( self : List[str] ): __snake_case : List[Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) __snake_case : Tuple = None if self.use_labels: __snake_case : Optional[Any] = ids_tensor([self.batch_size] , self.num_labels ) __snake_case : List[Any] = self.get_config() return config, pixel_values, labels def snake_case__ ( self : Optional[int] ): return BitConfig( num_channels=self.num_channels , embeddings_size=self.embeddings_size , hidden_sizes=self.hidden_sizes , depths=self.depths , hidden_act=self.hidden_act , num_labels=self.num_labels , out_features=self.out_features , out_indices=self.out_indices , num_groups=self.num_groups , ) def snake_case__ ( self : str , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : List[str] ): __snake_case : Any = BitModel(config=_lowerCAmelCase ) model.to(_lowerCAmelCase ) model.eval() __snake_case : List[Any] = model(_lowerCAmelCase ) self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) , ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[str] , _lowerCAmelCase : str , _lowerCAmelCase : Union[str, Any] ): __snake_case : Dict = self.num_labels __snake_case : List[str] = BitForImageClassification(_lowerCAmelCase ) model.to(_lowerCAmelCase ) model.eval() __snake_case : Dict = model(_lowerCAmelCase , labels=_lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[Any] ): __snake_case : List[str] = BitBackbone(config=_lowerCAmelCase ) model.to(_lowerCAmelCase ) model.eval() __snake_case : List[str] = model(_lowerCAmelCase ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) , len(config.out_features ) ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[1], 4, 4] ) # verify channels self.parent.assertEqual(len(model.channels ) , len(config.out_features ) ) self.parent.assertListEqual(model.channels , config.hidden_sizes[1:] ) # verify backbone works with out_features=None __snake_case : Dict = None __snake_case : int = BitBackbone(config=_lowerCAmelCase ) model.to(_lowerCAmelCase ) model.eval() __snake_case : List[Any] = model(_lowerCAmelCase ) # verify feature maps self.parent.assertEqual(len(result.feature_maps ) , 1 ) self.parent.assertListEqual(list(result.feature_maps[0].shape ) , [self.batch_size, self.hidden_sizes[-1], 1, 1] ) # verify channels self.parent.assertEqual(len(model.channels ) , 1 ) self.parent.assertListEqual(model.channels , [config.hidden_sizes[-1]] ) def snake_case__ ( self : int ): __snake_case : List[Any] = self.prepare_config_and_inputs() __snake_case , __snake_case , __snake_case : Union[str, Any] = config_and_inputs __snake_case : int = {"""pixel_values""": pixel_values} return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , __UpperCamelCase , unittest.TestCase ): A : List[str] = (BitModel, BitForImageClassification, BitBackbone) if is_torch_available() else () A : str = ( {"feature-extraction": BitModel, "image-classification": BitForImageClassification} if is_torch_available() else {} ) A : Optional[Any] = False A : List[str] = False A : List[Any] = False A : Optional[int] = False A : Tuple = False def snake_case__ ( self : Optional[int] ): __snake_case : Any = BitModelTester(self ) __snake_case : Optional[Any] = ConfigTester(self , config_class=_lowerCAmelCase , has_text_modality=_lowerCAmelCase ) def snake_case__ ( self : Tuple ): self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def snake_case__ ( self : Union[str, Any] ): return @unittest.skip(reason="""Bit does not output attentions""" ) def snake_case__ ( self : Optional[int] ): pass @unittest.skip(reason="""Bit does not use inputs_embeds""" ) def snake_case__ ( self : Dict ): pass @unittest.skip(reason="""Bit does not support input and output embeddings""" ) def snake_case__ ( self : Dict ): pass def snake_case__ ( self : Optional[Any] ): __snake_case , __snake_case : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __snake_case : Optional[Any] = model_class(_lowerCAmelCase ) __snake_case : List[Any] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic __snake_case : List[str] = [*signature.parameters.keys()] __snake_case : Optional[Any] = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , _lowerCAmelCase ) def snake_case__ ( self : Optional[Any] ): __snake_case : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_lowerCAmelCase ) def snake_case__ ( self : Union[str, Any] ): __snake_case : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*_lowerCAmelCase ) def snake_case__ ( self : Tuple ): __snake_case , __snake_case : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __snake_case : Dict = model_class(config=_lowerCAmelCase ) for name, module in model.named_modules(): if isinstance(_lowerCAmelCase , (nn.BatchNormad, nn.GroupNorm) ): self.assertTrue( torch.all(module.weight == 1 ) , msg=f'''Parameter {name} of model {model_class} seems not properly initialized''' , ) self.assertTrue( torch.all(module.bias == 0 ) , msg=f'''Parameter {name} of model {model_class} seems not properly initialized''' , ) def snake_case__ ( self : Dict ): def check_hidden_states_output(_lowerCAmelCase : List[Any] , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Dict ): __snake_case : Dict = model_class(_lowerCAmelCase ) model.to(_lowerCAmelCase ) model.eval() with torch.no_grad(): __snake_case : Tuple = model(**self._prepare_for_class(_lowerCAmelCase , _lowerCAmelCase ) ) __snake_case : Tuple = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states __snake_case : Any = self.model_tester.num_stages self.assertEqual(len(_lowerCAmelCase ) , expected_num_stages + 1 ) # Bit's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) __snake_case , __snake_case : int = self.model_tester.prepare_config_and_inputs_for_common() __snake_case : List[Any] = ["""preactivation""", """bottleneck"""] for model_class in self.all_model_classes: for layer_type in layers_type: __snake_case : List[str] = layer_type __snake_case : str = True check_hidden_states_output(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] __snake_case : Dict = True check_hidden_states_output(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) @unittest.skip(reason="""Bit does not use feedforward chunking""" ) def snake_case__ ( self : int ): pass def snake_case__ ( self : Any ): __snake_case : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase ) @slow def snake_case__ ( self : int ): for model_name in BIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __snake_case : Union[str, Any] = BitModel.from_pretrained(_lowerCAmelCase ) self.assertIsNotNone(_lowerCAmelCase ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : str = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) return image @require_torch @require_vision class SCREAMING_SNAKE_CASE__ ( unittest.TestCase ): @cached_property def snake_case__ ( self : Tuple ): return ( BitImageProcessor.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def snake_case__ ( self : str ): __snake_case : List[Any] = BitForImageClassification.from_pretrained(BIT_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(_lowerCAmelCase ) __snake_case : Tuple = self.default_image_processor __snake_case : List[str] = prepare_img() __snake_case : List[Any] = image_processor(images=_lowerCAmelCase , return_tensors="""pt""" ).to(_lowerCAmelCase ) # forward pass with torch.no_grad(): __snake_case : int = model(**_lowerCAmelCase ) # verify the logits __snake_case : Dict = torch.Size((1, 10_00) ) self.assertEqual(outputs.logits.shape , _lowerCAmelCase ) __snake_case : Dict = torch.tensor([[-0.6526, -0.5263, -1.4398]] ).to(_lowerCAmelCase ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , _lowerCAmelCase , atol=1e-4 ) ) @require_torch class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , unittest.TestCase ): A : Union[str, Any] = (BitBackbone,) if is_torch_available() else () A : Union[str, Any] = BitConfig A : Dict = False def snake_case__ ( self : Union[str, Any] ): __snake_case : int = BitModelTester(self )
20
import io import os import unicodedata from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = "▁" lowercase_ = {"vocab_file": "vocab.txt", "sentencepiece_model_ckpt": "sentencepiece.bpe.model"} lowercase_ = { "sentencepiece_model_file": "sentencepiece.bpe.model", "vocab_file": "vocab.txt", } lowercase_ = { "vocab_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt", }, "sentencepiece_model_file": { "ernie-m-base": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", "ernie-m-large": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model", }, } lowercase_ = { "ernie-m-base": 5_14, "ernie-m-large": 5_14, } lowercase_ = { "ernie-m-base": {"do_lower_case": False}, "ernie-m-large": {"do_lower_case": False}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = ["input_ids"] A : Tuple = VOCAB_FILES_NAMES A : List[Any] = PRETRAINED_INIT_CONFIGURATION A : Union[str, Any] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP A : Optional[Any] = RESOURCE_FILES_NAMES def __init__( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : Dict=False , _lowerCAmelCase : List[Any]="utf8" , _lowerCAmelCase : Optional[Any]="[UNK]" , _lowerCAmelCase : Optional[int]="[SEP]" , _lowerCAmelCase : List[str]="[PAD]" , _lowerCAmelCase : Dict="[CLS]" , _lowerCAmelCase : List[Any]="[MASK]" , _lowerCAmelCase : Optional[Dict[str, Any]] = None , **_lowerCAmelCase : Any , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. __snake_case : List[Any] = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , vocab_file=_lowerCAmelCase , encoding=_lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCAmelCase , ) __snake_case : List[Any] = do_lower_case __snake_case : Any = sentencepiece_model_ckpt __snake_case : int = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCAmelCase ) # to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning if vocab_file is not None: __snake_case : int = self.load_vocab(filepath=_lowerCAmelCase ) else: __snake_case : Tuple = {self.sp_model.id_to_piece(_lowerCAmelCase ): id for id in range(self.sp_model.get_piece_size() )} __snake_case : str = {v: k for k, v in self.vocab.items()} def snake_case__ ( self : List[Any] , _lowerCAmelCase : List[Any] ): if text is None: return None __snake_case : List[Any] = self.tokenize(_lowerCAmelCase ) __snake_case , __snake_case : Optional[Any] = """""", [] for i, ch in enumerate(_lowerCAmelCase ): if ch in self.SP_CHAR_MAPPING: __snake_case : Any = self.SP_CHAR_MAPPING.get(_lowerCAmelCase ) else: __snake_case : Dict = unicodedata.normalize("""NFKC""" , _lowerCAmelCase ) if self.is_whitespace(_lowerCAmelCase ): continue normalized_text += ch char_mapping.extend([i] * len(_lowerCAmelCase ) ) __snake_case , __snake_case , __snake_case : str = normalized_text, [], 0 if self.do_lower_case: __snake_case : int = text.lower() for token in split_tokens: if token[:1] == "▁": __snake_case : int = token[1:] __snake_case : Optional[int] = text[offset:].index(_lowerCAmelCase ) + offset __snake_case : int = start + len(_lowerCAmelCase ) token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) ) __snake_case : str = end return token_mapping @property def snake_case__ ( self : Tuple ): return len(self.vocab ) def snake_case__ ( self : Dict ): return dict(self.vocab , **self.added_tokens_encoder ) def __getstate__( self : int ): __snake_case : str = self.__dict__.copy() __snake_case : Union[str, Any] = None return state def __setstate__( self : Optional[Any] , _lowerCAmelCase : List[str] ): __snake_case : Union[str, Any] = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): __snake_case : Optional[Any] = {} __snake_case : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.sentencepiece_model_ckpt ) def snake_case__ ( self : str , _lowerCAmelCase : Optional[int] ): return "".join((self.SP_CHAR_MAPPING.get(_lowerCAmelCase , _lowerCAmelCase ) for c in text) ) def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : str , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Optional[Any]=64 , _lowerCAmelCase : Optional[int]=0.1 ): if self.sp_model_kwargs.get("""enable_sampling""" ) is True: __snake_case : List[str] = True if self.sp_model_kwargs.get("""alpha""" ) is not None: __snake_case : Dict = self.sp_model_kwargs.get("""alpha""" ) if self.sp_model_kwargs.get("""nbest_size""" ) is not None: __snake_case : List[Any] = self.sp_model_kwargs.get("""nbest_size""" ) if not enable_sampling: __snake_case : str = self.sp_model.EncodeAsPieces(_lowerCAmelCase ) else: __snake_case : Tuple = self.sp_model.SampleEncodeAsPieces(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) __snake_case : Union[str, Any] = [] for pi, piece in enumerate(_lowerCAmelCase ): if piece == SPIECE_UNDERLINE: if not pieces[pi + 1].startswith(_lowerCAmelCase ) and pi != 0: new_pieces.append(_lowerCAmelCase ) continue else: continue __snake_case : Optional[int] = 0 for i, chunk in enumerate(_lowerCAmelCase ): if chunk == SPIECE_UNDERLINE: continue if self.is_ch_char(_lowerCAmelCase ) or self.is_punct(_lowerCAmelCase ): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) new_pieces.append(_lowerCAmelCase ) __snake_case : Tuple = i + 1 elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : List[str] = i elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit(): if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE: new_pieces.append(piece[lst_i:i] ) __snake_case : Tuple = i if len(_lowerCAmelCase ) > lst_i: new_pieces.append(piece[lst_i:] ) return new_pieces def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : int ): __snake_case : int = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): __snake_case : int = self.convert_ids_to_tokens(_lowerCAmelCase ) __snake_case : Any = """""".join(_lowerCAmelCase ).replace(_lowerCAmelCase , """ """ ).strip() return out_string def snake_case__ ( self : Dict , _lowerCAmelCase : Tuple ): return self.vocab.get(_lowerCAmelCase , self.vocab.get(self.unk_token ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Dict ): return self.reverse_vocab.get(_lowerCAmelCase , self.unk_token ) def snake_case__ ( self : Any , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Union[str, Any]=None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] __snake_case : Optional[Any] = [self.sep_token_id] return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep def snake_case__ ( self : List[str] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None ): if offset_mapping_a is None: return [(0, 0)] + offset_mapping_a + [(0, 0)] return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Optional[Any]=False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( """You should not supply a second sequence if the provided sequence of """ """ids is already formatted with special tokens for the model.""" ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] + ([0] * len(_lowerCAmelCase )) + [1] return [1] + ([0] * len(_lowerCAmelCase )) + [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): # called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method if token_ids_a is None: # [CLS] X [SEP] return (len(_lowerCAmelCase ) + 2) * [0] # [CLS] A [SEP] [SEP] B [SEP] return [0] * (len(_lowerCAmelCase ) + 1) + [1] * (len(_lowerCAmelCase ) + 3) def snake_case__ ( self : Tuple , _lowerCAmelCase : List[str] ): if "\u4e00" <= char <= "\u9fff": return True return False def snake_case__ ( self : List[str] , _lowerCAmelCase : Any ): if ("a" <= char <= "z") or ("A" <= char <= "Z"): return True return False def snake_case__ ( self : int , _lowerCAmelCase : List[Any] ): if char in ",;:.?!~,;:。?!《》【】": return True return False def snake_case__ ( self : str , _lowerCAmelCase : Optional[Any] ): if char == " " or char == "\t" or char == "\n" or char == "\r": return True if len(_lowerCAmelCase ) == 1: __snake_case : Dict = unicodedata.category(_lowerCAmelCase ) if cat == "Zs": return True return False def snake_case__ ( self : str , _lowerCAmelCase : List[Any] ): __snake_case : Dict = {} with io.open(_lowerCAmelCase , """r""" , encoding="""utf-8""" ) as f: for index, line in enumerate(_lowerCAmelCase ): __snake_case : Tuple = line.rstrip("""\n""" ) __snake_case : List[str] = int(_lowerCAmelCase ) return token_to_idx def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : Optional[int] = 0 if os.path.isdir(_lowerCAmelCase ): __snake_case : int = os.path.join( _lowerCAmelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) else: __snake_case : Optional[Any] = (filename_prefix + """-""" if filename_prefix else """""") + save_directory with open(_lowerCAmelCase , """w""" , encoding="""utf-8""" ) as writer: for token, token_index in sorted(self.vocab.items() , key=lambda _lowerCAmelCase : kv[1] ): if index != token_index: logger.warning( f'''Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.''' """ Please check that the vocabulary is not corrupted!""" ) __snake_case : Union[str, Any] = token_index writer.write(token + """\n""" ) index += 1 __snake_case : List[Any] = os.path.join(_lowerCAmelCase , """sentencepiece.bpe.model""" ) with open(_lowerCAmelCase , """wb""" ) as fi: __snake_case : List[Any] = self.sp_model.serialized_model_proto() fi.write(_lowerCAmelCase ) return (vocab_file,)
20
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) lowercase_ = { "configuration_mobilebert": [ "MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "MobileBertConfig", "MobileBertOnnxConfig", ], "tokenization_mobilebert": ["MobileBertTokenizer"], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = ["MobileBertTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST", "MobileBertForMaskedLM", "MobileBertForMultipleChoice", "MobileBertForNextSentencePrediction", "MobileBertForPreTraining", "MobileBertForQuestionAnswering", "MobileBertForSequenceClassification", "MobileBertForTokenClassification", "MobileBertLayer", "MobileBertModel", "MobileBertPreTrainedModel", "load_tf_weights_in_mobilebert", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ "TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST", "TFMobileBertForMaskedLM", "TFMobileBertForMultipleChoice", "TFMobileBertForNextSentencePrediction", "TFMobileBertForPreTraining", "TFMobileBertForQuestionAnswering", "TFMobileBertForSequenceClassification", "TFMobileBertForTokenClassification", "TFMobileBertMainLayer", "TFMobileBertModel", "TFMobileBertPreTrainedModel", ] if TYPE_CHECKING: from .configuration_mobilebert import ( MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, MobileBertConfig, MobileBertOnnxConfig, ) from .tokenization_mobilebert import MobileBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mobilebert_fast import MobileBertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mobilebert import ( MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, MobileBertForMaskedLM, MobileBertForMultipleChoice, MobileBertForNextSentencePrediction, MobileBertForPreTraining, MobileBertForQuestionAnswering, MobileBertForSequenceClassification, MobileBertForTokenClassification, MobileBertLayer, MobileBertModel, MobileBertPreTrainedModel, load_tf_weights_in_mobilebert, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mobilebert import ( TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFMobileBertForMaskedLM, TFMobileBertForMultipleChoice, TFMobileBertForNextSentencePrediction, TFMobileBertForPreTraining, TFMobileBertForQuestionAnswering, TFMobileBertForSequenceClassification, TFMobileBertForTokenClassification, TFMobileBertMainLayer, TFMobileBertModel, TFMobileBertPreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
20
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "xlm-mlm-en-2048": "https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json", "xlm-mlm-ende-1024": "https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json", "xlm-mlm-enfr-1024": "https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json", "xlm-mlm-enro-1024": "https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json", "xlm-mlm-tlm-xnli15-1024": "https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json", "xlm-mlm-xnli15-1024": "https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json", "xlm-clm-enfr-1024": "https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json", "xlm-clm-ende-1024": "https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json", "xlm-mlm-17-1280": "https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json", "xlm-mlm-100-1280": "https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[str] = "xlm" A : List[str] = { "hidden_size": "emb_dim", "num_attention_heads": "n_heads", "num_hidden_layers": "n_layers", "n_words": "vocab_size", # For backward compatibility } def __init__( self : List[Any] , _lowerCAmelCase : Optional[Any]=3_01_45 , _lowerCAmelCase : Optional[Any]=20_48 , _lowerCAmelCase : Dict=12 , _lowerCAmelCase : int=16 , _lowerCAmelCase : Tuple=0.1 , _lowerCAmelCase : List[Any]=0.1 , _lowerCAmelCase : str=True , _lowerCAmelCase : List[str]=False , _lowerCAmelCase : Tuple=False , _lowerCAmelCase : Dict=False , _lowerCAmelCase : Dict=1 , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Optional[Any]=5_12 , _lowerCAmelCase : List[Any]=20_48**-0.5 , _lowerCAmelCase : List[str]=1e-12 , _lowerCAmelCase : List[Any]=0.02 , _lowerCAmelCase : List[str]=0 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Dict=2 , _lowerCAmelCase : List[str]=3 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : Optional[int]=True , _lowerCAmelCase : Tuple="first" , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any=0.1 , _lowerCAmelCase : Tuple=5 , _lowerCAmelCase : List[str]=5 , _lowerCAmelCase : Optional[Any]=0 , _lowerCAmelCase : Tuple=0 , _lowerCAmelCase : Union[str, Any]=2 , _lowerCAmelCase : Union[str, Any]=0 , **_lowerCAmelCase : Tuple , ): __snake_case : Optional[Any] = vocab_size __snake_case : Tuple = emb_dim __snake_case : int = n_layers __snake_case : List[str] = n_heads __snake_case : Union[str, Any] = dropout __snake_case : Optional[int] = attention_dropout __snake_case : Optional[Any] = gelu_activation __snake_case : Tuple = sinusoidal_embeddings __snake_case : List[Any] = causal __snake_case : Dict = asm __snake_case : int = n_langs __snake_case : str = use_lang_emb __snake_case : Dict = layer_norm_eps __snake_case : List[Any] = bos_index __snake_case : Union[str, Any] = eos_index __snake_case : Dict = pad_index __snake_case : Any = unk_index __snake_case : Dict = mask_index __snake_case : Any = is_encoder __snake_case : Dict = max_position_embeddings __snake_case : Optional[Any] = embed_init_std __snake_case : List[Any] = init_std __snake_case : str = summary_type __snake_case : Optional[Any] = summary_use_proj __snake_case : str = summary_activation __snake_case : Optional[int] = summary_proj_to_labels __snake_case : Dict = summary_first_dropout __snake_case : Dict = start_n_top __snake_case : int = end_n_top __snake_case : str = mask_token_id __snake_case : int = lang_id if "n_words" in kwargs: __snake_case : Dict = kwargs["""n_words"""] super().__init__(pad_token_id=_lowerCAmelCase , bos_token_id=_lowerCAmelCase , **_lowerCAmelCase ) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @property def snake_case__ ( self : Dict ): if self.task == "multiple-choice": __snake_case : Optional[int] = {0: """batch""", 1: """choice""", 2: """sequence"""} else: __snake_case : Tuple = {0: """batch""", 1: """sequence"""} return OrderedDict( [ ("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis), ] )
20
1
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' # Checks if the entire collection has been sorted if len(__SCREAMING_SNAKE_CASE ) <= 1 or n <= 1: return insert_next(__SCREAMING_SNAKE_CASE , n - 1 ) rec_insertion_sort(__SCREAMING_SNAKE_CASE , n - 1 ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' # Checks order between adjacent elements if index >= len(__SCREAMING_SNAKE_CASE ) or collection[index - 1] <= collection[index]: return # Swaps adjacent elements since they are not in ascending order __snake_case , __snake_case : int = ( collection[index], collection[index - 1], ) insert_next(__SCREAMING_SNAKE_CASE , index + 1 ) if __name__ == "__main__": lowercase_ = input("Enter integers separated by spaces: ") lowercase_ = [int(num) for num in numbers.split()] rec_insertion_sort(number_list, len(number_list)) print(number_list)
20
import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase_ = logging.get_logger(__name__) lowercase_ = { "facebook/encodec_24khz": "https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json", "facebook/encodec_48khz": "https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json", } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : List[Any] = "encodec" def __init__( self : Tuple , _lowerCAmelCase : Union[str, Any]=[1.5, 3.0, 6.0, 12.0, 24.0] , _lowerCAmelCase : Tuple=2_40_00 , _lowerCAmelCase : List[Any]=1 , _lowerCAmelCase : Optional[int]=False , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : int=1_28 , _lowerCAmelCase : List[Any]=32 , _lowerCAmelCase : Optional[Any]=1 , _lowerCAmelCase : Union[str, Any]=[8, 5, 4, 2] , _lowerCAmelCase : str="weight_norm" , _lowerCAmelCase : Tuple=7 , _lowerCAmelCase : str=7 , _lowerCAmelCase : Any=3 , _lowerCAmelCase : int=2 , _lowerCAmelCase : str=True , _lowerCAmelCase : Dict="reflect" , _lowerCAmelCase : Tuple=2 , _lowerCAmelCase : List[Any]=2 , _lowerCAmelCase : int=1.0 , _lowerCAmelCase : Optional[int]=10_24 , _lowerCAmelCase : int=None , _lowerCAmelCase : List[str]=True , **_lowerCAmelCase : List[Any] , ): __snake_case : Optional[int] = target_bandwidths __snake_case : int = sampling_rate __snake_case : List[Any] = audio_channels __snake_case : str = normalize __snake_case : Union[str, Any] = chunk_length_s __snake_case : Union[str, Any] = overlap __snake_case : Union[str, Any] = hidden_size __snake_case : Union[str, Any] = num_filters __snake_case : Optional[Any] = num_residual_layers __snake_case : List[Any] = upsampling_ratios __snake_case : List[str] = norm_type __snake_case : Union[str, Any] = kernel_size __snake_case : Optional[int] = last_kernel_size __snake_case : Optional[Any] = residual_kernel_size __snake_case : Dict = dilation_growth_rate __snake_case : int = use_causal_conv __snake_case : Tuple = pad_mode __snake_case : str = compress __snake_case : Optional[Any] = num_lstm_layers __snake_case : List[Any] = trim_right_ratio __snake_case : Any = codebook_size __snake_case : int = codebook_dim if codebook_dim is not None else hidden_size __snake_case : int = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( f'''self.norm_type must be one of `"weight_norm"`, `"time_group_norm"`), got {self.norm_type}''' ) super().__init__(**_lowerCAmelCase ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def snake_case__ ( self : int ): if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def snake_case__ ( self : Union[str, Any] ): __snake_case : List[str] = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def snake_case__ ( self : Tuple ): return int(10_00 * self.target_bandwidths[-1] // (self.frame_rate * 10) )
20
1
import logging import os from .state import PartialState class SCREAMING_SNAKE_CASE__ ( logging.LoggerAdapter ): @staticmethod def snake_case__ ( _lowerCAmelCase : Union[str, Any] ): __snake_case : Dict = PartialState() return not main_process_only or (main_process_only and state.is_main_process) def snake_case__ ( self : Any , _lowerCAmelCase : int , _lowerCAmelCase : Tuple , *_lowerCAmelCase : str , **_lowerCAmelCase : str ): if PartialState._shared_state == {}: raise RuntimeError( """You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility.""" ) __snake_case : Dict = kwargs.pop("""main_process_only""" , _lowerCAmelCase ) __snake_case : List[str] = kwargs.pop("""in_order""" , _lowerCAmelCase ) if self.isEnabledFor(_lowerCAmelCase ): if self._should_log(_lowerCAmelCase ): __snake_case , __snake_case : List[str] = self.process(_lowerCAmelCase , _lowerCAmelCase ) self.logger.log(_lowerCAmelCase , _lowerCAmelCase , *_lowerCAmelCase , **_lowerCAmelCase ) elif in_order: __snake_case : List[str] = PartialState() for i in range(state.num_processes ): if i == state.process_index: __snake_case , __snake_case : Dict = self.process(_lowerCAmelCase , _lowerCAmelCase ) self.logger.log(_lowerCAmelCase , _lowerCAmelCase , *_lowerCAmelCase , **_lowerCAmelCase ) state.wait_for_everyone() def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str , __SCREAMING_SNAKE_CASE : str = None ): '''simple docstring''' if log_level is None: __snake_case : Dict = os.environ.get("""ACCELERATE_LOG_LEVEL""" , __SCREAMING_SNAKE_CASE ) __snake_case : Union[str, Any] = logging.getLogger(__SCREAMING_SNAKE_CASE ) if log_level is not None: logger.setLevel(log_level.upper() ) logger.root.setLevel(log_level.upper() ) return MultiProcessAdapter(__SCREAMING_SNAKE_CASE , {} )
20
from __future__ import annotations def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : str = [] __snake_case , __snake_case : List[str] = input_list[low:mid], input_list[mid : high + 1] while left and right: result.append((left if left[0] <= right[0] else right).pop(0 ) ) __snake_case : List[Any] = result + left + right return input_list def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list ): '''simple docstring''' if len(__SCREAMING_SNAKE_CASE ) <= 1: return input_list __snake_case : Union[str, Any] = list(__SCREAMING_SNAKE_CASE ) # iteration for two-way merging __snake_case : Tuple = 2 while p <= len(__SCREAMING_SNAKE_CASE ): # getting low, high and middle value for merge-sort of single list for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , __SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = i + p - 1 __snake_case : Optional[Any] = (low + high + 1) // 2 __snake_case : str = merge(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # final merge of last two parts if p * 2 >= len(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = i __snake_case : str = merge(__SCREAMING_SNAKE_CASE , 0 , __SCREAMING_SNAKE_CASE , len(__SCREAMING_SNAKE_CASE ) - 1 ) break p *= 2 return input_list if __name__ == "__main__": lowercase_ = input("Enter numbers separated by a comma:\n").strip() if user_input == "": lowercase_ = [] else: lowercase_ = [int(item.strip()) for item in user_input.split(",")] print(iter_merge_sort(unsorted))
20
1
import numpy as np import torch import torch.nn as nn from transformers import CLIPConfig, CLIPVisionModelWithProjection, PreTrainedModel from ...utils import logging lowercase_ = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Dict = CLIPConfig A : Any = ["CLIPEncoderLayer"] def __init__( self : str , _lowerCAmelCase : CLIPConfig ): super().__init__(_lowerCAmelCase ) __snake_case : Union[str, Any] = CLIPVisionModelWithProjection(config.vision_config ) __snake_case : List[str] = nn.Linear(config.vision_config.projection_dim , 1 ) __snake_case : int = nn.Linear(config.vision_config.projection_dim , 1 ) @torch.no_grad() def snake_case__ ( self : List[str] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : List[str] , _lowerCAmelCase : Tuple=0.5 , _lowerCAmelCase : List[str]=0.5 ): __snake_case : int = self.vision_model(_lowerCAmelCase )[0] __snake_case : Tuple = self.p_head(_lowerCAmelCase ) __snake_case : List[Any] = nsfw_detected.flatten() __snake_case : Union[str, Any] = nsfw_detected > p_threshold __snake_case : List[str] = nsfw_detected.tolist() if any(_lowerCAmelCase ): logger.warning( """Potential NSFW content was detected in one or more images. A black image will be returned instead.""" """ Try again with a different prompt and/or seed.""" ) for idx, nsfw_detected_ in enumerate(_lowerCAmelCase ): if nsfw_detected_: __snake_case : Optional[int] = np.zeros(images[idx].shape ) __snake_case : int = self.w_head(_lowerCAmelCase ) __snake_case : int = watermark_detected.flatten() __snake_case : Tuple = watermark_detected > w_threshold __snake_case : Union[str, Any] = watermark_detected.tolist() if any(_lowerCAmelCase ): logger.warning( """Potential watermarked content was detected in one or more images. A black image will be returned instead.""" """ Try again with a different prompt and/or seed.""" ) for idx, watermark_detected_ in enumerate(_lowerCAmelCase ): if watermark_detected_: __snake_case : Optional[Any] = np.zeros(images[idx].shape ) return images, nsfw_detected, watermark_detected
20
import random import sys import numpy as np from matplotlib import pyplot as plt from matplotlib.colors import ListedColormap lowercase_ = "Usage of script: script_name <size_of_canvas:int>" lowercase_ = [0] * 1_00 + [1] * 10 random.shuffle(choice) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' __snake_case : List[str] = [[False for i in range(__SCREAMING_SNAKE_CASE )] for j in range(__SCREAMING_SNAKE_CASE )] return canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' for i, row in enumerate(__SCREAMING_SNAKE_CASE ): for j, _ in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : int = bool(random.getrandbits(1 ) ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Union[str, Any] = np.array(__SCREAMING_SNAKE_CASE ) __snake_case : List[Any] = np.array(create_canvas(current_canvas.shape[0] ) ) for r, row in enumerate(__SCREAMING_SNAKE_CASE ): for c, pt in enumerate(__SCREAMING_SNAKE_CASE ): __snake_case : Optional[Any] = __judge_point( __SCREAMING_SNAKE_CASE , current_canvas[r - 1 : r + 2, c - 1 : c + 2] ) __snake_case : List[str] = next_gen_canvas del next_gen_canvas # cleaning memory as we move on. __snake_case : list[list[bool]] = current_canvas.tolist() return return_canvas def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[list[bool]] ): '''simple docstring''' __snake_case : Any = 0 __snake_case : Dict = 0 # finding dead or alive neighbours count. for i in neighbours: for status in i: if status: alive += 1 else: dead += 1 # handling duplicate entry for focus pt. if pt: alive -= 1 else: dead -= 1 # running the rules of game here. __snake_case : str = pt if pt: if alive < 2: __snake_case : Optional[Any] = False elif alive == 2 or alive == 3: __snake_case : Union[str, Any] = True elif alive > 3: __snake_case : Optional[int] = False else: if alive == 3: __snake_case : List[Any] = True return state if __name__ == "__main__": if len(sys.argv) != 2: raise Exception(usage_doc) lowercase_ = int(sys.argv[1]) # main working structure of this module. lowercase_ = create_canvas(canvas_size) seed(c) lowercase_ , lowercase_ = plt.subplots() fig.show() lowercase_ = ListedColormap(["w", "k"]) try: while True: lowercase_ = run(c) ax.matshow(c, cmap=cmap) fig.canvas.draw() ax.cla() except KeyboardInterrupt: # do nothing. pass
20
1
import argparse import json import logging import os import shutil import sys import tempfile import unittest from unittest import mock import torch from accelerate.utils import write_basic_config from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device from transformers.utils import is_apex_available logging.basicConfig(level=logging.DEBUG) lowercase_ = logging.getLogger() def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : int = argparse.ArgumentParser() parser.add_argument("""-f""" ) __snake_case : Optional[int] = parser.parse_args() return args.f def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Tuple ): '''simple docstring''' __snake_case : Optional[int] = {} __snake_case : Any = os.path.join(__SCREAMING_SNAKE_CASE , """all_results.json""" ) if os.path.exists(__SCREAMING_SNAKE_CASE ): with open(__SCREAMING_SNAKE_CASE , """r""" ) as f: __snake_case : Tuple = json.load(__SCREAMING_SNAKE_CASE ) else: raise ValueError(F'''can\'t find {path}''' ) return results def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : Any = torch.cuda.is_available() and torch_device == """cuda""" return is_using_cuda and is_apex_available() lowercase_ = logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): @classmethod def snake_case__ ( cls : Optional[Any] ): # Write Accelerate config, will pick up on CPU, GPU, and multi-GPU __snake_case : Optional[int] = tempfile.mkdtemp() __snake_case : Optional[int] = os.path.join(cls.tmpdir , """default_config.yml""" ) write_basic_config(save_location=cls.configPath ) __snake_case : List[Any] = ["""accelerate""", """launch""", """--config_file""", cls.configPath] @classmethod def snake_case__ ( cls : List[str] ): shutil.rmtree(cls.tmpdir ) @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : Tuple ): __snake_case : Optional[Any] = self.get_auto_remove_tmp_dir() __snake_case : List[str] = f''' {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py --model_name_or_path distilbert-base-uncased --output_dir {tmp_dir} --train_file ./tests/fixtures/tests_samples/MRPC/train.csv --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --learning_rate=1e-4 --seed=42 --checkpointing_steps epoch --with_tracking '''.split() if is_cuda_and_apex_available(): testargs.append("""--fp16""" ) run_command(self._launch_args + testargs ) __snake_case : List[str] = get_results(_lowerCAmelCase ) self.assertGreaterEqual(result["""eval_accuracy"""] , 0.75 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """glue_no_trainer""" ) ) ) @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : List[Any] ): __snake_case : str = self.get_auto_remove_tmp_dir() __snake_case : List[str] = f''' {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py --model_name_or_path distilgpt2 --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --block_size 128 --per_device_train_batch_size 5 --per_device_eval_batch_size 5 --num_train_epochs 2 --output_dir {tmp_dir} --checkpointing_steps epoch --with_tracking '''.split() if torch.cuda.device_count() > 1: # Skipping because there are not enough batches to train the model + would need a drop_last to work. return run_command(self._launch_args + testargs ) __snake_case : Dict = get_results(_lowerCAmelCase ) self.assertLess(result["""perplexity"""] , 1_00 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """clm_no_trainer""" ) ) ) @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : Dict ): __snake_case : List[str] = self.get_auto_remove_tmp_dir() __snake_case : Dict = f''' {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py --model_name_or_path distilroberta-base --train_file ./tests/fixtures/sample_text.txt --validation_file ./tests/fixtures/sample_text.txt --output_dir {tmp_dir} --num_train_epochs=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : List[str] = get_results(_lowerCAmelCase ) self.assertLess(result["""perplexity"""] , 42 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """mlm_no_trainer""" ) ) ) @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : Union[str, Any] ): # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu __snake_case : Any = 7 if get_gpu_count() > 1 else 2 __snake_case : Optional[int] = self.get_auto_remove_tmp_dir() __snake_case : Dict = f''' {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/conll/sample.json --validation_file tests/fixtures/tests_samples/conll/sample.json --output_dir {tmp_dir} --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=2 --num_train_epochs={epochs} --seed 7 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : int = get_results(_lowerCAmelCase ) self.assertGreaterEqual(result["""eval_accuracy"""] , 0.75 ) self.assertLess(result["""train_loss"""] , 0.5 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """ner_no_trainer""" ) ) ) @unittest.skip(reason="""Fix me @muellerzr""" ) @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : List[Any] ): __snake_case : Dict = self.get_auto_remove_tmp_dir() __snake_case : int = f''' {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py --model_name_or_path bert-base-uncased --version_2_with_negative --train_file tests/fixtures/tests_samples/SQUAD/sample.json --validation_file tests/fixtures/tests_samples/SQUAD/sample.json --output_dir {tmp_dir} --seed=42 --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Optional[int] = get_results(_lowerCAmelCase ) # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics. self.assertGreaterEqual(result["""eval_f1"""] , 28 ) self.assertGreaterEqual(result["""eval_exact"""] , 28 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """qa_no_trainer""" ) ) ) @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : Optional[int] ): __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : Optional[Any] = f''' {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py --model_name_or_path bert-base-uncased --train_file tests/fixtures/tests_samples/swag/sample.json --validation_file tests/fixtures/tests_samples/swag/sample.json --output_dir {tmp_dir} --max_train_steps=20 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Any = get_results(_lowerCAmelCase ) self.assertGreaterEqual(result["""eval_accuracy"""] , 0.8 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """swag_no_trainer""" ) ) ) @slow @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : Optional[int] ): __snake_case : Dict = self.get_auto_remove_tmp_dir() __snake_case : Any = f''' {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py --model_name_or_path t5-small --train_file tests/fixtures/tests_samples/xsum/sample.json --validation_file tests/fixtures/tests_samples/xsum/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Tuple = get_results(_lowerCAmelCase ) self.assertGreaterEqual(result["""eval_rouge1"""] , 10 ) self.assertGreaterEqual(result["""eval_rouge2"""] , 2 ) self.assertGreaterEqual(result["""eval_rougeL"""] , 7 ) self.assertGreaterEqual(result["""eval_rougeLsum"""] , 7 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """summarization_no_trainer""" ) ) ) @slow @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : List[Any] ): __snake_case : Union[str, Any] = self.get_auto_remove_tmp_dir() __snake_case : Any = f''' {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py --model_name_or_path sshleifer/student_marian_en_ro_6_1 --source_lang en --target_lang ro --train_file tests/fixtures/tests_samples/wmt16/sample.json --validation_file tests/fixtures/tests_samples/wmt16/sample.json --output_dir {tmp_dir} --max_train_steps=50 --num_warmup_steps=8 --num_beams=6 --learning_rate=3e-3 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --source_lang en_XX --target_lang ro_RO --checkpointing_steps epoch --with_tracking '''.split() run_command(self._launch_args + testargs ) __snake_case : Dict = get_results(_lowerCAmelCase ) self.assertGreaterEqual(result["""eval_bleu"""] , 30 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """epoch_0""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """translation_no_trainer""" ) ) ) @slow def snake_case__ ( self : List[Any] ): __snake_case : Optional[int] = logging.StreamHandler(sys.stdout ) logger.addHandler(_lowerCAmelCase ) __snake_case : Any = self.get_auto_remove_tmp_dir() __snake_case : Optional[int] = f''' {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py --dataset_name huggingface/semantic-segmentation-test-sample --output_dir {tmp_dir} --max_train_steps=10 --num_warmup_steps=2 --learning_rate=2e-4 --per_device_train_batch_size=2 --per_device_eval_batch_size=1 --checkpointing_steps epoch '''.split() run_command(self._launch_args + testargs ) __snake_case : Dict = get_results(_lowerCAmelCase ) self.assertGreaterEqual(result["""eval_overall_accuracy"""] , 0.10 ) @mock.patch.dict(os.environ , {"""WANDB_MODE""": """offline"""} ) def snake_case__ ( self : str ): __snake_case : Tuple = self.get_auto_remove_tmp_dir() __snake_case : Tuple = f''' {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py --model_name_or_path google/vit-base-patch16-224-in21k --dataset_name hf-internal-testing/cats_vs_dogs_sample --learning_rate 1e-4 --per_device_train_batch_size 2 --per_device_eval_batch_size 1 --max_train_steps 2 --train_val_split 0.1 --seed 42 --output_dir {tmp_dir} --with_tracking --checkpointing_steps 1 '''.split() if is_cuda_and_apex_available(): testargs.append("""--fp16""" ) run_command(self._launch_args + testargs ) __snake_case : Tuple = get_results(_lowerCAmelCase ) # The base model scores a 25% self.assertGreaterEqual(result["""eval_accuracy"""] , 0.6 ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """step_1""" ) ) ) self.assertTrue(os.path.exists(os.path.join(_lowerCAmelCase , """image_classification_no_trainer""" ) ) )
20
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def __lowerCAmelCase ( *__SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : Optional[Union[Dict, Any]] = None , __SCREAMING_SNAKE_CASE : Any=True , __SCREAMING_SNAKE_CASE : int=2 ): '''simple docstring''' from .. import __version__ __snake_case : List[Any] = take_from __snake_case : List[Any] = () if not isinstance(args[0] , __SCREAMING_SNAKE_CASE ): __snake_case : str = (args,) for attribute, version_name, message in args: if version.parse(version.parse(__SCREAMING_SNAKE_CASE ).base_version ) >= version.parse(__SCREAMING_SNAKE_CASE ): raise ValueError( F'''The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers\'''' F''' version {__version__} is >= {version_name}''' ) __snake_case : Optional[Any] = None if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(__SCREAMING_SNAKE_CASE ),) __snake_case : Optional[Any] = F'''The `{attribute}` argument is deprecated and will be removed in version {version_name}.''' elif hasattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): values += (getattr(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ),) __snake_case : Any = F'''The `{attribute}` attribute is deprecated and will be removed in version {version_name}.''' elif deprecated_kwargs is None: __snake_case : Tuple = F'''`{attribute}` is deprecated and will be removed in version {version_name}.''' if warning is not None: __snake_case : Optional[Any] = warning + """ """ if standard_warn else """""" warnings.warn(warning + message , __SCREAMING_SNAKE_CASE , stacklevel=__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) and len(__SCREAMING_SNAKE_CASE ) > 0: __snake_case : Dict = inspect.getouterframes(inspect.currentframe() )[1] __snake_case : int = call_frame.filename __snake_case : int = call_frame.lineno __snake_case : List[str] = call_frame.function __snake_case , __snake_case : List[Any] = next(iter(deprecated_kwargs.items() ) ) raise TypeError(F'''{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`''' ) if len(__SCREAMING_SNAKE_CASE ) == 0: return elif len(__SCREAMING_SNAKE_CASE ) == 1: return values[0] return values
20
1
from typing import Tuple, Union from ...modeling_outputs import BackboneOutput from ...modeling_utils import PreTrainedModel from ...utils import is_timm_available, is_torch_available, requires_backends from ...utils.backbone_utils import BackboneMixin from .configuration_timm_backbone import TimmBackboneConfig if is_timm_available(): import timm if is_torch_available(): from torch import Tensor class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase , __UpperCamelCase ): A : Union[str, Any] = "pixel_values" A : Union[str, Any] = False A : str = TimmBackboneConfig def __init__( self : Tuple , _lowerCAmelCase : Optional[int] , **_lowerCAmelCase : Any ): requires_backends(self , """timm""" ) super().__init__(_lowerCAmelCase ) __snake_case : str = config if config.backbone is None: raise ValueError("""backbone is not set in the config. Please set it to a timm model name.""" ) if config.backbone not in timm.list_models(): raise ValueError(f'''backbone {config.backbone} is not supported by timm.''' ) if hasattr(_lowerCAmelCase , """out_features""" ) and config.out_features is not None: raise ValueError("""out_features is not supported by TimmBackbone. Please use out_indices instead.""" ) __snake_case : List[Any] = getattr(_lowerCAmelCase , """use_pretrained_backbone""" , _lowerCAmelCase ) if pretrained is None: raise ValueError("""use_pretrained_backbone is not set in the config. Please set it to True or False.""" ) # We just take the final layer by default. This matches the default for the transformers models. __snake_case : Tuple = config.out_indices if getattr(_lowerCAmelCase , """out_indices""" , _lowerCAmelCase ) is not None else (-1,) __snake_case : Any = timm.create_model( config.backbone , pretrained=_lowerCAmelCase , features_only=config.features_only , in_chans=config.num_channels , out_indices=_lowerCAmelCase , **_lowerCAmelCase , ) # These are used to control the output of the model when called. If output_hidden_states is True, then # return_layers is modified to include all layers. __snake_case : Optional[int] = self._backbone.return_layers __snake_case : Dict = {layer["""module"""]: str(_lowerCAmelCase ) for i, layer in enumerate(self._backbone.feature_info.info )} super()._init_backbone(_lowerCAmelCase ) @classmethod def snake_case__ ( cls : Optional[Any] , _lowerCAmelCase : List[Any] , *_lowerCAmelCase : str , **_lowerCAmelCase : List[str] ): requires_backends(cls , ["""vision""", """timm"""] ) from ...models.timm_backbone import TimmBackboneConfig __snake_case : List[str] = kwargs.pop("""config""" , TimmBackboneConfig() ) __snake_case : Optional[Any] = kwargs.pop("""use_timm_backbone""" , _lowerCAmelCase ) if not use_timm: raise ValueError("""use_timm_backbone must be True for timm backbones""" ) __snake_case : int = kwargs.pop("""num_channels""" , config.num_channels ) __snake_case : List[Any] = kwargs.pop("""features_only""" , config.features_only ) __snake_case : List[str] = kwargs.pop("""use_pretrained_backbone""" , config.use_pretrained_backbone ) __snake_case : Union[str, Any] = kwargs.pop("""out_indices""" , config.out_indices ) __snake_case : List[Any] = TimmBackboneConfig( backbone=_lowerCAmelCase , num_channels=_lowerCAmelCase , features_only=_lowerCAmelCase , use_pretrained_backbone=_lowerCAmelCase , out_indices=_lowerCAmelCase , ) return super()._from_config(_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : Optional[int] ): pass def snake_case__ ( self : int , _lowerCAmelCase : List[str] , _lowerCAmelCase : Optional[int]=None , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : List[str]=None , **_lowerCAmelCase : int ): __snake_case : Union[str, Any] = return_dict if return_dict is not None else self.config.use_return_dict __snake_case : int = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) __snake_case : Union[str, Any] = output_attentions if output_attentions is not None else self.config.output_attentions if output_attentions: raise ValueError("""Cannot output attentions for timm backbones at the moment""" ) if output_hidden_states: # We modify the return layers to include all the stages of the backbone __snake_case : Tuple = self._all_layers __snake_case : Union[str, Any] = self._backbone(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Any = self._return_layers __snake_case : Any = tuple(hidden_states[i] for i in self.out_indices ) else: __snake_case : Union[str, Any] = self._backbone(_lowerCAmelCase , **_lowerCAmelCase ) __snake_case : Any = None __snake_case : str = tuple(_lowerCAmelCase ) __snake_case : Tuple = tuple(_lowerCAmelCase ) if hidden_states is not None else None if not return_dict: __snake_case : Any = (feature_maps,) if output_hidden_states: __snake_case : int = output + (hidden_states,) return output return BackboneOutput(feature_maps=_lowerCAmelCase , hidden_states=_lowerCAmelCase , attentions=_lowerCAmelCase )
20
import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() lowercase_ = { "bart": ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), "bert": ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-uncased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-large-cased-whole-word-masking-finetuned-squad": ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "bert-base-cased-finetuned-mrpc": ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "dpr": ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), "gpt2": ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlnet": ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm": ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "xlm-roberta": ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "transfo-xl": ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "openai-gpt": ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "roberta": ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "layoutlm": ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), "roberta-large-mnli": ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "camembert": ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "flaubert": ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert": ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "distilbert-base-distilled-squad": ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert": ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "lxmert-visual-feature-encoder": ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "ctrl": ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "albert": ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "t5": ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "electra": ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), "wav2vec2": ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[Any] , __SCREAMING_SNAKE_CASE : Optional[int] , __SCREAMING_SNAKE_CASE : Any , __SCREAMING_SNAKE_CASE : Union[str, Any] , __SCREAMING_SNAKE_CASE : List[str]=False , __SCREAMING_SNAKE_CASE : List[Any]=True ): '''simple docstring''' if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case : Any = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) __snake_case : Dict = config_class.from_json_file(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = True __snake_case : Union[str, Any] = True print(F'''Building TensorFlow model from configuration: {config}''' ) __snake_case : List[Any] = model_class(__SCREAMING_SNAKE_CASE ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): __snake_case : Optional[Any] = cached_file( __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: __snake_case : List[Any] = load_pytorch_checkpoint_in_tfa_model(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) if compare_with_pt_model: __snake_case : Tuple = tf_model(tf_model.dummy_inputs , training=__SCREAMING_SNAKE_CASE ) # build the network __snake_case : List[str] = torch.load(__SCREAMING_SNAKE_CASE , map_location="""cpu""" ) __snake_case : Any = pt_model_class.from_pretrained( pretrained_model_name_or_path=__SCREAMING_SNAKE_CASE , config=__SCREAMING_SNAKE_CASE , state_dict=__SCREAMING_SNAKE_CASE ) with torch.no_grad(): __snake_case : Union[str, Any] = pt_model(**pt_model.dummy_inputs ) __snake_case : Any = pto[0].numpy() __snake_case : Optional[int] = tfo[0].numpy() __snake_case : Optional[int] = np.amax(np.abs(np_pt - np_tf ) ) print(F'''Max absolute difference between models outputs {diff}''' ) assert diff <= 2E-2, F'''Error, model absolute difference is >2e-2: {diff}''' # Save pytorch-model print(F'''Save TensorFlow model to {tf_dump_path}''' ) tf_model.save_weights(__SCREAMING_SNAKE_CASE , save_format="""h5""" ) def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : List[str]=None , __SCREAMING_SNAKE_CASE : Any=None , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : Tuple=False , __SCREAMING_SNAKE_CASE : List[Any]=False , __SCREAMING_SNAKE_CASE : Any=False , ): '''simple docstring''' if args_model_type is None: __snake_case : Tuple = list(MODEL_CLASSES.keys() ) else: __snake_case : Union[str, Any] = [args_model_type] for j, model_type in enumerate(__SCREAMING_SNAKE_CASE , start=1 ): print("""=""" * 1_0_0 ) print(F''' Converting model type {j}/{len(__SCREAMING_SNAKE_CASE )}: {model_type}''' ) print("""=""" * 1_0_0 ) if model_type not in MODEL_CLASSES: raise ValueError(F'''Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}.''' ) __snake_case , __snake_case , __snake_case , __snake_case , __snake_case : Optional[int] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: __snake_case : int = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: __snake_case : Union[str, Any] = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , start=1 ): print("""-""" * 1_0_0 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(F''' Skipping finetuned checkpoint {model_shortcut_name}''' ) continue __snake_case : List[Any] = model_shortcut_name elif only_convert_finetuned_models: print(F''' Skipping not finetuned checkpoint {model_shortcut_name}''' ) continue print( F''' Converting checkpoint {i}/{len(__SCREAMING_SNAKE_CASE )}: {model_shortcut_name} - model_type {model_type}''' ) print("""-""" * 1_0_0 ) if config_shortcut_name in aws_config_map: __snake_case : int = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : Dict = config_shortcut_name if model_shortcut_name in aws_model_maps: __snake_case : Union[str, Any] = cached_file(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , force_download=not use_cached_models ) else: __snake_case : List[Any] = model_shortcut_name if os.path.isfile(__SCREAMING_SNAKE_CASE ): __snake_case : List[str] = """converted_model""" convert_pt_checkpoint_to_tf( model_type=__SCREAMING_SNAKE_CASE , pytorch_checkpoint_path=__SCREAMING_SNAKE_CASE , config_file=__SCREAMING_SNAKE_CASE , tf_dump_path=os.path.join(__SCREAMING_SNAKE_CASE , model_shortcut_name + """-tf_model.h5""" ) , compare_with_pt_model=__SCREAMING_SNAKE_CASE , ) if remove_cached_files: os.remove(__SCREAMING_SNAKE_CASE ) os.remove(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--tf_dump_path", default=None, type=str, required=True, help="Path to the output Tensorflow dump file." ) parser.add_argument( "--model_type", default=None, type=str, help=( F'''Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ''' "convert all the models from AWS." ), ) parser.add_argument( "--pytorch_checkpoint_path", default=None, type=str, help=( "Path to the PyTorch checkpoint path or shortcut name to download from AWS. " "If not given, will download and convert all the checkpoints from AWS." ), ) parser.add_argument( "--config_file", default=None, type=str, help=( "The config json file corresponding to the pre-trained model. \n" "This specifies the model architecture. If not given and " "--pytorch_checkpoint_path is not given or is a shortcut name " "use the configuration associated to the shortcut name on the AWS" ), ) parser.add_argument( "--compare_with_pt_model", action="store_true", help="Compare Tensorflow and PyTorch model predictions." ) parser.add_argument( "--use_cached_models", action="store_true", help="Use cached models if possible instead of updating to latest checkpoint versions.", ) parser.add_argument( "--remove_cached_files", action="store_true", help="Remove pytorch models after conversion (save memory when converting in batches).", ) parser.add_argument("--only_convert_finetuned_models", action="store_true", help="Only convert finetuned models.") lowercase_ = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
20
1
def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int = 1_0_0_0_0_0_0 ): '''simple docstring''' __snake_case : Any = 1 __snake_case : Optional[int] = 1 __snake_case : List[Any] = {1: 1} for inputa in range(2 , __SCREAMING_SNAKE_CASE ): __snake_case : str = 0 __snake_case : Dict = inputa while True: if number in counters: counter += counters[number] break if number % 2 == 0: number //= 2 counter += 1 else: __snake_case : Union[str, Any] = (3 * number) + 1 counter += 1 if inputa not in counters: __snake_case : List[Any] = counter if counter > pre_counter: __snake_case : Tuple = inputa __snake_case : Union[str, Any] = counter return largest_number if __name__ == "__main__": print(solution(int(input().strip())))
20
import random def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' __snake_case , __snake_case , __snake_case : Tuple = [], [], [] for element in data: if element < pivot: less.append(__SCREAMING_SNAKE_CASE ) elif element > pivot: greater.append(__SCREAMING_SNAKE_CASE ) else: equal.append(__SCREAMING_SNAKE_CASE ) return less, equal, greater def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : list , __SCREAMING_SNAKE_CASE : int ): '''simple docstring''' # index = len(items) // 2 when trying to find the median # (value of index when items is sorted) # invalid input if index >= len(__SCREAMING_SNAKE_CASE ) or index < 0: return None __snake_case : int = items[random.randint(0 , len(__SCREAMING_SNAKE_CASE ) - 1 )] __snake_case : Tuple = 0 __snake_case , __snake_case , __snake_case : List[str] = _partition(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = len(__SCREAMING_SNAKE_CASE ) __snake_case : int = len(__SCREAMING_SNAKE_CASE ) # index is the pivot if m <= index < m + count: return pivot # must be in smaller elif m > index: return quick_select(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # must be in larger else: return quick_select(__SCREAMING_SNAKE_CASE , index - (m + count) )
20
1
import argparse import json from typing import List from ltp import LTP from transformers.models.bert.tokenization_bert import BertTokenizer def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Optional[int] ): '''simple docstring''' # This defines a "chinese character" as anything in the CJK Unicode block: # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) # # Note that the CJK Unicode block is NOT all Japanese and Korean characters, # despite its name. The modern Korean Hangul alphabet is a different block, # as is Japanese Hiragana and Katakana. Those alphabets are used to write # space-separated words, so they are not treated specially and handled # like the all of the other languages. if ( (cp >= 0X4_E_0_0 and cp <= 0X9_F_F_F) or (cp >= 0X3_4_0_0 and cp <= 0X4_D_B_F) # or (cp >= 0X2_0_0_0_0 and cp <= 0X2_A_6_D_F) # or (cp >= 0X2_A_7_0_0 and cp <= 0X2_B_7_3_F) # or (cp >= 0X2_B_7_4_0 and cp <= 0X2_B_8_1_F) # or (cp >= 0X2_B_8_2_0 and cp <= 0X2_C_E_A_F) # or (cp >= 0XF_9_0_0 and cp <= 0XF_A_F_F) or (cp >= 0X2_F_8_0_0 and cp <= 0X2_F_A_1_F) # ): # return True return False def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : str ): '''simple docstring''' # word like '180' or '身高' or '神' for char in word: __snake_case : str = ord(__SCREAMING_SNAKE_CASE ) if not _is_chinese_char(__SCREAMING_SNAKE_CASE ): return 0 return 1 def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] ): '''simple docstring''' __snake_case : str = set() for token in tokens: __snake_case : Optional[Any] = len(__SCREAMING_SNAKE_CASE ) > 1 and is_chinese(__SCREAMING_SNAKE_CASE ) if chinese_word: word_set.add(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = list(__SCREAMING_SNAKE_CASE ) return word_list def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : set() ): '''simple docstring''' if not chinese_word_set: return bert_tokens __snake_case : str = max([len(__SCREAMING_SNAKE_CASE ) for w in chinese_word_set] ) __snake_case : Tuple = bert_tokens __snake_case , __snake_case : Optional[int] = 0, len(__SCREAMING_SNAKE_CASE ) while start < end: __snake_case : Tuple = True if is_chinese(bert_word[start] ): __snake_case : Optional[int] = min(end - start , __SCREAMING_SNAKE_CASE ) for i in range(__SCREAMING_SNAKE_CASE , 1 , -1 ): __snake_case : Any = """""".join(bert_word[start : start + i] ) if whole_word in chinese_word_set: for j in range(start + 1 , start + i ): __snake_case : str = """##""" + bert_word[j] __snake_case : List[Any] = start + i __snake_case : Optional[int] = False break if single_word: start += 1 return bert_word def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : List[str] , __SCREAMING_SNAKE_CASE : LTP , __SCREAMING_SNAKE_CASE : BertTokenizer ): '''simple docstring''' __snake_case : Dict = [] for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , 1_0_0 ): __snake_case : Optional[int] = ltp_tokenizer.pipeline(lines[i : i + 1_0_0] , tasks=["""cws"""] ).cws __snake_case : int = [get_chinese_word(__SCREAMING_SNAKE_CASE ) for r in res] ltp_res.extend(__SCREAMING_SNAKE_CASE ) assert len(__SCREAMING_SNAKE_CASE ) == len(__SCREAMING_SNAKE_CASE ) __snake_case : str = [] for i in range(0 , len(__SCREAMING_SNAKE_CASE ) , 1_0_0 ): __snake_case : Optional[int] = bert_tokenizer(lines[i : i + 1_0_0] , add_special_tokens=__SCREAMING_SNAKE_CASE , truncation=__SCREAMING_SNAKE_CASE , max_length=5_1_2 ) bert_res.extend(res["""input_ids"""] ) assert len(__SCREAMING_SNAKE_CASE ) == len(__SCREAMING_SNAKE_CASE ) __snake_case : Optional[Any] = [] for input_ids, chinese_word in zip(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): __snake_case : List[str] = [] for id in input_ids: __snake_case : List[Any] = bert_tokenizer._convert_id_to_token(__SCREAMING_SNAKE_CASE ) input_tokens.append(__SCREAMING_SNAKE_CASE ) __snake_case : Tuple = add_sub_symbol(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) __snake_case : Dict = [] # We only save pos of chinese subwords start with ##, which mean is part of a whole word. for i, token in enumerate(__SCREAMING_SNAKE_CASE ): if token[:2] == "##": __snake_case : int = token[2:] # save chinese tokens' pos if len(__SCREAMING_SNAKE_CASE ) == 1 and _is_chinese_char(ord(__SCREAMING_SNAKE_CASE ) ): ref_id.append(__SCREAMING_SNAKE_CASE ) ref_ids.append(__SCREAMING_SNAKE_CASE ) assert len(__SCREAMING_SNAKE_CASE ) == len(__SCREAMING_SNAKE_CASE ) return ref_ids def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : Union[str, Any] ): '''simple docstring''' # For Chinese (Ro)Bert, the best result is from : RoBERTa-wwm-ext (https://github.com/ymcui/Chinese-BERT-wwm) # If we want to fine-tune these model, we have to use same tokenizer : LTP (https://github.com/HIT-SCIR/ltp) with open(args.file_name , """r""" , encoding="""utf-8""" ) as f: __snake_case : str = f.readlines() __snake_case : int = [line.strip() for line in data if len(__SCREAMING_SNAKE_CASE ) > 0 and not line.isspace()] # avoid delimiter like '\u2029' __snake_case : List[str] = LTP(args.ltp ) # faster in GPU device __snake_case : Any = BertTokenizer.from_pretrained(args.bert ) __snake_case : Tuple = prepare_ref(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) with open(args.save_path , """w""" , encoding="""utf-8""" ) as f: __snake_case : str = [json.dumps(__SCREAMING_SNAKE_CASE ) + """\n""" for ref in ref_ids] f.writelines(__SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser(description="prepare_chinese_ref") parser.add_argument( "--file_name", required=False, type=str, default="./resources/chinese-demo.txt", help="file need process, same as training data in lm", ) parser.add_argument( "--ltp", required=False, type=str, default="./resources/ltp", help="resources for LTP tokenizer, usually a path", ) parser.add_argument( "--bert", required=False, type=str, default="./resources/robert", help="resources for Bert tokenizer", ) parser.add_argument( "--save_path", required=False, type=str, default="./resources/ref.txt", help="path to save res", ) lowercase_ = parser.parse_args() main(args)
20
import json from typing import List, Optional, Tuple from tokenizers import normalizers from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_roformer import RoFormerTokenizer from .tokenization_utils import JiebaPreTokenizer lowercase_ = logging.get_logger(__name__) lowercase_ = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} lowercase_ = { "vocab_file": { "junnyu/roformer_chinese_small": "https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt", "junnyu/roformer_chinese_base": "https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt", "junnyu/roformer_chinese_char_small": ( "https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt" ), "junnyu/roformer_chinese_char_base": ( "https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt" ), "junnyu/roformer_small_discriminator": ( "https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt" ), "junnyu/roformer_small_generator": ( "https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt" ), } } lowercase_ = { "junnyu/roformer_chinese_small": 15_36, "junnyu/roformer_chinese_base": 15_36, "junnyu/roformer_chinese_char_small": 5_12, "junnyu/roformer_chinese_char_base": 5_12, "junnyu/roformer_small_discriminator": 1_28, "junnyu/roformer_small_generator": 1_28, } lowercase_ = { "junnyu/roformer_chinese_small": {"do_lower_case": True}, "junnyu/roformer_chinese_base": {"do_lower_case": True}, "junnyu/roformer_chinese_char_small": {"do_lower_case": True}, "junnyu/roformer_chinese_char_base": {"do_lower_case": True}, "junnyu/roformer_small_discriminator": {"do_lower_case": True}, "junnyu/roformer_small_generator": {"do_lower_case": True}, } class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = VOCAB_FILES_NAMES A : Optional[int] = PRETRAINED_VOCAB_FILES_MAP A : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : int = PRETRAINED_INIT_CONFIGURATION A : List[str] = RoFormerTokenizer def __init__( self : Optional[Any] , _lowerCAmelCase : Dict=None , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : List[Any]=True , _lowerCAmelCase : Any="[UNK]" , _lowerCAmelCase : int="[SEP]" , _lowerCAmelCase : Optional[int]="[PAD]" , _lowerCAmelCase : Optional[int]="[CLS]" , _lowerCAmelCase : Optional[Any]="[MASK]" , _lowerCAmelCase : Optional[Any]=True , _lowerCAmelCase : Optional[Any]=None , **_lowerCAmelCase : Dict , ): super().__init__( _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , do_lower_case=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , tokenize_chinese_chars=_lowerCAmelCase , strip_accents=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : Dict = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( pre_tok_state.get("""lowercase""" , _lowerCAmelCase ) != do_lower_case or pre_tok_state.get("""strip_accents""" , _lowerCAmelCase ) != strip_accents ): __snake_case : Tuple = getattr(_lowerCAmelCase , pre_tok_state.pop("""type""" ) ) __snake_case : List[Any] = do_lower_case __snake_case : Optional[Any] = strip_accents __snake_case : List[str] = pre_tok_class(**_lowerCAmelCase ) __snake_case : Optional[Any] = do_lower_case def __getstate__( self : Optional[Any] ): __snake_case : Optional[int] = self.__dict__.copy() __snake_case : Optional[Any] = BertPreTokenizer() return state def __setstate__( self : str , _lowerCAmelCase : Dict ): __snake_case : str = d __snake_case : int = self.__dict__["""_tokenizer"""].get_vocab() __snake_case : List[str] = PreTokenizer.custom(JiebaPreTokenizer(_lowerCAmelCase ) ) def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Optional[int]=None ): __snake_case : Dict = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : Optional[int] = [self.sep_token_id] __snake_case : Union[str, Any] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : int = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase ) def snake_case__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Tuple=None , _lowerCAmelCase : Union[str, Any]=False , **_lowerCAmelCase : Tuple , ): __snake_case : Tuple = BertPreTokenizer() return super().save_pretrained(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase )
20
1
import json from typing import TYPE_CHECKING, List, Optional, Tuple from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_blenderbot import BlenderbotTokenizer if TYPE_CHECKING: from transformers.pipelines.conversational import Conversation lowercase_ = logging.get_logger(__name__) lowercase_ = { "vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_config_file": "tokenizer_config.json", } lowercase_ = { "vocab_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"}, "merges_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"}, "tokenizer_config_file": { "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json" }, } lowercase_ = {"facebook/blenderbot-3B": 1_28} class SCREAMING_SNAKE_CASE__ ( __UpperCamelCase ): A : Optional[int] = VOCAB_FILES_NAMES A : int = PRETRAINED_VOCAB_FILES_MAP A : List[str] = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A : List[str] = ["input_ids", "attention_mask"] A : str = BlenderbotTokenizer def __init__( self : Optional[int] , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : int=None , _lowerCAmelCase : List[Any]="replace" , _lowerCAmelCase : Union[str, Any]="<s>" , _lowerCAmelCase : int="</s>" , _lowerCAmelCase : int="</s>" , _lowerCAmelCase : Any="<s>" , _lowerCAmelCase : str="<unk>" , _lowerCAmelCase : Optional[Any]="<pad>" , _lowerCAmelCase : str="<mask>" , _lowerCAmelCase : Dict=False , _lowerCAmelCase : List[Any]=True , **_lowerCAmelCase : int , ): super().__init__( _lowerCAmelCase , _lowerCAmelCase , tokenizer_file=_lowerCAmelCase , errors=_lowerCAmelCase , bos_token=_lowerCAmelCase , eos_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , unk_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , add_prefix_space=_lowerCAmelCase , trim_offsets=_lowerCAmelCase , **_lowerCAmelCase , ) __snake_case : List[str] = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get("""add_prefix_space""" , _lowerCAmelCase ) != add_prefix_space: __snake_case : Dict = getattr(_lowerCAmelCase , pre_tok_state.pop("""type""" ) ) __snake_case : Optional[int] = add_prefix_space __snake_case : Dict = pre_tok_class(**_lowerCAmelCase ) __snake_case : List[str] = add_prefix_space __snake_case : Union[str, Any] = """post_processor""" __snake_case : Optional[int] = getattr(self.backend_tokenizer , _lowerCAmelCase , _lowerCAmelCase ) if tokenizer_component_instance: __snake_case : Optional[int] = json.loads(tokenizer_component_instance.__getstate__() ) # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class` if "sep" in state: __snake_case : str = tuple(state["""sep"""] ) if "cls" in state: __snake_case : List[str] = tuple(state["""cls"""] ) __snake_case : str = False if state.get("""add_prefix_space""" , _lowerCAmelCase ) != add_prefix_space: __snake_case : Optional[Any] = add_prefix_space __snake_case : Tuple = True if state.get("""trim_offsets""" , _lowerCAmelCase ) != trim_offsets: __snake_case : Dict = trim_offsets __snake_case : Dict = True if changes_to_apply: __snake_case : Any = getattr(_lowerCAmelCase , state.pop("""type""" ) ) __snake_case : int = component_class(**_lowerCAmelCase ) setattr(self.backend_tokenizer , _lowerCAmelCase , _lowerCAmelCase ) @property # Copied from transformers.models.roberta.tokenization_roberta_fast.RobertaTokenizerFast.mask_token with Roberta->Blenderbot, RoBERTa->Blenderbot def snake_case__ ( self : Union[str, Any] ): if self._mask_token is None: if self.verbose: logger.error("""Using mask_token, but it is not set yet.""" ) return None return str(self._mask_token ) @mask_token.setter def snake_case__ ( self : Union[str, Any] , _lowerCAmelCase : Dict ): __snake_case : Dict = AddedToken(_lowerCAmelCase , lstrip=_lowerCAmelCase , rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ) else value __snake_case : Optional[Any] = value def snake_case__ ( self : List[Any] , *_lowerCAmelCase : List[Any] , **_lowerCAmelCase : str ): __snake_case : List[str] = kwargs.get("""is_split_into_words""" , _lowerCAmelCase ) assert self.add_prefix_space or not is_split_into_words, ( f'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True ''' "to use it with pretokenized inputs." ) return super()._batch_encode_plus(*_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : Tuple , *_lowerCAmelCase : Union[str, Any] , **_lowerCAmelCase : List[str] ): __snake_case : List[Any] = kwargs.get("""is_split_into_words""" , _lowerCAmelCase ) assert self.add_prefix_space or not is_split_into_words, ( f'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True ''' "to use it with pretokenized inputs." ) return super()._encode_plus(*_lowerCAmelCase , **_lowerCAmelCase ) def snake_case__ ( self : str , _lowerCAmelCase : str , _lowerCAmelCase : Optional[str] = None ): __snake_case : Tuple = self._tokenizer.model.save(_lowerCAmelCase , name=_lowerCAmelCase ) return tuple(_lowerCAmelCase ) def snake_case__ ( self : Optional[int] , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): __snake_case : str = [self.sep_token_id] __snake_case : List[str] = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def snake_case__ ( self : str , _lowerCAmelCase : List[int] , _lowerCAmelCase : Optional[List[int]] = None ): return token_ids_a + [self.eos_token_id] def snake_case__ ( self : Optional[Any] , _lowerCAmelCase : "Conversation" ): __snake_case : Dict = [] for is_user, text in conversation.iter_texts(): if is_user: # We need to space prefix as it's being done within blenderbot inputs.append(""" """ + text ) else: # Generated responses should contain them already. inputs.append(_lowerCAmelCase ) __snake_case : Any = """ """.join(_lowerCAmelCase ) __snake_case : List[Any] = self.encode(_lowerCAmelCase ) if len(_lowerCAmelCase ) > self.model_max_length: __snake_case : int = input_ids[-self.model_max_length :] logger.warning(f'''Trimmed input from conversation as it was longer than {self.model_max_length} tokens.''' ) return input_ids
20
from __future__ import annotations import math def __lowerCAmelCase ( __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : int , __SCREAMING_SNAKE_CASE : bool , __SCREAMING_SNAKE_CASE : list[int] , __SCREAMING_SNAKE_CASE : float ): '''simple docstring''' if depth < 0: raise ValueError("""Depth cannot be less than 0""" ) if len(__SCREAMING_SNAKE_CASE ) == 0: raise ValueError("""Scores cannot be empty""" ) if depth == height: return scores[node_index] if is_max: return max( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) return min( minimax(depth + 1 , node_index * 2 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , minimax(depth + 1 , node_index * 2 + 1 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) , ) def __lowerCAmelCase ( ): '''simple docstring''' __snake_case : str = [9_0, 2_3, 6, 3_3, 2_1, 6_5, 1_2_3, 3_4_4_2_3] __snake_case : Optional[Any] = math.log(len(__SCREAMING_SNAKE_CASE ) , 2 ) print("""Optimal value : """ , end="""""" ) print(minimax(0 , 0 , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
20
1