code
stringlengths
82
54.1k
code_codestyle
int64
0
699
style_context
stringlengths
111
35.6k
style_context_codestyle
int64
0
699
label
int64
0
1
import argparse from collections import defaultdict def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase): UpperCamelCase_ = f"""{file}_{class_name}_{test_name}""" done_test[_id] += 1 with open(__lowercase , 'r') as f: UpperCamelCase_ = f.readlines() UpperCamelCase_ = f"""class {class_name}(""" UpperCamelCase_ = f"""{4 * " "}def {test_name}(""" UpperCamelCase_ = f"""{8 * " "}{correct_line.split()[0]}""" UpperCamelCase_ = f"""{16 * " "}{correct_line.split()[0]}""" UpperCamelCase_ = False UpperCamelCase_ = False UpperCamelCase_ = False UpperCamelCase_ = False UpperCamelCase_ = 0 UpperCamelCase_ = 0 UpperCamelCase_ = [] for line in lines: if line.startswith(__lowercase): UpperCamelCase_ = True elif in_class and line.startswith(__lowercase): UpperCamelCase_ = True elif in_class and in_func and (line.startswith(__lowercase) or line.startswith(__lowercase)): UpperCamelCase_ = len(line.split(correct_line.split()[0])[0]) count += 1 if count == done_test[_id]: UpperCamelCase_ = True if in_class and in_func and in_line: if ")" not in line: continue else: UpperCamelCase_ = True if in_class and in_func and in_line and insert_line: new_lines.append(f"""{spaces * " "}{correct_line}""") UpperCamelCase_ = UpperCamelCase_ = UpperCamelCase_ = UpperCamelCase_ = False else: new_lines.append(__lowercase) with open(__lowercase , 'w') as f: for line in new_lines: f.write(__lowercase) def _snake_case (__lowercase , __lowercase=None): if fail is not None: with open(__lowercase , 'r') as f: UpperCamelCase_ = {l.strip() for l in f.readlines()} else: UpperCamelCase_ = None with open(__lowercase , 'r') as f: UpperCamelCase_ = f.readlines() UpperCamelCase_ = defaultdict(__lowercase) for line in correct_lines: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = line.split(';') if test_failures is None or "::".join([file, class_name, test_name]) in test_failures: overwrite_file(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase) if __name__ == "__main__": snake_case__ : Optional[Any] = argparse.ArgumentParser() parser.add_argument("""--correct_filename""", help="""filename of tests with expected result""") parser.add_argument("""--fail_filename""", help="""filename of test failures""", type=str, default=None) snake_case__ : Optional[int] = parser.parse_args() main(args.correct_filename, args.fail_filename)
23
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Optional[int] = { """configuration_pegasus_x""": ["""PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusXConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST""", """PegasusXForConditionalGeneration""", """PegasusXModel""", """PegasusXPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys snake_case__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
1
# Lint as: python3 import dataclasses import re from dataclasses import dataclass from functools import total_ordering from typing import Optional, Union snake_case__ : List[str] = re.compile(R"""^(?P<major>\d+)""" R"""\.(?P<minor>\d+)""" R"""\.(?P<patch>\d+)$""") @total_ordering @dataclass class _a : """simple docstring""" A_ = 42 A_ = None A_ = None A_ = None A_ = None def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = _str_to_version_tuple(self.version_str ) def __repr__( self ) -> Union[str, Any]: return f"""{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}""" @property def _UpperCAmelCase ( self ) -> int: return self.major, self.minor, self.patch def _UpperCAmelCase ( self , _UpperCAmelCase ) -> str: if isinstance(_UpperCAmelCase , _UpperCAmelCase ): return Version(_UpperCAmelCase ) elif isinstance(_UpperCAmelCase , _UpperCAmelCase ): return other raise TypeError(f"""{other} (type {type(_UpperCAmelCase )}) cannot be compared to version.""" ) def __eq__( self , _UpperCAmelCase ) -> List[Any]: try: UpperCamelCase_ = self._validate_operand(_UpperCAmelCase ) except (TypeError, ValueError): return False else: return self.tuple == other.tuple def __lt__( self , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = self._validate_operand(_UpperCAmelCase ) return self.tuple < other.tuple def __hash__( self ) -> Dict: return hash(_version_tuple_to_str(self.tuple ) ) @classmethod def _UpperCAmelCase ( cls , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = {f.name for f in dataclasses.fields(cls )} return cls(**{k: v for k, v in dic.items() if k in field_names} ) def _UpperCAmelCase ( self ) -> str: return self.version_str def _snake_case (__lowercase): UpperCamelCase_ = _VERSION_REG.match(__lowercase) if not res: raise ValueError(f"""Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits.""") return tuple(int(__lowercase) for v in [res.group('major'), res.group('minor'), res.group('patch')]) def _snake_case (__lowercase): return ".".join(str(__lowercase) for v in version_tuple)
23
import datasets from .evaluate import evaluate snake_case__ : int = """\ @article{hendrycks2021cuad, title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review}, author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball}, journal={arXiv preprint arXiv:2103.06268}, year={2021} } """ snake_case__ : Union[str, Any] = """ This metric wrap the official scoring script for version 1 of the Contract Understanding Atticus Dataset (CUAD). Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions. """ snake_case__ : Any = """ Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall). Args: predictions: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair as given in the references (see below) - 'prediction_text': list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction. references: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair (see above), - 'answers': a Dict in the CUAD dataset format { 'text': list of possible texts for the answer, as a list of strings 'answer_start': list of start positions for the answer, as a list of ints } Note that answer_start values are not taken into account to compute the metric. Returns: 'exact_match': Exact match (the normalized answer exactly match the gold answer) 'f1': The F-score of predicted tokens versus the gold answer 'aupr': Area Under the Precision-Recall curve 'prec_at_80_recall': Precision at 80% recall 'prec_at_90_recall': Precision at 90% recall Examples: >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> cuad_metric = datasets.load_metric(\"cuad\") >>> results = cuad_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _a ( datasets.Metric ): """simple docstring""" def _UpperCAmelCase ( self ) -> Optional[int]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': { 'id': datasets.Value('string' ), 'prediction_text': datasets.features.Sequence(datasets.Value('string' ) ), }, 'references': { 'id': datasets.Value('string' ), 'answers': datasets.features.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), }, } ) , codebase_urls=['https://www.atticusprojectai.org/cuad'] , reference_urls=['https://www.atticusprojectai.org/cuad'] , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = {prediction['id']: prediction['prediction_text'] for prediction in predictions} UpperCamelCase_ = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] UpperCamelCase_ = evaluate(dataset=_UpperCAmelCase , predictions=_UpperCAmelCase ) return score
23
1
from ..utils import DummyObject, requires_backends class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Optional[Any]: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Dict: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Optional[Any]: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Dict: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Optional[int]: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Union[str, Any]: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> str: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> int: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Any: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> int: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[Any]: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Any: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Dict: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> int: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Tuple: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Tuple: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Dict: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Any: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Any: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[Any]: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Tuple: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Optional[Any]: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> int: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Any: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> int: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> str: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Dict: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> Union[str, Any]: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Dict: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> str: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[Any]: requires_backends(cls , ['flax'] ) class _a ( metaclass=UpperCAmelCase__ ): """simple docstring""" A_ = ["""flax"""] def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Dict: requires_backends(self , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: requires_backends(cls , ['flax'] ) @classmethod def _UpperCAmelCase ( cls , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: requires_backends(cls , ['flax'] )
23
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import datasets import datasets.config from .utils import require_beam class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> List[str]: return datasets.DatasetInfo( features=datasets.Features({'content': datasets.Value('string' )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_dummy_examples()} )] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> Any: return datasets.DatasetInfo( features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: return [ datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_nested_examples()} ) ] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) def _snake_case (): return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar'])] def _snake_case (): return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['foo', 'bar', 'foobar'])] class _a ( UpperCAmelCase__ ): """simple docstring""" @require_beam def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_dummy_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_dummy_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> List[str]: import apache_beam as beam UpperCamelCase_ = beam.io.parquetio.WriteToParquet UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) with patch('apache_beam.io.parquetio.WriteToParquet' ) as write_parquet_mock: UpperCamelCase_ = partial(_UpperCAmelCase , num_shards=2 ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) # Order is not preserved when sharding, so we just check that all the elements are there self.assertListEqual(sorted(dset['train']['content'] ) , sorted(['foo', 'bar', 'foobar'] ) ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> Any: with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase ) self.assertRaises(datasets.builder.MissingBeamOptions , builder.download_and_prepare ) @require_beam def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = len(get_test_nested_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = NestedBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual( builder.info.features , datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_nested_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_nested_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset
23
1
def _snake_case (__lowercase): UpperCamelCase_ = 1 for i in range(1 , num + 1): fact *= i return fact def _snake_case (__lowercase): UpperCamelCase_ = 0 while number > 0: UpperCamelCase_ = number % 10 sum_of_digits += last_digit UpperCamelCase_ = number // 10 # Removing the last_digit from the given number return sum_of_digits def _snake_case (__lowercase = 100): UpperCamelCase_ = factorial(__lowercase) UpperCamelCase_ = split_and_add(__lowercase) return result if __name__ == "__main__": print(solution(int(input("""Enter the Number: """).strip())))
23
import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = AlbertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = AlbertForPreTraining(__lowercase) # Load weights from tf checkpoint load_tf_weights_in_albert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--albert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained ALBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : str = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
23
1
# Function to print upper half of diamond (pyramid) def _snake_case (__lowercase): for i in range(0 , __lowercase): for _ in range(0 , n - i - 1): # printing spaces print(' ' , end='') for _ in range(0 , i + 1): # printing stars print('* ' , end='') print() def _snake_case (__lowercase): for i in range(__lowercase , 0 , -1): for _ in range(__lowercase , 0 , -1): # printing stars print('* ' , end='') print() for _ in range(n - i + 1 , 0 , -1): # printing spaces print(' ' , end='') def _snake_case (__lowercase): if n <= 0: print(' ... .... nothing printing :(') return floyd(__lowercase) # upper half reverse_floyd(__lowercase) # lower half if __name__ == "__main__": print(R"""| /\ | |- | |- |--| |\ /| |-""") print(R"""|/ \| |- |_ |_ |__| | \/ | |_""") snake_case__ : Dict = 1 while K: snake_case__ : Tuple = int(input("""enter the number and , and see the magic : """)) print() pretty_print(user_number) snake_case__ : List[Any] = int(input("""press 0 to exit... and 1 to continue...""")) print("""Good Bye...""")
23
from transformers import BertTokenizer, EncoderDecoderModel, SeqaSeqTrainer, SeqaSeqTrainingArguments from transformers.testing_utils import TestCasePlus, require_torch, slow from transformers.utils import is_datasets_available if is_datasets_available(): import datasets class _a ( UpperCAmelCase__ ): """simple docstring""" @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = EncoderDecoderModel.from_encoder_decoder_pretrained('prajjwal1/bert-tiny' , 'prajjwal1/bert-tiny' ) UpperCamelCase_ = BertTokenizer.from_pretrained('bert-base-uncased' ) UpperCamelCase_ = bertabert.config.encoder.vocab_size UpperCamelCase_ = tokenizer.sep_token_id UpperCamelCase_ = tokenizer.cls_token_id UpperCamelCase_ = 128 UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='train[:1%]' ) UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='validation[:1%]' ) UpperCamelCase_ = train_dataset.select(range(32 ) ) UpperCamelCase_ = val_dataset.select(range(16 ) ) UpperCamelCase_ = 4 def _map_to_encoder_decoder_inputs(_UpperCAmelCase ): # Tokenizer will automatically set [BOS] <text> [EOS] UpperCamelCase_ = tokenizer(batch['article'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=512 ) UpperCamelCase_ = tokenizer(batch['highlights'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=128 ) UpperCamelCase_ = inputs.input_ids UpperCamelCase_ = inputs.attention_mask UpperCamelCase_ = outputs.input_ids UpperCamelCase_ = outputs.input_ids.copy() UpperCamelCase_ = [ [-100 if token == tokenizer.pad_token_id else token for token in labels] for labels in batch['labels'] ] UpperCamelCase_ = outputs.attention_mask assert all(len(_UpperCAmelCase ) == 512 for x in inputs.input_ids ) assert all(len(_UpperCAmelCase ) == 128 for x in outputs.input_ids ) return batch def _compute_metrics(_UpperCAmelCase ): UpperCamelCase_ = pred.label_ids UpperCamelCase_ = pred.predictions # all unnecessary tokens are removed UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = sum([int(pred_str[i] == label_str[i] ) for i in range(len(_UpperCAmelCase ) )] ) / len(_UpperCAmelCase ) return {"accuracy": accuracy} # map train dataset UpperCamelCase_ = train_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) train_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) # same for validation dataset UpperCamelCase_ = val_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) val_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) UpperCamelCase_ = self.get_auto_remove_tmp_dir() UpperCamelCase_ = SeqaSeqTrainingArguments( output_dir=_UpperCAmelCase , per_device_train_batch_size=_UpperCAmelCase , per_device_eval_batch_size=_UpperCAmelCase , predict_with_generate=_UpperCAmelCase , evaluation_strategy='steps' , do_train=_UpperCAmelCase , do_eval=_UpperCAmelCase , warmup_steps=0 , eval_steps=2 , logging_steps=2 , ) # instantiate trainer UpperCamelCase_ = SeqaSeqTrainer( model=_UpperCAmelCase , args=_UpperCAmelCase , compute_metrics=_compute_metrics , train_dataset=_UpperCAmelCase , eval_dataset=_UpperCAmelCase , tokenizer=_UpperCAmelCase , ) # start training trainer.train()
23
1
import datasets from .evaluate import evaluate snake_case__ : int = """\ @article{hendrycks2021cuad, title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review}, author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball}, journal={arXiv preprint arXiv:2103.06268}, year={2021} } """ snake_case__ : Union[str, Any] = """ This metric wrap the official scoring script for version 1 of the Contract Understanding Atticus Dataset (CUAD). Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions. """ snake_case__ : Any = """ Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall). Args: predictions: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair as given in the references (see below) - 'prediction_text': list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction. references: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair (see above), - 'answers': a Dict in the CUAD dataset format { 'text': list of possible texts for the answer, as a list of strings 'answer_start': list of start positions for the answer, as a list of ints } Note that answer_start values are not taken into account to compute the metric. Returns: 'exact_match': Exact match (the normalized answer exactly match the gold answer) 'f1': The F-score of predicted tokens versus the gold answer 'aupr': Area Under the Precision-Recall curve 'prec_at_80_recall': Precision at 80% recall 'prec_at_90_recall': Precision at 90% recall Examples: >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> cuad_metric = datasets.load_metric(\"cuad\") >>> results = cuad_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _a ( datasets.Metric ): """simple docstring""" def _UpperCAmelCase ( self ) -> Optional[int]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': { 'id': datasets.Value('string' ), 'prediction_text': datasets.features.Sequence(datasets.Value('string' ) ), }, 'references': { 'id': datasets.Value('string' ), 'answers': datasets.features.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), }, } ) , codebase_urls=['https://www.atticusprojectai.org/cuad'] , reference_urls=['https://www.atticusprojectai.org/cuad'] , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = {prediction['id']: prediction['prediction_text'] for prediction in predictions} UpperCamelCase_ = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] UpperCamelCase_ = evaluate(dataset=_UpperCAmelCase , predictions=_UpperCAmelCase ) return score
23
import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType ######################################################################## # This is a fully working simple example to use Accelerate # and perform gradient accumulation # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## snake_case__ : Dict = 1_6 snake_case__ : List[str] = 3_2 def _snake_case (__lowercase , __lowercase = 16): UpperCamelCase_ = AutoTokenizer.from_pretrained('bert-base-cased') UpperCamelCase_ = load_dataset('glue' , 'mrpc') def tokenize_function(__lowercase): # max_length=None => use the model max length (it's actually the default) UpperCamelCase_ = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=__lowercase , max_length=__lowercase) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): UpperCamelCase_ = datasets.map( __lowercase , batched=__lowercase , remove_columns=['idx', 'sentence1', 'sentence2'] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library UpperCamelCase_ = tokenized_datasets.rename_column('label' , 'labels') def collate_fn(__lowercase): # On TPU it's best to pad everything to the same length or training will be very slow. UpperCamelCase_ = 128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": UpperCamelCase_ = 16 elif accelerator.mixed_precision != "no": UpperCamelCase_ = 8 else: UpperCamelCase_ = None return tokenizer.pad( __lowercase , padding='longest' , max_length=__lowercase , pad_to_multiple_of=__lowercase , return_tensors='pt' , ) # Instantiate dataloaders. UpperCamelCase_ = DataLoader( tokenized_datasets['train'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) UpperCamelCase_ = DataLoader( tokenized_datasets['validation'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) return train_dataloader, eval_dataloader # For testing only if os.environ.get("""TESTING_MOCKED_DATALOADERS""", None) == "1": from accelerate.test_utils.training import mocked_dataloaders snake_case__ : List[str] = mocked_dataloaders # noqa: F811 def _snake_case (__lowercase , __lowercase): # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS' , __lowercase) == "1": UpperCamelCase_ = 2 # New Code # UpperCamelCase_ = int(args.gradient_accumulation_steps) # Initialize accelerator UpperCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=__lowercase) if accelerator.distributed_type == DistributedType.TPU and gradient_accumulation_steps > 1: raise NotImplementedError( 'Gradient accumulation on TPUs is currently not supported. Pass `gradient_accumulation_steps=1`') # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs UpperCamelCase_ = config['lr'] UpperCamelCase_ = int(config['num_epochs']) UpperCamelCase_ = int(config['seed']) UpperCamelCase_ = int(config['batch_size']) UpperCamelCase_ = evaluate.load('glue' , 'mrpc') set_seed(__lowercase) UpperCamelCase_ , UpperCamelCase_ = get_dataloaders(__lowercase , __lowercase) # Instantiate the model (we build the model here so that the seed also control new weights initialization) UpperCamelCase_ = AutoModelForSequenceClassification.from_pretrained('bert-base-cased' , return_dict=__lowercase) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). UpperCamelCase_ = model.to(accelerator.device) # Instantiate optimizer UpperCamelCase_ = AdamW(params=model.parameters() , lr=__lowercase) # Instantiate scheduler UpperCamelCase_ = get_linear_schedule_with_warmup( optimizer=__lowercase , num_warmup_steps=100 , num_training_steps=(len(__lowercase) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare( __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # Now we train the model for epoch in range(__lowercase): model.train() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(__lowercase): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = output.loss accelerator.backward(__lowercase) optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) with torch.no_grad(): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = outputs.logits.argmax(dim=-1) UpperCamelCase_ , UpperCamelCase_ = accelerator.gather_for_metrics((predictions, batch['labels'])) metric.add_batch( predictions=__lowercase , references=__lowercase , ) UpperCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , __lowercase) def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Simple example of training script.') parser.add_argument( '--mixed_precision' , type=__lowercase , default=__lowercase , choices=['no', 'fp16', 'bf16', 'fp8'] , help='Whether to use mixed precision. Choose' 'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.' 'and an Nvidia Ampere GPU.' , ) # New Code # parser.add_argument( '--gradient_accumulation_steps' , type=__lowercase , default=1 , help='The number of minibatches to be ran before gradients are accumulated.' , ) parser.add_argument('--cpu' , action='store_true' , help='If passed, will train on the CPU.') UpperCamelCase_ = parser.parse_args() UpperCamelCase_ = {'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(__lowercase , __lowercase) if __name__ == "__main__": main()
23
1
import heapq as hq import math from collections.abc import Iterator class _a : """simple docstring""" def __init__( self , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = str(id_ ) UpperCamelCase_ = None UpperCamelCase_ = None UpperCamelCase_ = [] UpperCamelCase_ = {} # {vertex:distance} def __lt__( self , _UpperCAmelCase ) -> Optional[int]: return self.key < other.key def __repr__( self ) -> Optional[int]: return self.id def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[str]: self.neighbors.append(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = weight def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase): # add the neighbors: graph[a - 1].add_neighbor(graph[b - 1]) graph[b - 1].add_neighbor(graph[a - 1]) # add the edges: graph[a - 1].add_edge(graph[b - 1] , __lowercase) graph[b - 1].add_edge(graph[a - 1] , __lowercase) def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = [] for u in graph: UpperCamelCase_ = math.inf UpperCamelCase_ = None UpperCamelCase_ = 0 UpperCamelCase_ = graph[:] while q: UpperCamelCase_ = min(__lowercase) q.remove(__lowercase) for v in u.neighbors: if (v in q) and (u.edges[v.id] < v.key): UpperCamelCase_ = u UpperCamelCase_ = u.edges[v.id] for i in range(1 , len(__lowercase)): a.append((int(graph[i].id) + 1, int(graph[i].pi.id) + 1)) return a def _snake_case (__lowercase , __lowercase): for u in graph: UpperCamelCase_ = math.inf UpperCamelCase_ = None UpperCamelCase_ = 0 UpperCamelCase_ = list(__lowercase) hq.heapify(__lowercase) while h: UpperCamelCase_ = hq.heappop(__lowercase) for v in u.neighbors: if (v in h) and (u.edges[v.id] < v.key): UpperCamelCase_ = u UpperCamelCase_ = u.edges[v.id] hq.heapify(__lowercase) for i in range(1 , len(__lowercase)): yield (int(graph[i].id) + 1, int(graph[i].pi.id) + 1) def _snake_case (): pass if __name__ == "__main__": import doctest doctest.testmod()
23
import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import MaskaFormerConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel if is_vision_available(): from transformers import MaskaFormerImageProcessor if is_vision_available(): from PIL import Image class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=2 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=10 , _UpperCAmelCase=3 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=4 , _UpperCAmelCase=64 , ) -> List[Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = is_training UpperCamelCase_ = use_auxiliary_loss UpperCamelCase_ = num_queries UpperCamelCase_ = num_channels UpperCamelCase_ = min_size UpperCamelCase_ = max_size UpperCamelCase_ = num_labels UpperCamelCase_ = hidden_dim UpperCamelCase_ = hidden_dim def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( _UpperCAmelCase ) UpperCamelCase_ = torch.ones([self.batch_size, self.min_size, self.max_size] , device=_UpperCAmelCase ) UpperCamelCase_ = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=_UpperCAmelCase ) > 0.5 ).float() UpperCamelCase_ = (torch.rand((self.batch_size, self.num_labels) , device=_UpperCAmelCase ) > 0.5).long() UpperCamelCase_ = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = MaskaFormerConfig( hidden_size=self.hidden_dim , ) UpperCamelCase_ = self.num_queries UpperCamelCase_ = self.num_labels UpperCamelCase_ = [1, 1, 1, 1] UpperCamelCase_ = self.num_channels UpperCamelCase_ = 64 UpperCamelCase_ = 128 UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim return config def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ = {'pixel_values': pixel_values, 'pixel_mask': pixel_mask} return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = output.encoder_hidden_states UpperCamelCase_ = output.pixel_decoder_hidden_states UpperCamelCase_ = output.transformer_decoder_hidden_states self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , config.decoder_layers ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False ) -> Any: with torch.no_grad(): UpperCamelCase_ = MaskaFormerModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.hidden_dim) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() def comm_check_on_output(_UpperCAmelCase ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) UpperCamelCase_ = model( pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else () A_ = {"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {} A_ = False A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , has_text_modality=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_UpperCAmelCase ) @unittest.skip(reason='Mask2Former does not use inputs_embeds' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method' ) def _UpperCAmelCase ( self ) -> Optional[int]: pass @unittest.skip(reason='Mask2Former is not a generative model' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not use token embeddings' ) def _UpperCAmelCase ( self ) -> Optional[Any]: pass @require_torch_multi_gpu @unittest.skip( reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' ) def _UpperCAmelCase ( self ) -> int: pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Tuple: for model_name in ["facebook/mask2former-swin-small-coco-instance"]: UpperCamelCase_ = MaskaFormerModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = (self.model_tester.min_size,) * 2 UpperCamelCase_ = { 'pixel_values': torch.randn((2, 3, *size) , device=_UpperCAmelCase ), 'mask_labels': torch.randn((2, 10, *size) , device=_UpperCAmelCase ), 'class_labels': torch.zeros(2 , 10 , device=_UpperCAmelCase ).long(), } UpperCamelCase_ = self.model_tester.get_config() UpperCamelCase_ = MaskaFormerForUniversalSegmentation(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None ) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase , output_attentions=_UpperCAmelCase ) self.assertTrue(outputs.attentions is not None ) def _UpperCAmelCase ( self ) -> List[Any]: if not self.model_tester.is_training: return UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = True UpperCamelCase_ = True UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) UpperCamelCase_ = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=_UpperCAmelCase ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) snake_case__ : List[Any] = 1E-4 def _snake_case (): UpperCamelCase_ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') return image @require_vision @slow class _a ( unittest.TestCase ): """simple docstring""" @cached_property def _UpperCAmelCase ( self ) -> Optional[int]: return "facebook/mask2former-swin-small-coco-instance" @cached_property def _UpperCAmelCase ( self ) -> List[str]: return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) UpperCamelCase_ = torch.tensor( [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) # masks_queries_logits UpperCamelCase_ = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) ) UpperCamelCase_ = [ [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1], [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1], [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5], ] UpperCamelCase_ = torch.tensor(_UpperCAmelCase ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) # class_queries_logits UpperCamelCase_ = outputs.class_queries_logits self.assertEqual(class_queries_logits.shape , (1, model.config.num_queries, model.config.num_labels + 1) ) UpperCamelCase_ = torch.tensor( [ [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2], [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3], [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5], ] ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = image_processor( [np.zeros((3, 800, 1333) ), np.zeros((3, 800, 1333) )] , segmentation_maps=[np.zeros((384, 384) ).astype(np.floataa ), np.zeros((384, 384) ).astype(np.floataa )] , return_tensors='pt' , ) UpperCamelCase_ = inputs['pixel_values'].to(_UpperCAmelCase ) UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['mask_labels']] UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['class_labels']] with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None )
23
1
import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = AlbertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = AlbertForPreTraining(__lowercase) # Load weights from tf checkpoint load_tf_weights_in_albert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--albert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained ALBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : str = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
23
import copy from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto.configuration_auto import AutoConfig if TYPE_CHECKING: from ... import PreTrainedTokenizerBase, TensorType snake_case__ : List[str] = logging.get_logger(__name__) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """vision-encoder-decoder""" A_ = True def __init__( self , **_UpperCAmelCase ) -> Dict: super().__init__(**_UpperCAmelCase ) if "encoder" not in kwargs or "decoder" not in kwargs: raise ValueError( f"""A configuraton of type {self.model_type} cannot be instantiated because """ f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}""" ) UpperCamelCase_ = kwargs.pop('encoder' ) UpperCamelCase_ = encoder_config.pop('model_type' ) UpperCamelCase_ = kwargs.pop('decoder' ) UpperCamelCase_ = decoder_config.pop('model_type' ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = True @classmethod def _UpperCAmelCase ( cls , _UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) -> PretrainedConfig: logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config' ) UpperCamelCase_ = True UpperCamelCase_ = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = copy.deepcopy(self.__dict__ ) UpperCamelCase_ = self.encoder.to_dict() UpperCamelCase_ = self.decoder.to_dict() UpperCamelCase_ = self.__class__.model_type return output class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = version.parse("""1.11""" ) @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) @property def _UpperCAmelCase ( self ) -> float: return 1e-4 @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict({'last_hidden_state': {0: 'batch', 1: 'encoder_sequence'}} ) class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: UpperCamelCase_ = OrderedDict() UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'encoder_sequence'} return common_inputs def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = -1 , _UpperCAmelCase = -1 , _UpperCAmelCase = False , _UpperCAmelCase = None , ) -> Mapping[str, Any]: import torch UpperCamelCase_ = OrderedDict() UpperCamelCase_ = super().generate_dummy_inputs( _UpperCAmelCase , batch_size=_UpperCAmelCase , seq_length=_UpperCAmelCase , is_pair=_UpperCAmelCase , framework=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = dummy_input['input_ids'].shape UpperCamelCase_ = (batch, encoder_sequence, self._config.encoder_hidden_size) UpperCamelCase_ = dummy_input.pop('input_ids' ) UpperCamelCase_ = dummy_input.pop('attention_mask' ) UpperCamelCase_ = torch.zeros(_UpperCAmelCase ) return common_inputs class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> None: pass def _UpperCAmelCase ( self , _UpperCAmelCase ) -> OnnxConfig: return VisionEncoderDecoderEncoderOnnxConfig(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = "default" ) -> OnnxConfig: UpperCamelCase_ = encoder_config.hidden_size return VisionEncoderDecoderDecoderOnnxConfig(_UpperCAmelCase , _UpperCAmelCase )
23
1
import json import os import subprocess import unittest from ast import literal_eval import pytest from parameterized import parameterized, parameterized_class from . import is_sagemaker_available if is_sagemaker_available(): from sagemaker import Session, TrainingJobAnalytics from sagemaker.huggingface import HuggingFace @pytest.mark.skipif( literal_eval(os.getenv("""TEST_SAGEMAKER""" , """False""" ) ) is not True , reason="""Skipping test because should only be run when releasing minor transformers version""" , ) @pytest.mark.usefixtures("""sm_env""" ) @parameterized_class( [ { """framework""": """pytorch""", """script""": """run_glue.py""", """model_name_or_path""": """distilbert-base-cased""", """instance_type""": """ml.p3.16xlarge""", """results""": {"""train_runtime""": 650, """eval_accuracy""": 0.7, """eval_loss""": 0.6}, }, { """framework""": """pytorch""", """script""": """run_ddp.py""", """model_name_or_path""": """distilbert-base-cased""", """instance_type""": """ml.p3.16xlarge""", """results""": {"""train_runtime""": 600, """eval_accuracy""": 0.7, """eval_loss""": 0.6}, }, { """framework""": """tensorflow""", """script""": """run_tf_dist.py""", """model_name_or_path""": """distilbert-base-cased""", """instance_type""": """ml.p3.16xlarge""", """results""": {"""train_runtime""": 600, """eval_accuracy""": 0.6, """eval_loss""": 0.7}, }, ] ) class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> str: if self.framework == "pytorch": subprocess.run( f"""cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py""".split() , encoding='utf-8' , check=_UpperCAmelCase , ) assert hasattr(self , 'env' ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> str: UpperCamelCase_ = f"""{self.env.base_job_name}-{instance_count}-{"ddp" if "ddp" in self.script else "smd"}""" # distributed data settings UpperCamelCase_ = {'smdistributed': {'dataparallel': {'enabled': True}}} if self.script != 'run_ddp.py' else None # creates estimator return HuggingFace( entry_point=self.script , source_dir=self.env.test_path , role=self.env.role , image_uri=self.env.image_uri , base_job_name=_UpperCAmelCase , instance_count=_UpperCAmelCase , instance_type=self.instance_type , debugger_hook_config=_UpperCAmelCase , hyperparameters={**self.env.distributed_hyperparameters, 'model_name_or_path': self.model_name_or_path} , metric_definitions=self.env.metric_definitions , distribution=_UpperCAmelCase , py_version='py36' , ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Any: TrainingJobAnalytics(_UpperCAmelCase ).export_csv(f"""{self.env.test_path}/{job_name}_metrics.csv""" ) @parameterized.expand([(2,)] ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: # create estimator UpperCamelCase_ = self.create_estimator(_UpperCAmelCase ) # run training estimator.fit() # result dataframe UpperCamelCase_ = TrainingJobAnalytics(estimator.latest_training_job.name ).dataframe() # extract kpis UpperCamelCase_ = list(result_metrics_df[result_metrics_df.metric_name == 'eval_accuracy']['value'] ) UpperCamelCase_ = list(result_metrics_df[result_metrics_df.metric_name == 'eval_loss']['value'] ) # get train time from SageMaker job, this includes starting, preprocessing, stopping UpperCamelCase_ = ( Session().describe_training_job(estimator.latest_training_job.name ).get('TrainingTimeInSeconds' , 999999 ) ) # assert kpis assert train_runtime <= self.results["train_runtime"] assert all(t >= self.results['eval_accuracy'] for t in eval_accuracy ) assert all(t <= self.results['eval_loss'] for t in eval_loss ) # dump tests result into json file to share in PR with open(f"""{estimator.latest_training_job.name}.json""" , 'w' ) as outfile: json.dump({'train_time': train_runtime, 'eval_accuracy': eval_accuracy, 'eval_loss': eval_loss} , _UpperCAmelCase )
23
import argparse import torch from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert from transformers.utils import logging logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = MobileBertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = MobileBertForPreTraining(__lowercase) # Load weights from tf checkpoint UpperCamelCase_ = load_tf_weights_in_mobilebert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--mobilebert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained MobileBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : Optional[Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
23
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Tuple = { """configuration_table_transformer""": [ """TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TableTransformerConfig""", """TableTransformerOnnxConfig""", ] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""", """TableTransformerForObjectDetection""", """TableTransformerModel""", """TableTransformerPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_table_transformer import ( TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TableTransformerConfig, TableTransformerOnnxConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_table_transformer import ( TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TableTransformerForObjectDetection, TableTransformerModel, TableTransformerPreTrainedModel, ) else: import sys snake_case__ : str = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
import gc import unittest from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline from transformers.pipelines import PipelineException from transformers.testing_utils import ( is_pipeline_test, is_torch_available, nested_simplify, require_tf, require_torch, require_torch_gpu, slow, ) from .test_pipelines_common import ANY @is_pipeline_test class _a ( unittest.TestCase ): """simple docstring""" A_ = MODEL_FOR_MASKED_LM_MAPPING A_ = TF_MODEL_FOR_MASKED_LM_MAPPING def _UpperCAmelCase ( self ) -> List[str]: super().tearDown() # clean-up as much as possible GPU memory occupied by PyTorch gc.collect() if is_torch_available(): import torch torch.cuda.empty_cache() @require_tf def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='tf' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped'}, {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped', }, { 'sequence': 'The largest city in France is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='pt' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul'}, {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', }, {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2941, 'token_str': ' Te'}, {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask> <mask>' , top_k=2 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is Maul<mask></s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'}, ], [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is<mask> Maul</s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'}, ], ] , ) @require_torch_gpu def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = pipeline('fill-mask' , model='hf-internal-testing/tiny-random-distilbert' , device=0 , framework='pt' ) # convert model to fp16 pipe.model.half() UpperCamelCase_ = pipe('Paris is the [MASK] of France.' ) # We actually don't care about the result, we just want to make sure # it works, meaning the float16 tensor got casted back to float32 # for postprocessing. self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='pt' ) self.run_large_test(_UpperCAmelCase ) @slow @require_tf def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='tf' ) self.run_large_test(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is John', 'score': 0.0_0_8, 'token': 610, 'token_str': ' John'}, {'sequence': 'My name is Chris', 'score': 0.0_0_7, 'token': 1573, 'token_str': ' Chris'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ { 'sequence': 'The largest city in France is Paris', 'score': 0.2_5_1, 'token': 2201, 'token_str': ' Paris', }, { 'sequence': 'The largest city in France is Lyon', 'score': 0.2_1_4, 'token': 12790, 'token_str': ' Lyon', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is Patrick', 'score': 0.0_0_5, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='pt' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) @require_tf def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='tf' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: if tokenizer is None or tokenizer.mask_token_id is None: self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)' ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = [ f"""This is another {tokenizer.mask_token} test""", ] return fill_masker, examples def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = fill_masker.tokenizer UpperCamelCase_ = fill_masker.model UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token}""" , ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}"""] ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""] ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , ) with self.assertRaises(_UpperCAmelCase ): fill_masker([None] ) # No mask_token is not supported with self.assertRaises(_UpperCAmelCase ): fill_masker('This is' ) self.run_test_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_targets(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_top_k_targets(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_duplicate_targets_and_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_multiple_masks(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = sorted(vocab.keys() )[:2] # Pipeline argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , targets=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Call argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Score equivalence UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['token_str'] for top_mask in outputs] UpperCamelCase_ = [top_mask['score'] for top_mask in outputs] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ) == set(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['score'] for top_mask in unmasked_targets] self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) # Raises with invalid with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[] ) # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised if "" not in tokenizer.get_vocab(): with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[''] ) with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets='' ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , top_k=2 ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) # top_k=2, ntargets=3 UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 , targets=_UpperCAmelCase ) # If we use the most probably targets, and filter differently, we should still # have the same results UpperCamelCase_ = [el['token_str'] for el in sorted(_UpperCAmelCase , key=lambda _UpperCAmelCase : x["score"] , reverse=_UpperCAmelCase )] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ).issubset(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=3 , targets=_UpperCAmelCase ) # They should yield exactly the same result self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.get_vocab() # String duplicates + id duplicates UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = [targets[0], targets[1], targets[0], targets[2], targets[1]] UpperCamelCase_ = fill_masker(f"""My name is {tokenizer.mask_token}""" , targets=_UpperCAmelCase , top_k=10 ) # The target list contains duplicates, so we can't output more # than them self.assertEqual(len(_UpperCAmelCase ) , 3 ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , )
23
1
from ...configuration_utils import PretrainedConfig from ...utils import logging snake_case__ : Union[str, Any] = logging.get_logger(__name__) snake_case__ : List[str] = { """alibaba-damo/mgp-str-base""": """https://huggingface.co/alibaba-damo/mgp-str-base/resolve/main/config.json""", } class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """mgp-str""" def __init__( self , _UpperCAmelCase=[32, 128] , _UpperCAmelCase=4 , _UpperCAmelCase=3 , _UpperCAmelCase=27 , _UpperCAmelCase=38 , _UpperCAmelCase=50257 , _UpperCAmelCase=30522 , _UpperCAmelCase=768 , _UpperCAmelCase=12 , _UpperCAmelCase=12 , _UpperCAmelCase=4.0 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=1e-5 , _UpperCAmelCase=0.0 , _UpperCAmelCase=0.0 , _UpperCAmelCase=0.0 , _UpperCAmelCase=False , _UpperCAmelCase=0.0_2 , **_UpperCAmelCase , ) -> Optional[int]: super().__init__(**_UpperCAmelCase ) UpperCamelCase_ = image_size UpperCamelCase_ = patch_size UpperCamelCase_ = num_channels UpperCamelCase_ = max_token_length UpperCamelCase_ = num_character_labels UpperCamelCase_ = num_bpe_labels UpperCamelCase_ = num_wordpiece_labels UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = mlp_ratio UpperCamelCase_ = distilled UpperCamelCase_ = layer_norm_eps UpperCamelCase_ = drop_rate UpperCamelCase_ = qkv_bias UpperCamelCase_ = attn_drop_rate UpperCamelCase_ = drop_path_rate UpperCamelCase_ = output_aa_attentions UpperCamelCase_ = initializer_range
23
import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, StableDiffusionSAGPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = StableDiffusionSAGPipeline A_ = TEXT_TO_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_BATCH_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) UpperCamelCase_ = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=32 , ) UpperCamelCase_ = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule='scaled_linear' , clip_sample=_UpperCAmelCase , set_alpha_to_one=_UpperCAmelCase , ) torch.manual_seed(0 ) UpperCamelCase_ = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) UpperCamelCase_ = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) UpperCamelCase_ = CLIPTextModel(_UpperCAmelCase ) UpperCamelCase_ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) UpperCamelCase_ = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=0 ) -> List[Any]: if str(_UpperCAmelCase ).startswith('mps' ): UpperCamelCase_ = torch.manual_seed(_UpperCAmelCase ) else: UpperCamelCase_ = torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase ) UpperCamelCase_ = { 'prompt': '.', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 1.0, 'sag_scale': 1.0, 'output_type': 'numpy', } return inputs def _UpperCAmelCase ( self ) -> Tuple: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Tuple: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , width=768 , height=512 , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' , ) UpperCamelCase_ = output.images assert image.shape == (1, 512, 768, 3)
23
1
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( SwiftFormerConfig, SwiftFormerForImageClassification, ViTImageProcessor, ) from transformers.utils import logging logging.set_verbosity_info() snake_case__ : List[str] = logging.get_logger(__name__) snake_case__ : str = torch.device("""cpu""") def _snake_case (): UpperCamelCase_ = 'http://images.cocodataset.org/val2017/000000039769.jpg' UpperCamelCase_ = Image.open(requests.get(__lowercase , stream=__lowercase).raw) return im def _snake_case (__lowercase): if swiftformer_name == "swiftformer_xs": return torch.tensor([-2.17_03e00, 2.11_07e00, -2.08_11e00, 8.86_85e-01, 2.43_60e-01]) elif swiftformer_name == "swiftformer_s": return torch.tensor([3.96_36e-01, 2.34_78e-01, -1.69_63e00, -1.73_81e00, -8.63_37e-01]) elif swiftformer_name == "swiftformer_l1": return torch.tensor([-4.27_68e-01, -4.74_29e-01, -1.08_97e00, -1.02_48e00, 3.55_23e-02]) elif swiftformer_name == "swiftformer_l3": return torch.tensor([-2.53_30e-01, 2.42_11e-01, -6.01_85e-01, -8.27_89e-01, -6.04_46e-02]) def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = dct.pop(__lowercase) UpperCamelCase_ = val def _snake_case (__lowercase): UpperCamelCase_ = [] for k in state_dict.keys(): UpperCamelCase_ = k if ".pwconv" in k: UpperCamelCase_ = k_new.replace('.pwconv' , '.point_wise_conv') if ".dwconv" in k: UpperCamelCase_ = k_new.replace('.dwconv' , '.depth_wise_conv') if ".Proj." in k: UpperCamelCase_ = k_new.replace('.Proj.' , '.proj.') if "patch_embed" in k_new: UpperCamelCase_ = k_new.replace('patch_embed' , 'swiftformer.patch_embed.patch_embedding') if "network" in k_new: UpperCamelCase_ = k_new.split('.') if ls[2].isdigit(): UpperCamelCase_ = 'swiftformer.encoder.network.' + ls[1] + '.blocks.' + ls[2] + '.' + '.'.join(ls[3:]) else: UpperCamelCase_ = k_new.replace('network' , 'swiftformer.encoder.network') rename_keys.append((k, k_new)) return rename_keys @torch.no_grad() def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = SwiftFormerConfig() # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size UpperCamelCase_ = 1000 UpperCamelCase_ = 'huggingface/label-files' UpperCamelCase_ = 'imagenet-1k-id2label.json' UpperCamelCase_ = json.load(open(hf_hub_download(__lowercase , __lowercase , repo_type='dataset') , 'r')) UpperCamelCase_ = {int(__lowercase): v for k, v in idalabel.items()} UpperCamelCase_ = idalabel UpperCamelCase_ = {v: k for k, v in idalabel.items()} # size of the architecture if swiftformer_name == "swiftformer_xs": UpperCamelCase_ = [3, 3, 6, 4] UpperCamelCase_ = [48, 56, 112, 220] elif swiftformer_name == "swiftformer_s": UpperCamelCase_ = [3, 3, 9, 6] UpperCamelCase_ = [48, 64, 168, 224] elif swiftformer_name == "swiftformer_l1": UpperCamelCase_ = [4, 3, 10, 5] UpperCamelCase_ = [48, 96, 192, 384] elif swiftformer_name == "swiftformer_l3": UpperCamelCase_ = [4, 4, 12, 6] UpperCamelCase_ = [64, 128, 320, 512] # load state_dict of original model, remove and rename some keys if original_ckpt: if original_ckpt.startswith('https'): UpperCamelCase_ = torch.hub.load_state_dict_from_url(__lowercase , map_location='cpu' , check_hash=__lowercase) else: UpperCamelCase_ = torch.load(__lowercase , map_location='cpu') UpperCamelCase_ = checkpoint UpperCamelCase_ = create_rename_keys(__lowercase) for rename_key_src, rename_key_dest in rename_keys: rename_key(__lowercase , __lowercase , __lowercase) # load HuggingFace model UpperCamelCase_ = SwiftFormerForImageClassification(__lowercase).eval() hf_model.load_state_dict(__lowercase) # prepare test inputs UpperCamelCase_ = prepare_img() UpperCamelCase_ = ViTImageProcessor.from_pretrained('preprocessor_config') UpperCamelCase_ = processor(images=__lowercase , return_tensors='pt') # compare outputs from both models UpperCamelCase_ = get_expected_output(__lowercase) UpperCamelCase_ = hf_model(inputs['pixel_values']).logits assert hf_logits.shape == torch.Size([1, 1000]) assert torch.allclose(hf_logits[0, 0:5] , __lowercase , atol=1e-3) Path(__lowercase).mkdir(exist_ok=__lowercase) print(f"""Saving model {swiftformer_name} to {pytorch_dump_folder_path}""") hf_model.save_pretrained(__lowercase) if __name__ == "__main__": snake_case__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--swiftformer_name""", default="""swiftformer_xs""", choices=["""swiftformer_xs""", """swiftformer_s""", """swiftformer_l1""", """swiftformer_l3"""], type=str, help="""Name of the SwiftFormer model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default="""./converted_outputs/""", type=str, help="""Path to the output PyTorch model directory.""", ) parser.add_argument("""--original_ckpt""", default=None, type=str, help="""Path to the original model checkpoint.""") snake_case__ : Tuple = parser.parse_args() convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)
23
from __future__ import annotations from sys import maxsize from typing import Generic, TypeVar snake_case__ : List[str] = TypeVar("""T""") def _snake_case (__lowercase): return (position - 1) // 2 def _snake_case (__lowercase): return (2 * position) + 1 def _snake_case (__lowercase): return (2 * position) + 2 class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = [] UpperCamelCase_ = {} UpperCamelCase_ = 0 def __len__( self ) -> int: return self.elements def __repr__( self ) -> str: return str(self.heap ) def _UpperCAmelCase ( self ) -> bool: # Check if the priority queue is empty return self.elements == 0 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an element with given priority to the queue self.heap.append((elem, weight) ) UpperCamelCase_ = self.elements self.elements += 1 self._bubble_up(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> T: # Remove and return the element with lowest weight (highest priority) if self.elements > 1: self._swap_nodes(0 , self.elements - 1 ) UpperCamelCase_ , UpperCamelCase_ = self.heap.pop() del self.position_map[elem] self.elements -= 1 if self.elements > 0: UpperCamelCase_ , UpperCamelCase_ = self.heap[0] self._bubble_down(_UpperCAmelCase ) return elem def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Update the weight of the given key UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ = (elem, weight) if position > 0: UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._bubble_up(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (upward movement) [to be used internally # only] UpperCamelCase_ = self.position_map[elem] if curr_pos == 0: return None UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_up(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (downward movement) [to be used # internally only] UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ = get_child_left_position(_UpperCAmelCase ) UpperCamelCase_ = get_child_right_position(_UpperCAmelCase ) if child_left_position < self.elements and child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < child_left_weight and child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) if child_left_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] if child_left_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) else: return None if child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Swap the nodes at the given positions UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ , UpperCamelCase_ = ( self.heap[nodea_pos], self.heap[nodea_pos], ) UpperCamelCase_ = nodea_pos UpperCamelCase_ = nodea_pos class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = {} UpperCamelCase_ = 0 def __repr__( self ) -> str: return str(self.connections ) def __len__( self ) -> int: return self.nodes def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Add a node in the graph if it is not in the graph if node not in self.connections: UpperCamelCase_ = {} self.nodes += 1 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an edge between 2 nodes in the graph self.add_node(_UpperCAmelCase ) self.add_node(_UpperCAmelCase ) UpperCamelCase_ = weight UpperCamelCase_ = weight def _snake_case (__lowercase , ): UpperCamelCase_ = {node: maxsize for node in graph.connections} UpperCamelCase_ = {node: None for node in graph.connections} UpperCamelCase_ = MinPriorityQueue() for node, weight in dist.items(): priority_queue.push(__lowercase , __lowercase) if priority_queue.is_empty(): return dist, parent # initialization UpperCamelCase_ = priority_queue.extract_min() UpperCamelCase_ = 0 for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node # running prim's algorithm while not priority_queue.is_empty(): UpperCamelCase_ = priority_queue.extract_min() for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node return dist, parent
23
1
import json import os import unittest from transformers import BatchEncoding, LEDTokenizer, LEDTokenizerFast from transformers.models.led.tokenization_led import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers, require_torch from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _a ( UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = LEDTokenizer A_ = LEDTokenizerFast A_ = True def _UpperCAmelCase ( self ) -> Dict: super().setUp() UpperCamelCase_ = [ 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', '\u0120', '\u0120l', '\u0120n', '\u0120lo', '\u0120low', 'er', '\u0120lowest', '\u0120newer', '\u0120wider', '<unk>', ] UpperCamelCase_ = dict(zip(_UpperCAmelCase , range(len(_UpperCAmelCase ) ) ) ) UpperCamelCase_ = ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', ''] UpperCamelCase_ = {'unk_token': '<unk>'} UpperCamelCase_ = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) UpperCamelCase_ = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['merges_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as fp: fp.write(json.dumps(_UpperCAmelCase ) + '\n' ) with open(self.merges_file , 'w' , encoding='utf-8' ) as fp: fp.write('\n'.join(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> List[str]: kwargs.update(self.special_tokens_map ) return self.tokenizer_class.from_pretrained(self.tmpdirname , **_UpperCAmelCase ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> Union[str, Any]: kwargs.update(self.special_tokens_map ) return self.rust_tokenizer_class.from_pretrained(self.tmpdirname , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Any: return "lower newer", "lower newer" @cached_property def _UpperCAmelCase ( self ) -> Optional[int]: return LEDTokenizer.from_pretrained('allenai/led-base-16384' ) @cached_property def _UpperCAmelCase ( self ) -> Dict: return LEDTokenizerFast.from_pretrained('allenai/led-base-16384' ) @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = ['A long paragraph for summarization.', 'Another paragraph for summarization.'] UpperCamelCase_ = [0, 250, 251, 17818, 13, 39186, 1938, 4, 2] for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]: UpperCamelCase_ = tokenizer(_UpperCAmelCase , max_length=len(_UpperCAmelCase ) , padding=_UpperCAmelCase , return_tensors='pt' ) self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) self.assertEqual((2, 9) , batch.input_ids.shape ) self.assertEqual((2, 9) , batch.attention_mask.shape ) UpperCamelCase_ = batch.input_ids.tolist()[0] self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) @require_torch def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = ['A long paragraph for summarization.', 'Another paragraph for summarization.'] for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]: UpperCamelCase_ = tokenizer(_UpperCAmelCase , padding=_UpperCAmelCase , return_tensors='pt' ) self.assertIn('input_ids' , _UpperCAmelCase ) self.assertIn('attention_mask' , _UpperCAmelCase ) self.assertNotIn('labels' , _UpperCAmelCase ) self.assertNotIn('decoder_attention_mask' , _UpperCAmelCase ) @require_torch def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = [ 'Summary of the text.', 'Another summary.', ] for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]: UpperCamelCase_ = tokenizer(text_target=_UpperCAmelCase , max_length=32 , padding='max_length' , return_tensors='pt' ) self.assertEqual(32 , targets['input_ids'].shape[1] ) @require_torch def _UpperCAmelCase ( self ) -> str: for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]: UpperCamelCase_ = tokenizer( ['I am a small frog' * 1024, 'I am a small frog'] , padding=_UpperCAmelCase , truncation=_UpperCAmelCase , return_tensors='pt' ) self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) self.assertEqual(batch.input_ids.shape , (2, 5122) ) @require_torch def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = ['A long paragraph for summarization.'] UpperCamelCase_ = [ 'Summary of the text.', ] for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]: UpperCamelCase_ = tokenizer(_UpperCAmelCase , return_tensors='pt' ) UpperCamelCase_ = tokenizer(text_target=_UpperCAmelCase , return_tensors='pt' ) UpperCamelCase_ = inputs['input_ids'] UpperCamelCase_ = targets['input_ids'] self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item() ) self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item() ) self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item() ) self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item() ) @require_torch def _UpperCAmelCase ( self ) -> Any: for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]: UpperCamelCase_ = ['Summary of the text.', 'Another summary.'] UpperCamelCase_ = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, -1, -1]] UpperCamelCase_ = tokenizer(_UpperCAmelCase , padding=_UpperCAmelCase ) UpperCamelCase_ = [[0] * len(_UpperCAmelCase ) for x in encoded_output['input_ids']] UpperCamelCase_ = tokenizer.pad(_UpperCAmelCase ) self.assertSequenceEqual(outputs['global_attention_mask'] , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[str]: pass def _UpperCAmelCase ( self ) -> Union[str, Any]: for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ): UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = self.tokenizer_class.from_pretrained(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = 'A, <mask> AllenNLP sentence.' UpperCamelCase_ = tokenizer_r.encode_plus(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , return_token_type_ids=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_p.encode_plus(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , return_token_type_ids=_UpperCAmelCase ) self.assertEqual(sum(tokens_r['token_type_ids'] ) , sum(tokens_p['token_type_ids'] ) ) self.assertEqual( sum(tokens_r['attention_mask'] ) / len(tokens_r['attention_mask'] ) , sum(tokens_p['attention_mask'] ) / len(tokens_p['attention_mask'] ) , ) UpperCamelCase_ = tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids'] ) UpperCamelCase_ = tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids'] ) self.assertSequenceEqual(tokens_p['input_ids'] , [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2] ) self.assertSequenceEqual(tokens_r['input_ids'] , [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2] ) self.assertSequenceEqual( _UpperCAmelCase , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'] ) self.assertSequenceEqual( _UpperCAmelCase , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'] )
23
from __future__ import annotations import sys from collections import deque from typing import Generic, TypeVar snake_case__ : Dict = TypeVar("""T""") class _a ( Generic[T] ): """simple docstring""" A_ = 42 # Cache store of keys A_ = 42 # References of the keys in cache A_ = 10 # Maximum capacity of cache def __init__( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = deque() UpperCamelCase_ = set() if not n: UpperCamelCase_ = sys.maxsize elif n < 0: raise ValueError('n should be an integer greater than 0.' ) else: UpperCamelCase_ = n def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: if x not in self.key_reference: if len(self.dq_store ) == LRUCache._MAX_CAPACITY: UpperCamelCase_ = self.dq_store.pop() self.key_reference.remove(_UpperCAmelCase ) else: self.dq_store.remove(_UpperCAmelCase ) self.dq_store.appendleft(_UpperCAmelCase ) self.key_reference.add(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> None: for k in self.dq_store: print(_UpperCAmelCase ) def __repr__( self ) -> str: return f"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store )}""" if __name__ == "__main__": import doctest doctest.testmod() snake_case__ : LRUCache[str | int] = LRUCache(4) lru_cache.refer("""A""") lru_cache.refer(2) lru_cache.refer(3) lru_cache.refer("""A""") lru_cache.refer(4) lru_cache.refer(5) lru_cache.display() print(lru_cache) assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"
23
1
import os import torch from ..logging import get_logger from .constants import FSDP_PYTORCH_VERSION, MODEL_NAME, OPTIMIZER_NAME from .versions import is_torch_version if is_torch_version(""">=""", FSDP_PYTORCH_VERSION): import torch.distributed.checkpoint as dist_cp from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner, DefaultSavePlanner from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType snake_case__ : List[str] = get_logger(__name__) def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase=0): os.makedirs(__lowercase , exist_ok=__lowercase) with FSDP.state_dict_type( __lowercase , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config): UpperCamelCase_ = model.state_dict() if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: UpperCamelCase_ = f"""{MODEL_NAME}.bin""" if model_index == 0 else f"""{MODEL_NAME}_{model_index}.bin""" UpperCamelCase_ = os.path.join(__lowercase , __lowercase) if accelerator.process_index == 0: logger.info(f"""Saving model to {output_model_file}""") torch.save(__lowercase , __lowercase) logger.info(f"""Model saved to {output_model_file}""") elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT: UpperCamelCase_ = ( f"""{MODEL_NAME}_rank{accelerator.process_index}.bin""" if model_index == 0 else f"""{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin""" ) UpperCamelCase_ = os.path.join(__lowercase , __lowercase) logger.info(f"""Saving model to {output_model_file}""") torch.save(__lowercase , __lowercase) logger.info(f"""Model saved to {output_model_file}""") elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT: UpperCamelCase_ = os.path.join(__lowercase , f"""{MODEL_NAME}_{model_index}""") os.makedirs(__lowercase , exist_ok=__lowercase) logger.info(f"""Saving model to {ckpt_dir}""") UpperCamelCase_ = {'model': state_dict} dist_cp.save_state_dict( state_dict=__lowercase , storage_writer=dist_cp.FileSystemWriter(__lowercase) , planner=DefaultSavePlanner() , ) logger.info(f"""Model saved to {ckpt_dir}""") def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase=0): accelerator.wait_for_everyone() with FSDP.state_dict_type( __lowercase , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config): if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: if type(__lowercase) != FSDP and accelerator.process_index != 0: if not fsdp_plugin.sync_module_states: raise ValueError( 'Set the `sync_module_states` flag to `True` so that model states are synced across processes when ' 'initializing FSDP object') return UpperCamelCase_ = f"""{MODEL_NAME}.bin""" if model_index == 0 else f"""{MODEL_NAME}_{model_index}.bin""" UpperCamelCase_ = os.path.join(__lowercase , __lowercase) logger.info(f"""Loading model from {input_model_file}""") UpperCamelCase_ = torch.load(__lowercase) logger.info(f"""Model loaded from {input_model_file}""") elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT: UpperCamelCase_ = ( f"""{MODEL_NAME}_rank{accelerator.process_index}.bin""" if model_index == 0 else f"""{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin""" ) UpperCamelCase_ = os.path.join(__lowercase , __lowercase) logger.info(f"""Loading model from {input_model_file}""") UpperCamelCase_ = torch.load(__lowercase) logger.info(f"""Model loaded from {input_model_file}""") elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT: UpperCamelCase_ = ( os.path.join(__lowercase , f"""{MODEL_NAME}_{model_index}""") if f"""{MODEL_NAME}""" not in input_dir else input_dir ) logger.info(f"""Loading model from {ckpt_dir}""") UpperCamelCase_ = {'model': model.state_dict()} dist_cp.load_state_dict( state_dict=__lowercase , storage_reader=dist_cp.FileSystemReader(__lowercase) , planner=DefaultLoadPlanner() , ) UpperCamelCase_ = state_dict['model'] logger.info(f"""Model loaded from {ckpt_dir}""") model.load_state_dict(__lowercase) def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase=0): os.makedirs(__lowercase , exist_ok=__lowercase) with FSDP.state_dict_type( __lowercase , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config): UpperCamelCase_ = FSDP.optim_state_dict(__lowercase , __lowercase) if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: if accelerator.process_index == 0: UpperCamelCase_ = ( f"""{OPTIMIZER_NAME}.bin""" if optimizer_index == 0 else f"""{OPTIMIZER_NAME}_{optimizer_index}.bin""" ) UpperCamelCase_ = os.path.join(__lowercase , __lowercase) logger.info(f"""Saving Optimizer state to {output_optimizer_file}""") torch.save(__lowercase , __lowercase) logger.info(f"""Optimizer state saved in {output_optimizer_file}""") else: UpperCamelCase_ = os.path.join(__lowercase , f"""{OPTIMIZER_NAME}_{optimizer_index}""") os.makedirs(__lowercase , exist_ok=__lowercase) logger.info(f"""Saving Optimizer state to {ckpt_dir}""") dist_cp.save_state_dict( state_dict={'optimizer': optim_state} , storage_writer=dist_cp.FileSystemWriter(__lowercase) , planner=DefaultSavePlanner() , ) logger.info(f"""Optimizer state saved in {ckpt_dir}""") def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase=0): accelerator.wait_for_everyone() with FSDP.state_dict_type( __lowercase , fsdp_plugin.state_dict_type , fsdp_plugin.state_dict_config , fsdp_plugin.optim_state_dict_config): if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT: UpperCamelCase_ = None # below check should work but currently it isn't working (mostly opytorch issue), # in the meantime disabling it at the cost of excess memory usage # if accelerator.process_index == 0 or not fsdp_plugin.optim_state_dict_config.rank0_only: UpperCamelCase_ = ( f"""{OPTIMIZER_NAME}.bin""" if optimizer_index == 0 else f"""{OPTIMIZER_NAME}_{optimizer_index}.bin""" ) UpperCamelCase_ = os.path.join(__lowercase , __lowercase) logger.info(f"""Loading Optimizer state from {input_optimizer_file}""") UpperCamelCase_ = torch.load(__lowercase) logger.info(f"""Optimizer state loaded from {input_optimizer_file}""") else: UpperCamelCase_ = ( os.path.join(__lowercase , f"""{OPTIMIZER_NAME}_{optimizer_index}""") if f"""{OPTIMIZER_NAME}""" not in input_dir else input_dir ) logger.info(f"""Loading Optimizer from {ckpt_dir}""") UpperCamelCase_ = load_sharded_optimizer_state_dict( model_state_dict=model.state_dict() , optimizer_key='optimizer' , storage_reader=dist_cp.FileSystemReader(__lowercase) , ) UpperCamelCase_ = optim_state['optimizer'] logger.info(f"""Optimizer loaded from {ckpt_dir}""") UpperCamelCase_ = FSDP.optim_state_dict_to_load(__lowercase , __lowercase , __lowercase) optimizer.load_state_dict(__lowercase)
23
import numpy as np def _snake_case (__lowercase): return 1 / (1 + np.exp(-vector)) def _snake_case (__lowercase): return vector * sigmoid(__lowercase) if __name__ == "__main__": import doctest doctest.testmod()
23
1
from __future__ import annotations def _snake_case (__lowercase): UpperCamelCase_ = 2 UpperCamelCase_ = [] while i * i <= n: if n % i: i += 1 else: n //= i factors.append(__lowercase) if n > 1: factors.append(__lowercase) return factors if __name__ == "__main__": import doctest doctest.testmod()
23
import math from datetime import datetime, timedelta def _snake_case (__lowercase): UpperCamelCase_ = year % 19 UpperCamelCase_ = year % 4 UpperCamelCase_ = year % 7 UpperCamelCase_ = math.floor(year / 100) UpperCamelCase_ = math.floor((13 + 8 * leap_day_inhibits) / 25) UpperCamelCase_ = leap_day_inhibits / 4 UpperCamelCase_ = ( 15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number ) % 30 UpperCamelCase_ = (4 + leap_day_inhibits - leap_day_reinstall_number) % 7 # days to be added to March 21 UpperCamelCase_ = (19 * metonic_cycle + secular_moon_shift) % 30 # PHM -> Paschal Full Moon UpperCamelCase_ = ( 2 * julian_leap_year + 4 * non_leap_year + 6 * days_to_add + century_starting_point ) % 7 if days_to_add == 29 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 19) elif days_to_add == 28 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 18) else: return datetime(__lowercase , 3 , 22) + timedelta( days=int(days_to_add + days_from_phm_to_sunday)) if __name__ == "__main__": for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3): snake_case__ : Dict = """will be""" if year > datetime.now().year else """was""" print(f'Easter in {year} {tense} {gauss_easter(year)}')
23
1
import pickle import numpy as np from matplotlib import pyplot as plt class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=0.2 , _UpperCAmelCase=0.2 ) -> List[Any]: UpperCamelCase_ = bp_numa UpperCamelCase_ = bp_numa UpperCamelCase_ = bp_numa UpperCamelCase_ = conva_get[:2] UpperCamelCase_ = conva_get[2] UpperCamelCase_ = size_pa UpperCamelCase_ = rate_w UpperCamelCase_ = rate_t UpperCamelCase_ = [ np.mat(-1 * np.random.rand(self.conva[0] , self.conva[0] ) + 0.5 ) for i in range(self.conva[1] ) ] UpperCamelCase_ = np.mat(-1 * np.random.rand(self.num_bpa , self.num_bpa ) + 0.5 ) UpperCamelCase_ = np.mat(-1 * np.random.rand(self.num_bpa , self.num_bpa ) + 0.5 ) UpperCamelCase_ = -2 * np.random.rand(self.conva[1] ) + 1 UpperCamelCase_ = -2 * np.random.rand(self.num_bpa ) + 1 UpperCamelCase_ = -2 * np.random.rand(self.num_bpa ) + 1 def _UpperCAmelCase ( self , _UpperCAmelCase ) -> int: # save model dict with pickle UpperCamelCase_ = { 'num_bp1': self.num_bpa, 'num_bp2': self.num_bpa, 'num_bp3': self.num_bpa, 'conv1': self.conva, 'step_conv1': self.step_conva, 'size_pooling1': self.size_poolinga, 'rate_weight': self.rate_weight, 'rate_thre': self.rate_thre, 'w_conv1': self.w_conva, 'wkj': self.wkj, 'vji': self.vji, 'thre_conv1': self.thre_conva, 'thre_bp2': self.thre_bpa, 'thre_bp3': self.thre_bpa, } with open(_UpperCAmelCase , 'wb' ) as f: pickle.dump(_UpperCAmelCase , _UpperCAmelCase ) print(f"""Model saved: {save_path}""" ) @classmethod def _UpperCAmelCase ( cls , _UpperCAmelCase ) -> Optional[Any]: # read saved model with open(_UpperCAmelCase , 'rb' ) as f: UpperCamelCase_ = pickle.load(_UpperCAmelCase ) # noqa: S301 UpperCamelCase_ = model_dic.get('conv1' ) conv_get.append(model_dic.get('step_conv1' ) ) UpperCamelCase_ = model_dic.get('size_pooling1' ) UpperCamelCase_ = model_dic.get('num_bp1' ) UpperCamelCase_ = model_dic.get('num_bp2' ) UpperCamelCase_ = model_dic.get('num_bp3' ) UpperCamelCase_ = model_dic.get('rate_weight' ) UpperCamelCase_ = model_dic.get('rate_thre' ) # create model instance UpperCamelCase_ = CNN(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) # modify model parameter UpperCamelCase_ = model_dic.get('w_conv1' ) UpperCamelCase_ = model_dic.get('wkj' ) UpperCamelCase_ = model_dic.get('vji' ) UpperCamelCase_ = model_dic.get('thre_conv1' ) UpperCamelCase_ = model_dic.get('thre_bp2' ) UpperCamelCase_ = model_dic.get('thre_bp3' ) return conv_ins def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: return 1 / (1 + np.exp(-1 * x )) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> str: return round(_UpperCAmelCase , 3 ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: # convolution process UpperCamelCase_ = convs[0] UpperCamelCase_ = convs[1] UpperCamelCase_ = np.shape(_UpperCAmelCase )[0] # get the data slice of original image data, data_focus UpperCamelCase_ = [] for i_focus in range(0 , size_data - size_conv + 1 , _UpperCAmelCase ): for j_focus in range(0 , size_data - size_conv + 1 , _UpperCAmelCase ): UpperCamelCase_ = data[ i_focus : i_focus + size_conv, j_focus : j_focus + size_conv ] data_focus.append(_UpperCAmelCase ) # calculate the feature map of every single kernel, and saved as list of matrix UpperCamelCase_ = [] UpperCamelCase_ = int((size_data - size_conv) / conv_step + 1 ) for i_map in range(_UpperCAmelCase ): UpperCamelCase_ = [] for i_focus in range(len(_UpperCAmelCase ) ): UpperCamelCase_ = ( np.sum(np.multiply(data_focus[i_focus] , w_convs[i_map] ) ) - thre_convs[i_map] ) featuremap.append(self.sig(_UpperCAmelCase ) ) UpperCamelCase_ = np.asmatrix(_UpperCAmelCase ).reshape( _UpperCAmelCase , _UpperCAmelCase ) data_featuremap.append(_UpperCAmelCase ) # expanding the data slice to One dimenssion UpperCamelCase_ = [] for each_focus in data_focus: focusa_list.extend(self.Expand_Mat(_UpperCAmelCase ) ) UpperCamelCase_ = np.asarray(_UpperCAmelCase ) return focus_list, data_featuremap def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase="average_pool" ) -> Tuple: # pooling process UpperCamelCase_ = len(featuremaps[0] ) UpperCamelCase_ = int(size_map / size_pooling ) UpperCamelCase_ = [] for i_map in range(len(_UpperCAmelCase ) ): UpperCamelCase_ = featuremaps[i_map] UpperCamelCase_ = [] for i_focus in range(0 , _UpperCAmelCase , _UpperCAmelCase ): for j_focus in range(0 , _UpperCAmelCase , _UpperCAmelCase ): UpperCamelCase_ = feature_map[ i_focus : i_focus + size_pooling, j_focus : j_focus + size_pooling, ] if pooling_type == "average_pool": # average pooling map_pooled.append(np.average(_UpperCAmelCase ) ) elif pooling_type == "max_pooling": # max pooling map_pooled.append(np.max(_UpperCAmelCase ) ) UpperCamelCase_ = np.asmatrix(_UpperCAmelCase ).reshape(_UpperCAmelCase , _UpperCAmelCase ) featuremap_pooled.append(_UpperCAmelCase ) return featuremap_pooled def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Union[str, Any]: # expanding three dimension data to one dimension list UpperCamelCase_ = [] for i in range(len(_UpperCAmelCase ) ): UpperCamelCase_ = np.shape(data[i] ) UpperCamelCase_ = data[i].reshape(1 , shapes[0] * shapes[1] ) UpperCamelCase_ = data_listed.getA().tolist()[0] data_expanded.extend(_UpperCAmelCase ) UpperCamelCase_ = np.asarray(_UpperCAmelCase ) return data_expanded def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[str]: # expanding matrix to one dimension list UpperCamelCase_ = np.asarray(_UpperCAmelCase ) UpperCamelCase_ = np.shape(_UpperCAmelCase ) UpperCamelCase_ = data_mat.reshape(1 , shapes[0] * shapes[1] ) return data_expanded def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = [] UpperCamelCase_ = 0 for i_map in range(_UpperCAmelCase ): UpperCamelCase_ = np.ones((size_map, size_map) ) for i in range(0 , _UpperCAmelCase , _UpperCAmelCase ): for j in range(0 , _UpperCAmelCase , _UpperCAmelCase ): UpperCamelCase_ = pd_pool[ i_pool ] UpperCamelCase_ = i_pool + 1 UpperCamelCase_ = np.multiply( _UpperCAmelCase , np.multiply(out_map[i_map] , (1 - out_map[i_map]) ) ) pd_all.append(_UpperCAmelCase ) return pd_all def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=bool ) -> Any: # model traning print('----------------------Start Training-------------------------' ) print((' - - Shape: Train_Data ', np.shape(_UpperCAmelCase )) ) print((' - - Shape: Teach_Data ', np.shape(_UpperCAmelCase )) ) UpperCamelCase_ = 0 UpperCamelCase_ = [] UpperCamelCase_ = 10000 while rp < n_repeat and mse >= error_accuracy: UpperCamelCase_ = 0 print(f"""-------------Learning Time {rp}--------------""" ) for p in range(len(_UpperCAmelCase ) ): # print('------------Learning Image: %d--------------'%p) UpperCamelCase_ = np.asmatrix(datas_train[p] ) UpperCamelCase_ = np.asarray(datas_teach[p] ) UpperCamelCase_ , UpperCamelCase_ = self.convolute( _UpperCAmelCase , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) UpperCamelCase_ = self.pooling(_UpperCAmelCase , self.size_poolinga ) UpperCamelCase_ = np.shape(_UpperCAmelCase ) UpperCamelCase_ = self._expand(_UpperCAmelCase ) UpperCamelCase_ = data_bp_input UpperCamelCase_ = np.dot(_UpperCAmelCase , self.vji.T ) - self.thre_bpa UpperCamelCase_ = self.sig(_UpperCAmelCase ) UpperCamelCase_ = np.dot(_UpperCAmelCase , self.wkj.T ) - self.thre_bpa UpperCamelCase_ = self.sig(_UpperCAmelCase ) # --------------Model Leaning ------------------------ # calculate error and gradient--------------- UpperCamelCase_ = np.multiply( (data_teach - bp_outa) , np.multiply(_UpperCAmelCase , (1 - bp_outa) ) ) UpperCamelCase_ = np.multiply( np.dot(_UpperCAmelCase , self.wkj ) , np.multiply(_UpperCAmelCase , (1 - bp_outa) ) ) UpperCamelCase_ = np.dot(_UpperCAmelCase , self.vji ) UpperCamelCase_ = pd_i_all / (self.size_poolinga * self.size_poolinga) UpperCamelCase_ = pd_conva_pooled.T.getA().tolist() UpperCamelCase_ = self._calculate_gradient_from_pool( _UpperCAmelCase , _UpperCAmelCase , shape_featuremapa[0] , shape_featuremapa[1] , self.size_poolinga , ) # weight and threshold learning process--------- # convolution layer for k_conv in range(self.conva[1] ): UpperCamelCase_ = self._expand_mat(pd_conva_all[k_conv] ) UpperCamelCase_ = self.rate_weight * np.dot(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = self.w_conva[k_conv] + delta_w.reshape( (self.conva[0], self.conva[0]) ) UpperCamelCase_ = ( self.thre_conva[k_conv] - np.sum(pd_conva_all[k_conv] ) * self.rate_thre ) # all connected layer UpperCamelCase_ = self.wkj + pd_k_all.T * bp_outa * self.rate_weight UpperCamelCase_ = self.vji + pd_j_all.T * bp_outa * self.rate_weight UpperCamelCase_ = self.thre_bpa - pd_k_all * self.rate_thre UpperCamelCase_ = self.thre_bpa - pd_j_all * self.rate_thre # calculate the sum error of all single image UpperCamelCase_ = np.sum(abs(data_teach - bp_outa ) ) error_count += errors # print(' ----Teach ',data_teach) # print(' ----BP_output ',bp_out3) UpperCamelCase_ = rp + 1 UpperCamelCase_ = error_count / patterns all_mse.append(_UpperCAmelCase ) def draw_error(): UpperCamelCase_ = [error_accuracy for i in range(int(n_repeat * 1.2 ) )] plt.plot(_UpperCAmelCase , '+-' ) plt.plot(_UpperCAmelCase , 'r--' ) plt.xlabel('Learning Times' ) plt.ylabel('All_mse' ) plt.grid(_UpperCAmelCase , alpha=0.5 ) plt.show() print('------------------Training Complished---------------------' ) print((' - - Training epoch: ', rp, f""" - - Mse: {mse:.6f}""") ) if draw_e: draw_error() return mse def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Optional[Any]: # model predict UpperCamelCase_ = [] print('-------------------Start Testing-------------------------' ) print((' - - Shape: Test_Data ', np.shape(_UpperCAmelCase )) ) for p in range(len(_UpperCAmelCase ) ): UpperCamelCase_ = np.asmatrix(datas_test[p] ) UpperCamelCase_ , UpperCamelCase_ = self.convolute( _UpperCAmelCase , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) UpperCamelCase_ = self.pooling(_UpperCAmelCase , self.size_poolinga ) UpperCamelCase_ = self._expand(_UpperCAmelCase ) UpperCamelCase_ = data_bp_input UpperCamelCase_ = bp_outa * self.vji.T - self.thre_bpa UpperCamelCase_ = self.sig(_UpperCAmelCase ) UpperCamelCase_ = bp_outa * self.wkj.T - self.thre_bpa UpperCamelCase_ = self.sig(_UpperCAmelCase ) produce_out.extend(bp_outa.getA().tolist() ) UpperCamelCase_ = [list(map(self.do_round , _UpperCAmelCase ) ) for each in produce_out] return np.asarray(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Union[str, Any]: # return the data of image after convoluting process so we can check it out UpperCamelCase_ = np.asmatrix(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.convolute( _UpperCAmelCase , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) UpperCamelCase_ = self.pooling(_UpperCAmelCase , self.size_poolinga ) return data_conveda, data_pooleda if __name__ == "__main__": pass
23
import requests def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = {'Content-Type': 'application/json'} UpperCamelCase_ = requests.post(__lowercase , json={'text': message_body} , headers=__lowercase) if response.status_code != 200: UpperCamelCase_ = ( 'Request to slack returned an error ' f"""{response.status_code}, the response is:\n{response.text}""" ) raise ValueError(__lowercase) if __name__ == "__main__": # Set the slack url to the one provided by Slack when you create the webhook at # https://my.slack.com/services/new/incoming-webhook/ send_slack_message("""<YOUR MESSAGE BODY>""", """<SLACK CHANNEL URL>""")
23
1
def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = 0 while b > 0: if b & 1: res += a a += a b >>= 1 return res def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = 0 while b > 0: if b & 1: UpperCamelCase_ = ((res % c) + (a % c)) % c a += a b >>= 1 return res
23
import re from pathlib import Path from unittest import TestCase import pytest @pytest.mark.integration class _a ( UpperCAmelCase__ ): """simple docstring""" def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)' ) UpperCamelCase_ = input_file.read() UpperCamelCase_ = regexp.search(_UpperCAmelCase ) return match def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()' , re.DOTALL ) UpperCamelCase_ = input_file.read() # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search` UpperCamelCase_ = regexp.finditer(_UpperCAmelCase ) UpperCamelCase_ = [match for match in matches if match is not None and match.group(1 ) is not None] return matches[0] if matches else None def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_encoding_on_file_open(str(_UpperCAmelCase ) ): raise AssertionError(f"""open(...) must use utf-8 encoding in {dataset}""" ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_print_statements(str(_UpperCAmelCase ) ): raise AssertionError(f"""print statement found in {dataset}. Use datasets.logger/logging instead.""" )
23
1
snake_case__ : Any = """ # Transformers installation ! pip install transformers datasets # To install from source instead of the last release, comment the command above and uncomment the following one. # ! pip install git+https://github.com/huggingface/transformers.git """ snake_case__ : Dict = [{"""type""": """code""", """content""": INSTALL_CONTENT}] snake_case__ : Optional[Any] = { """{processor_class}""": """FakeProcessorClass""", """{model_class}""": """FakeModelClass""", """{object_class}""": """FakeObjectClass""", }
23
import argparse import random import joblib import numpy as np import torch from igf.igf import ( SecondaryLearner, collect_objective_set, compute_perplexity, generate_datasets, load_gpta, recopy_gpta, set_seed, train_secondary_learner, ) from torch.utils.data import DataLoader, RandomSampler from transformers import GPTaLMHeadModel def _snake_case (__lowercase=32 , __lowercase=10 , __lowercase=100 , __lowercase=1026 , __lowercase=True , __lowercase="data/tokenized_stories_train_wikitext103.jbl" , __lowercase="igf_context_pairs.jbl" , ): set_seed(3) # generate train_data and objective_set UpperCamelCase_ , UpperCamelCase_ = generate_datasets( __lowercase , __lowercase , number=__lowercase , min_len=1026 , trim=__lowercase) # keeps model same across runs set_seed(4) # model, lm_optimizer, lm_scheduler = recopy_gpt2(model, device, max_steps) # store original model weights # can we train on GPU? UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # load pretrained model UpperCamelCase_ = load_gpta('gpt2').to(__lowercase) print('computing perplexity on objective set') UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase).item() print('perplexity on objective set:' , __lowercase) # collect igf pairs and save to file demo.jbl collect_objective_set(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # clean up, delete model and data we don't need anymore del model, train_data, objective_set torch.cuda.empty_cache() def _snake_case (__lowercase , __lowercase=15 , __lowercase=128 , __lowercase=100 , __lowercase="igf_model.pt" , ): set_seed(42) # Load pre-trained model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') # Initialize secondary learner to use embedding weights of model UpperCamelCase_ = SecondaryLearner(__lowercase) # Train secondary learner UpperCamelCase_ = train_secondary_learner( __lowercase , __lowercase , max_epochs=__lowercase , batch_size=__lowercase , eval_freq=100 , igf_model_path=__lowercase , ) del model, secondary_learner_train_data torch.cuda.empty_cache() return secondary_learner def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=32 , __lowercase=1000 , __lowercase=16 , __lowercase=1.0 , __lowercase=recopy_gpta , __lowercase=None , __lowercase=10 , __lowercase="gpt2_finetuned.pt" , ): UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') UpperCamelCase_ = RandomSampler(__lowercase) UpperCamelCase_ = DataLoader(__lowercase , sampler=__lowercase) UpperCamelCase_ = max_steps // (len(__lowercase)) + 1 UpperCamelCase_ = 0 UpperCamelCase_ = torch.zeros((1, context_len) , dtype=torch.long , device=__lowercase) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = recopy_model(__lowercase , __lowercase , __lowercase) model.train() if secondary_learner is not None: secondary_learner.to(__lowercase) secondary_learner.eval() UpperCamelCase_ = [] UpperCamelCase_ = 0 UpperCamelCase_ = [] UpperCamelCase_ = [] # Compute the performance of the transformer model at the beginning UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) for epoch in range(int(__lowercase)): for step, example in enumerate(__lowercase): torch.cuda.empty_cache() UpperCamelCase_ = random.randint(0 , example.size(2) - context_len - 1) UpperCamelCase_ = example[0, 0, start : start + context_len] lm_optimizer.zero_grad() UpperCamelCase_ = model(__lowercase , labels=__lowercase) UpperCamelCase_ = True if secondary_learner is not None: UpperCamelCase_ = secondary_learner.forward( torch.tensor(__lowercase , dtype=torch.long , device=__lowercase).unsqueeze(0))[0].item() observed_qs.append(float(__lowercase)) # Here we implement the simple non-constant threshold for the predicted IG(X) value # We will decay the selectivity of our secondary learner filter from # 1 standard deviation above average to 1 below average after 10 batches. if global_step == 10: UpperCamelCase_ = -1 if predicted_q < threshold: UpperCamelCase_ = False # If we passed the filter, add the context to the batch! if do_backprop: contexts.append(np.array(context.cpu())) UpperCamelCase_ = outputs[0] lm_loss.backward() examples += 1 del outputs # Once the batch is filled with enough contexts, backprop on the batch. if examples == batch_size: torch.cuda.empty_cache() UpperCamelCase_ = 0 # Do LM backprop torch.nn.utils.clip_grad_norm_(model.parameters() , 3.0) lm_optimizer.step() lm_scheduler.step() # Update learning rate schedule global_step += 1 # Compute the performance of the transformer model at this batch if global_step % eval_interval == 0: UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) # Break out of the loop after 60 batches if max_steps > 0 and global_step > 60: break if max_steps > 0 and global_step > 60: break # save finetuned transformer model torch.save(model.state_dict() , __lowercase) torch.cuda.empty_cache() # Do some cleaning up so we can reinitialize for the next run of this function del lm_optimizer del lm_scheduler return model def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Fine-tune a transformer model with IGF on a language modeling task') # Required parameters parser.add_argument( '--data_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The input data dir. Should contain data files for WikiText.' , ) parser.add_argument( '--model_name_or_path' , default=__lowercase , type=__lowercase , required=__lowercase , help='Path to pretrained model or model identifier from huggingface.co/models' , ) parser.add_argument( '--data_file' , type=__lowercase , default=__lowercase , help=( 'A jbl file containing tokenized data which can be split as objective dataset, ' 'train_dataset and test_dataset.' ) , ) parser.add_argument( '--igf_data_file' , type=__lowercase , default=__lowercase , help='A jbl file containing the context and information gain pairs to train secondary learner.' , ) parser.add_argument( '--output_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The output directory where the final fine-tuned model is stored.' , ) parser.add_argument( '--tokenizer_name' , default=__lowercase , type=__lowercase , help='Pretrained tokenizer name or path if not the same as model_name' , ) parser.add_argument('--seed' , type=__lowercase , default=__lowercase , help='A seed for reproducible training.') parser.add_argument( '--context_len' , default=32 , type=__lowercase , help=( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) , ) parser.add_argument( '--size_objective_set' , default=100 , type=__lowercase , help='number of articles that are long enough to be used as our objective set' , ) parser.add_argument( '--eval_freq' , default=100 , type=__lowercase , help='secondary model evaluation is triggered at eval_freq') parser.add_argument('--max_steps' , default=1000 , type=__lowercase , help='To calculate training epochs') parser.add_argument( '--secondary_learner_batch_size' , default=128 , type=__lowercase , help='batch size of training data for secondary learner' , ) parser.add_argument( '--batch_size' , default=16 , type=__lowercase , help='batch size of training data of language model(gpt2) ') parser.add_argument( '--eval_interval' , default=10 , type=__lowercase , help=( 'decay the selectivity of our secondary learner filter from' '1 standard deviation above average to 1 below average after 10 batches' ) , ) parser.add_argument( '--number' , default=100 , type=__lowercase , help='The number of examples split to be used as objective_set/test_data') parser.add_argument( '--min_len' , default=1026 , type=__lowercase , help='The minimum length of the article to be used as objective set') parser.add_argument( '--secondary_learner_max_epochs' , default=15 , type=__lowercase , help='number of epochs to train secondary learner') parser.add_argument('--trim' , default=__lowercase , type=__lowercase , help='truncate the example if it exceeds context length') parser.add_argument( '--threshold' , default=1.0 , type=__lowercase , help=( 'The threshold value used by secondary learner to filter the train_data and allow only' ' informative data as input to the model' ) , ) parser.add_argument('--finetuned_model_name' , default='gpt2_finetuned.pt' , type=__lowercase , help='finetuned_model_name') parser.add_argument( '--recopy_model' , default=__lowercase , type=__lowercase , help='Reset the model to the original pretrained GPT-2 weights after each iteration' , ) # function calls # Collecting *n* pairs of context and information gain(X, IG(X)) for training the secondary learner generate_n_pairs( context_len=32 , max_steps=10 , size_objective_set=100 , min_len=1026 , trim=__lowercase , data_file='data/tokenized_stories_train_wikitext103.jbl' , igf_data_file='igf_context_pairs.jbl' , ) # Load train data for secondary learner UpperCamelCase_ = joblib.load('data/IGF_values.jbl') # Train secondary learner UpperCamelCase_ = training_secondary_learner( __lowercase , secondary_learner_max_epochs=15 , secondary_learner_batch_size=128 , eval_freq=100 , igf_model_path='igf_model.pt' , ) # load pretrained gpt2 model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') set_seed(42) # Generate train and test data to train and evaluate gpt2 model UpperCamelCase_ , UpperCamelCase_ = generate_datasets( context_len=32 , file='data/tokenized_stories_train_wikitext103.jbl' , number=100 , min_len=1026 , trim=__lowercase) # fine-tuning of the gpt2 model using igf (Information Gain Filtration) finetune( __lowercase , __lowercase , __lowercase , context_len=32 , max_steps=1000 , batch_size=16 , threshold=1.0 , recopy_model=__lowercase , secondary_learner=__lowercase , eval_interval=10 , finetuned_model_name='gpt2_finetuned.pt' , ) if __name__ == "__main__": main()
23
1
import jax.numpy as jnp from ...utils import logging from ..ta.modeling_flax_ta import FlaxTaEncoderModel, FlaxTaForConditionalGeneration, FlaxTaModel from .configuration_mta import MTaConfig snake_case__ : List[Any] = logging.get_logger(__name__) snake_case__ : Any = """T5Config""" def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = jnp.zeros_like(__lowercase) UpperCamelCase_ = shifted_input_ids.at[:, 1:].set(input_ids[:, :-1]) UpperCamelCase_ = shifted_input_ids.at[:, 0].set(__lowercase) UpperCamelCase_ = jnp.where(shifted_input_ids == -100 , __lowercase , __lowercase) return shifted_input_ids class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """mt5""" A_ = MTaConfig class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """mt5""" A_ = MTaConfig class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """mt5""" A_ = MTaConfig
23
from __future__ import annotations import unittest from transformers import AutoTokenizer, MBartConfig, is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel @require_tf class _a : """simple docstring""" A_ = MBartConfig A_ = {} A_ = """gelu""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=99 , _UpperCAmelCase=32 , _UpperCAmelCase=2 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=20 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , ) -> Union[str, Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = eos_token_id UpperCamelCase_ = pad_token_id UpperCamelCase_ = bos_token_id def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) UpperCamelCase_ = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ) , 1 ) UpperCamelCase_ = tf.concat([input_ids, eos_tensor] , axis=1 ) UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) UpperCamelCase_ = prepare_mbart_inputs_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = TFMBartModel(config=_UpperCAmelCase ).get_decoder() UpperCamelCase_ = inputs_dict['input_ids'] UpperCamelCase_ = input_ids[:1, :] UpperCamelCase_ = inputs_dict['attention_mask'][:1, :] UpperCamelCase_ = inputs_dict['head_mask'] UpperCamelCase_ = 1 # first forward pass UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , head_mask=_UpperCAmelCase , use_cache=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = outputs.to_tuple() UpperCamelCase_ = past_key_values[1] def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , ): if attention_mask is None: UpperCamelCase_ = tf.cast(tf.math.not_equal(__lowercase , config.pad_token_id) , tf.inta) if decoder_attention_mask is None: UpperCamelCase_ = tf.concat( [ tf.ones(decoder_input_ids[:, :1].shape , dtype=tf.inta), tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id) , tf.inta), ] , axis=-1 , ) if head_mask is None: UpperCamelCase_ = tf.ones((config.encoder_layers, config.encoder_attention_heads)) if decoder_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) if cross_attn_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } @require_tf class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else () A_ = (TFMBartForConditionalGeneration,) if is_tf_available() else () A_ = ( { """conversational""": TFMBartForConditionalGeneration, """feature-extraction""": TFMBartModel, """summarization""": TFMBartForConditionalGeneration, """text2text-generation""": TFMBartForConditionalGeneration, """translation""": TFMBartForConditionalGeneration, } if is_tf_available() else {} ) A_ = True A_ = False A_ = False def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: if pipeline_test_casse_name != "FeatureExtractionPipelineTests": # Exception encountered when calling layer '...' return True return False def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = TFMBartModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase ) @require_sentencepiece @require_tokenizers @require_tf class _a ( unittest.TestCase ): """simple docstring""" A_ = [ """ UN Chief Says There Is No Military Solution in Syria""", ] A_ = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", ] A_ = """facebook/mbart-large-en-ro""" @cached_property def _UpperCAmelCase ( self ) -> Any: return AutoTokenizer.from_pretrained(self.model_name ) @cached_property def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name ) return model def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> int: UpperCamelCase_ = self.translate_src_text(**_UpperCAmelCase ) self.assertListEqual(self.expected_text , _UpperCAmelCase ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> List[str]: UpperCamelCase_ = self.tokenizer(self.src_text , **_UpperCAmelCase , return_tensors='tf' ) UpperCamelCase_ = self.model.generate( model_inputs.input_ids , attention_mask=model_inputs.attention_mask , num_beams=2 ) UpperCamelCase_ = self.tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) return generated_words @slow def _UpperCAmelCase ( self ) -> List[Any]: self._assert_generated_batch_equal_expected()
23
1
import unittest from transformers import BigBirdTokenizer, BigBirdTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin snake_case__ : int = """▁""" snake_case__ : Tuple = get_tests_dir("""fixtures/test_sentencepiece.model""") @require_sentencepiece @require_tokenizers class _a ( UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = BigBirdTokenizer A_ = BigBirdTokenizerFast A_ = True A_ = True def _UpperCAmelCase ( self ) -> int: super().setUp() UpperCamelCase_ = self.tokenizer_class(_UpperCAmelCase , keep_accents=_UpperCAmelCase ) tokenizer.save_pretrained(self.tmpdirname ) def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = '<s>' UpperCamelCase_ = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_UpperCAmelCase ) , _UpperCAmelCase ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_UpperCAmelCase ) , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '<unk>' ) self.assertEqual(vocab_keys[1] , '<s>' ) self.assertEqual(vocab_keys[-1] , '[MASK]' ) self.assertEqual(len(_UpperCAmelCase ) , 1004 ) def _UpperCAmelCase ( self ) -> Dict: self.assertEqual(self.get_tokenizer().vocab_size , 1000 ) def _UpperCAmelCase ( self ) -> Optional[Any]: if not self.test_rust_tokenizer: return UpperCamelCase_ = self.get_tokenizer() UpperCamelCase_ = self.get_rust_tokenizer() UpperCamelCase_ = 'I was born in 92000, and this is falsé.' UpperCamelCase_ = tokenizer.tokenize(_UpperCAmelCase ) UpperCamelCase_ = rust_tokenizer.tokenize(_UpperCAmelCase ) self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = rust_tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = self.get_rust_tokenizer() UpperCamelCase_ = tokenizer.encode(_UpperCAmelCase ) UpperCamelCase_ = rust_tokenizer.encode(_UpperCAmelCase ) self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ = BigBirdTokenizer(_UpperCAmelCase , keep_accents=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.tokenize('This is a test' ) self.assertListEqual(_UpperCAmelCase , ['▁This', '▁is', '▁a', '▁t', 'est'] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(_UpperCAmelCase ) , [285, 46, 10, 170, 382] , ) UpperCamelCase_ = tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( _UpperCAmelCase , [ 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', 'é', '.', ] , ) UpperCamelCase_ = tokenizer.convert_tokens_to_ids(_UpperCAmelCase ) self.assertListEqual( _UpperCAmelCase , [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4] , ) UpperCamelCase_ = tokenizer.convert_ids_to_tokens(_UpperCAmelCase ) self.assertListEqual( _UpperCAmelCase , [ 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>', '.', ] , ) @cached_property def _UpperCAmelCase ( self ) -> List[Any]: return BigBirdTokenizer.from_pretrained('google/bigbird-roberta-base' ) @slow def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = 'Hello World!' UpperCamelCase_ = [65, 18536, 2260, 101, 66] self.assertListEqual(_UpperCAmelCase , self.big_tokenizer.encode(_UpperCAmelCase ) ) @slow def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = ( 'This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will' ' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth' ) # fmt: off UpperCamelCase_ = [65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 34324, 497, 391, 408, 11342, 1244, 385, 100, 938, 985, 456, 574, 362, 12597, 3200, 3129, 1172, 66] # noqa: E231 # fmt: on self.assertListEqual(_UpperCAmelCase , self.big_tokenizer.encode(_UpperCAmelCase ) ) @require_torch @slow def _UpperCAmelCase ( self ) -> Optional[Any]: import torch from transformers import BigBirdConfig, BigBirdModel # Build sequence UpperCamelCase_ = list(self.big_tokenizer.get_vocab().keys() )[:10] UpperCamelCase_ = ' '.join(_UpperCAmelCase ) UpperCamelCase_ = self.big_tokenizer.encode_plus(_UpperCAmelCase , return_tensors='pt' , return_token_type_ids=_UpperCAmelCase ) UpperCamelCase_ = self.big_tokenizer.batch_encode_plus( [sequence + ' ' + sequence] , return_tensors='pt' , return_token_type_ids=_UpperCAmelCase ) UpperCamelCase_ = BigBirdConfig(attention_type='original_full' ) UpperCamelCase_ = BigBirdModel(_UpperCAmelCase ) assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size with torch.no_grad(): model(**_UpperCAmelCase ) model(**_UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = BigBirdTokenizer.from_pretrained('google/bigbird-roberta-base' ) UpperCamelCase_ = tokenizer.decode(tokenizer('Paris is the [MASK].' ).input_ids ) self.assertTrue(decoded_text == '[CLS] Paris is the[MASK].[SEP]' ) @slow def _UpperCAmelCase ( self ) -> Optional[Any]: # fmt: off UpperCamelCase_ = {'input_ids': [[65, 39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114, 66], [65, 448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=_UpperCAmelCase , model_name='google/bigbird-roberta-base' , revision='215c99f1600e06f83acce68422f2035b2b5c3510' , )
23
def _snake_case (__lowercase): UpperCamelCase_ = 1 for i in range(1 , num + 1): fact *= i return fact def _snake_case (__lowercase): UpperCamelCase_ = 0 while number > 0: UpperCamelCase_ = number % 10 sum_of_digits += last_digit UpperCamelCase_ = number // 10 # Removing the last_digit from the given number return sum_of_digits def _snake_case (__lowercase = 100): UpperCamelCase_ = factorial(__lowercase) UpperCamelCase_ = split_and_add(__lowercase) return result if __name__ == "__main__": print(solution(int(input("""Enter the Number: """).strip())))
23
1
import argparse import json import os import fairseq import torch from fairseq.data import Dictionary from transformers import ( HubertConfig, HubertForCTC, HubertModel, WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor, logging, ) logging.set_verbosity_info() snake_case__ : int = logging.get_logger(__name__) snake_case__ : Optional[int] = { """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""", """w2v_encoder.proj""": """lm_head""", """mask_emb""": """masked_spec_embed""", } def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase): for attribute in key.split('.'): UpperCamelCase_ = getattr(__lowercase , __lowercase) if weight_type is not None: UpperCamelCase_ = getattr(__lowercase , __lowercase).shape else: UpperCamelCase_ = 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": UpperCamelCase_ = value elif weight_type == "weight_g": UpperCamelCase_ = value elif weight_type == "weight_v": UpperCamelCase_ = value elif weight_type == "bias": UpperCamelCase_ = value else: UpperCamelCase_ = value logger.info(f"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.""") def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = [] UpperCamelCase_ = fairseq_model.state_dict() UpperCamelCase_ = hf_model.hubert.feature_extractor if is_finetuned else hf_model.feature_extractor for name, value in fairseq_dict.items(): UpperCamelCase_ = False if "conv_layers" in name: load_conv_layer( __lowercase , __lowercase , __lowercase , __lowercase , hf_model.config.feat_extract_norm == 'group' , ) UpperCamelCase_ = True else: for key, mapped_key in MAPPING.items(): UpperCamelCase_ = 'hubert.' + mapped_key if (is_finetuned and mapped_key != 'lm_head') else mapped_key if key in name or (key.split('w2v_model.')[-1] == name.split('.')[0] and not is_finetuned): UpperCamelCase_ = True if "*" in mapped_key: UpperCamelCase_ = name.split(__lowercase)[0].split('.')[-2] UpperCamelCase_ = mapped_key.replace('*' , __lowercase) if "weight_g" in name: UpperCamelCase_ = 'weight_g' elif "weight_v" in name: UpperCamelCase_ = 'weight_v' elif "weight" in name: UpperCamelCase_ = 'weight' elif "bias" in name: UpperCamelCase_ = 'bias' else: UpperCamelCase_ = None set_recursively(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase) continue if not is_used: unused_weights.append(__lowercase) logger.warning(f"""Unused weights: {unused_weights}""") def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase): UpperCamelCase_ = full_name.split('conv_layers.')[-1] UpperCamelCase_ = name.split('.') UpperCamelCase_ = int(items[0]) UpperCamelCase_ = 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.""" ) UpperCamelCase_ = 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.""" ) UpperCamelCase_ = 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." ) UpperCamelCase_ = 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.""" ) UpperCamelCase_ = value logger.info(f"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.""") else: unused_weights.append(__lowercase) @torch.no_grad() def _snake_case (__lowercase , __lowercase , __lowercase=None , __lowercase=None , __lowercase=True): if config_path is not None: UpperCamelCase_ = HubertConfig.from_pretrained(__lowercase) else: UpperCamelCase_ = HubertConfig() if is_finetuned: if dict_path: UpperCamelCase_ = Dictionary.load(__lowercase) # important change bos & pad token id since CTC symbol is <pad> and # not <s> as in fairseq UpperCamelCase_ = target_dict.pad_index UpperCamelCase_ = target_dict.bos_index UpperCamelCase_ = target_dict.eos_index UpperCamelCase_ = len(target_dict.symbols) UpperCamelCase_ = os.path.join(__lowercase , 'vocab.json') if not os.path.isdir(__lowercase): logger.error('--pytorch_dump_folder_path ({}) should be a directory'.format(__lowercase)) return os.makedirs(__lowercase , exist_ok=__lowercase) with open(__lowercase , 'w' , encoding='utf-8') as vocab_handle: json.dump(target_dict.indices , __lowercase) UpperCamelCase_ = WavaVecaCTCTokenizer( __lowercase , unk_token=target_dict.unk_word , pad_token=target_dict.pad_word , bos_token=target_dict.bos_word , eos_token=target_dict.eos_word , word_delimiter_token='|' , do_lower_case=__lowercase , ) UpperCamelCase_ = True if config.feat_extract_norm == 'layer' else False UpperCamelCase_ = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=16000 , padding_value=0 , do_normalize=__lowercase , return_attention_mask=__lowercase , ) UpperCamelCase_ = WavaVecaProcessor(feature_extractor=__lowercase , tokenizer=__lowercase) processor.save_pretrained(__lowercase) UpperCamelCase_ = HubertForCTC(__lowercase) else: UpperCamelCase_ = HubertModel(__lowercase) if is_finetuned: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={'data': '/'.join(dict_path.split('/')[:-1])}) else: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]) UpperCamelCase_ = model[0].eval() recursively_load_weights(__lowercase , __lowercase , __lowercase) hf_wavavec.save_pretrained(__lowercase) if __name__ == "__main__": snake_case__ : str = 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_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument( """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not""" ) snake_case__ : Optional[int] = parser.parse_args() convert_hubert_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
23
from typing import Dict, List, Optional, Union import numpy as np 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 TensorType, is_vision_available, logging if is_vision_available(): import PIL snake_case__ : str = logging.get_logger(__name__) def _snake_case (__lowercase): if isinstance(__lowercase , (list, tuple)) and isinstance(videos[0] , (list, tuple)) and is_valid_image(videos[0][0]): return videos elif isinstance(__lowercase , (list, tuple)) and is_valid_image(videos[0]): return [videos] elif is_valid_image(__lowercase): return [[videos]] raise ValueError(f"""Could not make batched video from {videos}""") class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = ["""pixel_values"""] def __init__( self , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = True , _UpperCAmelCase = 1 / 255 , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> None: super().__init__(**_UpperCAmelCase ) UpperCamelCase_ = size if size is not None else {'shortest_edge': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else {'height': 224, 'width': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) UpperCamelCase_ = do_resize UpperCamelCase_ = size UpperCamelCase_ = do_center_crop UpperCamelCase_ = crop_size UpperCamelCase_ = resample UpperCamelCase_ = do_rescale UpperCamelCase_ = rescale_factor UpperCamelCase_ = do_normalize UpperCamelCase_ = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN UpperCamelCase_ = image_std if image_std is not None else IMAGENET_STANDARD_STD def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) if "shortest_edge" in size: UpperCamelCase_ = get_resize_output_image_size(_UpperCAmelCase , size['shortest_edge'] , default_to_square=_UpperCAmelCase ) elif "height" in size and "width" in size: UpperCamelCase_ = (size['height'], size['width']) else: raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}""" ) return resize(_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase ) 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(_UpperCAmelCase , size=(size['height'], size['width']) , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> int: return rescale(_UpperCAmelCase , scale=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: return normalize(_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , ) -> np.ndarray: 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.' ) # All transformations expect numpy arrays. UpperCamelCase_ = to_numpy_array(_UpperCAmelCase ) if do_resize: UpperCamelCase_ = self.resize(image=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase ) if do_center_crop: UpperCamelCase_ = self.center_crop(_UpperCAmelCase , size=_UpperCAmelCase ) if do_rescale: UpperCamelCase_ = self.rescale(image=_UpperCAmelCase , scale=_UpperCAmelCase ) if do_normalize: UpperCamelCase_ = self.normalize(image=_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase ) UpperCamelCase_ = to_channel_dimension_format(_UpperCAmelCase , _UpperCAmelCase ) return image def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , **_UpperCAmelCase , ) -> PIL.Image.Image: UpperCamelCase_ = do_resize if do_resize is not None else self.do_resize UpperCamelCase_ = resample if resample is not None else self.resample UpperCamelCase_ = do_center_crop if do_center_crop is not None else self.do_center_crop UpperCamelCase_ = do_rescale if do_rescale is not None else self.do_rescale UpperCamelCase_ = rescale_factor if rescale_factor is not None else self.rescale_factor UpperCamelCase_ = do_normalize if do_normalize is not None else self.do_normalize UpperCamelCase_ = image_mean if image_mean is not None else self.image_mean UpperCamelCase_ = image_std if image_std is not None else self.image_std UpperCamelCase_ = size if size is not None else self.size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else self.crop_size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) if not valid_images(_UpperCAmelCase ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) UpperCamelCase_ = make_batched(_UpperCAmelCase ) UpperCamelCase_ = [ [ self._preprocess_image( image=_UpperCAmelCase , do_resize=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , do_center_crop=_UpperCAmelCase , crop_size=_UpperCAmelCase , do_rescale=_UpperCAmelCase , rescale_factor=_UpperCAmelCase , do_normalize=_UpperCAmelCase , image_mean=_UpperCAmelCase , image_std=_UpperCAmelCase , data_format=_UpperCAmelCase , ) for img in video ] for video in videos ] UpperCamelCase_ = {'pixel_values': videos} return BatchFeature(data=_UpperCAmelCase , tensor_type=_UpperCAmelCase )
23
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) snake_case__ : Optional[int] = { """configuration_gpt_bigcode""": ["""GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTBigCodeConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : List[Any] = [ """GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST""", """GPTBigCodeForSequenceClassification""", """GPTBigCodeForTokenClassification""", """GPTBigCodeForCausalLM""", """GPTBigCodeModel""", """GPTBigCodePreTrainedModel""", ] if TYPE_CHECKING: from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_bigcode import ( GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST, GPTBigCodeForCausalLM, GPTBigCodeForSequenceClassification, GPTBigCodeForTokenClassification, GPTBigCodeModel, GPTBigCodePreTrainedModel, ) else: import sys snake_case__ : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
# 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 _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 A_ = 42 class _a ( UpperCAmelCase__ , UpperCAmelCase__ ): """simple docstring""" A_ = 1 @register_to_config def __init__( self , _UpperCAmelCase = 2000 , _UpperCAmelCase = 0.1_5 , _UpperCAmelCase = 0.0_1 , _UpperCAmelCase = 1_3_4_8.0 , _UpperCAmelCase = 1e-5 , _UpperCAmelCase = 1 , ) -> Tuple: # standard deviation of the initial noise distribution UpperCamelCase_ = sigma_max # setable values UpperCamelCase_ = None self.set_sigmas(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> torch.FloatTensor: return sample def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> str: UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps UpperCamelCase_ = torch.linspace(1 , _UpperCAmelCase , _UpperCAmelCase , device=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> Any: UpperCamelCase_ = sigma_min if sigma_min is not None else self.config.sigma_min UpperCamelCase_ = sigma_max if sigma_max is not None else self.config.sigma_max UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) UpperCamelCase_ = torch.exp(torch.linspace(math.log(_UpperCAmelCase ) , math.log(_UpperCAmelCase ) , _UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: return torch.where( timesteps == 0 , torch.zeros_like(t.to(timesteps.device ) ) , self.discrete_sigmas[timesteps - 1].to(timesteps.device ) , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SdeVeOutput, Tuple]: if self.timesteps is None: raise ValueError( '`self.timesteps` is not set, you need to run \'set_timesteps\' after creating the scheduler' ) UpperCamelCase_ = timestep * torch.ones( sample.shape[0] , device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) UpperCamelCase_ = (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 UpperCamelCase_ = timesteps.to(self.discrete_sigmas.device ) UpperCamelCase_ = self.discrete_sigmas[timesteps].to(sample.device ) UpperCamelCase_ = self.get_adjacent_sigma(_UpperCAmelCase , _UpperCAmelCase ).to(sample.device ) UpperCamelCase_ = torch.zeros_like(_UpperCAmelCase ) UpperCamelCase_ = (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 UpperCamelCase_ = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): UpperCamelCase_ = diffusion.unsqueeze(-1 ) UpperCamelCase_ = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of UpperCamelCase_ = randn_tensor( sample.shape , layout=sample.layout , generator=_UpperCAmelCase , device=sample.device , dtype=sample.dtype ) UpperCamelCase_ = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? UpperCamelCase_ = 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=_UpperCAmelCase , prev_sample_mean=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SchedulerOutput, Tuple]: 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 UpperCamelCase_ = randn_tensor(sample.shape , layout=sample.layout , generator=_UpperCAmelCase ).to(sample.device ) # compute step size from the model_output, the noise, and the snr UpperCamelCase_ = torch.norm(model_output.reshape(model_output.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = torch.norm(noise.reshape(noise.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 UpperCamelCase_ = 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 UpperCamelCase_ = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): UpperCamelCase_ = step_size.unsqueeze(-1 ) UpperCamelCase_ = sample + step_size * model_output UpperCamelCase_ = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , ) -> torch.FloatTensor: # Make sure sigmas and timesteps have the same device and dtype as original_samples UpperCamelCase_ = timesteps.to(original_samples.device ) UpperCamelCase_ = self.discrete_sigmas.to(original_samples.device )[timesteps] UpperCamelCase_ = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(_UpperCAmelCase ) * sigmas[:, None, None, None] ) UpperCamelCase_ = noise + original_samples return noisy_samples def __len__( self ) -> Optional[int]: return self.config.num_train_timesteps
23
1
import numpy as np class _a : """simple docstring""" def __init__( self ) -> Union[str, Any]: UpperCamelCase_ = (0, 0) UpperCamelCase_ = None UpperCamelCase_ = 0 UpperCamelCase_ = 0 UpperCamelCase_ = 0 def __eq__( self , _UpperCAmelCase ) -> Optional[int]: return self.position == cell.position def _UpperCAmelCase ( self ) -> Optional[Any]: print(self.position ) class _a : """simple docstring""" def __init__( self , _UpperCAmelCase=(5, 5) ) -> str: UpperCamelCase_ = np.zeros(_UpperCAmelCase ) UpperCamelCase_ = world_size[0] UpperCamelCase_ = world_size[1] def _UpperCAmelCase ( self ) -> List[Any]: print(self.w ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = [ (-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1), ] UpperCamelCase_ = cell.position[0] UpperCamelCase_ = cell.position[1] UpperCamelCase_ = [] for n in neughbour_cord: UpperCamelCase_ = current_x + n[0] UpperCamelCase_ = current_y + n[1] if 0 <= x < self.world_x_limit and 0 <= y < self.world_y_limit: UpperCamelCase_ = Cell() UpperCamelCase_ = (x, y) UpperCamelCase_ = cell neighbours.append(_UpperCAmelCase ) return neighbours def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = [] UpperCamelCase_ = [] _open.append(__lowercase) while _open: UpperCamelCase_ = np.argmin([n.f for n in _open]) UpperCamelCase_ = _open[min_f] _closed.append(_open.pop(__lowercase)) if current == goal: break for n in world.get_neigbours(__lowercase): for c in _closed: if c == n: continue UpperCamelCase_ = current.g + 1 UpperCamelCase_ , UpperCamelCase_ = n.position UpperCamelCase_ , UpperCamelCase_ = goal.position UpperCamelCase_ = (ya - ya) ** 2 + (xa - xa) ** 2 UpperCamelCase_ = n.h + n.g for c in _open: if c == n and c.f < n.f: continue _open.append(__lowercase) UpperCamelCase_ = [] while current.parent is not None: path.append(current.position) UpperCamelCase_ = current.parent path.append(current.position) return path[::-1] if __name__ == "__main__": snake_case__ : List[str] = Gridworld() # Start position and goal snake_case__ : int = Cell() snake_case__ : Dict = (0, 0) snake_case__ : Optional[int] = Cell() snake_case__ : str = (4, 4) print(f'path from {start.position} to {goal.position}') snake_case__ : Tuple = astar(world, start, goal) # Just for visual reasons. for i in s: snake_case__ : List[str] = 1 print(world.w)
23
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Optional[int] = { """configuration_pegasus_x""": ["""PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusXConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST""", """PegasusXForConditionalGeneration""", """PegasusXModel""", """PegasusXPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys snake_case__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
1
from typing import Dict import numpy as np from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, GenericTensor, Pipeline, PipelineException if is_tf_available(): import tensorflow as tf from ..tf_utils import stable_softmax if is_torch_available(): import torch snake_case__ : List[Any] = logging.get_logger(__name__) @add_end_docstrings( UpperCAmelCase__ , r""" top_k (`int`, defaults to 5): The number of predictions to return. targets (`str` or `List[str]`, *optional*): When passed, the model will limit the scores to the passed targets instead of looking up in the whole vocab. If the provided targets are not in the model vocab, they will be tokenized and the first resulting token will be used (with a warning, and that might be slower). """ , ) class _a ( UpperCAmelCase__ ): """simple docstring""" def _UpperCAmelCase ( self , _UpperCAmelCase ) -> np.ndarray: if self.framework == "tf": UpperCamelCase_ = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy() elif self.framework == "pt": UpperCamelCase_ = torch.nonzero(input_ids == self.tokenizer.mask_token_id , as_tuple=_UpperCAmelCase ) else: raise ValueError('Unsupported framework' ) return masked_index def _UpperCAmelCase ( self , _UpperCAmelCase ) -> np.ndarray: UpperCamelCase_ = self.get_masked_index(_UpperCAmelCase ) UpperCamelCase_ = np.prod(masked_index.shape ) if numel < 1: raise PipelineException( 'fill-mask' , self.model.base_model_prefix , f"""No mask_token ({self.tokenizer.mask_token}) found on the input""" , ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Any: if isinstance(_UpperCAmelCase , _UpperCAmelCase ): for model_input in model_inputs: self._ensure_exactly_one_mask_token(model_input['input_ids'][0] ) else: for input_ids in model_inputs["input_ids"]: self._ensure_exactly_one_mask_token(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=None , **_UpperCAmelCase ) -> Dict[str, GenericTensor]: if return_tensors is None: UpperCamelCase_ = self.framework UpperCamelCase_ = self.tokenizer(_UpperCAmelCase , return_tensors=_UpperCAmelCase ) self.ensure_exactly_one_mask_token(_UpperCAmelCase ) return model_inputs def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = self.model(**_UpperCAmelCase ) UpperCamelCase_ = model_inputs['input_ids'] return model_outputs def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=5 , _UpperCAmelCase=None ) -> Any: # Cap top_k if there are targets if target_ids is not None and target_ids.shape[0] < top_k: UpperCamelCase_ = target_ids.shape[0] UpperCamelCase_ = model_outputs['input_ids'][0] UpperCamelCase_ = model_outputs['logits'] if self.framework == "tf": UpperCamelCase_ = tf.where(input_ids == self.tokenizer.mask_token_id ).numpy()[:, 0] UpperCamelCase_ = outputs.numpy() UpperCamelCase_ = outputs[0, masked_index, :] UpperCamelCase_ = stable_softmax(_UpperCAmelCase , axis=-1 ) if target_ids is not None: UpperCamelCase_ = tf.gather_nd(tf.squeeze(_UpperCAmelCase , 0 ) , target_ids.reshape(-1 , 1 ) ) UpperCamelCase_ = tf.expand_dims(_UpperCAmelCase , 0 ) UpperCamelCase_ = tf.math.top_k(_UpperCAmelCase , k=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = topk.values.numpy(), topk.indices.numpy() else: UpperCamelCase_ = torch.nonzero(input_ids == self.tokenizer.mask_token_id , as_tuple=_UpperCAmelCase ).squeeze(-1 ) # Fill mask pipeline supports only one ${mask_token} per sample UpperCamelCase_ = outputs[0, masked_index, :] UpperCamelCase_ = logits.softmax(dim=-1 ) if target_ids is not None: UpperCamelCase_ = probs[..., target_ids] UpperCamelCase_ , UpperCamelCase_ = probs.topk(_UpperCAmelCase ) UpperCamelCase_ = [] UpperCamelCase_ = values.shape[0] == 1 for i, (_values, _predictions) in enumerate(zip(values.tolist() , predictions.tolist() ) ): UpperCamelCase_ = [] for v, p in zip(_values , _predictions ): # Copy is important since we're going to modify this array in place UpperCamelCase_ = input_ids.numpy().copy() if target_ids is not None: UpperCamelCase_ = target_ids[p].tolist() UpperCamelCase_ = p # Filter padding out: UpperCamelCase_ = tokens[np.where(tokens != self.tokenizer.pad_token_id )] # Originally we skip special tokens to give readable output. # For multi masks though, the other [MASK] would be removed otherwise # making the output look odd, so we add them back UpperCamelCase_ = self.tokenizer.decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = {'score': v, 'token': p, 'token_str': self.tokenizer.decode([p] ), 'sequence': sequence} row.append(_UpperCAmelCase ) result.append(_UpperCAmelCase ) if single_mask: return result[0] return result def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=None ) -> Any: if isinstance(_UpperCAmelCase , _UpperCAmelCase ): UpperCamelCase_ = [targets] try: UpperCamelCase_ = self.tokenizer.get_vocab() except Exception: UpperCamelCase_ = {} UpperCamelCase_ = [] for target in targets: UpperCamelCase_ = vocab.get(_UpperCAmelCase , _UpperCAmelCase ) if id_ is None: UpperCamelCase_ = self.tokenizer( _UpperCAmelCase , add_special_tokens=_UpperCAmelCase , return_attention_mask=_UpperCAmelCase , return_token_type_ids=_UpperCAmelCase , max_length=1 , truncation=_UpperCAmelCase , )['input_ids'] if len(_UpperCAmelCase ) == 0: logger.warning( f"""The specified target token `{target}` does not exist in the model vocabulary. """ 'We cannot replace it with anything meaningful, ignoring it' ) continue UpperCamelCase_ = input_ids[0] # XXX: If users encounter this pass # it becomes pretty slow, so let's make sure # The warning enables them to fix the input to # get faster performance. logger.warning( f"""The specified target token `{target}` does not exist in the model vocabulary. """ f"""Replacing with `{self.tokenizer.convert_ids_to_tokens(id_ )}`.""" ) target_ids.append(id_ ) UpperCamelCase_ = list(set(_UpperCAmelCase ) ) if len(_UpperCAmelCase ) == 0: raise ValueError('At least one target must be provided when passed.' ) UpperCamelCase_ = np.array(_UpperCAmelCase ) return target_ids def _UpperCAmelCase ( self , _UpperCAmelCase=None , _UpperCAmelCase=None ) -> List[str]: UpperCamelCase_ = {} if targets is not None: UpperCamelCase_ = self.get_target_ids(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = target_ids if top_k is not None: UpperCamelCase_ = top_k if self.tokenizer.mask_token_id is None: raise PipelineException( 'fill-mask' , self.model.base_model_prefix , 'The tokenizer does not define a `mask_token`.' ) return {}, {}, postprocess_params def __call__( self , _UpperCAmelCase , *_UpperCAmelCase , **_UpperCAmelCase ) -> Any: UpperCamelCase_ = super().__call__(_UpperCAmelCase , **_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) and len(_UpperCAmelCase ) == 1: return outputs[0] return outputs
23
import datasets from .evaluate import evaluate snake_case__ : int = """\ @article{hendrycks2021cuad, title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review}, author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball}, journal={arXiv preprint arXiv:2103.06268}, year={2021} } """ snake_case__ : Union[str, Any] = """ This metric wrap the official scoring script for version 1 of the Contract Understanding Atticus Dataset (CUAD). Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions. """ snake_case__ : Any = """ Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall). Args: predictions: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair as given in the references (see below) - 'prediction_text': list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction. references: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair (see above), - 'answers': a Dict in the CUAD dataset format { 'text': list of possible texts for the answer, as a list of strings 'answer_start': list of start positions for the answer, as a list of ints } Note that answer_start values are not taken into account to compute the metric. Returns: 'exact_match': Exact match (the normalized answer exactly match the gold answer) 'f1': The F-score of predicted tokens versus the gold answer 'aupr': Area Under the Precision-Recall curve 'prec_at_80_recall': Precision at 80% recall 'prec_at_90_recall': Precision at 90% recall Examples: >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> cuad_metric = datasets.load_metric(\"cuad\") >>> results = cuad_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _a ( datasets.Metric ): """simple docstring""" def _UpperCAmelCase ( self ) -> Optional[int]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': { 'id': datasets.Value('string' ), 'prediction_text': datasets.features.Sequence(datasets.Value('string' ) ), }, 'references': { 'id': datasets.Value('string' ), 'answers': datasets.features.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), }, } ) , codebase_urls=['https://www.atticusprojectai.org/cuad'] , reference_urls=['https://www.atticusprojectai.org/cuad'] , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = {prediction['id']: prediction['prediction_text'] for prediction in predictions} UpperCamelCase_ = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] UpperCamelCase_ = evaluate(dataset=_UpperCAmelCase , predictions=_UpperCAmelCase ) return score
23
1
from typing import Any, Dict, List, Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): import torch from transformers.modeling_outputs import BaseModelOutput from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING snake_case__ : int = logging.get_logger(__name__) @add_end_docstrings(UpperCAmelCase__ ) class _a ( UpperCAmelCase__ ): """simple docstring""" def __init__( self , **_UpperCAmelCase ) -> Union[str, Any]: super().__init__(**_UpperCAmelCase ) if self.framework == "tf": raise ValueError(f"""The {self.__class__} is only available in PyTorch.""" ) requires_backends(self , 'vision' ) self.check_model_type(_UpperCAmelCase ) def __call__( self , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> Union[str, Any]: if "text_queries" in kwargs: UpperCamelCase_ = kwargs.pop('text_queries' ) if isinstance(_UpperCAmelCase , (str, Image.Image) ): UpperCamelCase_ = {'image': image, 'candidate_labels': candidate_labels} else: UpperCamelCase_ = image UpperCamelCase_ = super().__call__(_UpperCAmelCase , **_UpperCAmelCase ) return results def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = {} if "threshold" in kwargs: UpperCamelCase_ = kwargs['threshold'] if "top_k" in kwargs: UpperCamelCase_ = kwargs['top_k'] return {}, {}, postprocess_params def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = load_image(inputs['image'] ) UpperCamelCase_ = inputs['candidate_labels'] if isinstance(_UpperCAmelCase , _UpperCAmelCase ): UpperCamelCase_ = candidate_labels.split(',' ) UpperCamelCase_ = torch.tensor([[image.height, image.width]] , dtype=torch.intaa ) for i, candidate_label in enumerate(_UpperCAmelCase ): UpperCamelCase_ = self.tokenizer(_UpperCAmelCase , return_tensors=self.framework ) UpperCamelCase_ = self.image_processor(_UpperCAmelCase , return_tensors=self.framework ) yield { "is_last": i == len(_UpperCAmelCase ) - 1, "target_size": target_size, "candidate_label": candidate_label, **text_inputs, **image_features, } def _UpperCAmelCase ( self , _UpperCAmelCase ) -> str: UpperCamelCase_ = model_inputs.pop('target_size' ) UpperCamelCase_ = model_inputs.pop('candidate_label' ) UpperCamelCase_ = model_inputs.pop('is_last' ) UpperCamelCase_ = self.model(**_UpperCAmelCase ) UpperCamelCase_ = {'target_size': target_size, 'candidate_label': candidate_label, 'is_last': is_last, **outputs} return model_outputs def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=0.1 , _UpperCAmelCase=None ) -> List[str]: UpperCamelCase_ = [] for model_output in model_outputs: UpperCamelCase_ = model_output['candidate_label'] UpperCamelCase_ = BaseModelOutput(_UpperCAmelCase ) UpperCamelCase_ = self.image_processor.post_process_object_detection( outputs=_UpperCAmelCase , threshold=_UpperCAmelCase , target_sizes=model_output['target_size'] )[0] for index in outputs["scores"].nonzero(): UpperCamelCase_ = outputs['scores'][index].item() UpperCamelCase_ = self._get_bounding_box(outputs['boxes'][index][0] ) UpperCamelCase_ = {'score': score, 'label': label, 'box': box} results.append(_UpperCAmelCase ) UpperCamelCase_ = sorted(_UpperCAmelCase , key=lambda _UpperCAmelCase : x["score"] , reverse=_UpperCAmelCase ) if top_k: UpperCamelCase_ = results[:top_k] return results def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict[str, int]: if self.framework != "pt": raise ValueError('The ZeroShotObjectDetectionPipeline is only available in PyTorch.' ) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = box.int().tolist() UpperCamelCase_ = { 'xmin': xmin, 'ymin': ymin, 'xmax': xmax, 'ymax': ymax, } return bbox
23
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import datasets import datasets.config from .utils import require_beam class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> List[str]: return datasets.DatasetInfo( features=datasets.Features({'content': datasets.Value('string' )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_dummy_examples()} )] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> Any: return datasets.DatasetInfo( features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: return [ datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_nested_examples()} ) ] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) def _snake_case (): return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar'])] def _snake_case (): return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['foo', 'bar', 'foobar'])] class _a ( UpperCAmelCase__ ): """simple docstring""" @require_beam def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_dummy_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_dummy_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> List[str]: import apache_beam as beam UpperCamelCase_ = beam.io.parquetio.WriteToParquet UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) with patch('apache_beam.io.parquetio.WriteToParquet' ) as write_parquet_mock: UpperCamelCase_ = partial(_UpperCAmelCase , num_shards=2 ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) # Order is not preserved when sharding, so we just check that all the elements are there self.assertListEqual(sorted(dset['train']['content'] ) , sorted(['foo', 'bar', 'foobar'] ) ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> Any: with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase ) self.assertRaises(datasets.builder.MissingBeamOptions , builder.download_and_prepare ) @require_beam def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = len(get_test_nested_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = NestedBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual( builder.info.features , datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_nested_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_nested_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset
23
1
from ...configuration_utils import PretrainedConfig from ...utils import logging snake_case__ : Dict = logging.get_logger(__name__) snake_case__ : Optional[Any] = { """uw-madison/mra-base-512-4""": """https://huggingface.co/uw-madison/mra-base-512-4/resolve/main/config.json""", } class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """mra""" def __init__( self , _UpperCAmelCase=50265 , _UpperCAmelCase=768 , _UpperCAmelCase=12 , _UpperCAmelCase=12 , _UpperCAmelCase=3072 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=512 , _UpperCAmelCase=1 , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=1e-5 , _UpperCAmelCase="absolute" , _UpperCAmelCase=4 , _UpperCAmelCase="full" , _UpperCAmelCase=0 , _UpperCAmelCase=0 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , _UpperCAmelCase=2 , **_UpperCAmelCase , ) -> Dict: super().__init__(pad_token_id=_UpperCAmelCase , bos_token_id=_UpperCAmelCase , eos_token_id=_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = vocab_size UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = initializer_range UpperCamelCase_ = type_vocab_size UpperCamelCase_ = layer_norm_eps UpperCamelCase_ = position_embedding_type UpperCamelCase_ = block_per_row UpperCamelCase_ = approx_mode UpperCamelCase_ = initial_prior_first_n_blocks UpperCamelCase_ = initial_prior_diagonal_n_blocks
23
import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = AlbertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = AlbertForPreTraining(__lowercase) # Load weights from tf checkpoint load_tf_weights_in_albert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--albert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained ALBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : str = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
23
1
import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, XLMRobertaTokenizer from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class _a ( UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = AltDiffusionPipeline A_ = TEXT_TO_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_BATCH_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS def _UpperCAmelCase ( self ) -> List[str]: torch.manual_seed(0 ) UpperCamelCase_ = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=32 , ) UpperCamelCase_ = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule='scaled_linear' , clip_sample=_UpperCAmelCase , set_alpha_to_one=_UpperCAmelCase , ) torch.manual_seed(0 ) UpperCamelCase_ = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) # TODO: address the non-deterministic text encoder (fails for save-load tests) # torch.manual_seed(0) # text_encoder_config = RobertaSeriesConfig( # hidden_size=32, # project_dim=32, # intermediate_size=37, # layer_norm_eps=1e-05, # num_attention_heads=4, # num_hidden_layers=5, # vocab_size=5002, # ) # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config) torch.manual_seed(0 ) UpperCamelCase_ = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , projection_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=5002 , ) UpperCamelCase_ = CLIPTextModel(_UpperCAmelCase ) UpperCamelCase_ = XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta' ) UpperCamelCase_ = 77 UpperCamelCase_ = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=0 ) -> Optional[Any]: if str(_UpperCAmelCase ).startswith('mps' ): UpperCamelCase_ = torch.manual_seed(_UpperCAmelCase ) else: UpperCamelCase_ = torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase ) UpperCamelCase_ = { 'prompt': 'A painting of a squirrel eating a burger', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 6.0, 'output_type': 'numpy', } return inputs def _UpperCAmelCase ( self ) -> Tuple: super().test_attention_slicing_forward_pass(expected_max_diff=3e-3 ) def _UpperCAmelCase ( self ) -> Optional[int]: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = 'cpu' # ensure determinism for the device-dependent torch.Generator UpperCamelCase_ = self.get_dummy_components() torch.manual_seed(0 ) UpperCamelCase_ = RobertaSeriesConfig( hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , vocab_size=5002 , ) # TODO: remove after fixing the non-deterministic text encoder UpperCamelCase_ = RobertaSeriesModelWithTransformation(_UpperCAmelCase ) UpperCamelCase_ = text_encoder UpperCamelCase_ = AltDiffusionPipeline(**_UpperCAmelCase ) UpperCamelCase_ = alt_pipe.to(_UpperCAmelCase ) alt_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = self.get_dummy_inputs(_UpperCAmelCase ) UpperCamelCase_ = 'A photo of an astronaut' UpperCamelCase_ = alt_pipe(**_UpperCAmelCase ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) UpperCamelCase_ = np.array( [0.5_7_4_8_1_6_2, 0.6_0_4_4_7_1_4_5, 0.4_8_8_2_1_2_1_7, 0.5_0_1_0_0_6_3_6, 0.5_4_3_1_1_8_5, 0.4_5_7_6_3_6_8_3, 0.4_9_6_5_7_6_9_6, 0.4_8_1_3_2_7_3_3, 0.4_7_5_7_3_0_9_3] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = 'cpu' # ensure determinism for the device-dependent torch.Generator UpperCamelCase_ = self.get_dummy_components() UpperCamelCase_ = PNDMScheduler(skip_prk_steps=_UpperCAmelCase ) torch.manual_seed(0 ) UpperCamelCase_ = RobertaSeriesConfig( hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , vocab_size=5002 , ) # TODO: remove after fixing the non-deterministic text encoder UpperCamelCase_ = RobertaSeriesModelWithTransformation(_UpperCAmelCase ) UpperCamelCase_ = text_encoder UpperCamelCase_ = AltDiffusionPipeline(**_UpperCAmelCase ) UpperCamelCase_ = alt_pipe.to(_UpperCAmelCase ) alt_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = self.get_dummy_inputs(_UpperCAmelCase ) UpperCamelCase_ = alt_pipe(**_UpperCAmelCase ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) UpperCamelCase_ = np.array( [0.5_1_6_0_5_0_9_3, 0.5_7_0_7_2_4_1, 0.4_7_3_6_5_5_0_7, 0.5_0_5_7_8_8_8_6, 0.5_6_3_3_8_7_7, 0.4_6_4_2_5_0_3, 0.5_1_8_2_0_8_1, 0.4_8_7_6_3_4_8_4, 0.4_9_0_8_4_2_3_7] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 @slow @require_torch_gpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Tuple: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def _UpperCAmelCase ( self ) -> List[Any]: # make sure here that pndm scheduler skips prk UpperCamelCase_ = AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion' , safety_checker=_UpperCAmelCase ) UpperCamelCase_ = alt_pipe.to(_UpperCAmelCase ) alt_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = 'A painting of a squirrel eating a burger' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = alt_pipe([prompt] , generator=_UpperCAmelCase , guidance_scale=6.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.1_0_1_0, 0.0_8_0_0, 0.0_7_9_4, 0.0_8_8_5, 0.0_8_4_3, 0.0_7_6_2, 0.0_7_6_9, 0.0_7_2_9, 0.0_5_8_6] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = DDIMScheduler.from_pretrained('BAAI/AltDiffusion' , subfolder='scheduler' ) UpperCamelCase_ = AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion' , scheduler=_UpperCAmelCase , safety_checker=_UpperCAmelCase ) UpperCamelCase_ = alt_pipe.to(_UpperCAmelCase ) alt_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = 'A painting of a squirrel eating a burger' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = alt_pipe([prompt] , generator=_UpperCAmelCase , num_inference_steps=2 , output_type='numpy' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.4_0_1_9, 0.4_0_5_2, 0.3_8_1_0, 0.4_1_1_9, 0.3_9_1_6, 0.3_9_8_2, 0.4_6_5_1, 0.4_1_9_5, 0.5_3_2_3] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
23
from transformers import BertTokenizer, EncoderDecoderModel, SeqaSeqTrainer, SeqaSeqTrainingArguments from transformers.testing_utils import TestCasePlus, require_torch, slow from transformers.utils import is_datasets_available if is_datasets_available(): import datasets class _a ( UpperCAmelCase__ ): """simple docstring""" @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = EncoderDecoderModel.from_encoder_decoder_pretrained('prajjwal1/bert-tiny' , 'prajjwal1/bert-tiny' ) UpperCamelCase_ = BertTokenizer.from_pretrained('bert-base-uncased' ) UpperCamelCase_ = bertabert.config.encoder.vocab_size UpperCamelCase_ = tokenizer.sep_token_id UpperCamelCase_ = tokenizer.cls_token_id UpperCamelCase_ = 128 UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='train[:1%]' ) UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='validation[:1%]' ) UpperCamelCase_ = train_dataset.select(range(32 ) ) UpperCamelCase_ = val_dataset.select(range(16 ) ) UpperCamelCase_ = 4 def _map_to_encoder_decoder_inputs(_UpperCAmelCase ): # Tokenizer will automatically set [BOS] <text> [EOS] UpperCamelCase_ = tokenizer(batch['article'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=512 ) UpperCamelCase_ = tokenizer(batch['highlights'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=128 ) UpperCamelCase_ = inputs.input_ids UpperCamelCase_ = inputs.attention_mask UpperCamelCase_ = outputs.input_ids UpperCamelCase_ = outputs.input_ids.copy() UpperCamelCase_ = [ [-100 if token == tokenizer.pad_token_id else token for token in labels] for labels in batch['labels'] ] UpperCamelCase_ = outputs.attention_mask assert all(len(_UpperCAmelCase ) == 512 for x in inputs.input_ids ) assert all(len(_UpperCAmelCase ) == 128 for x in outputs.input_ids ) return batch def _compute_metrics(_UpperCAmelCase ): UpperCamelCase_ = pred.label_ids UpperCamelCase_ = pred.predictions # all unnecessary tokens are removed UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = sum([int(pred_str[i] == label_str[i] ) for i in range(len(_UpperCAmelCase ) )] ) / len(_UpperCAmelCase ) return {"accuracy": accuracy} # map train dataset UpperCamelCase_ = train_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) train_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) # same for validation dataset UpperCamelCase_ = val_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) val_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) UpperCamelCase_ = self.get_auto_remove_tmp_dir() UpperCamelCase_ = SeqaSeqTrainingArguments( output_dir=_UpperCAmelCase , per_device_train_batch_size=_UpperCAmelCase , per_device_eval_batch_size=_UpperCAmelCase , predict_with_generate=_UpperCAmelCase , evaluation_strategy='steps' , do_train=_UpperCAmelCase , do_eval=_UpperCAmelCase , warmup_steps=0 , eval_steps=2 , logging_steps=2 , ) # instantiate trainer UpperCamelCase_ = SeqaSeqTrainer( model=_UpperCAmelCase , args=_UpperCAmelCase , compute_metrics=_compute_metrics , train_dataset=_UpperCAmelCase , eval_dataset=_UpperCAmelCase , tokenizer=_UpperCAmelCase , ) # start training trainer.train()
23
1
import torch from torch import nn class _a ( nn.Module ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=1 , _UpperCAmelCase=False ) -> int: super().__init__() UpperCamelCase_ = n_token UpperCamelCase_ = d_embed UpperCamelCase_ = d_proj UpperCamelCase_ = cutoffs + [n_token] UpperCamelCase_ = [0] + self.cutoffs UpperCamelCase_ = div_val UpperCamelCase_ = self.cutoffs[0] UpperCamelCase_ = len(self.cutoffs ) - 1 UpperCamelCase_ = self.shortlist_size + self.n_clusters if self.n_clusters > 0: UpperCamelCase_ = nn.Parameter(torch.zeros(self.n_clusters , self.d_embed ) ) UpperCamelCase_ = nn.Parameter(torch.zeros(self.n_clusters ) ) UpperCamelCase_ = nn.ModuleList() UpperCamelCase_ = nn.ParameterList() if div_val == 1: for i in range(len(self.cutoffs ) ): if d_proj != d_embed: self.out_projs.append(nn.Parameter(torch.FloatTensor(_UpperCAmelCase , _UpperCAmelCase ) ) ) else: self.out_projs.append(_UpperCAmelCase ) self.out_layers.append(nn.Linear(_UpperCAmelCase , _UpperCAmelCase ) ) else: for i in range(len(self.cutoffs ) ): UpperCamelCase_ , UpperCamelCase_ = self.cutoff_ends[i], self.cutoff_ends[i + 1] UpperCamelCase_ = d_embed // (div_val**i) self.out_projs.append(nn.Parameter(torch.FloatTensor(_UpperCAmelCase , _UpperCAmelCase ) ) ) self.out_layers.append(nn.Linear(_UpperCAmelCase , r_idx - l_idx ) ) UpperCamelCase_ = keep_order def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Any: if proj is None: UpperCamelCase_ = nn.functional.linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) else: # if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1: UpperCamelCase_ = nn.functional.linear(_UpperCAmelCase , proj.t().contiguous() ) UpperCamelCase_ = nn.functional.linear(_UpperCAmelCase , _UpperCAmelCase , bias=_UpperCAmelCase ) # else: # logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t())) # if bias is not None: # logit = logit + bias return logit def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=None , _UpperCAmelCase=False ) -> int: if labels is not None: # Shift so that tokens < n predict n UpperCamelCase_ = hidden[..., :-1, :].contiguous() UpperCamelCase_ = labels[..., 1:].contiguous() UpperCamelCase_ = hidden.view(-1 , hidden.size(-1 ) ) UpperCamelCase_ = labels.view(-1 ) if hidden.size(0 ) != labels.size(0 ): raise RuntimeError('Input and labels should have the same size in the batch dimension.' ) else: UpperCamelCase_ = hidden.view(-1 , hidden.size(-1 ) ) if self.n_clusters == 0: UpperCamelCase_ = self._compute_logit(_UpperCAmelCase , self.out_layers[0].weight , self.out_layers[0].bias , self.out_projs[0] ) if labels is not None: UpperCamelCase_ = labels != -100 UpperCamelCase_ = torch.zeros_like(_UpperCAmelCase , dtype=hidden.dtype , device=hidden.device ) UpperCamelCase_ = ( -nn.functional.log_softmax(_UpperCAmelCase , dim=-1 )[mask].gather(1 , labels[mask].unsqueeze(1 ) ).squeeze(1 ) ) else: UpperCamelCase_ = nn.functional.log_softmax(_UpperCAmelCase , dim=-1 ) else: # construct weights and biases UpperCamelCase_ , UpperCamelCase_ = [], [] for i in range(len(self.cutoffs ) ): if self.div_val == 1: UpperCamelCase_ , UpperCamelCase_ = self.cutoff_ends[i], self.cutoff_ends[i + 1] UpperCamelCase_ = self.out_layers[0].weight[l_idx:r_idx] UpperCamelCase_ = self.out_layers[0].bias[l_idx:r_idx] else: UpperCamelCase_ = self.out_layers[i].weight UpperCamelCase_ = self.out_layers[i].bias if i == 0: UpperCamelCase_ = torch.cat([weight_i, self.cluster_weight] , dim=0 ) UpperCamelCase_ = torch.cat([bias_i, self.cluster_bias] , dim=0 ) weights.append(_UpperCAmelCase ) biases.append(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = weights[0], biases[0], self.out_projs[0] UpperCamelCase_ = self._compute_logit(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = nn.functional.log_softmax(_UpperCAmelCase , dim=1 ) if labels is None: UpperCamelCase_ = hidden.new_empty((head_logit.size(0 ), self.n_token) ) else: UpperCamelCase_ = torch.zeros_like(_UpperCAmelCase , dtype=hidden.dtype , device=hidden.device ) UpperCamelCase_ = 0 UpperCamelCase_ = [0] + self.cutoffs for i in range(len(_UpperCAmelCase ) - 1 ): UpperCamelCase_ , UpperCamelCase_ = cutoff_values[i], cutoff_values[i + 1] if labels is not None: UpperCamelCase_ = (labels >= l_idx) & (labels < r_idx) UpperCamelCase_ = mask_i.nonzero().squeeze() if indices_i.numel() == 0: continue UpperCamelCase_ = labels.index_select(0 , _UpperCAmelCase ) - l_idx UpperCamelCase_ = head_logprob.index_select(0 , _UpperCAmelCase ) UpperCamelCase_ = hidden.index_select(0 , _UpperCAmelCase ) else: UpperCamelCase_ = hidden if i == 0: if labels is not None: UpperCamelCase_ = head_logprob_i.gather(1 , target_i[:, None] ).squeeze(1 ) else: UpperCamelCase_ = head_logprob[:, : self.cutoffs[0]] else: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = weights[i], biases[i], self.out_projs[i] UpperCamelCase_ = self._compute_logit(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = nn.functional.log_softmax(_UpperCAmelCase , dim=1 ) UpperCamelCase_ = self.cutoffs[0] + i - 1 # No probability for the head cluster if labels is not None: UpperCamelCase_ = head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather( 1 , target_i[:, None] ).squeeze(1 ) else: UpperCamelCase_ = head_logprob[:, cluster_prob_idx, None] + tail_logprob_i UpperCamelCase_ = logprob_i if labels is not None: if (hasattr(self , 'keep_order' ) and self.keep_order) or keep_order: out.index_copy_(0 , _UpperCAmelCase , -logprob_i ) else: out[offset : offset + logprob_i.size(0 )].copy_(-logprob_i ) offset += logprob_i.size(0 ) return out def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[Any]: if self.n_clusters == 0: UpperCamelCase_ = self._compute_logit(_UpperCAmelCase , self.out_layers[0].weight , self.out_layers[0].bias , self.out_projs[0] ) return nn.functional.log_softmax(_UpperCAmelCase , dim=-1 ) else: # construct weights and biases UpperCamelCase_ , UpperCamelCase_ = [], [] for i in range(len(self.cutoffs ) ): if self.div_val == 1: UpperCamelCase_ , UpperCamelCase_ = self.cutoff_ends[i], self.cutoff_ends[i + 1] UpperCamelCase_ = self.out_layers[0].weight[l_idx:r_idx] UpperCamelCase_ = self.out_layers[0].bias[l_idx:r_idx] else: UpperCamelCase_ = self.out_layers[i].weight UpperCamelCase_ = self.out_layers[i].bias if i == 0: UpperCamelCase_ = torch.cat([weight_i, self.cluster_weight] , dim=0 ) UpperCamelCase_ = torch.cat([bias_i, self.cluster_bias] , dim=0 ) weights.append(_UpperCAmelCase ) biases.append(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = weights[0], biases[0], self.out_projs[0] UpperCamelCase_ = self._compute_logit(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = hidden.new_empty((head_logit.size(0 ), self.n_token) ) UpperCamelCase_ = nn.functional.log_softmax(_UpperCAmelCase , dim=1 ) UpperCamelCase_ = [0] + self.cutoffs for i in range(len(_UpperCAmelCase ) - 1 ): UpperCamelCase_ , UpperCamelCase_ = cutoff_values[i], cutoff_values[i + 1] if i == 0: UpperCamelCase_ = head_logprob[:, : self.cutoffs[0]] else: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = weights[i], biases[i], self.out_projs[i] UpperCamelCase_ = self._compute_logit(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = nn.functional.log_softmax(_UpperCAmelCase , dim=1 ) UpperCamelCase_ = head_logprob[:, -i] + tail_logprob_i UpperCamelCase_ = logprob_i return out
23
import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType ######################################################################## # This is a fully working simple example to use Accelerate # and perform gradient accumulation # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## snake_case__ : Dict = 1_6 snake_case__ : List[str] = 3_2 def _snake_case (__lowercase , __lowercase = 16): UpperCamelCase_ = AutoTokenizer.from_pretrained('bert-base-cased') UpperCamelCase_ = load_dataset('glue' , 'mrpc') def tokenize_function(__lowercase): # max_length=None => use the model max length (it's actually the default) UpperCamelCase_ = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=__lowercase , max_length=__lowercase) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): UpperCamelCase_ = datasets.map( __lowercase , batched=__lowercase , remove_columns=['idx', 'sentence1', 'sentence2'] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library UpperCamelCase_ = tokenized_datasets.rename_column('label' , 'labels') def collate_fn(__lowercase): # On TPU it's best to pad everything to the same length or training will be very slow. UpperCamelCase_ = 128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": UpperCamelCase_ = 16 elif accelerator.mixed_precision != "no": UpperCamelCase_ = 8 else: UpperCamelCase_ = None return tokenizer.pad( __lowercase , padding='longest' , max_length=__lowercase , pad_to_multiple_of=__lowercase , return_tensors='pt' , ) # Instantiate dataloaders. UpperCamelCase_ = DataLoader( tokenized_datasets['train'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) UpperCamelCase_ = DataLoader( tokenized_datasets['validation'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) return train_dataloader, eval_dataloader # For testing only if os.environ.get("""TESTING_MOCKED_DATALOADERS""", None) == "1": from accelerate.test_utils.training import mocked_dataloaders snake_case__ : List[str] = mocked_dataloaders # noqa: F811 def _snake_case (__lowercase , __lowercase): # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS' , __lowercase) == "1": UpperCamelCase_ = 2 # New Code # UpperCamelCase_ = int(args.gradient_accumulation_steps) # Initialize accelerator UpperCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=__lowercase) if accelerator.distributed_type == DistributedType.TPU and gradient_accumulation_steps > 1: raise NotImplementedError( 'Gradient accumulation on TPUs is currently not supported. Pass `gradient_accumulation_steps=1`') # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs UpperCamelCase_ = config['lr'] UpperCamelCase_ = int(config['num_epochs']) UpperCamelCase_ = int(config['seed']) UpperCamelCase_ = int(config['batch_size']) UpperCamelCase_ = evaluate.load('glue' , 'mrpc') set_seed(__lowercase) UpperCamelCase_ , UpperCamelCase_ = get_dataloaders(__lowercase , __lowercase) # Instantiate the model (we build the model here so that the seed also control new weights initialization) UpperCamelCase_ = AutoModelForSequenceClassification.from_pretrained('bert-base-cased' , return_dict=__lowercase) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). UpperCamelCase_ = model.to(accelerator.device) # Instantiate optimizer UpperCamelCase_ = AdamW(params=model.parameters() , lr=__lowercase) # Instantiate scheduler UpperCamelCase_ = get_linear_schedule_with_warmup( optimizer=__lowercase , num_warmup_steps=100 , num_training_steps=(len(__lowercase) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare( __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # Now we train the model for epoch in range(__lowercase): model.train() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(__lowercase): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = output.loss accelerator.backward(__lowercase) optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) with torch.no_grad(): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = outputs.logits.argmax(dim=-1) UpperCamelCase_ , UpperCamelCase_ = accelerator.gather_for_metrics((predictions, batch['labels'])) metric.add_batch( predictions=__lowercase , references=__lowercase , ) UpperCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , __lowercase) def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Simple example of training script.') parser.add_argument( '--mixed_precision' , type=__lowercase , default=__lowercase , choices=['no', 'fp16', 'bf16', 'fp8'] , help='Whether to use mixed precision. Choose' 'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.' 'and an Nvidia Ampere GPU.' , ) # New Code # parser.add_argument( '--gradient_accumulation_steps' , type=__lowercase , default=1 , help='The number of minibatches to be ran before gradients are accumulated.' , ) parser.add_argument('--cpu' , action='store_true' , help='If passed, will train on the CPU.') UpperCamelCase_ = parser.parse_args() UpperCamelCase_ = {'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(__lowercase , __lowercase) if __name__ == "__main__": main()
23
1
from __future__ import annotations import math import random from typing import Any class _a : """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = [] UpperCamelCase_ = 0 UpperCamelCase_ = 0 def _UpperCAmelCase ( self ) -> bool: return self.head == self.tail def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: self.data.append(_UpperCAmelCase ) UpperCamelCase_ = self.tail + 1 def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = self.data[self.head] UpperCamelCase_ = self.head + 1 return ret def _UpperCAmelCase ( self ) -> int: return self.tail - self.head def _UpperCAmelCase ( self ) -> None: print(self.data ) print('**************' ) print(self.data[self.head : self.tail] ) class _a : """simple docstring""" def __init__( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = data UpperCamelCase_ = None UpperCamelCase_ = None UpperCamelCase_ = 1 def _UpperCAmelCase ( self ) -> Any: return self.data def _UpperCAmelCase ( self ) -> MyNode | None: return self.left def _UpperCAmelCase ( self ) -> MyNode | None: return self.right def _UpperCAmelCase ( self ) -> int: return self.height def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = data def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = node def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = node def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = height def _snake_case (__lowercase): if node is None: return 0 return node.get_height() def _snake_case (__lowercase , __lowercase): if a > b: return a return b def _snake_case (__lowercase): print('left rotation node:' , node.get_data()) UpperCamelCase_ = node.get_left() assert ret is not None node.set_left(ret.get_right()) ret.set_right(__lowercase) UpperCamelCase_ = my_max(get_height(node.get_right()) , get_height(node.get_left())) + 1 node.set_height(__lowercase) UpperCamelCase_ = my_max(get_height(ret.get_right()) , get_height(ret.get_left())) + 1 ret.set_height(__lowercase) return ret def _snake_case (__lowercase): print('right rotation node:' , node.get_data()) UpperCamelCase_ = node.get_right() assert ret is not None node.set_right(ret.get_left()) ret.set_left(__lowercase) UpperCamelCase_ = my_max(get_height(node.get_right()) , get_height(node.get_left())) + 1 node.set_height(__lowercase) UpperCamelCase_ = my_max(get_height(ret.get_right()) , get_height(ret.get_left())) + 1 ret.set_height(__lowercase) return ret def _snake_case (__lowercase): UpperCamelCase_ = node.get_left() assert left_child is not None node.set_left(left_rotation(__lowercase)) return right_rotation(__lowercase) def _snake_case (__lowercase): UpperCamelCase_ = node.get_right() assert right_child is not None node.set_right(right_rotation(__lowercase)) return left_rotation(__lowercase) def _snake_case (__lowercase , __lowercase): if node is None: return MyNode(__lowercase) if data < node.get_data(): node.set_left(insert_node(node.get_left() , __lowercase)) if ( get_height(node.get_left()) - get_height(node.get_right()) == 2 ): # an unbalance detected UpperCamelCase_ = node.get_left() assert left_child is not None if ( data < left_child.get_data() ): # new node is the left child of the left child UpperCamelCase_ = right_rotation(__lowercase) else: UpperCamelCase_ = lr_rotation(__lowercase) else: node.set_right(insert_node(node.get_right() , __lowercase)) if get_height(node.get_right()) - get_height(node.get_left()) == 2: UpperCamelCase_ = node.get_right() assert right_child is not None if data < right_child.get_data(): UpperCamelCase_ = rl_rotation(__lowercase) else: UpperCamelCase_ = left_rotation(__lowercase) UpperCamelCase_ = my_max(get_height(node.get_right()) , get_height(node.get_left())) + 1 node.set_height(__lowercase) return node def _snake_case (__lowercase): while True: UpperCamelCase_ = root.get_right() if right_child is None: break UpperCamelCase_ = right_child return root.get_data() def _snake_case (__lowercase): while True: UpperCamelCase_ = root.get_left() if left_child is None: break UpperCamelCase_ = left_child return root.get_data() def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = root.get_left() UpperCamelCase_ = root.get_right() if root.get_data() == data: if left_child is not None and right_child is not None: UpperCamelCase_ = get_left_most(__lowercase) root.set_data(__lowercase) root.set_right(del_node(__lowercase , __lowercase)) elif left_child is not None: UpperCamelCase_ = left_child elif right_child is not None: UpperCamelCase_ = right_child else: return None elif root.get_data() > data: if left_child is None: print('No such data') return root else: root.set_left(del_node(__lowercase , __lowercase)) else: # root.get_data() < data if right_child is None: return root else: root.set_right(del_node(__lowercase , __lowercase)) if get_height(__lowercase) - get_height(__lowercase) == 2: assert right_child is not None if get_height(right_child.get_right()) > get_height(right_child.get_left()): UpperCamelCase_ = left_rotation(__lowercase) else: UpperCamelCase_ = rl_rotation(__lowercase) elif get_height(__lowercase) - get_height(__lowercase) == -2: assert left_child is not None if get_height(left_child.get_left()) > get_height(left_child.get_right()): UpperCamelCase_ = right_rotation(__lowercase) else: UpperCamelCase_ = lr_rotation(__lowercase) UpperCamelCase_ = my_max(get_height(root.get_right()) , get_height(root.get_left())) + 1 root.set_height(__lowercase) return root class _a : """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = None def _UpperCAmelCase ( self ) -> int: return get_height(self.root ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: print('insert:' + str(_UpperCAmelCase ) ) UpperCamelCase_ = insert_node(self.root , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: print('delete:' + str(_UpperCAmelCase ) ) if self.root is None: print('Tree is empty!' ) return UpperCamelCase_ = del_node(self.root , _UpperCAmelCase ) def __str__( self , ) -> str: # a level traversale, gives a more intuitive look on the tree UpperCamelCase_ = '' UpperCamelCase_ = MyQueue() q.push(self.root ) UpperCamelCase_ = self.get_height() if layer == 0: return output UpperCamelCase_ = 0 while not q.is_empty(): UpperCamelCase_ = q.pop() UpperCamelCase_ = ' ' * int(math.pow(2 , layer - 1 ) ) output += space if node is None: output += "*" q.push(_UpperCAmelCase ) q.push(_UpperCAmelCase ) else: output += str(node.get_data() ) q.push(node.get_left() ) q.push(node.get_right() ) output += space UpperCamelCase_ = cnt + 1 for i in range(100 ): if cnt == math.pow(2 , _UpperCAmelCase ) - 1: UpperCamelCase_ = layer - 1 if layer == 0: output += "\n*************************************" return output output += "\n" break output += "\n*************************************" return output def _snake_case (): import doctest doctest.testmod() if __name__ == "__main__": _test() snake_case__ : Optional[Any] = AVLtree() snake_case__ : Union[str, Any] = list(range(1_0)) random.shuffle(lst) for i in lst: t.insert(i) print(str(t)) random.shuffle(lst) for i in lst: t.del_node(i) print(str(t))
23
import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import MaskaFormerConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel if is_vision_available(): from transformers import MaskaFormerImageProcessor if is_vision_available(): from PIL import Image class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=2 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=10 , _UpperCAmelCase=3 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=4 , _UpperCAmelCase=64 , ) -> List[Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = is_training UpperCamelCase_ = use_auxiliary_loss UpperCamelCase_ = num_queries UpperCamelCase_ = num_channels UpperCamelCase_ = min_size UpperCamelCase_ = max_size UpperCamelCase_ = num_labels UpperCamelCase_ = hidden_dim UpperCamelCase_ = hidden_dim def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( _UpperCAmelCase ) UpperCamelCase_ = torch.ones([self.batch_size, self.min_size, self.max_size] , device=_UpperCAmelCase ) UpperCamelCase_ = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=_UpperCAmelCase ) > 0.5 ).float() UpperCamelCase_ = (torch.rand((self.batch_size, self.num_labels) , device=_UpperCAmelCase ) > 0.5).long() UpperCamelCase_ = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = MaskaFormerConfig( hidden_size=self.hidden_dim , ) UpperCamelCase_ = self.num_queries UpperCamelCase_ = self.num_labels UpperCamelCase_ = [1, 1, 1, 1] UpperCamelCase_ = self.num_channels UpperCamelCase_ = 64 UpperCamelCase_ = 128 UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim return config def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ = {'pixel_values': pixel_values, 'pixel_mask': pixel_mask} return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = output.encoder_hidden_states UpperCamelCase_ = output.pixel_decoder_hidden_states UpperCamelCase_ = output.transformer_decoder_hidden_states self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , config.decoder_layers ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False ) -> Any: with torch.no_grad(): UpperCamelCase_ = MaskaFormerModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.hidden_dim) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() def comm_check_on_output(_UpperCAmelCase ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) UpperCamelCase_ = model( pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else () A_ = {"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {} A_ = False A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , has_text_modality=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_UpperCAmelCase ) @unittest.skip(reason='Mask2Former does not use inputs_embeds' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method' ) def _UpperCAmelCase ( self ) -> Optional[int]: pass @unittest.skip(reason='Mask2Former is not a generative model' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not use token embeddings' ) def _UpperCAmelCase ( self ) -> Optional[Any]: pass @require_torch_multi_gpu @unittest.skip( reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' ) def _UpperCAmelCase ( self ) -> int: pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Tuple: for model_name in ["facebook/mask2former-swin-small-coco-instance"]: UpperCamelCase_ = MaskaFormerModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = (self.model_tester.min_size,) * 2 UpperCamelCase_ = { 'pixel_values': torch.randn((2, 3, *size) , device=_UpperCAmelCase ), 'mask_labels': torch.randn((2, 10, *size) , device=_UpperCAmelCase ), 'class_labels': torch.zeros(2 , 10 , device=_UpperCAmelCase ).long(), } UpperCamelCase_ = self.model_tester.get_config() UpperCamelCase_ = MaskaFormerForUniversalSegmentation(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None ) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase , output_attentions=_UpperCAmelCase ) self.assertTrue(outputs.attentions is not None ) def _UpperCAmelCase ( self ) -> List[Any]: if not self.model_tester.is_training: return UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = True UpperCamelCase_ = True UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) UpperCamelCase_ = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=_UpperCAmelCase ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) snake_case__ : List[Any] = 1E-4 def _snake_case (): UpperCamelCase_ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') return image @require_vision @slow class _a ( unittest.TestCase ): """simple docstring""" @cached_property def _UpperCAmelCase ( self ) -> Optional[int]: return "facebook/mask2former-swin-small-coco-instance" @cached_property def _UpperCAmelCase ( self ) -> List[str]: return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) UpperCamelCase_ = torch.tensor( [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) # masks_queries_logits UpperCamelCase_ = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) ) UpperCamelCase_ = [ [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1], [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1], [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5], ] UpperCamelCase_ = torch.tensor(_UpperCAmelCase ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) # class_queries_logits UpperCamelCase_ = outputs.class_queries_logits self.assertEqual(class_queries_logits.shape , (1, model.config.num_queries, model.config.num_labels + 1) ) UpperCamelCase_ = torch.tensor( [ [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2], [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3], [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5], ] ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = image_processor( [np.zeros((3, 800, 1333) ), np.zeros((3, 800, 1333) )] , segmentation_maps=[np.zeros((384, 384) ).astype(np.floataa ), np.zeros((384, 384) ).astype(np.floataa )] , return_tensors='pt' , ) UpperCamelCase_ = inputs['pixel_values'].to(_UpperCAmelCase ) UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['mask_labels']] UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['class_labels']] with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None )
23
1
from ...configuration_utils import PretrainedConfig from ...utils import logging from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices snake_case__ : Any = logging.get_logger(__name__) snake_case__ : str = { """shi-labs/nat-mini-in1k-224""": """https://huggingface.co/shi-labs/nat-mini-in1k-224/resolve/main/config.json""", # See all Nat models at https://huggingface.co/models?filter=nat } class _a ( UpperCAmelCase__ , UpperCAmelCase__ ): """simple docstring""" A_ = """nat""" A_ = { """num_attention_heads""": """num_heads""", """num_hidden_layers""": """num_layers""", } def __init__( self , _UpperCAmelCase=4 , _UpperCAmelCase=3 , _UpperCAmelCase=64 , _UpperCAmelCase=[3, 4, 6, 5] , _UpperCAmelCase=[2, 4, 8, 16] , _UpperCAmelCase=7 , _UpperCAmelCase=3.0 , _UpperCAmelCase=True , _UpperCAmelCase=0.0 , _UpperCAmelCase=0.0 , _UpperCAmelCase=0.1 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=1e-5 , _UpperCAmelCase=0.0 , _UpperCAmelCase=None , _UpperCAmelCase=None , **_UpperCAmelCase , ) -> List[Any]: super().__init__(**_UpperCAmelCase ) UpperCamelCase_ = patch_size UpperCamelCase_ = num_channels UpperCamelCase_ = embed_dim UpperCamelCase_ = depths UpperCamelCase_ = len(_UpperCAmelCase ) UpperCamelCase_ = num_heads UpperCamelCase_ = kernel_size UpperCamelCase_ = mlp_ratio UpperCamelCase_ = qkv_bias UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = drop_path_rate UpperCamelCase_ = hidden_act UpperCamelCase_ = layer_norm_eps UpperCamelCase_ = initializer_range # we set the hidden_size attribute in order to make Nat work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model UpperCamelCase_ = int(embed_dim * 2 ** (len(_UpperCAmelCase ) - 1) ) UpperCamelCase_ = layer_scale_init_value UpperCamelCase_ = ['stem'] + [f"""stage{idx}""" for idx in range(1 , len(_UpperCAmelCase ) + 1 )] UpperCamelCase_ , UpperCamelCase_ = get_aligned_output_features_output_indices( out_features=_UpperCAmelCase , out_indices=_UpperCAmelCase , stage_names=self.stage_names )
23
import copy from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto.configuration_auto import AutoConfig if TYPE_CHECKING: from ... import PreTrainedTokenizerBase, TensorType snake_case__ : List[str] = logging.get_logger(__name__) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """vision-encoder-decoder""" A_ = True def __init__( self , **_UpperCAmelCase ) -> Dict: super().__init__(**_UpperCAmelCase ) if "encoder" not in kwargs or "decoder" not in kwargs: raise ValueError( f"""A configuraton of type {self.model_type} cannot be instantiated because """ f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}""" ) UpperCamelCase_ = kwargs.pop('encoder' ) UpperCamelCase_ = encoder_config.pop('model_type' ) UpperCamelCase_ = kwargs.pop('decoder' ) UpperCamelCase_ = decoder_config.pop('model_type' ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = True @classmethod def _UpperCAmelCase ( cls , _UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) -> PretrainedConfig: logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config' ) UpperCamelCase_ = True UpperCamelCase_ = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = copy.deepcopy(self.__dict__ ) UpperCamelCase_ = self.encoder.to_dict() UpperCamelCase_ = self.decoder.to_dict() UpperCamelCase_ = self.__class__.model_type return output class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = version.parse("""1.11""" ) @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) @property def _UpperCAmelCase ( self ) -> float: return 1e-4 @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict({'last_hidden_state': {0: 'batch', 1: 'encoder_sequence'}} ) class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: UpperCamelCase_ = OrderedDict() UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'encoder_sequence'} return common_inputs def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = -1 , _UpperCAmelCase = -1 , _UpperCAmelCase = False , _UpperCAmelCase = None , ) -> Mapping[str, Any]: import torch UpperCamelCase_ = OrderedDict() UpperCamelCase_ = super().generate_dummy_inputs( _UpperCAmelCase , batch_size=_UpperCAmelCase , seq_length=_UpperCAmelCase , is_pair=_UpperCAmelCase , framework=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = dummy_input['input_ids'].shape UpperCamelCase_ = (batch, encoder_sequence, self._config.encoder_hidden_size) UpperCamelCase_ = dummy_input.pop('input_ids' ) UpperCamelCase_ = dummy_input.pop('attention_mask' ) UpperCamelCase_ = torch.zeros(_UpperCAmelCase ) return common_inputs class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> None: pass def _UpperCAmelCase ( self , _UpperCAmelCase ) -> OnnxConfig: return VisionEncoderDecoderEncoderOnnxConfig(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = "default" ) -> OnnxConfig: UpperCamelCase_ = encoder_config.hidden_size return VisionEncoderDecoderDecoderOnnxConfig(_UpperCAmelCase , _UpperCAmelCase )
23
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_speech_available, is_torch_available snake_case__ : Tuple = { """configuration_audio_spectrogram_transformer""": [ """AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ASTConfig""", ] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Union[str, Any] = [ """AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""", """ASTForAudioClassification""", """ASTModel""", """ASTPreTrainedModel""", ] try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Any = ["""ASTFeatureExtractor"""] if TYPE_CHECKING: from .configuration_audio_spectrogram_transformer import ( AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, ASTConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_audio_spectrogram_transformer import ( AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ASTForAudioClassification, ASTModel, ASTPreTrainedModel, ) try: if not is_speech_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_audio_spectrogram_transformer import ASTFeatureExtractor else: import sys snake_case__ : Any = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
import argparse import torch from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert from transformers.utils import logging logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = MobileBertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = MobileBertForPreTraining(__lowercase) # Load weights from tf checkpoint UpperCamelCase_ = load_tf_weights_in_mobilebert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--mobilebert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained MobileBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : Optional[Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
23
1
import argparse import pathlib import fairseq import torch from fairseq.models.roberta import RobertaModel as FairseqRobertaModel from fairseq.modules import TransformerSentenceEncoderLayer from packaging import version from transformers import XLMRobertaConfig, XLMRobertaXLForMaskedLM, XLMRobertaXLForSequenceClassification from transformers.models.bert.modeling_bert import ( BertIntermediate, BertLayer, BertOutput, BertSelfAttention, BertSelfOutput, ) from transformers.models.roberta.modeling_roberta import RobertaAttention from transformers.utils import logging if version.parse(fairseq.__version__) < version.parse("""1.0.0a"""): raise Exception("""requires fairseq >= 1.0.0a""") logging.set_verbosity_info() snake_case__ : Any = logging.get_logger(__name__) snake_case__ : Dict = """Hello world! cécé herlolip""" def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = FairseqRobertaModel.from_pretrained(__lowercase) roberta.eval() # disable dropout UpperCamelCase_ = roberta.model.encoder.sentence_encoder UpperCamelCase_ = XLMRobertaConfig( vocab_size=roberta_sent_encoder.embed_tokens.num_embeddings , hidden_size=roberta.cfg.model.encoder_embed_dim , num_hidden_layers=roberta.cfg.model.encoder_layers , num_attention_heads=roberta.cfg.model.encoder_attention_heads , intermediate_size=roberta.cfg.model.encoder_ffn_embed_dim , max_position_embeddings=514 , type_vocab_size=1 , layer_norm_eps=1e-5 , ) if classification_head: UpperCamelCase_ = roberta.model.classification_heads['mnli'].out_proj.weight.shape[0] print('Our RoBERTa config:' , __lowercase) UpperCamelCase_ = XLMRobertaXLForSequenceClassification(__lowercase) if classification_head else XLMRobertaXLForMaskedLM(__lowercase) model.eval() # Now let's copy all the weights. # Embeddings UpperCamelCase_ = roberta_sent_encoder.embed_tokens.weight UpperCamelCase_ = roberta_sent_encoder.embed_positions.weight UpperCamelCase_ = torch.zeros_like( model.roberta.embeddings.token_type_embeddings.weight) # just zero them out b/c RoBERTa doesn't use them. UpperCamelCase_ = roberta_sent_encoder.layer_norm.weight UpperCamelCase_ = roberta_sent_encoder.layer_norm.bias for i in range(config.num_hidden_layers): # Encoder: start of layer UpperCamelCase_ = model.roberta.encoder.layer[i] UpperCamelCase_ = roberta_sent_encoder.layers[i] UpperCamelCase_ = layer.attention UpperCamelCase_ = roberta_layer.self_attn_layer_norm.weight UpperCamelCase_ = roberta_layer.self_attn_layer_norm.bias # self attention UpperCamelCase_ = layer.attention.self assert ( roberta_layer.self_attn.k_proj.weight.data.shape == roberta_layer.self_attn.q_proj.weight.data.shape == roberta_layer.self_attn.v_proj.weight.data.shape == torch.Size((config.hidden_size, config.hidden_size)) ) UpperCamelCase_ = roberta_layer.self_attn.q_proj.weight UpperCamelCase_ = roberta_layer.self_attn.q_proj.bias UpperCamelCase_ = roberta_layer.self_attn.k_proj.weight UpperCamelCase_ = roberta_layer.self_attn.k_proj.bias UpperCamelCase_ = roberta_layer.self_attn.v_proj.weight UpperCamelCase_ = roberta_layer.self_attn.v_proj.bias # self-attention output UpperCamelCase_ = layer.attention.output assert self_output.dense.weight.shape == roberta_layer.self_attn.out_proj.weight.shape UpperCamelCase_ = roberta_layer.self_attn.out_proj.weight UpperCamelCase_ = roberta_layer.self_attn.out_proj.bias # this one is final layer norm UpperCamelCase_ = roberta_layer.final_layer_norm.weight UpperCamelCase_ = roberta_layer.final_layer_norm.bias # intermediate UpperCamelCase_ = layer.intermediate assert intermediate.dense.weight.shape == roberta_layer.fca.weight.shape UpperCamelCase_ = roberta_layer.fca.weight UpperCamelCase_ = roberta_layer.fca.bias # output UpperCamelCase_ = layer.output assert bert_output.dense.weight.shape == roberta_layer.fca.weight.shape UpperCamelCase_ = roberta_layer.fca.weight UpperCamelCase_ = roberta_layer.fca.bias # end of layer if classification_head: UpperCamelCase_ = roberta.model.classification_heads['mnli'].dense.weight UpperCamelCase_ = roberta.model.classification_heads['mnli'].dense.bias UpperCamelCase_ = roberta.model.classification_heads['mnli'].out_proj.weight UpperCamelCase_ = roberta.model.classification_heads['mnli'].out_proj.bias else: # LM Head UpperCamelCase_ = roberta.model.encoder.lm_head.dense.weight UpperCamelCase_ = roberta.model.encoder.lm_head.dense.bias UpperCamelCase_ = roberta.model.encoder.lm_head.layer_norm.weight UpperCamelCase_ = roberta.model.encoder.lm_head.layer_norm.bias UpperCamelCase_ = roberta.model.encoder.lm_head.weight UpperCamelCase_ = roberta.model.encoder.lm_head.bias # Let's check that we get the same results. UpperCamelCase_ = roberta.encode(__lowercase).unsqueeze(0) # batch of size 1 UpperCamelCase_ = model(__lowercase)[0] if classification_head: UpperCamelCase_ = roberta.model.classification_heads['mnli'](roberta.extract_features(__lowercase)) else: UpperCamelCase_ = roberta.model(__lowercase)[0] print(our_output.shape , their_output.shape) UpperCamelCase_ = torch.max(torch.abs(our_output - their_output)).item() print(f"""max_absolute_diff = {max_absolute_diff}""") # ~ 1e-7 UpperCamelCase_ = torch.allclose(__lowercase , __lowercase , atol=1e-3) print('Do both models output the same tensors?' , '🔥' if success else '💩') if not success: raise Exception('Something went wRoNg') pathlib.Path(__lowercase).mkdir(parents=__lowercase , exist_ok=__lowercase) print(f"""Saving model to {pytorch_dump_folder_path}""") model.save_pretrained(__lowercase) if __name__ == "__main__": snake_case__ : str = argparse.ArgumentParser() # Required parameters parser.add_argument( """--roberta_checkpoint_path""", default=None, type=str, required=True, help="""Path the official PyTorch dump.""" ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) parser.add_argument( """--classification_head""", action="""store_true""", help="""Whether to convert a final classification head.""" ) snake_case__ : int = parser.parse_args() convert_xlm_roberta_xl_checkpoint_to_pytorch( args.roberta_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head )
23
import gc import unittest from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline from transformers.pipelines import PipelineException from transformers.testing_utils import ( is_pipeline_test, is_torch_available, nested_simplify, require_tf, require_torch, require_torch_gpu, slow, ) from .test_pipelines_common import ANY @is_pipeline_test class _a ( unittest.TestCase ): """simple docstring""" A_ = MODEL_FOR_MASKED_LM_MAPPING A_ = TF_MODEL_FOR_MASKED_LM_MAPPING def _UpperCAmelCase ( self ) -> List[str]: super().tearDown() # clean-up as much as possible GPU memory occupied by PyTorch gc.collect() if is_torch_available(): import torch torch.cuda.empty_cache() @require_tf def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='tf' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped'}, {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped', }, { 'sequence': 'The largest city in France is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='pt' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul'}, {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', }, {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2941, 'token_str': ' Te'}, {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask> <mask>' , top_k=2 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is Maul<mask></s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'}, ], [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is<mask> Maul</s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'}, ], ] , ) @require_torch_gpu def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = pipeline('fill-mask' , model='hf-internal-testing/tiny-random-distilbert' , device=0 , framework='pt' ) # convert model to fp16 pipe.model.half() UpperCamelCase_ = pipe('Paris is the [MASK] of France.' ) # We actually don't care about the result, we just want to make sure # it works, meaning the float16 tensor got casted back to float32 # for postprocessing. self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='pt' ) self.run_large_test(_UpperCAmelCase ) @slow @require_tf def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='tf' ) self.run_large_test(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is John', 'score': 0.0_0_8, 'token': 610, 'token_str': ' John'}, {'sequence': 'My name is Chris', 'score': 0.0_0_7, 'token': 1573, 'token_str': ' Chris'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ { 'sequence': 'The largest city in France is Paris', 'score': 0.2_5_1, 'token': 2201, 'token_str': ' Paris', }, { 'sequence': 'The largest city in France is Lyon', 'score': 0.2_1_4, 'token': 12790, 'token_str': ' Lyon', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is Patrick', 'score': 0.0_0_5, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='pt' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) @require_tf def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='tf' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: if tokenizer is None or tokenizer.mask_token_id is None: self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)' ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = [ f"""This is another {tokenizer.mask_token} test""", ] return fill_masker, examples def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = fill_masker.tokenizer UpperCamelCase_ = fill_masker.model UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token}""" , ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}"""] ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""] ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , ) with self.assertRaises(_UpperCAmelCase ): fill_masker([None] ) # No mask_token is not supported with self.assertRaises(_UpperCAmelCase ): fill_masker('This is' ) self.run_test_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_targets(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_top_k_targets(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_duplicate_targets_and_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_multiple_masks(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = sorted(vocab.keys() )[:2] # Pipeline argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , targets=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Call argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Score equivalence UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['token_str'] for top_mask in outputs] UpperCamelCase_ = [top_mask['score'] for top_mask in outputs] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ) == set(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['score'] for top_mask in unmasked_targets] self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) # Raises with invalid with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[] ) # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised if "" not in tokenizer.get_vocab(): with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[''] ) with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets='' ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , top_k=2 ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) # top_k=2, ntargets=3 UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 , targets=_UpperCAmelCase ) # If we use the most probably targets, and filter differently, we should still # have the same results UpperCamelCase_ = [el['token_str'] for el in sorted(_UpperCAmelCase , key=lambda _UpperCAmelCase : x["score"] , reverse=_UpperCAmelCase )] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ).issubset(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=3 , targets=_UpperCAmelCase ) # They should yield exactly the same result self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.get_vocab() # String duplicates + id duplicates UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = [targets[0], targets[1], targets[0], targets[2], targets[1]] UpperCamelCase_ = fill_masker(f"""My name is {tokenizer.mask_token}""" , targets=_UpperCAmelCase , top_k=10 ) # The target list contains duplicates, so we can't output more # than them self.assertEqual(len(_UpperCAmelCase ) , 3 ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , )
23
1
import unittest from transformers import is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device if is_torch_available(): from transformers import AutoModelForSeqaSeqLM, AutoTokenizer @require_torch @require_sentencepiece @require_tokenizers class _a ( unittest.TestCase ): """simple docstring""" @slow def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = AutoModelForSeqaSeqLM.from_pretrained('google/mt5-small' , return_dict=_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = AutoTokenizer.from_pretrained('google/mt5-small' ) UpperCamelCase_ = tokenizer('Hello there' , return_tensors='pt' ).input_ids UpperCamelCase_ = tokenizer('Hi I am' , return_tensors='pt' ).input_ids UpperCamelCase_ = model(input_ids.to(_UpperCAmelCase ) , labels=labels.to(_UpperCAmelCase ) ).loss UpperCamelCase_ = -(labels.shape[-1] * loss.item()) UpperCamelCase_ = -8_4.9_1_2_7 self.assertTrue(abs(mtf_score - EXPECTED_SCORE ) < 1e-4 )
23
import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, StableDiffusionSAGPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = StableDiffusionSAGPipeline A_ = TEXT_TO_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_BATCH_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) UpperCamelCase_ = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=32 , ) UpperCamelCase_ = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule='scaled_linear' , clip_sample=_UpperCAmelCase , set_alpha_to_one=_UpperCAmelCase , ) torch.manual_seed(0 ) UpperCamelCase_ = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) UpperCamelCase_ = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) UpperCamelCase_ = CLIPTextModel(_UpperCAmelCase ) UpperCamelCase_ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) UpperCamelCase_ = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=0 ) -> List[Any]: if str(_UpperCAmelCase ).startswith('mps' ): UpperCamelCase_ = torch.manual_seed(_UpperCAmelCase ) else: UpperCamelCase_ = torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase ) UpperCamelCase_ = { 'prompt': '.', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 1.0, 'sag_scale': 1.0, 'output_type': 'numpy', } return inputs def _UpperCAmelCase ( self ) -> Tuple: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Tuple: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , width=768 , height=512 , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' , ) UpperCamelCase_ = output.images assert image.shape == (1, 512, 768, 3)
23
1
import numpy as np import torch from torch.utils.data import Dataset, IterableDataset from ..utils.generic import ModelOutput class _a ( UpperCAmelCase__ ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = dataset UpperCamelCase_ = process UpperCamelCase_ = params def __len__( self ) -> Optional[Any]: return len(self.dataset ) def __getitem__( self , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = self.dataset[i] UpperCamelCase_ = self.process(_UpperCAmelCase , **self.params ) return processed class _a ( UpperCAmelCase__ ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=None ) -> Optional[int]: UpperCamelCase_ = loader UpperCamelCase_ = infer UpperCamelCase_ = params if loader_batch_size == 1: # Let's spare some time by deactivating altogether UpperCamelCase_ = None UpperCamelCase_ = loader_batch_size # Internal bookkeeping UpperCamelCase_ = None UpperCamelCase_ = None def __len__( self ) -> List[Any]: return len(self.loader ) def __iter__( self ) -> List[Any]: UpperCamelCase_ = iter(self.loader ) return self def _UpperCAmelCase ( self ) -> List[str]: if isinstance(self._loader_batch_data , torch.Tensor ): # Batch data is simple tensor, just fetch the slice UpperCamelCase_ = self._loader_batch_data[self._loader_batch_index] else: # Batch data is assumed to be BaseModelOutput (or dict) UpperCamelCase_ = {} for k, element in self._loader_batch_data.items(): if isinstance(_UpperCAmelCase , _UpperCAmelCase ): # Convert ModelOutput to tuple first UpperCamelCase_ = element.to_tuple() if isinstance(element[0] , torch.Tensor ): UpperCamelCase_ = tuple(el[self._loader_batch_index].unsqueeze(0 ) for el in element ) elif isinstance(element[0] , np.ndarray ): UpperCamelCase_ = tuple(np.expand_dims(el[self._loader_batch_index] , 0 ) for el in element ) continue if k in {"hidden_states", "past_key_values", "attentions"} and isinstance(_UpperCAmelCase , _UpperCAmelCase ): # Those are stored as lists of tensors so need specific unbatching. if isinstance(element[0] , torch.Tensor ): UpperCamelCase_ = tuple(el[self._loader_batch_index].unsqueeze(0 ) for el in element ) elif isinstance(element[0] , np.ndarray ): UpperCamelCase_ = tuple(np.expand_dims(el[self._loader_batch_index] , 0 ) for el in element ) continue if element is None: # This can happen for optional data that get passed around UpperCamelCase_ = None elif isinstance(element[self._loader_batch_index] , torch.Tensor ): # Take correct batch data, but make it looked like batch_size=1 # For compatibility with other methods within transformers UpperCamelCase_ = element[self._loader_batch_index].unsqueeze(0 ) elif isinstance(element[self._loader_batch_index] , np.ndarray ): # Take correct batch data, but make it looked like batch_size=1 # For compatibility with other methods within transformers UpperCamelCase_ = np.expand_dims(element[self._loader_batch_index] , 0 ) else: # This is typically a list, so no need to `unsqueeze`. UpperCamelCase_ = element[self._loader_batch_index] # Recreate the element by reusing the original class to make it look # batch_size=1 UpperCamelCase_ = self._loader_batch_data.__class__(_UpperCAmelCase ) self._loader_batch_index += 1 return result def _UpperCAmelCase ( self ) -> Optional[int]: if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size: # We are currently unrolling a batch so we just need to return # the current item within a batch return self.loader_batch_item() # We're out of items within a batch UpperCamelCase_ = next(self.iterator ) UpperCamelCase_ = self.infer(_UpperCAmelCase , **self.params ) # We now have a batch of "inferred things". if self.loader_batch_size is not None: # Try to infer the size of the batch if isinstance(_UpperCAmelCase , torch.Tensor ): UpperCamelCase_ = processed else: UpperCamelCase_ = list(processed.keys() )[0] UpperCamelCase_ = processed[key] if isinstance(_UpperCAmelCase , _UpperCAmelCase ): UpperCamelCase_ = len(_UpperCAmelCase ) else: UpperCamelCase_ = first_tensor.shape[0] if 0 < observed_batch_size < self.loader_batch_size: # could be last batch so we can't unroll as many # elements. UpperCamelCase_ = observed_batch_size # Setting internal index to unwrap the batch UpperCamelCase_ = processed UpperCamelCase_ = 0 return self.loader_batch_item() else: # We're not unrolling batches return processed class _a ( UpperCAmelCase__ ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=None ) -> List[str]: super().__init__(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def __iter__( self ) -> Tuple: UpperCamelCase_ = iter(self.loader ) UpperCamelCase_ = None return self def _UpperCAmelCase ( self ) -> List[Any]: if self.subiterator is None: UpperCamelCase_ = self.infer(next(self.iterator ) , **self.params ) try: # Try to return next item UpperCamelCase_ = next(self.subiterator ) except StopIteration: # When a preprocess iterator ends, we can start lookig at the next item # ChunkIterator will keep feeding until ALL elements of iterator # all have created their subiterator and have been iterating against. # # Another way to look at it, is we're basically flattening lists of lists # into a single list, but with generators UpperCamelCase_ = self.infer(next(self.iterator ) , **self.params ) UpperCamelCase_ = next(self.subiterator ) return processed class _a ( UpperCAmelCase__ ): """simple docstring""" def __iter__( self ) -> Tuple: UpperCamelCase_ = iter(self.loader ) return self def _UpperCAmelCase ( self ) -> Any: # Extremely similar to PipelineIterator in its unpacking mechanism # BUT, we have an extra required item which is the presence of `is_last` # That is because everything is flattened by `PipelineChunkIterator` we # need to keep track of how to regroup here in the original `process` # boundaries so that `process` and `postprocess` see the same data. # This iterator accumulates items (possibly while unbatching) until it # its a `is_last` and then just passes it on to the caller. UpperCamelCase_ = False UpperCamelCase_ = [] if self._loader_batch_index is not None and self._loader_batch_index < self.loader_batch_size: while self._loader_batch_index < self.loader_batch_size: UpperCamelCase_ = self.loader_batch_item() UpperCamelCase_ = item.pop('is_last' ) accumulator.append(_UpperCAmelCase ) if is_last: return accumulator while not is_last: UpperCamelCase_ = self.infer(next(self.iterator ) , **self.params ) if self.loader_batch_size is not None: if isinstance(_UpperCAmelCase , torch.Tensor ): UpperCamelCase_ = processed else: UpperCamelCase_ = list(processed.keys() )[0] UpperCamelCase_ = processed[key] if isinstance(_UpperCAmelCase , _UpperCAmelCase ): UpperCamelCase_ = len(_UpperCAmelCase ) else: UpperCamelCase_ = first_tensor.shape[0] if 0 < observed_batch_size < self.loader_batch_size: # could be last batch so we can't unroll as many # elements. UpperCamelCase_ = observed_batch_size UpperCamelCase_ = processed UpperCamelCase_ = 0 while self._loader_batch_index < self.loader_batch_size: UpperCamelCase_ = self.loader_batch_item() UpperCamelCase_ = item.pop('is_last' ) accumulator.append(_UpperCAmelCase ) if is_last: return accumulator else: UpperCamelCase_ = processed UpperCamelCase_ = item.pop('is_last' ) accumulator.append(_UpperCAmelCase ) return accumulator class _a ( UpperCAmelCase__ ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase ) -> Any: UpperCamelCase_ = dataset UpperCamelCase_ = key def __len__( self ) -> Optional[int]: return len(self.dataset ) def __getitem__( self , _UpperCAmelCase ) -> Union[str, Any]: return self.dataset[i][self.key] class _a ( UpperCAmelCase__ ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = dataset UpperCamelCase_ = keya UpperCamelCase_ = keya def __len__( self ) -> int: return len(self.dataset ) def __getitem__( self , _UpperCAmelCase ) -> List[str]: return {"text": self.dataset[i][self.keya], "text_pair": self.dataset[i][self.keya]}
23
from __future__ import annotations from sys import maxsize from typing import Generic, TypeVar snake_case__ : List[str] = TypeVar("""T""") def _snake_case (__lowercase): return (position - 1) // 2 def _snake_case (__lowercase): return (2 * position) + 1 def _snake_case (__lowercase): return (2 * position) + 2 class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = [] UpperCamelCase_ = {} UpperCamelCase_ = 0 def __len__( self ) -> int: return self.elements def __repr__( self ) -> str: return str(self.heap ) def _UpperCAmelCase ( self ) -> bool: # Check if the priority queue is empty return self.elements == 0 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an element with given priority to the queue self.heap.append((elem, weight) ) UpperCamelCase_ = self.elements self.elements += 1 self._bubble_up(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> T: # Remove and return the element with lowest weight (highest priority) if self.elements > 1: self._swap_nodes(0 , self.elements - 1 ) UpperCamelCase_ , UpperCamelCase_ = self.heap.pop() del self.position_map[elem] self.elements -= 1 if self.elements > 0: UpperCamelCase_ , UpperCamelCase_ = self.heap[0] self._bubble_down(_UpperCAmelCase ) return elem def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Update the weight of the given key UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ = (elem, weight) if position > 0: UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._bubble_up(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (upward movement) [to be used internally # only] UpperCamelCase_ = self.position_map[elem] if curr_pos == 0: return None UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_up(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (downward movement) [to be used # internally only] UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ = get_child_left_position(_UpperCAmelCase ) UpperCamelCase_ = get_child_right_position(_UpperCAmelCase ) if child_left_position < self.elements and child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < child_left_weight and child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) if child_left_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] if child_left_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) else: return None if child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Swap the nodes at the given positions UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ , UpperCamelCase_ = ( self.heap[nodea_pos], self.heap[nodea_pos], ) UpperCamelCase_ = nodea_pos UpperCamelCase_ = nodea_pos class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = {} UpperCamelCase_ = 0 def __repr__( self ) -> str: return str(self.connections ) def __len__( self ) -> int: return self.nodes def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Add a node in the graph if it is not in the graph if node not in self.connections: UpperCamelCase_ = {} self.nodes += 1 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an edge between 2 nodes in the graph self.add_node(_UpperCAmelCase ) self.add_node(_UpperCAmelCase ) UpperCamelCase_ = weight UpperCamelCase_ = weight def _snake_case (__lowercase , ): UpperCamelCase_ = {node: maxsize for node in graph.connections} UpperCamelCase_ = {node: None for node in graph.connections} UpperCamelCase_ = MinPriorityQueue() for node, weight in dist.items(): priority_queue.push(__lowercase , __lowercase) if priority_queue.is_empty(): return dist, parent # initialization UpperCamelCase_ = priority_queue.extract_min() UpperCamelCase_ = 0 for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node # running prim's algorithm while not priority_queue.is_empty(): UpperCamelCase_ = priority_queue.extract_min() for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node return dist, parent
23
1
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging snake_case__ : Optional[Any] = logging.get_logger(__name__) snake_case__ : Optional[Any] = {"""vocab_file""": """spiece.model"""} snake_case__ : Dict = { """vocab_file""": { """bert_for_seq_generation""": ( """https://huggingface.co/google/bert_for_seq_generation_L-24_bbc_encoder/resolve/main/spiece.model""" ), } } snake_case__ : Tuple = {"""bert_for_seq_generation""": 5_1_2} class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = VOCAB_FILES_NAMES A_ = PRETRAINED_VOCAB_FILES_MAP A_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A_ = [] A_ = ["""input_ids""", """attention_mask"""] def __init__( self , _UpperCAmelCase , _UpperCAmelCase="<s>" , _UpperCAmelCase="</s>" , _UpperCAmelCase="<unk>" , _UpperCAmelCase="<pad>" , _UpperCAmelCase="<::::>" , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> None: UpperCamelCase_ = {} if sp_model_kwargs is None else sp_model_kwargs # Add extra_ids to the special token list super().__init__( bos_token=_UpperCAmelCase , eos_token=_UpperCAmelCase , unk_token=_UpperCAmelCase , pad_token=_UpperCAmelCase , sep_token=_UpperCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_UpperCAmelCase , ) UpperCamelCase_ = vocab_file UpperCamelCase_ = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_UpperCAmelCase ) @property def _UpperCAmelCase ( self ) -> Union[str, Any]: return self.sp_model.get_piece_size() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = {self.convert_ids_to_tokens(_UpperCAmelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self ) -> str: UpperCamelCase_ = self.__dict__.copy() UpperCamelCase_ = None return state def __setstate__( self , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = d # for backward compatibility if not hasattr(self , 'sp_model_kwargs' ): UpperCamelCase_ = {} UpperCamelCase_ = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[str]: return self.sp_model.encode(_UpperCAmelCase , out_type=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Union[str, Any]: return self.sp_model.piece_to_id(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = self.sp_model.IdToPiece(_UpperCAmelCase ) return token def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = [] UpperCamelCase_ = '' for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: out_string += self.sp_model.decode(_UpperCAmelCase ) + token UpperCamelCase_ = [] else: current_sub_tokens.append(_UpperCAmelCase ) out_string += self.sp_model.decode(_UpperCAmelCase ) return out_string.strip() def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> Tuple[str]: if not os.path.isdir(_UpperCAmelCase ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" ) return UpperCamelCase_ = os.path.join( _UpperCAmelCase , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_UpperCAmelCase ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , _UpperCAmelCase ) elif not os.path.isfile(self.vocab_file ): with open(_UpperCAmelCase , 'wb' ) as fi: UpperCamelCase_ = self.sp_model.serialized_model_proto() fi.write(_UpperCAmelCase ) return (out_vocab_file,)
23
from __future__ import annotations import sys from collections import deque from typing import Generic, TypeVar snake_case__ : Dict = TypeVar("""T""") class _a ( Generic[T] ): """simple docstring""" A_ = 42 # Cache store of keys A_ = 42 # References of the keys in cache A_ = 10 # Maximum capacity of cache def __init__( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = deque() UpperCamelCase_ = set() if not n: UpperCamelCase_ = sys.maxsize elif n < 0: raise ValueError('n should be an integer greater than 0.' ) else: UpperCamelCase_ = n def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: if x not in self.key_reference: if len(self.dq_store ) == LRUCache._MAX_CAPACITY: UpperCamelCase_ = self.dq_store.pop() self.key_reference.remove(_UpperCAmelCase ) else: self.dq_store.remove(_UpperCAmelCase ) self.dq_store.appendleft(_UpperCAmelCase ) self.key_reference.add(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> None: for k in self.dq_store: print(_UpperCAmelCase ) def __repr__( self ) -> str: return f"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store )}""" if __name__ == "__main__": import doctest doctest.testmod() snake_case__ : LRUCache[str | int] = LRUCache(4) lru_cache.refer("""A""") lru_cache.refer(2) lru_cache.refer(3) lru_cache.refer("""A""") lru_cache.refer(4) lru_cache.refer(5) lru_cache.display() print(lru_cache) assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"
23
1
# # This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or # many nodes) can talk to each other via nccl and allocate gpu memory. # # To run first adjust the number of processes and nodes: # # python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port # # You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d # # use torch.distributed.launch instead of torch.distributed.run for torch < 1.9 # # If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with: # # NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py # # which should tell you what's going on behind the scenes. # # # This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that # runs on 2 nodes of 4 gpus per node: # # #SBATCH --job-name=test-nodes # name # #SBATCH --nodes=2 # nodes # #SBATCH --ntasks-per-node=1 # crucial - only 1 task per dist per node! # #SBATCH --cpus-per-task=10 # number of cores per tasks # #SBATCH --gres=gpu:4 # number of gpus # #SBATCH --time 0:05:00 # maximum execution time (HH:MM:SS) # #SBATCH --output=%x-%j.out # output file name # # GPUS_PER_NODE=4 # MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1) # MASTER_PORT=6000 # # srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \ # --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \ # --master_addr $MASTER_ADDR --master_port $MASTER_PORT \ # torch-distributed-gpu-test.py' # import fcntl import os import socket import torch import torch.distributed as dist def _snake_case (*__lowercase): with open(__lowercase , 'r') as fh: fcntl.flock(__lowercase , fcntl.LOCK_EX) try: print(*__lowercase) finally: fcntl.flock(__lowercase , fcntl.LOCK_UN) snake_case__ : Optional[int] = int(os.environ["""LOCAL_RANK"""]) torch.cuda.set_device(local_rank) snake_case__ : List[str] = torch.device("""cuda""", local_rank) snake_case__ : List[Any] = socket.gethostname() snake_case__ : List[str] = f'[{hostname}-{local_rank}]' try: # test distributed dist.init_process_group("""nccl""") dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM) dist.barrier() # test cuda is available and can allocate memory torch.cuda.is_available() torch.ones(1).cuda(local_rank) # global rank snake_case__ : Optional[Any] = dist.get_rank() snake_case__ : Optional[Any] = dist.get_world_size() printflock(f'{gpu} is OK (global rank: {rank}/{world_size})') dist.barrier() if rank == 0: printflock(f'pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}') except Exception: printflock(f'{gpu} is broken') raise
23
import numpy as np def _snake_case (__lowercase): return 1 / (1 + np.exp(-vector)) def _snake_case (__lowercase): return vector * sigmoid(__lowercase) if __name__ == "__main__": import doctest doctest.testmod()
23
1
import math import numpy as np import qiskit from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute def _snake_case (__lowercase = 3): if isinstance(__lowercase , __lowercase): raise TypeError('number of qubits must be a integer.') if number_of_qubits <= 0: raise ValueError('number of qubits must be > 0.') if math.floor(__lowercase) != number_of_qubits: raise ValueError('number of qubits must be exact integer.') if number_of_qubits > 10: raise ValueError('number of qubits too large to simulate(>10).') UpperCamelCase_ = QuantumRegister(__lowercase , 'qr') UpperCamelCase_ = ClassicalRegister(__lowercase , 'cr') UpperCamelCase_ = QuantumCircuit(__lowercase , __lowercase) UpperCamelCase_ = number_of_qubits for i in range(__lowercase): quantum_circuit.h(number_of_qubits - i - 1) counter -= 1 for j in range(__lowercase): quantum_circuit.cp(np.pi / 2 ** (counter - j) , __lowercase , __lowercase) for k in range(number_of_qubits // 2): quantum_circuit.swap(__lowercase , number_of_qubits - k - 1) # measure all the qubits quantum_circuit.measure(__lowercase , __lowercase) # simulate with 10000 shots UpperCamelCase_ = Aer.get_backend('qasm_simulator') UpperCamelCase_ = execute(__lowercase , __lowercase , shots=10000) return job.result().get_counts(__lowercase) if __name__ == "__main__": print( f'Total count for quantum fourier transform state is: \ {quantum_fourier_transform(3)}' )
23
import math from datetime import datetime, timedelta def _snake_case (__lowercase): UpperCamelCase_ = year % 19 UpperCamelCase_ = year % 4 UpperCamelCase_ = year % 7 UpperCamelCase_ = math.floor(year / 100) UpperCamelCase_ = math.floor((13 + 8 * leap_day_inhibits) / 25) UpperCamelCase_ = leap_day_inhibits / 4 UpperCamelCase_ = ( 15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number ) % 30 UpperCamelCase_ = (4 + leap_day_inhibits - leap_day_reinstall_number) % 7 # days to be added to March 21 UpperCamelCase_ = (19 * metonic_cycle + secular_moon_shift) % 30 # PHM -> Paschal Full Moon UpperCamelCase_ = ( 2 * julian_leap_year + 4 * non_leap_year + 6 * days_to_add + century_starting_point ) % 7 if days_to_add == 29 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 19) elif days_to_add == 28 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 18) else: return datetime(__lowercase , 3 , 22) + timedelta( days=int(days_to_add + days_from_phm_to_sunday)) if __name__ == "__main__": for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3): snake_case__ : Dict = """will be""" if year > datetime.now().year else """was""" print(f'Easter in {year} {tense} {gauss_easter(year)}')
23
1
import unittest from parameterized import parameterized from transformers import AutoTokenizer, GPTNeoXConfig, is_torch_available, set_seed from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( GPTNeoXForCausalLM, GPTNeoXForQuestionAnswering, GPTNeoXForSequenceClassification, GPTNeoXForTokenClassification, GPTNeoXModel, ) class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=99 , _UpperCAmelCase=64 , _UpperCAmelCase=5 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=512 , _UpperCAmelCase=16 , _UpperCAmelCase=2 , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=3 , _UpperCAmelCase=4 , _UpperCAmelCase=None , ) -> List[str]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_input_mask UpperCamelCase_ = use_token_type_ids UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = type_vocab_size UpperCamelCase_ = type_sequence_label_size UpperCamelCase_ = initializer_range UpperCamelCase_ = num_labels UpperCamelCase_ = num_choices UpperCamelCase_ = scope UpperCamelCase_ = vocab_size - 1 def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = None if self.use_input_mask: UpperCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) UpperCamelCase_ = None if self.use_labels: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) UpperCamelCase_ = self.get_config() return config, input_ids, input_mask, token_labels def _UpperCAmelCase ( self ) -> List[Any]: return GPTNeoXConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=_UpperCAmelCase , initializer_range=self.initializer_range , pad_token_id=self.pad_token_id , ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ = True return config, input_ids, input_mask, token_labels def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = GPTNeoXModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> int: UpperCamelCase_ = True UpperCamelCase_ = GPTNeoXModel(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = GPTNeoXForCausalLM(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , labels=_UpperCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = self.num_labels UpperCamelCase_ = GPTNeoXForQuestionAnswering(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase ) 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 _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Any: UpperCamelCase_ = self.num_labels UpperCamelCase_ = GPTNeoXForSequenceClassification(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , labels=_UpperCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = self.num_labels UpperCamelCase_ = GPTNeoXForTokenClassification(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , labels=_UpperCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = True UpperCamelCase_ = GPTNeoXForCausalLM(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() # first forward pass UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , use_cache=_UpperCAmelCase ) UpperCamelCase_ = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids UpperCamelCase_ = ids_tensor((self.batch_size, 3) , config.vocab_size ) UpperCamelCase_ = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and UpperCamelCase_ = torch.cat([input_ids, next_tokens] , dim=-1 ) UpperCamelCase_ = torch.cat([input_mask, next_mask] , dim=-1 ) UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) UpperCamelCase_ = output_from_no_past['hidden_states'][0] UpperCamelCase_ = model( _UpperCAmelCase , attention_mask=_UpperCAmelCase , past_key_values=_UpperCAmelCase , output_hidden_states=_UpperCAmelCase , )['hidden_states'][0] # select random slice UpperCamelCase_ = ids_tensor((1,) , output_from_past.shape[-1] ).item() UpperCamelCase_ = output_from_no_past[:, -3:, random_slice_idx].detach() UpperCamelCase_ = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(_UpperCAmelCase , _UpperCAmelCase , atol=1e-3 ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = config_and_inputs UpperCamelCase_ = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = ( ( GPTNeoXModel, GPTNeoXForCausalLM, GPTNeoXForQuestionAnswering, GPTNeoXForSequenceClassification, GPTNeoXForTokenClassification, ) if is_torch_available() else () ) A_ = (GPTNeoXForCausalLM,) if is_torch_available() else () A_ = ( { """feature-extraction""": GPTNeoXModel, """question-answering""": GPTNeoXForQuestionAnswering, """text-classification""": GPTNeoXForSequenceClassification, """text-generation""": GPTNeoXForCausalLM, """token-classification""": GPTNeoXForTokenClassification, """zero-shot""": GPTNeoXForSequenceClassification, } if is_torch_available() else {} ) A_ = False A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = GPTNeoXModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , hidden_size=64 , num_attention_heads=8 ) def _UpperCAmelCase ( self ) -> Any: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: # This regression test was failing with PyTorch < 1.3 UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() UpperCamelCase_ = None self.model_tester.create_and_check_model_as_decoder(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_decoder_model_past_large_inputs(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_causal_lm(*_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase ) @unittest.skip(reason='Feed forward chunking is not implemented' ) def _UpperCAmelCase ( self ) -> str: pass @parameterized.expand([('linear',), ('dynamic',)] ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() UpperCamelCase_ = ids_tensor([1, 10] , config.vocab_size ) UpperCamelCase_ = ids_tensor([1, int(config.max_position_embeddings * 1.5 )] , config.vocab_size ) set_seed(42 ) # Fixed seed at init time so the two models get the same random weights UpperCamelCase_ = GPTNeoXModel(_UpperCAmelCase ) original_model.to(_UpperCAmelCase ) original_model.eval() UpperCamelCase_ = original_model(_UpperCAmelCase ).last_hidden_state UpperCamelCase_ = original_model(_UpperCAmelCase ).last_hidden_state set_seed(42 ) # Fixed seed at init time so the two models get the same random weights UpperCamelCase_ = {'type': scaling_type, 'factor': 1_0.0} UpperCamelCase_ = GPTNeoXModel(_UpperCAmelCase ) scaled_model.to(_UpperCAmelCase ) scaled_model.eval() UpperCamelCase_ = scaled_model(_UpperCAmelCase ).last_hidden_state UpperCamelCase_ = scaled_model(_UpperCAmelCase ).last_hidden_state # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original # maximum sequence length, so the outputs for the short input should match. if scaling_type == "dynamic": self.assertTrue(torch.allclose(_UpperCAmelCase , _UpperCAmelCase , atol=1e-5 ) ) else: self.assertFalse(torch.allclose(_UpperCAmelCase , _UpperCAmelCase , atol=1e-5 ) ) # The output should be different for long inputs self.assertFalse(torch.allclose(_UpperCAmelCase , _UpperCAmelCase , atol=1e-5 ) ) @require_torch class _a ( unittest.TestCase ): """simple docstring""" @slow def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = AutoTokenizer.from_pretrained('EleutherAI/pythia-410m-deduped' ) for checkpointing in [True, False]: UpperCamelCase_ = GPTNeoXForCausalLM.from_pretrained('EleutherAI/pythia-410m-deduped' ) if checkpointing: model.gradient_checkpointing_enable() else: model.gradient_checkpointing_disable() model.to(_UpperCAmelCase ) UpperCamelCase_ = tokenizer('My favorite food is' , return_tensors='pt' ).to(_UpperCAmelCase ) # The hub repo. is updated on 2023-04-04, resulting in poor outputs. # See: https://github.com/huggingface/transformers/pull/24193 UpperCamelCase_ = 'My favorite food is a good old-fashioned, old-fashioned, old-fashioned.\n\nI\'m not sure' UpperCamelCase_ = model.generate(**_UpperCAmelCase , do_sample=_UpperCAmelCase , max_new_tokens=20 ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase )[0] self.assertEqual(_UpperCAmelCase , _UpperCAmelCase )
23
import requests def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = {'Content-Type': 'application/json'} UpperCamelCase_ = requests.post(__lowercase , json={'text': message_body} , headers=__lowercase) if response.status_code != 200: UpperCamelCase_ = ( 'Request to slack returned an error ' f"""{response.status_code}, the response is:\n{response.text}""" ) raise ValueError(__lowercase) if __name__ == "__main__": # Set the slack url to the one provided by Slack when you create the webhook at # https://my.slack.com/services/new/incoming-webhook/ send_slack_message("""<YOUR MESSAGE BODY>""", """<SLACK CHANNEL URL>""")
23
1
import inspect import os import sys import unittest import accelerate from accelerate.test_utils import execute_subprocess_async, require_tpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = inspect.getfile(accelerate.test_utils ) UpperCamelCase_ = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ['scripts', 'test_script.py'] ) UpperCamelCase_ = os.path.sep.join(inspect.getfile(self.__class__ ).split(os.path.sep )[:-1] ) @require_tpu def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = f""" {self.test_dir}/xla_spawn.py --num_cores 8 {self.test_file_path} """.split() UpperCamelCase_ = [sys.executable] + distributed_args execute_subprocess_async(_UpperCAmelCase , env=os.environ.copy() )
23
import re from pathlib import Path from unittest import TestCase import pytest @pytest.mark.integration class _a ( UpperCAmelCase__ ): """simple docstring""" def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)' ) UpperCamelCase_ = input_file.read() UpperCamelCase_ = regexp.search(_UpperCAmelCase ) return match def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()' , re.DOTALL ) UpperCamelCase_ = input_file.read() # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search` UpperCamelCase_ = regexp.finditer(_UpperCAmelCase ) UpperCamelCase_ = [match for match in matches if match is not None and match.group(1 ) is not None] return matches[0] if matches else None def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_encoding_on_file_open(str(_UpperCAmelCase ) ): raise AssertionError(f"""open(...) must use utf-8 encoding in {dataset}""" ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_print_statements(str(_UpperCAmelCase ) ): raise AssertionError(f"""print statement found in {dataset}. Use datasets.logger/logging instead.""" )
23
1
from typing import List from .keymap import KEYMAP, get_character def _snake_case (__lowercase): def decorator(__lowercase): UpperCamelCase_ = getattr(__lowercase , 'handle_key' , []) handle += [key] setattr(__lowercase , 'handle_key' , __lowercase) return func return decorator def _snake_case (*__lowercase): def decorator(__lowercase): UpperCamelCase_ = getattr(__lowercase , 'handle_key' , []) handle += keys setattr(__lowercase , 'handle_key' , __lowercase) return func return decorator class _a ( UpperCAmelCase__ ): """simple docstring""" def __new__( cls , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = super().__new__(cls , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) if not hasattr(_UpperCAmelCase , 'key_handler' ): setattr(_UpperCAmelCase , 'key_handler' , {} ) setattr(_UpperCAmelCase , 'handle_input' , KeyHandler.handle_input ) for value in attrs.values(): UpperCamelCase_ = getattr(_UpperCAmelCase , 'handle_key' , [] ) for key in handled_keys: UpperCamelCase_ = value return new_cls @staticmethod def _UpperCAmelCase ( cls ) -> str: UpperCamelCase_ = get_character() if char != KEYMAP["undefined"]: UpperCamelCase_ = ord(_UpperCAmelCase ) UpperCamelCase_ = cls.key_handler.get(_UpperCAmelCase ) if handler: UpperCamelCase_ = char return handler(cls ) else: return None def _snake_case (cls): return KeyHandler(cls.__name__ , cls.__bases__ , cls.__dict__.copy())
23
import argparse import random import joblib import numpy as np import torch from igf.igf import ( SecondaryLearner, collect_objective_set, compute_perplexity, generate_datasets, load_gpta, recopy_gpta, set_seed, train_secondary_learner, ) from torch.utils.data import DataLoader, RandomSampler from transformers import GPTaLMHeadModel def _snake_case (__lowercase=32 , __lowercase=10 , __lowercase=100 , __lowercase=1026 , __lowercase=True , __lowercase="data/tokenized_stories_train_wikitext103.jbl" , __lowercase="igf_context_pairs.jbl" , ): set_seed(3) # generate train_data and objective_set UpperCamelCase_ , UpperCamelCase_ = generate_datasets( __lowercase , __lowercase , number=__lowercase , min_len=1026 , trim=__lowercase) # keeps model same across runs set_seed(4) # model, lm_optimizer, lm_scheduler = recopy_gpt2(model, device, max_steps) # store original model weights # can we train on GPU? UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # load pretrained model UpperCamelCase_ = load_gpta('gpt2').to(__lowercase) print('computing perplexity on objective set') UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase).item() print('perplexity on objective set:' , __lowercase) # collect igf pairs and save to file demo.jbl collect_objective_set(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # clean up, delete model and data we don't need anymore del model, train_data, objective_set torch.cuda.empty_cache() def _snake_case (__lowercase , __lowercase=15 , __lowercase=128 , __lowercase=100 , __lowercase="igf_model.pt" , ): set_seed(42) # Load pre-trained model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') # Initialize secondary learner to use embedding weights of model UpperCamelCase_ = SecondaryLearner(__lowercase) # Train secondary learner UpperCamelCase_ = train_secondary_learner( __lowercase , __lowercase , max_epochs=__lowercase , batch_size=__lowercase , eval_freq=100 , igf_model_path=__lowercase , ) del model, secondary_learner_train_data torch.cuda.empty_cache() return secondary_learner def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=32 , __lowercase=1000 , __lowercase=16 , __lowercase=1.0 , __lowercase=recopy_gpta , __lowercase=None , __lowercase=10 , __lowercase="gpt2_finetuned.pt" , ): UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') UpperCamelCase_ = RandomSampler(__lowercase) UpperCamelCase_ = DataLoader(__lowercase , sampler=__lowercase) UpperCamelCase_ = max_steps // (len(__lowercase)) + 1 UpperCamelCase_ = 0 UpperCamelCase_ = torch.zeros((1, context_len) , dtype=torch.long , device=__lowercase) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = recopy_model(__lowercase , __lowercase , __lowercase) model.train() if secondary_learner is not None: secondary_learner.to(__lowercase) secondary_learner.eval() UpperCamelCase_ = [] UpperCamelCase_ = 0 UpperCamelCase_ = [] UpperCamelCase_ = [] # Compute the performance of the transformer model at the beginning UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) for epoch in range(int(__lowercase)): for step, example in enumerate(__lowercase): torch.cuda.empty_cache() UpperCamelCase_ = random.randint(0 , example.size(2) - context_len - 1) UpperCamelCase_ = example[0, 0, start : start + context_len] lm_optimizer.zero_grad() UpperCamelCase_ = model(__lowercase , labels=__lowercase) UpperCamelCase_ = True if secondary_learner is not None: UpperCamelCase_ = secondary_learner.forward( torch.tensor(__lowercase , dtype=torch.long , device=__lowercase).unsqueeze(0))[0].item() observed_qs.append(float(__lowercase)) # Here we implement the simple non-constant threshold for the predicted IG(X) value # We will decay the selectivity of our secondary learner filter from # 1 standard deviation above average to 1 below average after 10 batches. if global_step == 10: UpperCamelCase_ = -1 if predicted_q < threshold: UpperCamelCase_ = False # If we passed the filter, add the context to the batch! if do_backprop: contexts.append(np.array(context.cpu())) UpperCamelCase_ = outputs[0] lm_loss.backward() examples += 1 del outputs # Once the batch is filled with enough contexts, backprop on the batch. if examples == batch_size: torch.cuda.empty_cache() UpperCamelCase_ = 0 # Do LM backprop torch.nn.utils.clip_grad_norm_(model.parameters() , 3.0) lm_optimizer.step() lm_scheduler.step() # Update learning rate schedule global_step += 1 # Compute the performance of the transformer model at this batch if global_step % eval_interval == 0: UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) # Break out of the loop after 60 batches if max_steps > 0 and global_step > 60: break if max_steps > 0 and global_step > 60: break # save finetuned transformer model torch.save(model.state_dict() , __lowercase) torch.cuda.empty_cache() # Do some cleaning up so we can reinitialize for the next run of this function del lm_optimizer del lm_scheduler return model def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Fine-tune a transformer model with IGF on a language modeling task') # Required parameters parser.add_argument( '--data_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The input data dir. Should contain data files for WikiText.' , ) parser.add_argument( '--model_name_or_path' , default=__lowercase , type=__lowercase , required=__lowercase , help='Path to pretrained model or model identifier from huggingface.co/models' , ) parser.add_argument( '--data_file' , type=__lowercase , default=__lowercase , help=( 'A jbl file containing tokenized data which can be split as objective dataset, ' 'train_dataset and test_dataset.' ) , ) parser.add_argument( '--igf_data_file' , type=__lowercase , default=__lowercase , help='A jbl file containing the context and information gain pairs to train secondary learner.' , ) parser.add_argument( '--output_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The output directory where the final fine-tuned model is stored.' , ) parser.add_argument( '--tokenizer_name' , default=__lowercase , type=__lowercase , help='Pretrained tokenizer name or path if not the same as model_name' , ) parser.add_argument('--seed' , type=__lowercase , default=__lowercase , help='A seed for reproducible training.') parser.add_argument( '--context_len' , default=32 , type=__lowercase , help=( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) , ) parser.add_argument( '--size_objective_set' , default=100 , type=__lowercase , help='number of articles that are long enough to be used as our objective set' , ) parser.add_argument( '--eval_freq' , default=100 , type=__lowercase , help='secondary model evaluation is triggered at eval_freq') parser.add_argument('--max_steps' , default=1000 , type=__lowercase , help='To calculate training epochs') parser.add_argument( '--secondary_learner_batch_size' , default=128 , type=__lowercase , help='batch size of training data for secondary learner' , ) parser.add_argument( '--batch_size' , default=16 , type=__lowercase , help='batch size of training data of language model(gpt2) ') parser.add_argument( '--eval_interval' , default=10 , type=__lowercase , help=( 'decay the selectivity of our secondary learner filter from' '1 standard deviation above average to 1 below average after 10 batches' ) , ) parser.add_argument( '--number' , default=100 , type=__lowercase , help='The number of examples split to be used as objective_set/test_data') parser.add_argument( '--min_len' , default=1026 , type=__lowercase , help='The minimum length of the article to be used as objective set') parser.add_argument( '--secondary_learner_max_epochs' , default=15 , type=__lowercase , help='number of epochs to train secondary learner') parser.add_argument('--trim' , default=__lowercase , type=__lowercase , help='truncate the example if it exceeds context length') parser.add_argument( '--threshold' , default=1.0 , type=__lowercase , help=( 'The threshold value used by secondary learner to filter the train_data and allow only' ' informative data as input to the model' ) , ) parser.add_argument('--finetuned_model_name' , default='gpt2_finetuned.pt' , type=__lowercase , help='finetuned_model_name') parser.add_argument( '--recopy_model' , default=__lowercase , type=__lowercase , help='Reset the model to the original pretrained GPT-2 weights after each iteration' , ) # function calls # Collecting *n* pairs of context and information gain(X, IG(X)) for training the secondary learner generate_n_pairs( context_len=32 , max_steps=10 , size_objective_set=100 , min_len=1026 , trim=__lowercase , data_file='data/tokenized_stories_train_wikitext103.jbl' , igf_data_file='igf_context_pairs.jbl' , ) # Load train data for secondary learner UpperCamelCase_ = joblib.load('data/IGF_values.jbl') # Train secondary learner UpperCamelCase_ = training_secondary_learner( __lowercase , secondary_learner_max_epochs=15 , secondary_learner_batch_size=128 , eval_freq=100 , igf_model_path='igf_model.pt' , ) # load pretrained gpt2 model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') set_seed(42) # Generate train and test data to train and evaluate gpt2 model UpperCamelCase_ , UpperCamelCase_ = generate_datasets( context_len=32 , file='data/tokenized_stories_train_wikitext103.jbl' , number=100 , min_len=1026 , trim=__lowercase) # fine-tuning of the gpt2 model using igf (Information Gain Filtration) finetune( __lowercase , __lowercase , __lowercase , context_len=32 , max_steps=1000 , batch_size=16 , threshold=1.0 , recopy_model=__lowercase , secondary_learner=__lowercase , eval_interval=10 , finetuned_model_name='gpt2_finetuned.pt' , ) if __name__ == "__main__": main()
23
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) snake_case__ : Tuple = {"""configuration_plbart""": ["""PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PLBartConfig"""]} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : str = ["""PLBartTokenizer"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Any = [ """PLBART_PRETRAINED_MODEL_ARCHIVE_LIST""", """PLBartForCausalLM""", """PLBartForConditionalGeneration""", """PLBartForSequenceClassification""", """PLBartModel""", """PLBartPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_plbart import PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP, PLBartConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_plbart import PLBartTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_plbart import ( PLBART_PRETRAINED_MODEL_ARCHIVE_LIST, PLBartForCausalLM, PLBartForConditionalGeneration, PLBartForSequenceClassification, PLBartModel, PLBartPreTrainedModel, ) else: import sys snake_case__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure)
23
from __future__ import annotations import unittest from transformers import AutoTokenizer, MBartConfig, is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel @require_tf class _a : """simple docstring""" A_ = MBartConfig A_ = {} A_ = """gelu""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=99 , _UpperCAmelCase=32 , _UpperCAmelCase=2 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=20 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , ) -> Union[str, Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = eos_token_id UpperCamelCase_ = pad_token_id UpperCamelCase_ = bos_token_id def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) UpperCamelCase_ = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ) , 1 ) UpperCamelCase_ = tf.concat([input_ids, eos_tensor] , axis=1 ) UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) UpperCamelCase_ = prepare_mbart_inputs_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = TFMBartModel(config=_UpperCAmelCase ).get_decoder() UpperCamelCase_ = inputs_dict['input_ids'] UpperCamelCase_ = input_ids[:1, :] UpperCamelCase_ = inputs_dict['attention_mask'][:1, :] UpperCamelCase_ = inputs_dict['head_mask'] UpperCamelCase_ = 1 # first forward pass UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , head_mask=_UpperCAmelCase , use_cache=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = outputs.to_tuple() UpperCamelCase_ = past_key_values[1] def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , ): if attention_mask is None: UpperCamelCase_ = tf.cast(tf.math.not_equal(__lowercase , config.pad_token_id) , tf.inta) if decoder_attention_mask is None: UpperCamelCase_ = tf.concat( [ tf.ones(decoder_input_ids[:, :1].shape , dtype=tf.inta), tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id) , tf.inta), ] , axis=-1 , ) if head_mask is None: UpperCamelCase_ = tf.ones((config.encoder_layers, config.encoder_attention_heads)) if decoder_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) if cross_attn_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } @require_tf class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else () A_ = (TFMBartForConditionalGeneration,) if is_tf_available() else () A_ = ( { """conversational""": TFMBartForConditionalGeneration, """feature-extraction""": TFMBartModel, """summarization""": TFMBartForConditionalGeneration, """text2text-generation""": TFMBartForConditionalGeneration, """translation""": TFMBartForConditionalGeneration, } if is_tf_available() else {} ) A_ = True A_ = False A_ = False def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: if pipeline_test_casse_name != "FeatureExtractionPipelineTests": # Exception encountered when calling layer '...' return True return False def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = TFMBartModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase ) @require_sentencepiece @require_tokenizers @require_tf class _a ( unittest.TestCase ): """simple docstring""" A_ = [ """ UN Chief Says There Is No Military Solution in Syria""", ] A_ = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", ] A_ = """facebook/mbart-large-en-ro""" @cached_property def _UpperCAmelCase ( self ) -> Any: return AutoTokenizer.from_pretrained(self.model_name ) @cached_property def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name ) return model def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> int: UpperCamelCase_ = self.translate_src_text(**_UpperCAmelCase ) self.assertListEqual(self.expected_text , _UpperCAmelCase ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> List[str]: UpperCamelCase_ = self.tokenizer(self.src_text , **_UpperCAmelCase , return_tensors='tf' ) UpperCamelCase_ = self.model.generate( model_inputs.input_ids , attention_mask=model_inputs.attention_mask , num_beams=2 ) UpperCamelCase_ = self.tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) return generated_words @slow def _UpperCAmelCase ( self ) -> List[Any]: self._assert_generated_batch_equal_expected()
23
1
import json from typing import TYPE_CHECKING, List, Optional, Tuple from tokenizers import pre_tokenizers from ...tokenization_utils_base import BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_gpta import GPTaTokenizer if TYPE_CHECKING: from transformers.pipelines.conversational import Conversation snake_case__ : Optional[Any] = logging.get_logger(__name__) snake_case__ : List[str] = {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""} snake_case__ : str = { """vocab_file""": { """gpt2""": """https://huggingface.co/gpt2/resolve/main/vocab.json""", """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/vocab.json""", """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/vocab.json""", """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/vocab.json""", """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/vocab.json""", }, """merges_file""": { """gpt2""": """https://huggingface.co/gpt2/resolve/main/merges.txt""", """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/merges.txt""", """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/merges.txt""", """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/merges.txt""", """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/merges.txt""", }, """tokenizer_file""": { """gpt2""": """https://huggingface.co/gpt2/resolve/main/tokenizer.json""", """gpt2-medium""": """https://huggingface.co/gpt2-medium/resolve/main/tokenizer.json""", """gpt2-large""": """https://huggingface.co/gpt2-large/resolve/main/tokenizer.json""", """gpt2-xl""": """https://huggingface.co/gpt2-xl/resolve/main/tokenizer.json""", """distilgpt2""": """https://huggingface.co/distilgpt2/resolve/main/tokenizer.json""", }, } snake_case__ : Optional[int] = { """gpt2""": 1_0_2_4, """gpt2-medium""": 1_0_2_4, """gpt2-large""": 1_0_2_4, """gpt2-xl""": 1_0_2_4, """distilgpt2""": 1_0_2_4, } class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = VOCAB_FILES_NAMES A_ = PRETRAINED_VOCAB_FILES_MAP A_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A_ = ["""input_ids""", """attention_mask"""] A_ = GPTaTokenizer def __init__( self , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase="<|endoftext|>" , _UpperCAmelCase="<|endoftext|>" , _UpperCAmelCase="<|endoftext|>" , _UpperCAmelCase=False , **_UpperCAmelCase , ) -> Union[str, Any]: super().__init__( _UpperCAmelCase , _UpperCAmelCase , tokenizer_file=_UpperCAmelCase , unk_token=_UpperCAmelCase , bos_token=_UpperCAmelCase , eos_token=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , **_UpperCAmelCase , ) UpperCamelCase_ = kwargs.pop('add_bos_token' , _UpperCAmelCase ) UpperCamelCase_ = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get('add_prefix_space' , _UpperCAmelCase ) != add_prefix_space: UpperCamelCase_ = getattr(_UpperCAmelCase , pre_tok_state.pop('type' ) ) UpperCamelCase_ = add_prefix_space UpperCamelCase_ = pre_tok_class(**_UpperCAmelCase ) UpperCamelCase_ = add_prefix_space def _UpperCAmelCase ( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> BatchEncoding: UpperCamelCase_ = kwargs.get('is_split_into_words' , _UpperCAmelCase ) 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(*_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> BatchEncoding: UpperCamelCase_ = kwargs.get('is_split_into_words' , _UpperCAmelCase ) 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(*_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> Tuple[str]: UpperCamelCase_ = self._tokenizer.model.save(_UpperCAmelCase , name=_UpperCAmelCase ) return tuple(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[int]: UpperCamelCase_ = [] for is_user, text in conversation.iter_texts(): input_ids.extend(self.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) + [self.eos_token_id] ) if len(_UpperCAmelCase ) > self.model_max_length: UpperCamelCase_ = input_ids[-self.model_max_length :] return input_ids
23
def _snake_case (__lowercase): UpperCamelCase_ = 1 for i in range(1 , num + 1): fact *= i return fact def _snake_case (__lowercase): UpperCamelCase_ = 0 while number > 0: UpperCamelCase_ = number % 10 sum_of_digits += last_digit UpperCamelCase_ = number // 10 # Removing the last_digit from the given number return sum_of_digits def _snake_case (__lowercase = 100): UpperCamelCase_ = factorial(__lowercase) UpperCamelCase_ = split_and_add(__lowercase) return result if __name__ == "__main__": print(solution(int(input("""Enter the Number: """).strip())))
23
1
def _snake_case (__lowercase): UpperCamelCase_ = [1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = 0, 0, 0 UpperCamelCase_ = ugly_nums[ia] * 2 UpperCamelCase_ = ugly_nums[ia] * 3 UpperCamelCase_ = ugly_nums[ia] * 5 for _ in range(1 , __lowercase): UpperCamelCase_ = min(__lowercase , __lowercase , __lowercase) ugly_nums.append(__lowercase) if next_num == next_a: ia += 1 UpperCamelCase_ = ugly_nums[ia] * 2 if next_num == next_a: ia += 1 UpperCamelCase_ = ugly_nums[ia] * 3 if next_num == next_a: ia += 1 UpperCamelCase_ = ugly_nums[ia] * 5 return ugly_nums[-1] if __name__ == "__main__": from doctest import testmod testmod(verbose=True) print(f'{ugly_numbers(2_0_0) = }')
23
from typing import Dict, List, Optional, Union import numpy as np 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 TensorType, is_vision_available, logging if is_vision_available(): import PIL snake_case__ : str = logging.get_logger(__name__) def _snake_case (__lowercase): if isinstance(__lowercase , (list, tuple)) and isinstance(videos[0] , (list, tuple)) and is_valid_image(videos[0][0]): return videos elif isinstance(__lowercase , (list, tuple)) and is_valid_image(videos[0]): return [videos] elif is_valid_image(__lowercase): return [[videos]] raise ValueError(f"""Could not make batched video from {videos}""") class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = ["""pixel_values"""] def __init__( self , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = True , _UpperCAmelCase = 1 / 255 , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> None: super().__init__(**_UpperCAmelCase ) UpperCamelCase_ = size if size is not None else {'shortest_edge': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else {'height': 224, 'width': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) UpperCamelCase_ = do_resize UpperCamelCase_ = size UpperCamelCase_ = do_center_crop UpperCamelCase_ = crop_size UpperCamelCase_ = resample UpperCamelCase_ = do_rescale UpperCamelCase_ = rescale_factor UpperCamelCase_ = do_normalize UpperCamelCase_ = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN UpperCamelCase_ = image_std if image_std is not None else IMAGENET_STANDARD_STD def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) if "shortest_edge" in size: UpperCamelCase_ = get_resize_output_image_size(_UpperCAmelCase , size['shortest_edge'] , default_to_square=_UpperCAmelCase ) elif "height" in size and "width" in size: UpperCamelCase_ = (size['height'], size['width']) else: raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}""" ) return resize(_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase ) 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(_UpperCAmelCase , size=(size['height'], size['width']) , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> int: return rescale(_UpperCAmelCase , scale=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: return normalize(_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , ) -> np.ndarray: 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.' ) # All transformations expect numpy arrays. UpperCamelCase_ = to_numpy_array(_UpperCAmelCase ) if do_resize: UpperCamelCase_ = self.resize(image=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase ) if do_center_crop: UpperCamelCase_ = self.center_crop(_UpperCAmelCase , size=_UpperCAmelCase ) if do_rescale: UpperCamelCase_ = self.rescale(image=_UpperCAmelCase , scale=_UpperCAmelCase ) if do_normalize: UpperCamelCase_ = self.normalize(image=_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase ) UpperCamelCase_ = to_channel_dimension_format(_UpperCAmelCase , _UpperCAmelCase ) return image def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , **_UpperCAmelCase , ) -> PIL.Image.Image: UpperCamelCase_ = do_resize if do_resize is not None else self.do_resize UpperCamelCase_ = resample if resample is not None else self.resample UpperCamelCase_ = do_center_crop if do_center_crop is not None else self.do_center_crop UpperCamelCase_ = do_rescale if do_rescale is not None else self.do_rescale UpperCamelCase_ = rescale_factor if rescale_factor is not None else self.rescale_factor UpperCamelCase_ = do_normalize if do_normalize is not None else self.do_normalize UpperCamelCase_ = image_mean if image_mean is not None else self.image_mean UpperCamelCase_ = image_std if image_std is not None else self.image_std UpperCamelCase_ = size if size is not None else self.size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else self.crop_size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) if not valid_images(_UpperCAmelCase ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) UpperCamelCase_ = make_batched(_UpperCAmelCase ) UpperCamelCase_ = [ [ self._preprocess_image( image=_UpperCAmelCase , do_resize=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , do_center_crop=_UpperCAmelCase , crop_size=_UpperCAmelCase , do_rescale=_UpperCAmelCase , rescale_factor=_UpperCAmelCase , do_normalize=_UpperCAmelCase , image_mean=_UpperCAmelCase , image_std=_UpperCAmelCase , data_format=_UpperCAmelCase , ) for img in video ] for video in videos ] UpperCamelCase_ = {'pixel_values': videos} return BatchFeature(data=_UpperCAmelCase , tensor_type=_UpperCAmelCase )
23
1
import inspect import unittest import warnings from transformers import DeiTConfig from transformers.models.auto import get_values from transformers.testing_utils import ( require_accelerate, require_torch, require_torch_gpu, require_vision, slow, torch_device, ) from transformers.utils import cached_property, is_torch_available, is_vision_available 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 ( MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING, MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING, MODEL_MAPPING, DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTForMaskedImageModeling, DeiTModel, ) from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import DeiTImageProcessor class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=30 , _UpperCAmelCase=2 , _UpperCAmelCase=3 , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=32 , _UpperCAmelCase=5 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=10 , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=3 , _UpperCAmelCase=None , _UpperCAmelCase=2 , ) -> List[Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = image_size UpperCamelCase_ = patch_size UpperCamelCase_ = num_channels UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = type_sequence_label_size UpperCamelCase_ = initializer_range UpperCamelCase_ = scope UpperCamelCase_ = encoder_stride # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens) UpperCamelCase_ = (image_size // patch_size) ** 2 UpperCamelCase_ = num_patches + 2 def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCamelCase_ = None if self.use_labels: UpperCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) UpperCamelCase_ = self.get_config() return config, pixel_values, labels def _UpperCAmelCase ( self ) -> List[Any]: return DeiTConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=_UpperCAmelCase , initializer_range=self.initializer_range , encoder_stride=self.encoder_stride , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = DeiTModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = DeiTForMaskedImageModeling(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase ) self.parent.assertEqual( result.reconstruction.shape , (self.batch_size, self.num_channels, self.image_size, self.image_size) ) # test greyscale images UpperCamelCase_ = 1 UpperCamelCase_ = DeiTForMaskedImageModeling(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) UpperCamelCase_ = model(_UpperCAmelCase ) self.parent.assertEqual(result.reconstruction.shape , (self.batch_size, 1, self.image_size, self.image_size) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = self.type_sequence_label_size UpperCamelCase_ = DeiTForImageClassification(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(_UpperCAmelCase , labels=_UpperCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) # test greyscale images UpperCamelCase_ = 1 UpperCamelCase_ = DeiTForImageClassification(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) UpperCamelCase_ = model(_UpperCAmelCase , labels=_UpperCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = self.prepare_config_and_inputs() ( ( UpperCamelCase_ ) , ( UpperCamelCase_ ) , ( UpperCamelCase_ ) , ) = config_and_inputs UpperCamelCase_ = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = ( ( DeiTModel, DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTForMaskedImageModeling, ) if is_torch_available() else () ) A_ = ( { """feature-extraction""": DeiTModel, """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher), } if is_torch_available() else {} ) A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = DeiTModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , has_text_modality=_UpperCAmelCase , hidden_size=37 ) def _UpperCAmelCase ( self ) -> Optional[Any]: self.config_tester.run_common_tests() @unittest.skip(reason='DeiT does not use inputs_embeds' ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) UpperCamelCase_ = model.get_output_embeddings() self.assertTrue(x is None or isinstance(_UpperCAmelCase , nn.Linear ) ) def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False ) -> Union[str, Any]: UpperCamelCase_ = super()._prepare_for_class(_UpperCAmelCase , _UpperCAmelCase , return_labels=_UpperCAmelCase ) if return_labels: if model_class.__name__ == "DeiTForImageClassificationWithTeacher": del inputs_dict["labels"] return inputs_dict def _UpperCAmelCase ( self ) -> List[str]: if not self.model_tester.is_training: return UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() UpperCamelCase_ = True for model_class in self.all_model_classes: # DeiTForImageClassificationWithTeacher supports inference-only if ( model_class in get_values(_UpperCAmelCase ) or model_class.__name__ == "DeiTForImageClassificationWithTeacher" ): continue UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = self._prepare_for_class(_UpperCAmelCase , _UpperCAmelCase , return_labels=_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() if not self.model_tester.is_training: return UpperCamelCase_ = False UpperCamelCase_ = True for model_class in self.all_model_classes: if model_class in get_values(_UpperCAmelCase ) or not model_class.supports_gradient_checkpointing: continue # DeiTForImageClassificationWithTeacher supports inference-only if model_class.__name__ == "DeiTForImageClassificationWithTeacher": continue UpperCamelCase_ = model_class(_UpperCAmelCase ) model.gradient_checkpointing_enable() model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = self._prepare_for_class(_UpperCAmelCase , _UpperCAmelCase , return_labels=_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() UpperCamelCase_ = [ {'title': 'multi_label_classification', 'num_labels': 2, 'dtype': torch.float}, {'title': 'single_label_classification', 'num_labels': 1, 'dtype': torch.long}, {'title': 'regression', 'num_labels': 1, 'dtype': torch.float}, ] for model_class in self.all_model_classes: if ( model_class not in [ *get_values(_UpperCAmelCase ), *get_values(_UpperCAmelCase ), ] or model_class.__name__ == "DeiTForImageClassificationWithTeacher" ): continue for problem_type in problem_types: with self.subTest(msg=f"""Testing {model_class} with {problem_type["title"]}""" ): UpperCamelCase_ = problem_type['title'] UpperCamelCase_ = problem_type['num_labels'] UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = self._prepare_for_class(_UpperCAmelCase , _UpperCAmelCase , return_labels=_UpperCAmelCase ) if problem_type["num_labels"] > 1: UpperCamelCase_ = inputs['labels'].unsqueeze(1 ).repeat(1 , problem_type['num_labels'] ) UpperCamelCase_ = inputs['labels'].to(problem_type['dtype'] ) # This tests that we do not trigger the warning form PyTorch "Using a target size that is different # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure # they have the same size." which is a symptom something in wrong for the regression problem. # See https://github.com/huggingface/transformers/issues/11780 with warnings.catch_warnings(record=_UpperCAmelCase ) as warning_list: UpperCamelCase_ = model(**_UpperCAmelCase ).loss for w in warning_list: if "Using a target size that is different to the input size" in str(w.message ): raise ValueError( f"""Something is going wrong in the regression problem: intercepted {w.message}""" ) loss.backward() @slow def _UpperCAmelCase ( self ) -> List[Any]: for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase_ = DeiTModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) def _snake_case (): UpperCamelCase_ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') return image @require_torch @require_vision class _a ( unittest.TestCase ): """simple docstring""" @cached_property def _UpperCAmelCase ( self ) -> List[Any]: return ( DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224' ) if is_vision_available() else None ) @slow def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = DeiTForImageClassificationWithTeacher.from_pretrained('facebook/deit-base-distilled-patch16-224' ).to( _UpperCAmelCase ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(images=_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) # forward pass with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) # verify the logits UpperCamelCase_ = torch.Size((1, 1000) ) self.assertEqual(outputs.logits.shape , _UpperCAmelCase ) UpperCamelCase_ = torch.tensor([-1.0_2_6_6, 0.1_9_1_2, -1.2_8_6_1] ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , _UpperCAmelCase , atol=1e-4 ) ) @slow @require_accelerate @require_torch_gpu def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = DeiTModel.from_pretrained( 'facebook/deit-base-distilled-patch16-224' , torch_dtype=torch.floataa , device_map='auto' ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(images=_UpperCAmelCase , return_tensors='pt' ) UpperCamelCase_ = inputs.pixel_values.to(_UpperCAmelCase ) # forward pass to make sure inference works in fp16 with torch.no_grad(): UpperCamelCase_ = model(_UpperCAmelCase )
23
# 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 _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 A_ = 42 class _a ( UpperCAmelCase__ , UpperCAmelCase__ ): """simple docstring""" A_ = 1 @register_to_config def __init__( self , _UpperCAmelCase = 2000 , _UpperCAmelCase = 0.1_5 , _UpperCAmelCase = 0.0_1 , _UpperCAmelCase = 1_3_4_8.0 , _UpperCAmelCase = 1e-5 , _UpperCAmelCase = 1 , ) -> Tuple: # standard deviation of the initial noise distribution UpperCamelCase_ = sigma_max # setable values UpperCamelCase_ = None self.set_sigmas(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> torch.FloatTensor: return sample def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> str: UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps UpperCamelCase_ = torch.linspace(1 , _UpperCAmelCase , _UpperCAmelCase , device=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> Any: UpperCamelCase_ = sigma_min if sigma_min is not None else self.config.sigma_min UpperCamelCase_ = sigma_max if sigma_max is not None else self.config.sigma_max UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) UpperCamelCase_ = torch.exp(torch.linspace(math.log(_UpperCAmelCase ) , math.log(_UpperCAmelCase ) , _UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: return torch.where( timesteps == 0 , torch.zeros_like(t.to(timesteps.device ) ) , self.discrete_sigmas[timesteps - 1].to(timesteps.device ) , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SdeVeOutput, Tuple]: if self.timesteps is None: raise ValueError( '`self.timesteps` is not set, you need to run \'set_timesteps\' after creating the scheduler' ) UpperCamelCase_ = timestep * torch.ones( sample.shape[0] , device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) UpperCamelCase_ = (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 UpperCamelCase_ = timesteps.to(self.discrete_sigmas.device ) UpperCamelCase_ = self.discrete_sigmas[timesteps].to(sample.device ) UpperCamelCase_ = self.get_adjacent_sigma(_UpperCAmelCase , _UpperCAmelCase ).to(sample.device ) UpperCamelCase_ = torch.zeros_like(_UpperCAmelCase ) UpperCamelCase_ = (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 UpperCamelCase_ = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): UpperCamelCase_ = diffusion.unsqueeze(-1 ) UpperCamelCase_ = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of UpperCamelCase_ = randn_tensor( sample.shape , layout=sample.layout , generator=_UpperCAmelCase , device=sample.device , dtype=sample.dtype ) UpperCamelCase_ = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? UpperCamelCase_ = 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=_UpperCAmelCase , prev_sample_mean=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SchedulerOutput, Tuple]: 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 UpperCamelCase_ = randn_tensor(sample.shape , layout=sample.layout , generator=_UpperCAmelCase ).to(sample.device ) # compute step size from the model_output, the noise, and the snr UpperCamelCase_ = torch.norm(model_output.reshape(model_output.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = torch.norm(noise.reshape(noise.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 UpperCamelCase_ = 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 UpperCamelCase_ = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): UpperCamelCase_ = step_size.unsqueeze(-1 ) UpperCamelCase_ = sample + step_size * model_output UpperCamelCase_ = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , ) -> torch.FloatTensor: # Make sure sigmas and timesteps have the same device and dtype as original_samples UpperCamelCase_ = timesteps.to(original_samples.device ) UpperCamelCase_ = self.discrete_sigmas.to(original_samples.device )[timesteps] UpperCamelCase_ = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(_UpperCAmelCase ) * sigmas[:, None, None, None] ) UpperCamelCase_ = noise + original_samples return noisy_samples def __len__( self ) -> Optional[int]: return self.config.num_train_timesteps
23
1
import itertools import json import os import unittest from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _a ( UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = RobertaTokenizer A_ = RobertaTokenizerFast A_ = True A_ = {"""cls_token""": """<s>"""} def _UpperCAmelCase ( self ) -> Tuple: super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt UpperCamelCase_ = [ 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', '\u0120', '\u0120l', '\u0120n', '\u0120lo', '\u0120low', 'er', '\u0120lowest', '\u0120newer', '\u0120wider', '<unk>', ] UpperCamelCase_ = dict(zip(_UpperCAmelCase , range(len(_UpperCAmelCase ) ) ) ) UpperCamelCase_ = ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', ''] UpperCamelCase_ = {'unk_token': '<unk>'} UpperCamelCase_ = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) UpperCamelCase_ = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['merges_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as fp: fp.write(json.dumps(_UpperCAmelCase ) + '\n' ) with open(self.merges_file , 'w' , encoding='utf-8' ) as fp: fp.write('\n'.join(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> str: kwargs.update(self.special_tokens_map ) return self.tokenizer_class.from_pretrained(self.tmpdirname , **_UpperCAmelCase ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> int: kwargs.update(self.special_tokens_map ) return RobertaTokenizerFast.from_pretrained(self.tmpdirname , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = 'lower newer' UpperCamelCase_ = 'lower newer' return input_text, output_text def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = self.tokenizer_class(self.vocab_file , self.merges_file , **self.special_tokens_map ) UpperCamelCase_ = 'lower newer' UpperCamelCase_ = ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er'] UpperCamelCase_ = tokenizer.tokenize(_UpperCAmelCase ) # , add_prefix_space=True) self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = tokens + [tokenizer.unk_token] UpperCamelCase_ = [0, 1, 2, 15, 10, 9, 3, 2, 15, 19] self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase ) , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = self.get_tokenizer() self.assertListEqual(tokenizer.encode('Hello world!' , add_special_tokens=_UpperCAmelCase ) , [0, 31414, 232, 328, 2] ) self.assertListEqual( tokenizer.encode('Hello world! cécé herlolip 418' , add_special_tokens=_UpperCAmelCase ) , [0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2] , ) @slow def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = self.tokenizer_class.from_pretrained('roberta-base' ) UpperCamelCase_ = tokenizer.encode('sequence builders' , add_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.encode('multi-sequence build' , add_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.encode( 'sequence builders' , add_special_tokens=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.encode( 'sequence builders' , 'multi-sequence build' , add_special_tokens=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase ) UpperCamelCase_ = tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase , _UpperCAmelCase ) assert encoded_sentence == encoded_text_from_decode assert encoded_pair == encoded_pair_from_decode def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = self.get_tokenizer() UpperCamelCase_ = 'Encode this sequence.' UpperCamelCase_ = tokenizer.byte_encoder[' '.encode('utf-8' )[0]] # Testing encoder arguments UpperCamelCase_ = tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.convert_ids_to_tokens(encoded[0] )[0] self.assertNotEqual(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.convert_ids_to_tokens(encoded[0] )[0] self.assertEqual(_UpperCAmelCase , _UpperCAmelCase ) tokenizer.add_special_tokens({'bos_token': '<s>'} ) UpperCamelCase_ = tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.convert_ids_to_tokens(encoded[1] )[0] self.assertNotEqual(_UpperCAmelCase , _UpperCAmelCase ) # Testing spaces after special tokens UpperCamelCase_ = '<mask>' tokenizer.add_special_tokens( {'mask_token': AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase )} ) # mask token has a left space UpperCamelCase_ = tokenizer.convert_tokens_to_ids(_UpperCAmelCase ) UpperCamelCase_ = 'Encode <mask> sequence' UpperCamelCase_ = 'Encode <mask>sequence' UpperCamelCase_ = tokenizer.encode(_UpperCAmelCase ) UpperCamelCase_ = encoded.index(_UpperCAmelCase ) UpperCamelCase_ = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1] )[0] self.assertEqual(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = tokenizer.encode(_UpperCAmelCase ) UpperCamelCase_ = encoded.index(_UpperCAmelCase ) UpperCamelCase_ = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1] )[0] self.assertNotEqual(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> int: for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ): UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = self.tokenizer_class.from_pretrained(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = 'A, <mask> AllenNLP sentence.' UpperCamelCase_ = tokenizer_r.encode_plus(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , return_token_type_ids=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_p.encode_plus(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , return_token_type_ids=_UpperCAmelCase ) # token_type_ids should put 0 everywhere self.assertEqual(sum(tokens_r['token_type_ids'] ) , sum(tokens_p['token_type_ids'] ) ) # attention_mask should put 1 everywhere, so sum over length should be 1 self.assertEqual( sum(tokens_r['attention_mask'] ) / len(tokens_r['attention_mask'] ) , sum(tokens_p['attention_mask'] ) / len(tokens_p['attention_mask'] ) , ) UpperCamelCase_ = tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids'] ) UpperCamelCase_ = tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids'] ) # Rust correctly handles the space before the mask while python doesnt self.assertSequenceEqual(tokens_p['input_ids'] , [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2] ) self.assertSequenceEqual(tokens_r['input_ids'] , [0, 250, 6, 50264, 3823, 487, 21992, 3645, 4, 2] ) self.assertSequenceEqual( _UpperCAmelCase , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'] ) self.assertSequenceEqual( _UpperCAmelCase , ['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>'] ) def _UpperCAmelCase ( self ) -> List[str]: for trim_offsets, add_prefix_space in itertools.product([True, False] , repeat=2 ): UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( self.tmpdirname , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__() ) UpperCamelCase_ = json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__() ) self.assertEqual(pre_tokenizer_state['add_prefix_space'] , _UpperCAmelCase ) self.assertEqual(post_processor_state['add_prefix_space'] , _UpperCAmelCase ) self.assertEqual(post_processor_state['trim_offsets'] , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space` and # `trim_offsets` for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ): UpperCamelCase_ = 'hello' # `hello` is a token in the vocabulary of `pretrained_name` UpperCamelCase_ = f"""{text_of_1_token} {text_of_1_token}""" UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( _UpperCAmelCase , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_r(_UpperCAmelCase , return_offsets_mapping=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(_UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(_UpperCAmelCase ) + 1, len(_UpperCAmelCase ) + 1 + len(_UpperCAmelCase )) , ) UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( _UpperCAmelCase , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_r(_UpperCAmelCase , return_offsets_mapping=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(_UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(_UpperCAmelCase ) + 1, len(_UpperCAmelCase ) + 1 + len(_UpperCAmelCase )) , ) UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( _UpperCAmelCase , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_r(_UpperCAmelCase , return_offsets_mapping=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(_UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(_UpperCAmelCase ), len(_UpperCAmelCase ) + 1 + len(_UpperCAmelCase )) , ) UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( _UpperCAmelCase , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_r(_UpperCAmelCase , return_offsets_mapping=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, len(_UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (len(_UpperCAmelCase ), len(_UpperCAmelCase ) + 1 + len(_UpperCAmelCase )) , ) UpperCamelCase_ = f""" {text}""" # tokenizer_r = self.rust_tokenizer_class.from_pretrained( # pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True # ) # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False) # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token))) # self.assertEqual( # encoding.offset_mapping[1], # (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)), # ) UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( _UpperCAmelCase , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_r(_UpperCAmelCase , return_offsets_mapping=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (1, 1 + len(_UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (1 + len(_UpperCAmelCase ) + 1, 1 + len(_UpperCAmelCase ) + 1 + len(_UpperCAmelCase )) , ) UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( _UpperCAmelCase , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_r(_UpperCAmelCase , return_offsets_mapping=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, 1 + len(_UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (1 + len(_UpperCAmelCase ), 1 + len(_UpperCAmelCase ) + 1 + len(_UpperCAmelCase )) , ) UpperCamelCase_ = self.rust_tokenizer_class.from_pretrained( _UpperCAmelCase , use_fast=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase ) UpperCamelCase_ = tokenizer_r(_UpperCAmelCase , return_offsets_mapping=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) self.assertEqual(encoding.offset_mapping[0] , (0, 1 + len(_UpperCAmelCase )) ) self.assertEqual( encoding.offset_mapping[1] , (1 + len(_UpperCAmelCase ), 1 + len(_UpperCAmelCase ) + 1 + len(_UpperCAmelCase )) , )
23
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Optional[int] = { """configuration_pegasus_x""": ["""PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusXConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST""", """PegasusXForConditionalGeneration""", """PegasusXModel""", """PegasusXPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys snake_case__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
1
def _snake_case (__lowercase = 1000): UpperCamelCase_ , UpperCamelCase_ = 1, 1 UpperCamelCase_ = 2 while True: UpperCamelCase_ = 0 UpperCamelCase_ = fa + fa UpperCamelCase_ , UpperCamelCase_ = fa, f index += 1 for _ in str(__lowercase): i += 1 if i == n: break return index if __name__ == "__main__": print(solution(int(str(input()).strip())))
23
import datasets from .evaluate import evaluate snake_case__ : int = """\ @article{hendrycks2021cuad, title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review}, author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball}, journal={arXiv preprint arXiv:2103.06268}, year={2021} } """ snake_case__ : Union[str, Any] = """ This metric wrap the official scoring script for version 1 of the Contract Understanding Atticus Dataset (CUAD). Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions. """ snake_case__ : Any = """ Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall). Args: predictions: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair as given in the references (see below) - 'prediction_text': list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction. references: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair (see above), - 'answers': a Dict in the CUAD dataset format { 'text': list of possible texts for the answer, as a list of strings 'answer_start': list of start positions for the answer, as a list of ints } Note that answer_start values are not taken into account to compute the metric. Returns: 'exact_match': Exact match (the normalized answer exactly match the gold answer) 'f1': The F-score of predicted tokens versus the gold answer 'aupr': Area Under the Precision-Recall curve 'prec_at_80_recall': Precision at 80% recall 'prec_at_90_recall': Precision at 90% recall Examples: >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> cuad_metric = datasets.load_metric(\"cuad\") >>> results = cuad_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _a ( datasets.Metric ): """simple docstring""" def _UpperCAmelCase ( self ) -> Optional[int]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': { 'id': datasets.Value('string' ), 'prediction_text': datasets.features.Sequence(datasets.Value('string' ) ), }, 'references': { 'id': datasets.Value('string' ), 'answers': datasets.features.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), }, } ) , codebase_urls=['https://www.atticusprojectai.org/cuad'] , reference_urls=['https://www.atticusprojectai.org/cuad'] , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = {prediction['id']: prediction['prediction_text'] for prediction in predictions} UpperCamelCase_ = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] UpperCamelCase_ = evaluate(dataset=_UpperCAmelCase , predictions=_UpperCAmelCase ) return score
23
1
import numpy class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: UpperCamelCase_ = input_array # Random initial weights are assigned where first argument is the # number of nodes in previous layer and second argument is the # number of nodes in the next layer. # Random initial weights are assigned. # self.input_array.shape[1] is used to represent number of nodes in input layer. # First hidden layer consists of 4 nodes. UpperCamelCase_ = numpy.random.rand( self.input_array.shape[1] , 4 ) # Random initial values for the first hidden layer. # First hidden layer has 4 nodes. # Second hidden layer has 3 nodes. UpperCamelCase_ = numpy.random.rand( 4 , 3 ) # Random initial values for the second hidden layer. # Second hidden layer has 3 nodes. # Output layer has 1 node. UpperCamelCase_ = numpy.random.rand(3 , 1 ) # Real output values provided. UpperCamelCase_ = output_array # Predicted output values by the neural network. # Predicted_output array initially consists of zeroes. UpperCamelCase_ = numpy.zeros(output_array.shape ) def _UpperCAmelCase ( self ) -> numpy.ndarray: UpperCamelCase_ = sigmoid( numpy.dot(self.input_array , self.input_layer_and_first_hidden_layer_weights ) ) # layer_between_first_hidden_layer_and_second_hidden_layer is the layer # connecting the first hidden set of nodes with the second hidden set of nodes. UpperCamelCase_ = sigmoid( numpy.dot( self.layer_between_input_and_first_hidden_layer , self.first_hidden_layer_and_second_hidden_layer_weights , ) ) # layer_between_second_hidden_layer_and_output is the layer connecting # second hidden layer with the output node. UpperCamelCase_ = sigmoid( numpy.dot( self.layer_between_first_hidden_layer_and_second_hidden_layer , self.second_hidden_layer_and_output_layer_weights , ) ) return self.layer_between_second_hidden_layer_and_output def _UpperCAmelCase ( self ) -> None: UpperCamelCase_ = numpy.dot( self.layer_between_first_hidden_layer_and_second_hidden_layer.T , 2 * (self.output_array - self.predicted_output) * sigmoid_derivative(self.predicted_output ) , ) UpperCamelCase_ = numpy.dot( self.layer_between_input_and_first_hidden_layer.T , numpy.dot( 2 * (self.output_array - self.predicted_output) * sigmoid_derivative(self.predicted_output ) , self.second_hidden_layer_and_output_layer_weights.T , ) * sigmoid_derivative( self.layer_between_first_hidden_layer_and_second_hidden_layer ) , ) UpperCamelCase_ = numpy.dot( self.input_array.T , numpy.dot( numpy.dot( 2 * (self.output_array - self.predicted_output) * sigmoid_derivative(self.predicted_output ) , self.second_hidden_layer_and_output_layer_weights.T , ) * sigmoid_derivative( self.layer_between_first_hidden_layer_and_second_hidden_layer ) , self.first_hidden_layer_and_second_hidden_layer_weights.T , ) * sigmoid_derivative(self.layer_between_input_and_first_hidden_layer ) , ) self.input_layer_and_first_hidden_layer_weights += ( updated_input_layer_and_first_hidden_layer_weights ) self.first_hidden_layer_and_second_hidden_layer_weights += ( updated_first_hidden_layer_and_second_hidden_layer_weights ) self.second_hidden_layer_and_output_layer_weights += ( updated_second_hidden_layer_and_output_layer_weights ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> None: for iteration in range(1 , iterations + 1 ): UpperCamelCase_ = self.feedforward() self.back_propagation() if give_loss: UpperCamelCase_ = numpy.mean(numpy.square(output - self.feedforward() ) ) print(f"""Iteration {iteration} Loss: {loss}""" ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> int: UpperCamelCase_ = input_arr UpperCamelCase_ = sigmoid( numpy.dot(self.array , self.input_layer_and_first_hidden_layer_weights ) ) UpperCamelCase_ = sigmoid( numpy.dot( self.layer_between_input_and_first_hidden_layer , self.first_hidden_layer_and_second_hidden_layer_weights , ) ) UpperCamelCase_ = sigmoid( numpy.dot( self.layer_between_first_hidden_layer_and_second_hidden_layer , self.second_hidden_layer_and_output_layer_weights , ) ) return int(self.layer_between_second_hidden_layer_and_output > 0.6 ) def _snake_case (__lowercase): return 1 / (1 + numpy.exp(-value)) def _snake_case (__lowercase): return (value) * (1 - (value)) def _snake_case (): UpperCamelCase_ = numpy.array( ( [0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1], ) , dtype=numpy.floataa , ) # True output values for the given input values. UpperCamelCase_ = numpy.array(([0], [1], [1], [0], [1], [0], [0], [1]) , dtype=numpy.floataa) # Calling neural network class. UpperCamelCase_ = TwoHiddenLayerNeuralNetwork( input_array=__lowercase , output_array=__lowercase) # Calling training function. # Set give_loss to True if you want to see loss in every iteration. neural_network.train(output=__lowercase , iterations=10 , give_loss=__lowercase) return neural_network.predict(numpy.array(([1, 1, 1]) , dtype=numpy.floataa)) if __name__ == "__main__": example()
23
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import datasets import datasets.config from .utils import require_beam class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> List[str]: return datasets.DatasetInfo( features=datasets.Features({'content': datasets.Value('string' )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_dummy_examples()} )] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> Any: return datasets.DatasetInfo( features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: return [ datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_nested_examples()} ) ] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) def _snake_case (): return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar'])] def _snake_case (): return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['foo', 'bar', 'foobar'])] class _a ( UpperCAmelCase__ ): """simple docstring""" @require_beam def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_dummy_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_dummy_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> List[str]: import apache_beam as beam UpperCamelCase_ = beam.io.parquetio.WriteToParquet UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) with patch('apache_beam.io.parquetio.WriteToParquet' ) as write_parquet_mock: UpperCamelCase_ = partial(_UpperCAmelCase , num_shards=2 ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) # Order is not preserved when sharding, so we just check that all the elements are there self.assertListEqual(sorted(dset['train']['content'] ) , sorted(['foo', 'bar', 'foobar'] ) ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> Any: with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase ) self.assertRaises(datasets.builder.MissingBeamOptions , builder.download_and_prepare ) @require_beam def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = len(get_test_nested_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = NestedBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual( builder.info.features , datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_nested_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_nested_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset
23
1
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import datasets import datasets.config from .utils import require_beam class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> List[str]: return datasets.DatasetInfo( features=datasets.Features({'content': datasets.Value('string' )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_dummy_examples()} )] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> Any: return datasets.DatasetInfo( features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: return [ datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_nested_examples()} ) ] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) def _snake_case (): return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar'])] def _snake_case (): return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['foo', 'bar', 'foobar'])] class _a ( UpperCAmelCase__ ): """simple docstring""" @require_beam def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_dummy_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_dummy_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> List[str]: import apache_beam as beam UpperCamelCase_ = beam.io.parquetio.WriteToParquet UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) with patch('apache_beam.io.parquetio.WriteToParquet' ) as write_parquet_mock: UpperCamelCase_ = partial(_UpperCAmelCase , num_shards=2 ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) # Order is not preserved when sharding, so we just check that all the elements are there self.assertListEqual(sorted(dset['train']['content'] ) , sorted(['foo', 'bar', 'foobar'] ) ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> Any: with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase ) self.assertRaises(datasets.builder.MissingBeamOptions , builder.download_and_prepare ) @require_beam def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = len(get_test_nested_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = NestedBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual( builder.info.features , datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_nested_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_nested_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset
23
import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = AlbertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = AlbertForPreTraining(__lowercase) # Load weights from tf checkpoint load_tf_weights_in_albert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--albert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained ALBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : str = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
23
1
import argparse import json import os from pathlib import Path import requests import torch from transformers import JukeboxConfig, JukeboxModel from transformers.utils import logging logging.set_verbosity_info() snake_case__ : List[str] = logging.get_logger(__name__) snake_case__ : int = """https://openaipublic.azureedge.net/jukebox/models/""" snake_case__ : List[Any] = { """jukebox-1b-lyrics""": [ """5b/vqvae.pth.tar""", """5b/prior_level_0.pth.tar""", """5b/prior_level_1.pth.tar""", """1b_lyrics/prior_level_2.pth.tar""", ], """jukebox-5b-lyrics""": [ """5b/vqvae.pth.tar""", """5b/prior_level_0.pth.tar""", """5b/prior_level_1.pth.tar""", """5b_lyrics/prior_level_2.pth.tar""", ], } def _snake_case (__lowercase): if key.endswith('.model.1.bias') and len(key.split('.')) > 10: UpperCamelCase_ = key.replace('.model.1.bias' , '.conv1d_1.bias') elif key.endswith('.model.1.weight') and len(key.split('.')) > 10: UpperCamelCase_ = key.replace('.model.1.weight' , '.conv1d_1.weight') elif key.endswith('.model.3.bias') and len(key.split('.')) > 10: UpperCamelCase_ = key.replace('.model.3.bias' , '.conv1d_2.bias') elif key.endswith('.model.3.weight') and len(key.split('.')) > 10: UpperCamelCase_ = key.replace('.model.3.weight' , '.conv1d_2.weight') if "conditioner_blocks.0." in key: UpperCamelCase_ = key.replace('conditioner_blocks.0' , 'conditioner_blocks') if "prime_prior" in key: UpperCamelCase_ = key.replace('prime_prior' , 'encoder') if ".emb." in key and "total" not in key and "absolute" not in key and "relative" not in key: UpperCamelCase_ = key.replace('.emb.' , '.') if key.endswith('k'): # replace vqvae.X.k with vqvae.X.codebook return key.replace('.k' , '.codebook') if "y_emb." in key: return key.replace('y_emb.' , 'metadata_embedding.') if "x_emb.emb." in key: UpperCamelCase_ = key.replace('0.x_emb.emb' , 'embed_tokens') if "prime_state_ln" in key: return key.replace('prime_state_ln' , 'encoder.final_layer_norm') if ".ln" in key: return key.replace('.ln' , '.layer_norm') if "_ln" in key: return key.replace('_ln' , '_layer_norm') if "prime_state_proj" in key: return key.replace('prime_state_proj' , 'encoder.proj_in') if "prime_x_out" in key: return key.replace('prime_x_out' , 'encoder.lm_head') if "prior.x_out" in key: return key.replace('x_out' , 'fc_proj_out') if "x_emb" in key: return key.replace('x_emb' , 'embed_tokens') return key def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase): UpperCamelCase_ = {} import re UpperCamelCase_ = re.compile(r'encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)') UpperCamelCase_ = re.compile( r'encoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)') UpperCamelCase_ = re.compile(r'encoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)') UpperCamelCase_ = re.compile(r'decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).(bias|weight)') UpperCamelCase_ = re.compile( r'decoders.(\d*).level_blocks.(\d*).model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)') UpperCamelCase_ = re.compile(r'decoders.(\d*).level_blocks.(\d*).model.(\d*).(bias|weight)') UpperCamelCase_ = re.compile(r'conditioner_blocks.(\d*).cond.model.(\d*).(\d).(bias|weight)') UpperCamelCase_ = re.compile( r'conditioner_blocks.(\d*).cond.model.(\d*).(\d).model.(\d*).model.(\d*).(bias|weight)') UpperCamelCase_ = re.compile(r'conditioner_blocks.(\d*).cond.model.(\d*).(bias|weight)') for original_key, value in state_dict.items(): # rename vqvae.encoder keys if re_encoder_block_conv_in.fullmatch(__lowercase): UpperCamelCase_ = re_encoder_block_conv_in.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = int(groups[2]) * 2 + int(groups[3]) UpperCamelCase_ = f"""encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}.{groups[-1]}""" UpperCamelCase_ = re_encoder_block_conv_in.sub(__lowercase , __lowercase) elif re_encoder_block_resnet.fullmatch(__lowercase): UpperCamelCase_ = re_encoder_block_resnet.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = int(groups[2]) * 2 + int(groups[3]) UpperCamelCase_ = {'1': 1, '3': 2}[groups[-2]] UpperCamelCase_ = f"""encoders.{groups[0]}.level_blocks.{groups[1]}.downsample_block.{block_index}.""" UpperCamelCase_ = f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}""" UpperCamelCase_ = prefix + resnet_block UpperCamelCase_ = re_encoder_block_resnet.sub(__lowercase , __lowercase) elif re_encoder_block_proj_out.fullmatch(__lowercase): UpperCamelCase_ = re_encoder_block_proj_out.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = f"""encoders.{groups[0]}.level_blocks.{groups[1]}.proj_out.{groups[-1]}""" UpperCamelCase_ = re_encoder_block_proj_out.sub(__lowercase , __lowercase) # rename vqvae.decoder keys elif re_decoder_block_conv_out.fullmatch(__lowercase): UpperCamelCase_ = re_decoder_block_conv_out.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = int(groups[2]) * 2 + int(groups[3]) - 2 UpperCamelCase_ = f"""decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}.{groups[-1]}""" UpperCamelCase_ = re_decoder_block_conv_out.sub(__lowercase , __lowercase) elif re_decoder_block_resnet.fullmatch(__lowercase): UpperCamelCase_ = re_decoder_block_resnet.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = int(groups[2]) * 2 + int(groups[3]) - 2 UpperCamelCase_ = {'1': 1, '3': 2}[groups[-2]] UpperCamelCase_ = f"""decoders.{groups[0]}.level_blocks.{groups[1]}.upsample_block.{block_index}.""" UpperCamelCase_ = f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}""" UpperCamelCase_ = prefix + resnet_block UpperCamelCase_ = re_decoder_block_resnet.sub(__lowercase , __lowercase) elif re_decoder_block_proj_in.fullmatch(__lowercase): UpperCamelCase_ = re_decoder_block_proj_in.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = f"""decoders.{groups[0]}.level_blocks.{groups[1]}.proj_in.{groups[-1]}""" UpperCamelCase_ = re_decoder_block_proj_in.sub(__lowercase , __lowercase) # rename prior cond.model to upsampler.upsample_block and resnet elif re_prior_cond_conv_out.fullmatch(__lowercase): UpperCamelCase_ = re_prior_cond_conv_out.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = int(groups[1]) * 2 + int(groups[2]) - 2 UpperCamelCase_ = f"""conditioner_blocks.upsampler.upsample_block.{block_index}.{groups[-1]}""" UpperCamelCase_ = re_prior_cond_conv_out.sub(__lowercase , __lowercase) elif re_prior_cond_resnet.fullmatch(__lowercase): UpperCamelCase_ = re_prior_cond_resnet.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = int(groups[1]) * 2 + int(groups[2]) - 2 UpperCamelCase_ = {'1': 1, '3': 2}[groups[-2]] UpperCamelCase_ = f"""conditioner_blocks.upsampler.upsample_block.{block_index}.""" UpperCamelCase_ = f"""resnet_block.{groups[-3]}.conv1d_{conv_index}.{groups[-1]}""" UpperCamelCase_ = prefix + resnet_block UpperCamelCase_ = re_prior_cond_resnet.sub(__lowercase , __lowercase) elif re_prior_cond_proj_in.fullmatch(__lowercase): UpperCamelCase_ = re_prior_cond_proj_in.match(__lowercase) UpperCamelCase_ = regex_match.groups() UpperCamelCase_ = f"""conditioner_blocks.upsampler.proj_in.{groups[-1]}""" UpperCamelCase_ = re_prior_cond_proj_in.sub(__lowercase , __lowercase) # keep original key else: UpperCamelCase_ = original_key UpperCamelCase_ = replace_key(__lowercase) if f"""{key_prefix}.{key}""" not in model_state_dict or key is None: print(f"""failed converting {original_key} to {key}, does not match""") # handle missmatched shape elif value.shape != model_state_dict[f"""{key_prefix}.{key}"""].shape: UpperCamelCase_ = model_state_dict[f"""{key_prefix}.{key}"""] print(f"""{original_key}-> {key} : \nshape {val.shape} and { value.shape}, do not match""") UpperCamelCase_ = original_key UpperCamelCase_ = original_key UpperCamelCase_ = value return new_dict @torch.no_grad() def _snake_case (__lowercase=None , __lowercase=None): for file in MODEL_MAPPING[model_name]: if not os.path.isfile(f"""{pytorch_dump_folder_path}/{file.split("/")[-1]}"""): UpperCamelCase_ = requests.get(f"""{PREFIX}{file}""" , allow_redirects=__lowercase) os.makedirs(f"""{pytorch_dump_folder_path}/""" , exist_ok=__lowercase) open(f"""{pytorch_dump_folder_path}/{file.split("/")[-1]}""" , 'wb').write(r.content) UpperCamelCase_ = MODEL_MAPPING[model_name.split('/')[-1]] UpperCamelCase_ = JukeboxConfig.from_pretrained(__lowercase) UpperCamelCase_ = JukeboxModel(__lowercase) UpperCamelCase_ = [] UpperCamelCase_ = {} for i, dict_name in enumerate(__lowercase): UpperCamelCase_ = torch.load(f"""{pytorch_dump_folder_path}/{dict_name.split("/")[-1]}""")['model'] UpperCamelCase_ = {} for k in old_dic.keys(): if k.endswith('.b'): UpperCamelCase_ = old_dic[k] elif k.endswith('.w'): UpperCamelCase_ = old_dic[k] elif "level_2" not in dict_name and "cond.model." in k: UpperCamelCase_ = old_dic[k] else: UpperCamelCase_ = old_dic[k] UpperCamelCase_ = 'vqvae' if i == 0 else f"""priors.{3 - i}""" UpperCamelCase_ = fix_jukebox_keys(__lowercase , model.state_dict() , __lowercase , __lowercase) weight_dict.append(__lowercase) UpperCamelCase_ = weight_dict.pop(0) model.vqvae.load_state_dict(__lowercase) for i in range(len(__lowercase)): model.priors[i].load_state_dict(weight_dict[2 - i]) Path(__lowercase).mkdir(exist_ok=__lowercase) with open(f"""{pytorch_dump_folder_path}/mapping.json""" , 'w') as txtfile: json.dump(__lowercase , __lowercase) print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""") model.save_pretrained(__lowercase) return weight_dict if __name__ == "__main__": snake_case__ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default="""jukebox-5b-lyrics""", type=str, help="""Name of the model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default="""jukebox-5b-lyrics-converted""", type=str, help="""Path to the output PyTorch model directory.""", ) snake_case__ : int = parser.parse_args() convert_openai_checkpoint(args.model_name, args.pytorch_dump_folder_path)
23
from transformers import BertTokenizer, EncoderDecoderModel, SeqaSeqTrainer, SeqaSeqTrainingArguments from transformers.testing_utils import TestCasePlus, require_torch, slow from transformers.utils import is_datasets_available if is_datasets_available(): import datasets class _a ( UpperCAmelCase__ ): """simple docstring""" @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = EncoderDecoderModel.from_encoder_decoder_pretrained('prajjwal1/bert-tiny' , 'prajjwal1/bert-tiny' ) UpperCamelCase_ = BertTokenizer.from_pretrained('bert-base-uncased' ) UpperCamelCase_ = bertabert.config.encoder.vocab_size UpperCamelCase_ = tokenizer.sep_token_id UpperCamelCase_ = tokenizer.cls_token_id UpperCamelCase_ = 128 UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='train[:1%]' ) UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='validation[:1%]' ) UpperCamelCase_ = train_dataset.select(range(32 ) ) UpperCamelCase_ = val_dataset.select(range(16 ) ) UpperCamelCase_ = 4 def _map_to_encoder_decoder_inputs(_UpperCAmelCase ): # Tokenizer will automatically set [BOS] <text> [EOS] UpperCamelCase_ = tokenizer(batch['article'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=512 ) UpperCamelCase_ = tokenizer(batch['highlights'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=128 ) UpperCamelCase_ = inputs.input_ids UpperCamelCase_ = inputs.attention_mask UpperCamelCase_ = outputs.input_ids UpperCamelCase_ = outputs.input_ids.copy() UpperCamelCase_ = [ [-100 if token == tokenizer.pad_token_id else token for token in labels] for labels in batch['labels'] ] UpperCamelCase_ = outputs.attention_mask assert all(len(_UpperCAmelCase ) == 512 for x in inputs.input_ids ) assert all(len(_UpperCAmelCase ) == 128 for x in outputs.input_ids ) return batch def _compute_metrics(_UpperCAmelCase ): UpperCamelCase_ = pred.label_ids UpperCamelCase_ = pred.predictions # all unnecessary tokens are removed UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = sum([int(pred_str[i] == label_str[i] ) for i in range(len(_UpperCAmelCase ) )] ) / len(_UpperCAmelCase ) return {"accuracy": accuracy} # map train dataset UpperCamelCase_ = train_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) train_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) # same for validation dataset UpperCamelCase_ = val_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) val_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) UpperCamelCase_ = self.get_auto_remove_tmp_dir() UpperCamelCase_ = SeqaSeqTrainingArguments( output_dir=_UpperCAmelCase , per_device_train_batch_size=_UpperCAmelCase , per_device_eval_batch_size=_UpperCAmelCase , predict_with_generate=_UpperCAmelCase , evaluation_strategy='steps' , do_train=_UpperCAmelCase , do_eval=_UpperCAmelCase , warmup_steps=0 , eval_steps=2 , logging_steps=2 , ) # instantiate trainer UpperCamelCase_ = SeqaSeqTrainer( model=_UpperCAmelCase , args=_UpperCAmelCase , compute_metrics=_compute_metrics , train_dataset=_UpperCAmelCase , eval_dataset=_UpperCAmelCase , tokenizer=_UpperCAmelCase , ) # start training trainer.train()
23
1
from __future__ import annotations import sys from collections import deque from typing import Generic, TypeVar snake_case__ : Dict = TypeVar("""T""") class _a ( Generic[T] ): """simple docstring""" A_ = 42 # Cache store of keys A_ = 42 # References of the keys in cache A_ = 10 # Maximum capacity of cache def __init__( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = deque() UpperCamelCase_ = set() if not n: UpperCamelCase_ = sys.maxsize elif n < 0: raise ValueError('n should be an integer greater than 0.' ) else: UpperCamelCase_ = n def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: if x not in self.key_reference: if len(self.dq_store ) == LRUCache._MAX_CAPACITY: UpperCamelCase_ = self.dq_store.pop() self.key_reference.remove(_UpperCAmelCase ) else: self.dq_store.remove(_UpperCAmelCase ) self.dq_store.appendleft(_UpperCAmelCase ) self.key_reference.add(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> None: for k in self.dq_store: print(_UpperCAmelCase ) def __repr__( self ) -> str: return f"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store )}""" if __name__ == "__main__": import doctest doctest.testmod() snake_case__ : LRUCache[str | int] = LRUCache(4) lru_cache.refer("""A""") lru_cache.refer(2) lru_cache.refer(3) lru_cache.refer("""A""") lru_cache.refer(4) lru_cache.refer(5) lru_cache.display() print(lru_cache) assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"
23
import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType ######################################################################## # This is a fully working simple example to use Accelerate # and perform gradient accumulation # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## snake_case__ : Dict = 1_6 snake_case__ : List[str] = 3_2 def _snake_case (__lowercase , __lowercase = 16): UpperCamelCase_ = AutoTokenizer.from_pretrained('bert-base-cased') UpperCamelCase_ = load_dataset('glue' , 'mrpc') def tokenize_function(__lowercase): # max_length=None => use the model max length (it's actually the default) UpperCamelCase_ = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=__lowercase , max_length=__lowercase) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): UpperCamelCase_ = datasets.map( __lowercase , batched=__lowercase , remove_columns=['idx', 'sentence1', 'sentence2'] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library UpperCamelCase_ = tokenized_datasets.rename_column('label' , 'labels') def collate_fn(__lowercase): # On TPU it's best to pad everything to the same length or training will be very slow. UpperCamelCase_ = 128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": UpperCamelCase_ = 16 elif accelerator.mixed_precision != "no": UpperCamelCase_ = 8 else: UpperCamelCase_ = None return tokenizer.pad( __lowercase , padding='longest' , max_length=__lowercase , pad_to_multiple_of=__lowercase , return_tensors='pt' , ) # Instantiate dataloaders. UpperCamelCase_ = DataLoader( tokenized_datasets['train'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) UpperCamelCase_ = DataLoader( tokenized_datasets['validation'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) return train_dataloader, eval_dataloader # For testing only if os.environ.get("""TESTING_MOCKED_DATALOADERS""", None) == "1": from accelerate.test_utils.training import mocked_dataloaders snake_case__ : List[str] = mocked_dataloaders # noqa: F811 def _snake_case (__lowercase , __lowercase): # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS' , __lowercase) == "1": UpperCamelCase_ = 2 # New Code # UpperCamelCase_ = int(args.gradient_accumulation_steps) # Initialize accelerator UpperCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=__lowercase) if accelerator.distributed_type == DistributedType.TPU and gradient_accumulation_steps > 1: raise NotImplementedError( 'Gradient accumulation on TPUs is currently not supported. Pass `gradient_accumulation_steps=1`') # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs UpperCamelCase_ = config['lr'] UpperCamelCase_ = int(config['num_epochs']) UpperCamelCase_ = int(config['seed']) UpperCamelCase_ = int(config['batch_size']) UpperCamelCase_ = evaluate.load('glue' , 'mrpc') set_seed(__lowercase) UpperCamelCase_ , UpperCamelCase_ = get_dataloaders(__lowercase , __lowercase) # Instantiate the model (we build the model here so that the seed also control new weights initialization) UpperCamelCase_ = AutoModelForSequenceClassification.from_pretrained('bert-base-cased' , return_dict=__lowercase) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). UpperCamelCase_ = model.to(accelerator.device) # Instantiate optimizer UpperCamelCase_ = AdamW(params=model.parameters() , lr=__lowercase) # Instantiate scheduler UpperCamelCase_ = get_linear_schedule_with_warmup( optimizer=__lowercase , num_warmup_steps=100 , num_training_steps=(len(__lowercase) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare( __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # Now we train the model for epoch in range(__lowercase): model.train() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(__lowercase): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = output.loss accelerator.backward(__lowercase) optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) with torch.no_grad(): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = outputs.logits.argmax(dim=-1) UpperCamelCase_ , UpperCamelCase_ = accelerator.gather_for_metrics((predictions, batch['labels'])) metric.add_batch( predictions=__lowercase , references=__lowercase , ) UpperCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , __lowercase) def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Simple example of training script.') parser.add_argument( '--mixed_precision' , type=__lowercase , default=__lowercase , choices=['no', 'fp16', 'bf16', 'fp8'] , help='Whether to use mixed precision. Choose' 'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.' 'and an Nvidia Ampere GPU.' , ) # New Code # parser.add_argument( '--gradient_accumulation_steps' , type=__lowercase , default=1 , help='The number of minibatches to be ran before gradients are accumulated.' , ) parser.add_argument('--cpu' , action='store_true' , help='If passed, will train on the CPU.') UpperCamelCase_ = parser.parse_args() UpperCamelCase_ = {'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(__lowercase , __lowercase) if __name__ == "__main__": main()
23
1
import gc import threading import time import psutil import torch class _a : """simple docstring""" def __init__( self ) -> Optional[int]: UpperCamelCase_ = psutil.Process() UpperCamelCase_ = False def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = -1 while True: UpperCamelCase_ = max(self.process.memory_info().rss , self.cpu_memory_peak ) # can't sleep or will not catch the peak right (this comment is here on purpose) if not self.peak_monitoring: break def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = True UpperCamelCase_ = threading.Thread(target=self.peak_monitor ) UpperCamelCase_ = True self.thread.start() def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ = False self.thread.join() return self.cpu_memory_peak snake_case__ : Any = PeakCPUMemory() def _snake_case (): # Time UpperCamelCase_ = {'time': time.time()} gc.collect() torch.cuda.empty_cache() # CPU mem UpperCamelCase_ = psutil.Process().memory_info().rss cpu_peak_tracker.start() # GPU mem for i in range(torch.cuda.device_count()): UpperCamelCase_ = torch.cuda.memory_allocated(__lowercase) torch.cuda.reset_peak_memory_stats() return measures def _snake_case (__lowercase): # Time UpperCamelCase_ = {'time': time.time() - start_measures['time']} gc.collect() torch.cuda.empty_cache() # CPU mem UpperCamelCase_ = (psutil.Process().memory_info().rss - start_measures['cpu']) / 2**20 UpperCamelCase_ = (cpu_peak_tracker.stop() - start_measures['cpu']) / 2**20 # GPU mem for i in range(torch.cuda.device_count()): UpperCamelCase_ = (torch.cuda.memory_allocated(__lowercase) - start_measures[str(__lowercase)]) / 2**20 UpperCamelCase_ = (torch.cuda.max_memory_allocated(__lowercase) - start_measures[str(__lowercase)]) / 2**20 return measures def _snake_case (__lowercase , __lowercase): print(f"""{description}:""") print(f"""- Time: {measures["time"]:.2f}s""") for i in range(torch.cuda.device_count()): print(f"""- GPU {i} allocated: {measures[str(__lowercase)]:.2f}MiB""") UpperCamelCase_ = measures[f"""{i}-peak"""] print(f"""- GPU {i} peak: {peak:.2f}MiB""") print(f"""- CPU RAM allocated: {measures["cpu"]:.2f}MiB""") print(f"""- CPU RAM peak: {measures["cpu-peak"]:.2f}MiB""")
23
import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import MaskaFormerConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel if is_vision_available(): from transformers import MaskaFormerImageProcessor if is_vision_available(): from PIL import Image class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=2 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=10 , _UpperCAmelCase=3 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=4 , _UpperCAmelCase=64 , ) -> List[Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = is_training UpperCamelCase_ = use_auxiliary_loss UpperCamelCase_ = num_queries UpperCamelCase_ = num_channels UpperCamelCase_ = min_size UpperCamelCase_ = max_size UpperCamelCase_ = num_labels UpperCamelCase_ = hidden_dim UpperCamelCase_ = hidden_dim def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( _UpperCAmelCase ) UpperCamelCase_ = torch.ones([self.batch_size, self.min_size, self.max_size] , device=_UpperCAmelCase ) UpperCamelCase_ = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=_UpperCAmelCase ) > 0.5 ).float() UpperCamelCase_ = (torch.rand((self.batch_size, self.num_labels) , device=_UpperCAmelCase ) > 0.5).long() UpperCamelCase_ = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = MaskaFormerConfig( hidden_size=self.hidden_dim , ) UpperCamelCase_ = self.num_queries UpperCamelCase_ = self.num_labels UpperCamelCase_ = [1, 1, 1, 1] UpperCamelCase_ = self.num_channels UpperCamelCase_ = 64 UpperCamelCase_ = 128 UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim return config def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ = {'pixel_values': pixel_values, 'pixel_mask': pixel_mask} return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = output.encoder_hidden_states UpperCamelCase_ = output.pixel_decoder_hidden_states UpperCamelCase_ = output.transformer_decoder_hidden_states self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , config.decoder_layers ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False ) -> Any: with torch.no_grad(): UpperCamelCase_ = MaskaFormerModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.hidden_dim) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() def comm_check_on_output(_UpperCAmelCase ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) UpperCamelCase_ = model( pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else () A_ = {"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {} A_ = False A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , has_text_modality=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_UpperCAmelCase ) @unittest.skip(reason='Mask2Former does not use inputs_embeds' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method' ) def _UpperCAmelCase ( self ) -> Optional[int]: pass @unittest.skip(reason='Mask2Former is not a generative model' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not use token embeddings' ) def _UpperCAmelCase ( self ) -> Optional[Any]: pass @require_torch_multi_gpu @unittest.skip( reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' ) def _UpperCAmelCase ( self ) -> int: pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Tuple: for model_name in ["facebook/mask2former-swin-small-coco-instance"]: UpperCamelCase_ = MaskaFormerModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = (self.model_tester.min_size,) * 2 UpperCamelCase_ = { 'pixel_values': torch.randn((2, 3, *size) , device=_UpperCAmelCase ), 'mask_labels': torch.randn((2, 10, *size) , device=_UpperCAmelCase ), 'class_labels': torch.zeros(2 , 10 , device=_UpperCAmelCase ).long(), } UpperCamelCase_ = self.model_tester.get_config() UpperCamelCase_ = MaskaFormerForUniversalSegmentation(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None ) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase , output_attentions=_UpperCAmelCase ) self.assertTrue(outputs.attentions is not None ) def _UpperCAmelCase ( self ) -> List[Any]: if not self.model_tester.is_training: return UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = True UpperCamelCase_ = True UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) UpperCamelCase_ = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=_UpperCAmelCase ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) snake_case__ : List[Any] = 1E-4 def _snake_case (): UpperCamelCase_ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') return image @require_vision @slow class _a ( unittest.TestCase ): """simple docstring""" @cached_property def _UpperCAmelCase ( self ) -> Optional[int]: return "facebook/mask2former-swin-small-coco-instance" @cached_property def _UpperCAmelCase ( self ) -> List[str]: return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) UpperCamelCase_ = torch.tensor( [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) # masks_queries_logits UpperCamelCase_ = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) ) UpperCamelCase_ = [ [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1], [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1], [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5], ] UpperCamelCase_ = torch.tensor(_UpperCAmelCase ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) # class_queries_logits UpperCamelCase_ = outputs.class_queries_logits self.assertEqual(class_queries_logits.shape , (1, model.config.num_queries, model.config.num_labels + 1) ) UpperCamelCase_ = torch.tensor( [ [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2], [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3], [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5], ] ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = image_processor( [np.zeros((3, 800, 1333) ), np.zeros((3, 800, 1333) )] , segmentation_maps=[np.zeros((384, 384) ).astype(np.floataa ), np.zeros((384, 384) ).astype(np.floataa )] , return_tensors='pt' , ) UpperCamelCase_ = inputs['pixel_values'].to(_UpperCAmelCase ) UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['mask_labels']] UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['class_labels']] with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None )
23
1
import logging from transformers.configuration_utils import PretrainedConfig snake_case__ : Optional[int] = logging.getLogger(__name__) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """masked_bert""" def __init__( self , _UpperCAmelCase=30522 , _UpperCAmelCase=768 , _UpperCAmelCase=12 , _UpperCAmelCase=12 , _UpperCAmelCase=3072 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=512 , _UpperCAmelCase=2 , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=1e-12 , _UpperCAmelCase=0 , _UpperCAmelCase="topK" , _UpperCAmelCase="constant" , _UpperCAmelCase=0.0 , **_UpperCAmelCase , ) -> Union[str, Any]: super().__init__(pad_token_id=_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = hidden_act UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = type_vocab_size UpperCamelCase_ = initializer_range UpperCamelCase_ = layer_norm_eps UpperCamelCase_ = pruning_method UpperCamelCase_ = mask_init UpperCamelCase_ = mask_scale
23
import copy from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto.configuration_auto import AutoConfig if TYPE_CHECKING: from ... import PreTrainedTokenizerBase, TensorType snake_case__ : List[str] = logging.get_logger(__name__) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """vision-encoder-decoder""" A_ = True def __init__( self , **_UpperCAmelCase ) -> Dict: super().__init__(**_UpperCAmelCase ) if "encoder" not in kwargs or "decoder" not in kwargs: raise ValueError( f"""A configuraton of type {self.model_type} cannot be instantiated because """ f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}""" ) UpperCamelCase_ = kwargs.pop('encoder' ) UpperCamelCase_ = encoder_config.pop('model_type' ) UpperCamelCase_ = kwargs.pop('decoder' ) UpperCamelCase_ = decoder_config.pop('model_type' ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = True @classmethod def _UpperCAmelCase ( cls , _UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) -> PretrainedConfig: logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config' ) UpperCamelCase_ = True UpperCamelCase_ = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = copy.deepcopy(self.__dict__ ) UpperCamelCase_ = self.encoder.to_dict() UpperCamelCase_ = self.decoder.to_dict() UpperCamelCase_ = self.__class__.model_type return output class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = version.parse("""1.11""" ) @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) @property def _UpperCAmelCase ( self ) -> float: return 1e-4 @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict({'last_hidden_state': {0: 'batch', 1: 'encoder_sequence'}} ) class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: UpperCamelCase_ = OrderedDict() UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'encoder_sequence'} return common_inputs def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = -1 , _UpperCAmelCase = -1 , _UpperCAmelCase = False , _UpperCAmelCase = None , ) -> Mapping[str, Any]: import torch UpperCamelCase_ = OrderedDict() UpperCamelCase_ = super().generate_dummy_inputs( _UpperCAmelCase , batch_size=_UpperCAmelCase , seq_length=_UpperCAmelCase , is_pair=_UpperCAmelCase , framework=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = dummy_input['input_ids'].shape UpperCamelCase_ = (batch, encoder_sequence, self._config.encoder_hidden_size) UpperCamelCase_ = dummy_input.pop('input_ids' ) UpperCamelCase_ = dummy_input.pop('attention_mask' ) UpperCamelCase_ = torch.zeros(_UpperCAmelCase ) return common_inputs class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> None: pass def _UpperCAmelCase ( self , _UpperCAmelCase ) -> OnnxConfig: return VisionEncoderDecoderEncoderOnnxConfig(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = "default" ) -> OnnxConfig: UpperCamelCase_ = encoder_config.hidden_size return VisionEncoderDecoderDecoderOnnxConfig(_UpperCAmelCase , _UpperCAmelCase )
23
1
from ...configuration_utils import PretrainedConfig class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """bert-generation""" def __init__( self , _UpperCAmelCase=50358 , _UpperCAmelCase=1024 , _UpperCAmelCase=24 , _UpperCAmelCase=16 , _UpperCAmelCase=4096 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=512 , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=1e-12 , _UpperCAmelCase=0 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase="absolute" , _UpperCAmelCase=True , **_UpperCAmelCase , ) -> Optional[int]: super().__init__(pad_token_id=_UpperCAmelCase , bos_token_id=_UpperCAmelCase , eos_token_id=_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = hidden_act UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = initializer_range UpperCamelCase_ = layer_norm_eps UpperCamelCase_ = position_embedding_type UpperCamelCase_ = use_cache
23
import argparse import torch from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert from transformers.utils import logging logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = MobileBertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = MobileBertForPreTraining(__lowercase) # Load weights from tf checkpoint UpperCamelCase_ = load_tf_weights_in_mobilebert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--mobilebert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained MobileBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : Optional[Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
23
1
from argparse import ArgumentParser, Namespace from typing import Any, List, Optional from ..pipelines import Pipeline, get_supported_tasks, pipeline from ..utils import logging from . import BaseTransformersCLICommand try: from fastapi import Body, FastAPI, HTTPException from fastapi.routing import APIRoute from pydantic import BaseModel from starlette.responses import JSONResponse from uvicorn import run snake_case__ : Any = True except (ImportError, AttributeError): snake_case__ : Dict = object def _snake_case (*__lowercase , **__lowercase): pass snake_case__ : Union[str, Any] = False snake_case__ : Optional[int] = logging.get_logger("""transformers-cli/serving""") def _snake_case (__lowercase): UpperCamelCase_ = pipeline( task=args.task , model=args.model if args.model else None , config=args.config , tokenizer=args.tokenizer , device=args.device , ) return ServeCommand(__lowercase , args.host , args.port , args.workers) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 A_ = 42 class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 class _a ( UpperCAmelCase__ ): """simple docstring""" @staticmethod def _UpperCAmelCase ( _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = parser.add_parser( 'serve' , help='CLI tool to run inference requests through REST and GraphQL endpoints.' ) serve_parser.add_argument( '--task' , type=_UpperCAmelCase , choices=get_supported_tasks() , help='The task to run the pipeline on' , ) serve_parser.add_argument('--host' , type=_UpperCAmelCase , default='localhost' , help='Interface the server will listen on.' ) serve_parser.add_argument('--port' , type=_UpperCAmelCase , default=8888 , help='Port the serving will listen to.' ) serve_parser.add_argument('--workers' , type=_UpperCAmelCase , default=1 , help='Number of http workers' ) serve_parser.add_argument('--model' , type=_UpperCAmelCase , help='Model\'s name or path to stored model.' ) serve_parser.add_argument('--config' , type=_UpperCAmelCase , help='Model\'s config name or path to stored model.' ) serve_parser.add_argument('--tokenizer' , type=_UpperCAmelCase , help='Tokenizer name to use.' ) serve_parser.add_argument( '--device' , type=_UpperCAmelCase , default=-1 , help='Indicate the device to run onto, -1 indicates CPU, >= 0 indicates GPU (default: -1)' , ) serve_parser.set_defaults(func=_UpperCAmelCase ) def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = pipeline UpperCamelCase_ = host UpperCamelCase_ = port UpperCamelCase_ = workers if not _serve_dependencies_installed: raise RuntimeError( 'Using serve command requires FastAPI and uvicorn. ' 'Please install transformers with [serving]: pip install "transformers[serving]".' 'Or install FastAPI and uvicorn separately.' ) else: logger.info(f"""Serving model over {host}:{port}""" ) UpperCamelCase_ = FastAPI( routes=[ APIRoute( '/' , self.model_info , response_model=_UpperCAmelCase , response_class=_UpperCAmelCase , methods=['GET'] , ), APIRoute( '/tokenize' , self.tokenize , response_model=_UpperCAmelCase , response_class=_UpperCAmelCase , methods=['POST'] , ), APIRoute( '/detokenize' , self.detokenize , response_model=_UpperCAmelCase , response_class=_UpperCAmelCase , methods=['POST'] , ), APIRoute( '/forward' , self.forward , response_model=_UpperCAmelCase , response_class=_UpperCAmelCase , methods=['POST'] , ), ] , timeout=600 , ) def _UpperCAmelCase ( self ) -> Any: run(self._app , host=self.host , port=self.port , workers=self.workers ) def _UpperCAmelCase ( self ) -> Optional[int]: return ServeModelInfoResult(infos=vars(self._pipeline.model.config ) ) def _UpperCAmelCase ( self , _UpperCAmelCase = Body(_UpperCAmelCase , embed=_UpperCAmelCase ) , _UpperCAmelCase = Body(_UpperCAmelCase , embed=_UpperCAmelCase ) ) -> Union[str, Any]: try: UpperCamelCase_ = self._pipeline.tokenizer.tokenize(_UpperCAmelCase ) if return_ids: UpperCamelCase_ = self._pipeline.tokenizer.convert_tokens_to_ids(_UpperCAmelCase ) return ServeTokenizeResult(tokens=_UpperCAmelCase , tokens_ids=_UpperCAmelCase ) else: return ServeTokenizeResult(tokens=_UpperCAmelCase ) except Exception as e: raise HTTPException(status_code=500 , detail={'model': '', 'error': str(_UpperCAmelCase )} ) def _UpperCAmelCase ( self , _UpperCAmelCase = Body(_UpperCAmelCase , embed=_UpperCAmelCase ) , _UpperCAmelCase = Body(_UpperCAmelCase , embed=_UpperCAmelCase ) , _UpperCAmelCase = Body(_UpperCAmelCase , embed=_UpperCAmelCase ) , ) -> int: try: UpperCamelCase_ = self._pipeline.tokenizer.decode(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return ServeDeTokenizeResult(model='' , text=_UpperCAmelCase ) except Exception as e: raise HTTPException(status_code=500 , detail={'model': '', 'error': str(_UpperCAmelCase )} ) async def _UpperCAmelCase ( self , _UpperCAmelCase=Body(_UpperCAmelCase , embed=_UpperCAmelCase ) ) -> Tuple: # Check we don't have empty string if len(_UpperCAmelCase ) == 0: return ServeForwardResult(output=[] , attention=[] ) try: # Forward through the model UpperCamelCase_ = self._pipeline(_UpperCAmelCase ) return ServeForwardResult(output=_UpperCAmelCase ) except Exception as e: raise HTTPException(500 , {'error': str(_UpperCAmelCase )} )
23
import gc import unittest from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline from transformers.pipelines import PipelineException from transformers.testing_utils import ( is_pipeline_test, is_torch_available, nested_simplify, require_tf, require_torch, require_torch_gpu, slow, ) from .test_pipelines_common import ANY @is_pipeline_test class _a ( unittest.TestCase ): """simple docstring""" A_ = MODEL_FOR_MASKED_LM_MAPPING A_ = TF_MODEL_FOR_MASKED_LM_MAPPING def _UpperCAmelCase ( self ) -> List[str]: super().tearDown() # clean-up as much as possible GPU memory occupied by PyTorch gc.collect() if is_torch_available(): import torch torch.cuda.empty_cache() @require_tf def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='tf' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped'}, {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped', }, { 'sequence': 'The largest city in France is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='pt' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul'}, {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', }, {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2941, 'token_str': ' Te'}, {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask> <mask>' , top_k=2 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is Maul<mask></s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'}, ], [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is<mask> Maul</s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'}, ], ] , ) @require_torch_gpu def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = pipeline('fill-mask' , model='hf-internal-testing/tiny-random-distilbert' , device=0 , framework='pt' ) # convert model to fp16 pipe.model.half() UpperCamelCase_ = pipe('Paris is the [MASK] of France.' ) # We actually don't care about the result, we just want to make sure # it works, meaning the float16 tensor got casted back to float32 # for postprocessing. self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='pt' ) self.run_large_test(_UpperCAmelCase ) @slow @require_tf def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='tf' ) self.run_large_test(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is John', 'score': 0.0_0_8, 'token': 610, 'token_str': ' John'}, {'sequence': 'My name is Chris', 'score': 0.0_0_7, 'token': 1573, 'token_str': ' Chris'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ { 'sequence': 'The largest city in France is Paris', 'score': 0.2_5_1, 'token': 2201, 'token_str': ' Paris', }, { 'sequence': 'The largest city in France is Lyon', 'score': 0.2_1_4, 'token': 12790, 'token_str': ' Lyon', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is Patrick', 'score': 0.0_0_5, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='pt' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) @require_tf def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='tf' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: if tokenizer is None or tokenizer.mask_token_id is None: self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)' ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = [ f"""This is another {tokenizer.mask_token} test""", ] return fill_masker, examples def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = fill_masker.tokenizer UpperCamelCase_ = fill_masker.model UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token}""" , ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}"""] ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""] ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , ) with self.assertRaises(_UpperCAmelCase ): fill_masker([None] ) # No mask_token is not supported with self.assertRaises(_UpperCAmelCase ): fill_masker('This is' ) self.run_test_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_targets(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_top_k_targets(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_duplicate_targets_and_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_multiple_masks(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = sorted(vocab.keys() )[:2] # Pipeline argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , targets=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Call argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Score equivalence UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['token_str'] for top_mask in outputs] UpperCamelCase_ = [top_mask['score'] for top_mask in outputs] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ) == set(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['score'] for top_mask in unmasked_targets] self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) # Raises with invalid with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[] ) # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised if "" not in tokenizer.get_vocab(): with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[''] ) with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets='' ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , top_k=2 ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) # top_k=2, ntargets=3 UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 , targets=_UpperCAmelCase ) # If we use the most probably targets, and filter differently, we should still # have the same results UpperCamelCase_ = [el['token_str'] for el in sorted(_UpperCAmelCase , key=lambda _UpperCAmelCase : x["score"] , reverse=_UpperCAmelCase )] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ).issubset(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=3 , targets=_UpperCAmelCase ) # They should yield exactly the same result self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.get_vocab() # String duplicates + id duplicates UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = [targets[0], targets[1], targets[0], targets[2], targets[1]] UpperCamelCase_ = fill_masker(f"""My name is {tokenizer.mask_token}""" , targets=_UpperCAmelCase , top_k=10 ) # The target list contains duplicates, so we can't output more # than them self.assertEqual(len(_UpperCAmelCase ) , 3 ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , )
23
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Dict = { """configuration_nllb_moe""": [ """NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """NllbMoeConfig""", ] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Optional[Any] = [ """NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST""", """NllbMoeForConditionalGeneration""", """NllbMoeModel""", """NllbMoePreTrainedModel""", """NllbMoeTop2Router""", """NllbMoeSparseMLP""", ] if TYPE_CHECKING: from .configuration_nllb_moe import ( NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP, NllbMoeConfig, ) try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_nllb_moe import ( NLLB_MOE_PRETRAINED_MODEL_ARCHIVE_LIST, NllbMoeForConditionalGeneration, NllbMoeModel, NllbMoePreTrainedModel, NllbMoeSparseMLP, NllbMoeTopaRouter, ) else: import sys snake_case__ : str = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, StableDiffusionSAGPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = StableDiffusionSAGPipeline A_ = TEXT_TO_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_BATCH_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) UpperCamelCase_ = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=32 , ) UpperCamelCase_ = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule='scaled_linear' , clip_sample=_UpperCAmelCase , set_alpha_to_one=_UpperCAmelCase , ) torch.manual_seed(0 ) UpperCamelCase_ = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) UpperCamelCase_ = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) UpperCamelCase_ = CLIPTextModel(_UpperCAmelCase ) UpperCamelCase_ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) UpperCamelCase_ = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=0 ) -> List[Any]: if str(_UpperCAmelCase ).startswith('mps' ): UpperCamelCase_ = torch.manual_seed(_UpperCAmelCase ) else: UpperCamelCase_ = torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase ) UpperCamelCase_ = { 'prompt': '.', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 1.0, 'sag_scale': 1.0, 'output_type': 'numpy', } return inputs def _UpperCAmelCase ( self ) -> Tuple: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Tuple: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , width=768 , height=512 , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' , ) UpperCamelCase_ = output.images assert image.shape == (1, 512, 768, 3)
23
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) snake_case__ : List[Any] = { """configuration_roberta""": ["""ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RobertaConfig""", """RobertaOnnxConfig"""], """tokenization_roberta""": ["""RobertaTokenizer"""], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : List[str] = ["""RobertaTokenizerFast"""] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : str = [ """ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST""", """RobertaForCausalLM""", """RobertaForMaskedLM""", """RobertaForMultipleChoice""", """RobertaForQuestionAnswering""", """RobertaForSequenceClassification""", """RobertaForTokenClassification""", """RobertaModel""", """RobertaPreTrainedModel""", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : List[str] = [ """TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST""", """TFRobertaForCausalLM""", """TFRobertaForMaskedLM""", """TFRobertaForMultipleChoice""", """TFRobertaForQuestionAnswering""", """TFRobertaForSequenceClassification""", """TFRobertaForTokenClassification""", """TFRobertaMainLayer""", """TFRobertaModel""", """TFRobertaPreTrainedModel""", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """FlaxRobertaForCausalLM""", """FlaxRobertaForMaskedLM""", """FlaxRobertaForMultipleChoice""", """FlaxRobertaForQuestionAnswering""", """FlaxRobertaForSequenceClassification""", """FlaxRobertaForTokenClassification""", """FlaxRobertaModel""", """FlaxRobertaPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_roberta import ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, RobertaConfig, RobertaOnnxConfig from .tokenization_roberta import RobertaTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_roberta_fast import RobertaTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_roberta import ( ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST, RobertaForCausalLM, RobertaForMaskedLM, RobertaForMultipleChoice, RobertaForQuestionAnswering, RobertaForSequenceClassification, RobertaForTokenClassification, RobertaModel, RobertaPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_roberta import ( TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForMultipleChoice, TFRobertaForQuestionAnswering, TFRobertaForSequenceClassification, TFRobertaForTokenClassification, TFRobertaMainLayer, TFRobertaModel, TFRobertaPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_roberta import ( FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaModel, FlaxRobertaPreTrainedModel, ) else: import sys snake_case__ : List[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
from __future__ import annotations from sys import maxsize from typing import Generic, TypeVar snake_case__ : List[str] = TypeVar("""T""") def _snake_case (__lowercase): return (position - 1) // 2 def _snake_case (__lowercase): return (2 * position) + 1 def _snake_case (__lowercase): return (2 * position) + 2 class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = [] UpperCamelCase_ = {} UpperCamelCase_ = 0 def __len__( self ) -> int: return self.elements def __repr__( self ) -> str: return str(self.heap ) def _UpperCAmelCase ( self ) -> bool: # Check if the priority queue is empty return self.elements == 0 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an element with given priority to the queue self.heap.append((elem, weight) ) UpperCamelCase_ = self.elements self.elements += 1 self._bubble_up(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> T: # Remove and return the element with lowest weight (highest priority) if self.elements > 1: self._swap_nodes(0 , self.elements - 1 ) UpperCamelCase_ , UpperCamelCase_ = self.heap.pop() del self.position_map[elem] self.elements -= 1 if self.elements > 0: UpperCamelCase_ , UpperCamelCase_ = self.heap[0] self._bubble_down(_UpperCAmelCase ) return elem def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Update the weight of the given key UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ = (elem, weight) if position > 0: UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._bubble_up(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (upward movement) [to be used internally # only] UpperCamelCase_ = self.position_map[elem] if curr_pos == 0: return None UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_up(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (downward movement) [to be used # internally only] UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ = get_child_left_position(_UpperCAmelCase ) UpperCamelCase_ = get_child_right_position(_UpperCAmelCase ) if child_left_position < self.elements and child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < child_left_weight and child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) if child_left_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] if child_left_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) else: return None if child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Swap the nodes at the given positions UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ , UpperCamelCase_ = ( self.heap[nodea_pos], self.heap[nodea_pos], ) UpperCamelCase_ = nodea_pos UpperCamelCase_ = nodea_pos class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = {} UpperCamelCase_ = 0 def __repr__( self ) -> str: return str(self.connections ) def __len__( self ) -> int: return self.nodes def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Add a node in the graph if it is not in the graph if node not in self.connections: UpperCamelCase_ = {} self.nodes += 1 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an edge between 2 nodes in the graph self.add_node(_UpperCAmelCase ) self.add_node(_UpperCAmelCase ) UpperCamelCase_ = weight UpperCamelCase_ = weight def _snake_case (__lowercase , ): UpperCamelCase_ = {node: maxsize for node in graph.connections} UpperCamelCase_ = {node: None for node in graph.connections} UpperCamelCase_ = MinPriorityQueue() for node, weight in dist.items(): priority_queue.push(__lowercase , __lowercase) if priority_queue.is_empty(): return dist, parent # initialization UpperCamelCase_ = priority_queue.extract_min() UpperCamelCase_ = 0 for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node # running prim's algorithm while not priority_queue.is_empty(): UpperCamelCase_ = priority_queue.extract_min() for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node return dist, parent
23
1
def _snake_case (__lowercase , __lowercase): 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()
23
from __future__ import annotations import sys from collections import deque from typing import Generic, TypeVar snake_case__ : Dict = TypeVar("""T""") class _a ( Generic[T] ): """simple docstring""" A_ = 42 # Cache store of keys A_ = 42 # References of the keys in cache A_ = 10 # Maximum capacity of cache def __init__( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = deque() UpperCamelCase_ = set() if not n: UpperCamelCase_ = sys.maxsize elif n < 0: raise ValueError('n should be an integer greater than 0.' ) else: UpperCamelCase_ = n def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: if x not in self.key_reference: if len(self.dq_store ) == LRUCache._MAX_CAPACITY: UpperCamelCase_ = self.dq_store.pop() self.key_reference.remove(_UpperCAmelCase ) else: self.dq_store.remove(_UpperCAmelCase ) self.dq_store.appendleft(_UpperCAmelCase ) self.key_reference.add(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> None: for k in self.dq_store: print(_UpperCAmelCase ) def __repr__( self ) -> str: return f"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store )}""" if __name__ == "__main__": import doctest doctest.testmod() snake_case__ : LRUCache[str | int] = LRUCache(4) lru_cache.refer("""A""") lru_cache.refer(2) lru_cache.refer(3) lru_cache.refer("""A""") lru_cache.refer(4) lru_cache.refer(5) lru_cache.display() print(lru_cache) assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"
23
1
def _snake_case (__lowercase = 1000000): UpperCamelCase_ = [i - 1 for i in range(limit + 1)] for i in range(2 , limit + 1): if phi[i] == i - 1: for j in range(2 * i , limit + 1 , __lowercase): phi[j] -= phi[j] // i return sum(phi[2 : limit + 1]) if __name__ == "__main__": print(solution())
23
import numpy as np def _snake_case (__lowercase): return 1 / (1 + np.exp(-vector)) def _snake_case (__lowercase): return vector * sigmoid(__lowercase) if __name__ == "__main__": import doctest doctest.testmod()
23
1
import json import os from functools import lru_cache from typing import List, Optional, Tuple import regex as re from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import logging snake_case__ : Optional[Any] = logging.get_logger(__name__) snake_case__ : List[str] = {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""} # See all BART models at https://huggingface.co/models?filter=bart snake_case__ : str = { """vocab_file""": { """facebook/bart-base""": """https://huggingface.co/facebook/bart-base/resolve/main/vocab.json""", """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/vocab.json""", """facebook/bart-large-mnli""": """https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json""", """facebook/bart-large-cnn""": """https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json""", """facebook/bart-large-xsum""": """https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json""", """yjernite/bart_eli5""": """https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json""", }, """merges_file""": { """facebook/bart-base""": """https://huggingface.co/facebook/bart-base/resolve/main/merges.txt""", """facebook/bart-large""": """https://huggingface.co/facebook/bart-large/resolve/main/merges.txt""", """facebook/bart-large-mnli""": """https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt""", """facebook/bart-large-cnn""": """https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt""", """facebook/bart-large-xsum""": """https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt""", """yjernite/bart_eli5""": """https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt""", }, } snake_case__ : List[Any] = { """facebook/bart-base""": 1_0_2_4, """facebook/bart-large""": 1_0_2_4, """facebook/bart-large-mnli""": 1_0_2_4, """facebook/bart-large-cnn""": 1_0_2_4, """facebook/bart-large-xsum""": 1_0_2_4, """yjernite/bart_eli5""": 1_0_2_4, } @lru_cache() def _snake_case (): UpperCamelCase_ = ( list(range(ord('!') , ord('~') + 1)) + list(range(ord('¡') , ord('¬') + 1)) + list(range(ord('®') , ord('ÿ') + 1)) ) UpperCamelCase_ = bs[:] UpperCamelCase_ = 0 for b in range(2**8): if b not in bs: bs.append(__lowercase) cs.append(2**8 + n) n += 1 UpperCamelCase_ = [chr(__lowercase) for n in cs] return dict(zip(__lowercase , __lowercase)) def _snake_case (__lowercase): UpperCamelCase_ = set() UpperCamelCase_ = word[0] for char in word[1:]: pairs.add((prev_char, char)) UpperCamelCase_ = char return pairs class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = VOCAB_FILES_NAMES A_ = PRETRAINED_VOCAB_FILES_MAP A_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A_ = ["""input_ids""", """attention_mask"""] def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase="replace" , _UpperCAmelCase="<s>" , _UpperCAmelCase="</s>" , _UpperCAmelCase="</s>" , _UpperCAmelCase="<s>" , _UpperCAmelCase="<unk>" , _UpperCAmelCase="<pad>" , _UpperCAmelCase="<mask>" , _UpperCAmelCase=False , **_UpperCAmelCase , ) -> Optional[int]: UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else bos_token UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else eos_token UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else sep_token UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else cls_token UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else unk_token UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else pad_token # Mask token behave like a normal word, i.e. include the space before it UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else mask_token super().__init__( errors=_UpperCAmelCase , bos_token=_UpperCAmelCase , eos_token=_UpperCAmelCase , unk_token=_UpperCAmelCase , sep_token=_UpperCAmelCase , cls_token=_UpperCAmelCase , pad_token=_UpperCAmelCase , mask_token=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , **_UpperCAmelCase , ) with open(_UpperCAmelCase , encoding='utf-8' ) as vocab_handle: UpperCamelCase_ = json.load(_UpperCAmelCase ) UpperCamelCase_ = {v: k for k, v in self.encoder.items()} UpperCamelCase_ = errors # how to handle errors in decoding UpperCamelCase_ = bytes_to_unicode() UpperCamelCase_ = {v: k for k, v in self.byte_encoder.items()} with open(_UpperCAmelCase , encoding='utf-8' ) as merges_handle: UpperCamelCase_ = merges_handle.read().split('\n' )[1:-1] UpperCamelCase_ = [tuple(merge.split() ) for merge in bpe_merges] UpperCamelCase_ = dict(zip(_UpperCAmelCase , range(len(_UpperCAmelCase ) ) ) ) UpperCamelCase_ = {} UpperCamelCase_ = add_prefix_space # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions UpperCamelCase_ = re.compile(R'\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+' ) @property def _UpperCAmelCase ( self ) -> int: return len(self.encoder ) def _UpperCAmelCase ( self ) -> str: return dict(self.encoder , **self.added_tokens_encoder ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> str: if token in self.cache: return self.cache[token] UpperCamelCase_ = tuple(_UpperCAmelCase ) UpperCamelCase_ = get_pairs(_UpperCAmelCase ) if not pairs: return token while True: UpperCamelCase_ = min(_UpperCAmelCase , key=lambda _UpperCAmelCase : self.bpe_ranks.get(_UpperCAmelCase , float('inf' ) ) ) if bigram not in self.bpe_ranks: break UpperCamelCase_ , UpperCamelCase_ = bigram UpperCamelCase_ = [] UpperCamelCase_ = 0 while i < len(_UpperCAmelCase ): try: UpperCamelCase_ = word.index(_UpperCAmelCase , _UpperCAmelCase ) except ValueError: new_word.extend(word[i:] ) break else: new_word.extend(word[i:j] ) UpperCamelCase_ = j if word[i] == first and i < len(_UpperCAmelCase ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 UpperCamelCase_ = tuple(_UpperCAmelCase ) UpperCamelCase_ = new_word if len(_UpperCAmelCase ) == 1: break else: UpperCamelCase_ = get_pairs(_UpperCAmelCase ) UpperCamelCase_ = ' '.join(_UpperCAmelCase ) UpperCamelCase_ = word return word def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Any: UpperCamelCase_ = [] for token in re.findall(self.pat , _UpperCAmelCase ): UpperCamelCase_ = ''.join( self.byte_encoder[b] for b in token.encode('utf-8' ) ) # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case) bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_UpperCAmelCase ).split(' ' ) ) return bpe_tokens def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[str]: return self.encoder.get(_UpperCAmelCase , self.encoder.get(self.unk_token ) ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[Any]: return self.decoder.get(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = ''.join(_UpperCAmelCase ) UpperCamelCase_ = bytearray([self.byte_decoder[c] for c in text] ).decode('utf-8' , errors=self.errors ) return text def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> Tuple[str]: if not os.path.isdir(_UpperCAmelCase ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" ) return UpperCamelCase_ = os.path.join( _UpperCAmelCase , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) UpperCamelCase_ = os.path.join( _UpperCAmelCase , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file'] ) with open(_UpperCAmelCase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=_UpperCAmelCase , ensure_ascii=_UpperCAmelCase ) + '\n' ) UpperCamelCase_ = 0 with open(_UpperCAmelCase , '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 _UpperCAmelCase : 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!' ) UpperCamelCase_ = token_index writer.write(' '.join(_UpperCAmelCase ) + '\n' ) index += 1 return vocab_file, merge_file def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> List[int]: if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] UpperCamelCase_ = [self.cls_token_id] UpperCamelCase_ = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = False ) -> List[int]: if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=_UpperCAmelCase , token_ids_a=_UpperCAmelCase , already_has_special_tokens=_UpperCAmelCase ) if token_ids_a is None: return [1] + ([0] * len(_UpperCAmelCase )) + [1] return [1] + ([0] * len(_UpperCAmelCase )) + [1, 1] + ([0] * len(_UpperCAmelCase )) + [1] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> List[int]: UpperCamelCase_ = [self.sep_token_id] UpperCamelCase_ = [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 _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=False , **_UpperCAmelCase ) -> List[str]: UpperCamelCase_ = kwargs.pop('add_prefix_space' , self.add_prefix_space ) if (is_split_into_words or add_prefix_space) and (len(_UpperCAmelCase ) > 0 and not text[0].isspace()): UpperCamelCase_ = ' ' + text return (text, kwargs)
23
import math from datetime import datetime, timedelta def _snake_case (__lowercase): UpperCamelCase_ = year % 19 UpperCamelCase_ = year % 4 UpperCamelCase_ = year % 7 UpperCamelCase_ = math.floor(year / 100) UpperCamelCase_ = math.floor((13 + 8 * leap_day_inhibits) / 25) UpperCamelCase_ = leap_day_inhibits / 4 UpperCamelCase_ = ( 15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number ) % 30 UpperCamelCase_ = (4 + leap_day_inhibits - leap_day_reinstall_number) % 7 # days to be added to March 21 UpperCamelCase_ = (19 * metonic_cycle + secular_moon_shift) % 30 # PHM -> Paschal Full Moon UpperCamelCase_ = ( 2 * julian_leap_year + 4 * non_leap_year + 6 * days_to_add + century_starting_point ) % 7 if days_to_add == 29 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 19) elif days_to_add == 28 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 18) else: return datetime(__lowercase , 3 , 22) + timedelta( days=int(days_to_add + days_from_phm_to_sunday)) if __name__ == "__main__": for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3): snake_case__ : Dict = """will be""" if year > datetime.now().year else """was""" print(f'Easter in {year} {tense} {gauss_easter(year)}')
23
1
import tensorflow as tf from ...tf_utils import shape_list class _a ( tf.keras.layers.Layer ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=1 , _UpperCAmelCase=False , **_UpperCAmelCase ) -> str: super().__init__(**_UpperCAmelCase ) UpperCamelCase_ = vocab_size UpperCamelCase_ = d_embed UpperCamelCase_ = d_proj UpperCamelCase_ = cutoffs + [vocab_size] UpperCamelCase_ = [0] + self.cutoffs UpperCamelCase_ = div_val UpperCamelCase_ = self.cutoffs[0] UpperCamelCase_ = len(self.cutoffs ) - 1 UpperCamelCase_ = self.shortlist_size + self.n_clusters UpperCamelCase_ = keep_order UpperCamelCase_ = [] UpperCamelCase_ = [] def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Optional[int]: if self.n_clusters > 0: UpperCamelCase_ = self.add_weight( shape=(self.n_clusters, self.d_embed) , initializer='zeros' , trainable=_UpperCAmelCase , name='cluster_weight' ) UpperCamelCase_ = self.add_weight( shape=(self.n_clusters,) , initializer='zeros' , trainable=_UpperCAmelCase , name='cluster_bias' ) if self.div_val == 1: for i in range(len(self.cutoffs ) ): if self.d_proj != self.d_embed: UpperCamelCase_ = self.add_weight( shape=(self.d_embed, self.d_proj) , initializer='zeros' , trainable=_UpperCAmelCase , name=f"""out_projs_._{i}""" , ) self.out_projs.append(_UpperCAmelCase ) else: self.out_projs.append(_UpperCAmelCase ) UpperCamelCase_ = self.add_weight( shape=(self.vocab_size, self.d_embed) , initializer='zeros' , trainable=_UpperCAmelCase , name=f"""out_layers_._{i}_._weight""" , ) UpperCamelCase_ = self.add_weight( shape=(self.vocab_size,) , initializer='zeros' , trainable=_UpperCAmelCase , name=f"""out_layers_._{i}_._bias""" , ) self.out_layers.append((weight, bias) ) else: for i in range(len(self.cutoffs ) ): UpperCamelCase_ , UpperCamelCase_ = self.cutoff_ends[i], self.cutoff_ends[i + 1] UpperCamelCase_ = self.d_embed // (self.div_val**i) UpperCamelCase_ = self.add_weight( shape=(d_emb_i, self.d_proj) , initializer='zeros' , trainable=_UpperCAmelCase , name=f"""out_projs_._{i}""" ) self.out_projs.append(_UpperCAmelCase ) UpperCamelCase_ = self.add_weight( shape=(r_idx - l_idx, d_emb_i) , initializer='zeros' , trainable=_UpperCAmelCase , name=f"""out_layers_._{i}_._weight""" , ) UpperCamelCase_ = self.add_weight( shape=(r_idx - l_idx,) , initializer='zeros' , trainable=_UpperCAmelCase , name=f"""out_layers_._{i}_._bias""" , ) self.out_layers.append((weight, bias) ) super().build(_UpperCAmelCase ) @staticmethod def _UpperCAmelCase ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=None ) -> Dict: UpperCamelCase_ = x if proj is not None: UpperCamelCase_ = tf.einsum('ibd,ed->ibe' , _UpperCAmelCase , _UpperCAmelCase ) return tf.einsum('ibd,nd->ibn' , _UpperCAmelCase , _UpperCAmelCase ) + b @staticmethod def _UpperCAmelCase ( _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = shape_list(_UpperCAmelCase ) UpperCamelCase_ = tf.range(lp_size[0] , dtype=target.dtype ) UpperCamelCase_ = tf.stack([r, target] , 1 ) return tf.gather_nd(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=True , _UpperCAmelCase=False ) -> Tuple: UpperCamelCase_ = 0 if self.n_clusters == 0: UpperCamelCase_ = self._logit(_UpperCAmelCase , self.out_layers[0][0] , self.out_layers[0][1] , self.out_projs[0] ) if target is not None: UpperCamelCase_ = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=_UpperCAmelCase , logits=_UpperCAmelCase ) UpperCamelCase_ = tf.nn.log_softmax(_UpperCAmelCase , axis=-1 ) else: UpperCamelCase_ = shape_list(_UpperCAmelCase ) UpperCamelCase_ = [] UpperCamelCase_ = tf.zeros(hidden_sizes[:2] ) for i in range(len(self.cutoffs ) ): UpperCamelCase_ , UpperCamelCase_ = self.cutoff_ends[i], self.cutoff_ends[i + 1] if target is not None: UpperCamelCase_ = (target >= l_idx) & (target < r_idx) UpperCamelCase_ = tf.where(_UpperCAmelCase ) UpperCamelCase_ = tf.boolean_mask(_UpperCAmelCase , _UpperCAmelCase ) - l_idx if self.div_val == 1: UpperCamelCase_ = self.out_layers[0][0][l_idx:r_idx] UpperCamelCase_ = self.out_layers[0][1][l_idx:r_idx] else: UpperCamelCase_ = self.out_layers[i][0] UpperCamelCase_ = self.out_layers[i][1] if i == 0: UpperCamelCase_ = tf.concat([cur_W, self.cluster_weight] , 0 ) UpperCamelCase_ = tf.concat([cur_b, self.cluster_bias] , 0 ) UpperCamelCase_ = self._logit(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , self.out_projs[0] ) UpperCamelCase_ = tf.nn.log_softmax(_UpperCAmelCase ) out.append(head_logprob[..., : self.cutoffs[0]] ) if target is not None: UpperCamelCase_ = tf.boolean_mask(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = self._gather_logprob(_UpperCAmelCase , _UpperCAmelCase ) else: UpperCamelCase_ = self._logit(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , self.out_projs[i] ) UpperCamelCase_ = tf.nn.log_softmax(_UpperCAmelCase ) UpperCamelCase_ = self.cutoffs[0] + i - 1 # No probability for the head cluster UpperCamelCase_ = head_logprob[..., cluster_prob_idx, None] + tail_logprob out.append(_UpperCAmelCase ) if target is not None: UpperCamelCase_ = tf.boolean_mask(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = tf.boolean_mask(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = self._gather_logprob(_UpperCAmelCase , _UpperCAmelCase ) cur_logprob += cur_head_logprob[:, self.cutoff_ends[1] + i - 1] if target is not None: loss += tf.scatter_nd(_UpperCAmelCase , -cur_logprob , shape_list(_UpperCAmelCase ) ) UpperCamelCase_ = tf.concat(_UpperCAmelCase , axis=-1 ) if target is not None: if return_mean: UpperCamelCase_ = tf.reduce_mean(_UpperCAmelCase ) # Add the training-time loss value to the layer using `self.add_loss()`. self.add_loss(_UpperCAmelCase ) # Log the loss as a metric (we could log arbitrary metrics, # including different metrics for training and inference. self.add_metric(_UpperCAmelCase , name=self.name , aggregation='mean' if return_mean else '' ) return out
23
import requests def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = {'Content-Type': 'application/json'} UpperCamelCase_ = requests.post(__lowercase , json={'text': message_body} , headers=__lowercase) if response.status_code != 200: UpperCamelCase_ = ( 'Request to slack returned an error ' f"""{response.status_code}, the response is:\n{response.text}""" ) raise ValueError(__lowercase) if __name__ == "__main__": # Set the slack url to the one provided by Slack when you create the webhook at # https://my.slack.com/services/new/incoming-webhook/ send_slack_message("""<YOUR MESSAGE BODY>""", """<SLACK CHANNEL URL>""")
23
1
import inspect import os import unittest from pathlib import Path import torch import accelerate from accelerate.test_utils import execute_subprocess_async from accelerate.test_utils.testing import run_command class _a ( unittest.TestCase ): """simple docstring""" A_ = inspect.getfile(accelerate.test_utils ) A_ = os.path.sep.join(mod_file.split(os.path.sep )[:-1] + ["""scripts""", """test_cli.py"""] ) A_ = ["""accelerate""", """launch"""] A_ = Path.home() / """.cache/huggingface/accelerate""" A_ = """default_config.yaml""" A_ = config_folder / config_file A_ = config_folder / """_default_config.yaml""" A_ = Path("""tests/test_configs""" ) @classmethod def _UpperCAmelCase ( cls ) -> Dict: if cls.config_path.is_file(): cls.config_path.rename(cls.changed_path ) @classmethod def _UpperCAmelCase ( cls ) -> int: if cls.changed_path.is_file(): cls.changed_path.rename(cls.config_path ) def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ = self.base_cmd if torch.cuda.is_available() and (torch.cuda.device_count() > 1): cmd += ["--multi_gpu"] execute_subprocess_async(cmd + [self.test_file_path] , env=os.environ.copy() ) def _UpperCAmelCase ( self ) -> List[Any]: for config in sorted(self.test_config_path.glob('**/*.yaml' ) ): with self.subTest(config_file=_UpperCAmelCase ): execute_subprocess_async( self.base_cmd + ['--config_file', str(_UpperCAmelCase ), self.test_file_path] , env=os.environ.copy() ) def _UpperCAmelCase ( self ) -> List[Any]: execute_subprocess_async(['accelerate', 'test'] , env=os.environ.copy() ) class _a ( unittest.TestCase ): """simple docstring""" A_ = """test-tpu""" A_ = """us-central1-a""" A_ = """ls""" A_ = ["""accelerate""", """tpu-config"""] A_ = """cd /usr/share""" A_ = """tests/test_samples/test_command_file.sh""" A_ = """Running gcloud compute tpus tpu-vm ssh""" def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = run_command( self.cmd + ['--command', self.command, '--tpu_zone', self.tpu_zone, '--tpu_name', self.tpu_name, '--debug'] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = run_command( self.cmd + [ '--config_file', 'tests/test_configs/0_12_0.yaml', '--command', self.command, '--tpu_zone', self.tpu_zone, '--tpu_name', self.tpu_name, '--debug', ] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = run_command( self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--debug'] , return_stdout=_UpperCAmelCase ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = run_command( self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--command', self.command, '--debug'] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = run_command( self.cmd + [ '--config_file', 'tests/test_configs/latest.yaml', '--command', self.command, '--command', 'echo "Hello World"', '--debug', ] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; ls; echo \"Hello World\" --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = run_command( self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--command_file', self.command_file, '--debug'] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = run_command( self.cmd + [ '--config_file', 'tests/test_configs/0_12_0.yaml', '--command_file', self.command_file, '--tpu_zone', self.tpu_zone, '--tpu_name', self.tpu_name, '--debug', ] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; echo \"hello world\"; echo \"this is a second command\" --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = run_command( self.cmd + ['--config_file', 'tests/test_configs/latest.yaml', '--install_accelerate', '--debug'] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate -U; echo \"hello world\"; echo \"this is a second command\" --worker all""" , _UpperCAmelCase , ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = run_command( self.cmd + [ '--config_file', 'tests/test_configs/latest.yaml', '--install_accelerate', '--accelerate_version', '12.0.0', '--debug', ] , return_stdout=_UpperCAmelCase , ) self.assertIn( f"""{self.gcloud} test-tpu --zone us-central1-a --command {self.base_output}; pip install accelerate==12.0.0; echo \"hello world\"; echo \"this is a second command\" --worker all""" , _UpperCAmelCase , )
23
import re from pathlib import Path from unittest import TestCase import pytest @pytest.mark.integration class _a ( UpperCAmelCase__ ): """simple docstring""" def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)' ) UpperCamelCase_ = input_file.read() UpperCamelCase_ = regexp.search(_UpperCAmelCase ) return match def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()' , re.DOTALL ) UpperCamelCase_ = input_file.read() # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search` UpperCamelCase_ = regexp.finditer(_UpperCAmelCase ) UpperCamelCase_ = [match for match in matches if match is not None and match.group(1 ) is not None] return matches[0] if matches else None def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_encoding_on_file_open(str(_UpperCAmelCase ) ): raise AssertionError(f"""open(...) must use utf-8 encoding in {dataset}""" ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_print_statements(str(_UpperCAmelCase ) ): raise AssertionError(f"""print statement found in {dataset}. Use datasets.logger/logging instead.""" )
23
1
import os def _snake_case (): UpperCamelCase_ = os.path.dirname(os.path.realpath(__lowercase)) UpperCamelCase_ = os.path.join(__lowercase , 'triangle.txt') with open(__lowercase) as f: UpperCamelCase_ = f.readlines() UpperCamelCase_ = [] for line in triangle: UpperCamelCase_ = [] for number in line.strip().split(' '): numbers_from_line.append(int(__lowercase)) a.append(__lowercase) for i in range(1 , len(__lowercase)): for j in range(len(a[i])): UpperCamelCase_ = a[i - 1][j] if j != len(a[i - 1]) else 0 UpperCamelCase_ = a[i - 1][j - 1] if j > 0 else 0 a[i][j] += max(__lowercase , __lowercase) return max(a[-1]) if __name__ == "__main__": print(solution())
23
import argparse import random import joblib import numpy as np import torch from igf.igf import ( SecondaryLearner, collect_objective_set, compute_perplexity, generate_datasets, load_gpta, recopy_gpta, set_seed, train_secondary_learner, ) from torch.utils.data import DataLoader, RandomSampler from transformers import GPTaLMHeadModel def _snake_case (__lowercase=32 , __lowercase=10 , __lowercase=100 , __lowercase=1026 , __lowercase=True , __lowercase="data/tokenized_stories_train_wikitext103.jbl" , __lowercase="igf_context_pairs.jbl" , ): set_seed(3) # generate train_data and objective_set UpperCamelCase_ , UpperCamelCase_ = generate_datasets( __lowercase , __lowercase , number=__lowercase , min_len=1026 , trim=__lowercase) # keeps model same across runs set_seed(4) # model, lm_optimizer, lm_scheduler = recopy_gpt2(model, device, max_steps) # store original model weights # can we train on GPU? UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # load pretrained model UpperCamelCase_ = load_gpta('gpt2').to(__lowercase) print('computing perplexity on objective set') UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase).item() print('perplexity on objective set:' , __lowercase) # collect igf pairs and save to file demo.jbl collect_objective_set(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # clean up, delete model and data we don't need anymore del model, train_data, objective_set torch.cuda.empty_cache() def _snake_case (__lowercase , __lowercase=15 , __lowercase=128 , __lowercase=100 , __lowercase="igf_model.pt" , ): set_seed(42) # Load pre-trained model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') # Initialize secondary learner to use embedding weights of model UpperCamelCase_ = SecondaryLearner(__lowercase) # Train secondary learner UpperCamelCase_ = train_secondary_learner( __lowercase , __lowercase , max_epochs=__lowercase , batch_size=__lowercase , eval_freq=100 , igf_model_path=__lowercase , ) del model, secondary_learner_train_data torch.cuda.empty_cache() return secondary_learner def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=32 , __lowercase=1000 , __lowercase=16 , __lowercase=1.0 , __lowercase=recopy_gpta , __lowercase=None , __lowercase=10 , __lowercase="gpt2_finetuned.pt" , ): UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') UpperCamelCase_ = RandomSampler(__lowercase) UpperCamelCase_ = DataLoader(__lowercase , sampler=__lowercase) UpperCamelCase_ = max_steps // (len(__lowercase)) + 1 UpperCamelCase_ = 0 UpperCamelCase_ = torch.zeros((1, context_len) , dtype=torch.long , device=__lowercase) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = recopy_model(__lowercase , __lowercase , __lowercase) model.train() if secondary_learner is not None: secondary_learner.to(__lowercase) secondary_learner.eval() UpperCamelCase_ = [] UpperCamelCase_ = 0 UpperCamelCase_ = [] UpperCamelCase_ = [] # Compute the performance of the transformer model at the beginning UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) for epoch in range(int(__lowercase)): for step, example in enumerate(__lowercase): torch.cuda.empty_cache() UpperCamelCase_ = random.randint(0 , example.size(2) - context_len - 1) UpperCamelCase_ = example[0, 0, start : start + context_len] lm_optimizer.zero_grad() UpperCamelCase_ = model(__lowercase , labels=__lowercase) UpperCamelCase_ = True if secondary_learner is not None: UpperCamelCase_ = secondary_learner.forward( torch.tensor(__lowercase , dtype=torch.long , device=__lowercase).unsqueeze(0))[0].item() observed_qs.append(float(__lowercase)) # Here we implement the simple non-constant threshold for the predicted IG(X) value # We will decay the selectivity of our secondary learner filter from # 1 standard deviation above average to 1 below average after 10 batches. if global_step == 10: UpperCamelCase_ = -1 if predicted_q < threshold: UpperCamelCase_ = False # If we passed the filter, add the context to the batch! if do_backprop: contexts.append(np.array(context.cpu())) UpperCamelCase_ = outputs[0] lm_loss.backward() examples += 1 del outputs # Once the batch is filled with enough contexts, backprop on the batch. if examples == batch_size: torch.cuda.empty_cache() UpperCamelCase_ = 0 # Do LM backprop torch.nn.utils.clip_grad_norm_(model.parameters() , 3.0) lm_optimizer.step() lm_scheduler.step() # Update learning rate schedule global_step += 1 # Compute the performance of the transformer model at this batch if global_step % eval_interval == 0: UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) # Break out of the loop after 60 batches if max_steps > 0 and global_step > 60: break if max_steps > 0 and global_step > 60: break # save finetuned transformer model torch.save(model.state_dict() , __lowercase) torch.cuda.empty_cache() # Do some cleaning up so we can reinitialize for the next run of this function del lm_optimizer del lm_scheduler return model def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Fine-tune a transformer model with IGF on a language modeling task') # Required parameters parser.add_argument( '--data_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The input data dir. Should contain data files for WikiText.' , ) parser.add_argument( '--model_name_or_path' , default=__lowercase , type=__lowercase , required=__lowercase , help='Path to pretrained model or model identifier from huggingface.co/models' , ) parser.add_argument( '--data_file' , type=__lowercase , default=__lowercase , help=( 'A jbl file containing tokenized data which can be split as objective dataset, ' 'train_dataset and test_dataset.' ) , ) parser.add_argument( '--igf_data_file' , type=__lowercase , default=__lowercase , help='A jbl file containing the context and information gain pairs to train secondary learner.' , ) parser.add_argument( '--output_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The output directory where the final fine-tuned model is stored.' , ) parser.add_argument( '--tokenizer_name' , default=__lowercase , type=__lowercase , help='Pretrained tokenizer name or path if not the same as model_name' , ) parser.add_argument('--seed' , type=__lowercase , default=__lowercase , help='A seed for reproducible training.') parser.add_argument( '--context_len' , default=32 , type=__lowercase , help=( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) , ) parser.add_argument( '--size_objective_set' , default=100 , type=__lowercase , help='number of articles that are long enough to be used as our objective set' , ) parser.add_argument( '--eval_freq' , default=100 , type=__lowercase , help='secondary model evaluation is triggered at eval_freq') parser.add_argument('--max_steps' , default=1000 , type=__lowercase , help='To calculate training epochs') parser.add_argument( '--secondary_learner_batch_size' , default=128 , type=__lowercase , help='batch size of training data for secondary learner' , ) parser.add_argument( '--batch_size' , default=16 , type=__lowercase , help='batch size of training data of language model(gpt2) ') parser.add_argument( '--eval_interval' , default=10 , type=__lowercase , help=( 'decay the selectivity of our secondary learner filter from' '1 standard deviation above average to 1 below average after 10 batches' ) , ) parser.add_argument( '--number' , default=100 , type=__lowercase , help='The number of examples split to be used as objective_set/test_data') parser.add_argument( '--min_len' , default=1026 , type=__lowercase , help='The minimum length of the article to be used as objective set') parser.add_argument( '--secondary_learner_max_epochs' , default=15 , type=__lowercase , help='number of epochs to train secondary learner') parser.add_argument('--trim' , default=__lowercase , type=__lowercase , help='truncate the example if it exceeds context length') parser.add_argument( '--threshold' , default=1.0 , type=__lowercase , help=( 'The threshold value used by secondary learner to filter the train_data and allow only' ' informative data as input to the model' ) , ) parser.add_argument('--finetuned_model_name' , default='gpt2_finetuned.pt' , type=__lowercase , help='finetuned_model_name') parser.add_argument( '--recopy_model' , default=__lowercase , type=__lowercase , help='Reset the model to the original pretrained GPT-2 weights after each iteration' , ) # function calls # Collecting *n* pairs of context and information gain(X, IG(X)) for training the secondary learner generate_n_pairs( context_len=32 , max_steps=10 , size_objective_set=100 , min_len=1026 , trim=__lowercase , data_file='data/tokenized_stories_train_wikitext103.jbl' , igf_data_file='igf_context_pairs.jbl' , ) # Load train data for secondary learner UpperCamelCase_ = joblib.load('data/IGF_values.jbl') # Train secondary learner UpperCamelCase_ = training_secondary_learner( __lowercase , secondary_learner_max_epochs=15 , secondary_learner_batch_size=128 , eval_freq=100 , igf_model_path='igf_model.pt' , ) # load pretrained gpt2 model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') set_seed(42) # Generate train and test data to train and evaluate gpt2 model UpperCamelCase_ , UpperCamelCase_ = generate_datasets( context_len=32 , file='data/tokenized_stories_train_wikitext103.jbl' , number=100 , min_len=1026 , trim=__lowercase) # fine-tuning of the gpt2 model using igf (Information Gain Filtration) finetune( __lowercase , __lowercase , __lowercase , context_len=32 , max_steps=1000 , batch_size=16 , threshold=1.0 , recopy_model=__lowercase , secondary_learner=__lowercase , eval_interval=10 , finetuned_model_name='gpt2_finetuned.pt' , ) if __name__ == "__main__": main()
23
1
from ....configuration_utils import PretrainedConfig from ....utils import logging snake_case__ : List[Any] = logging.get_logger(__name__) # TODO: upload to AWS snake_case__ : List[str] = { """yjernite/retribert-base-uncased""": ( """https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/config.json""" ), } class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """retribert""" def __init__( self , _UpperCAmelCase=30522 , _UpperCAmelCase=768 , _UpperCAmelCase=8 , _UpperCAmelCase=12 , _UpperCAmelCase=3072 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=512 , _UpperCAmelCase=2 , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=1e-12 , _UpperCAmelCase=True , _UpperCAmelCase=128 , _UpperCAmelCase=0 , **_UpperCAmelCase , ) -> List[Any]: super().__init__(pad_token_id=_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = hidden_act UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = type_vocab_size UpperCamelCase_ = initializer_range UpperCamelCase_ = layer_norm_eps UpperCamelCase_ = share_encoders UpperCamelCase_ = projection_dim
23
from __future__ import annotations import unittest from transformers import AutoTokenizer, MBartConfig, is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel @require_tf class _a : """simple docstring""" A_ = MBartConfig A_ = {} A_ = """gelu""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=99 , _UpperCAmelCase=32 , _UpperCAmelCase=2 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=20 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , ) -> Union[str, Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = eos_token_id UpperCamelCase_ = pad_token_id UpperCamelCase_ = bos_token_id def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) UpperCamelCase_ = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ) , 1 ) UpperCamelCase_ = tf.concat([input_ids, eos_tensor] , axis=1 ) UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) UpperCamelCase_ = prepare_mbart_inputs_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = TFMBartModel(config=_UpperCAmelCase ).get_decoder() UpperCamelCase_ = inputs_dict['input_ids'] UpperCamelCase_ = input_ids[:1, :] UpperCamelCase_ = inputs_dict['attention_mask'][:1, :] UpperCamelCase_ = inputs_dict['head_mask'] UpperCamelCase_ = 1 # first forward pass UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , head_mask=_UpperCAmelCase , use_cache=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = outputs.to_tuple() UpperCamelCase_ = past_key_values[1] def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , ): if attention_mask is None: UpperCamelCase_ = tf.cast(tf.math.not_equal(__lowercase , config.pad_token_id) , tf.inta) if decoder_attention_mask is None: UpperCamelCase_ = tf.concat( [ tf.ones(decoder_input_ids[:, :1].shape , dtype=tf.inta), tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id) , tf.inta), ] , axis=-1 , ) if head_mask is None: UpperCamelCase_ = tf.ones((config.encoder_layers, config.encoder_attention_heads)) if decoder_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) if cross_attn_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } @require_tf class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else () A_ = (TFMBartForConditionalGeneration,) if is_tf_available() else () A_ = ( { """conversational""": TFMBartForConditionalGeneration, """feature-extraction""": TFMBartModel, """summarization""": TFMBartForConditionalGeneration, """text2text-generation""": TFMBartForConditionalGeneration, """translation""": TFMBartForConditionalGeneration, } if is_tf_available() else {} ) A_ = True A_ = False A_ = False def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: if pipeline_test_casse_name != "FeatureExtractionPipelineTests": # Exception encountered when calling layer '...' return True return False def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = TFMBartModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase ) @require_sentencepiece @require_tokenizers @require_tf class _a ( unittest.TestCase ): """simple docstring""" A_ = [ """ UN Chief Says There Is No Military Solution in Syria""", ] A_ = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", ] A_ = """facebook/mbart-large-en-ro""" @cached_property def _UpperCAmelCase ( self ) -> Any: return AutoTokenizer.from_pretrained(self.model_name ) @cached_property def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name ) return model def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> int: UpperCamelCase_ = self.translate_src_text(**_UpperCAmelCase ) self.assertListEqual(self.expected_text , _UpperCAmelCase ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> List[str]: UpperCamelCase_ = self.tokenizer(self.src_text , **_UpperCAmelCase , return_tensors='tf' ) UpperCamelCase_ = self.model.generate( model_inputs.input_ids , attention_mask=model_inputs.attention_mask , num_beams=2 ) UpperCamelCase_ = self.tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) return generated_words @slow def _UpperCAmelCase ( self ) -> List[Any]: self._assert_generated_batch_equal_expected()
23
1
import unittest import numpy as np from transformers import DistilBertConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask if is_flax_available(): import jax.numpy as jnp from transformers.models.distilbert.modeling_flax_distilbert import ( FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertModel, ) class _a ( unittest.TestCase ): """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=99 , _UpperCAmelCase=32 , _UpperCAmelCase=5 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=512 , _UpperCAmelCase=16 , _UpperCAmelCase=2 , _UpperCAmelCase=0.0_2 , _UpperCAmelCase=4 , ) -> int: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_attention_mask UpperCamelCase_ = use_token_type_ids UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = type_vocab_size UpperCamelCase_ = type_sequence_label_size UpperCamelCase_ = initializer_range UpperCamelCase_ = num_choices def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = None if self.use_attention_mask: UpperCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) UpperCamelCase_ = DistilBertConfig( vocab_size=self.vocab_size , dim=self.hidden_size , n_layers=self.num_hidden_layers , n_heads=self.num_attention_heads , hidden_dim=self.intermediate_size , hidden_act=self.hidden_act , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , tie_weights_=_UpperCAmelCase , ) return config, input_ids, attention_mask def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = config_and_inputs UpperCamelCase_ = {'input_ids': input_ids, 'attention_mask': attention_mask} return config, inputs_dict @require_flax class _a ( UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = ( ( FlaxDistilBertModel, FlaxDistilBertForMaskedLM, FlaxDistilBertForMultipleChoice, FlaxDistilBertForQuestionAnswering, FlaxDistilBertForSequenceClassification, FlaxDistilBertForTokenClassification, FlaxDistilBertForQuestionAnswering, ) if is_flax_available() else () ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = FlaxDistilBertModelTester(self ) @slow def _UpperCAmelCase ( self ) -> List[str]: for model_class_name in self.all_model_classes: UpperCamelCase_ = model_class_name.from_pretrained('distilbert-base-uncased' ) UpperCamelCase_ = model(np.ones((1, 1) ) ) self.assertIsNotNone(_UpperCAmelCase ) @require_flax class _a ( unittest.TestCase ): """simple docstring""" @slow def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = FlaxDistilBertModel.from_pretrained('distilbert-base-uncased' ) UpperCamelCase_ = np.array([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]] ) UpperCamelCase_ = np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase )[0] UpperCamelCase_ = (1, 11, 768) self.assertEqual(output.shape , _UpperCAmelCase ) UpperCamelCase_ = np.array([[[-0.1_6_3_9, 0.3_2_9_9, 0.1_6_4_8], [-0.1_7_4_6, 0.3_2_8_9, 0.1_7_1_0], [-0.1_8_8_4, 0.3_3_5_7, 0.1_8_1_0]]] ) self.assertTrue(jnp.allclose(output[:, 1:4, 1:4] , _UpperCAmelCase , atol=1e-4 ) )
23
def _snake_case (__lowercase): UpperCamelCase_ = 1 for i in range(1 , num + 1): fact *= i return fact def _snake_case (__lowercase): UpperCamelCase_ = 0 while number > 0: UpperCamelCase_ = number % 10 sum_of_digits += last_digit UpperCamelCase_ = number // 10 # Removing the last_digit from the given number return sum_of_digits def _snake_case (__lowercase = 100): UpperCamelCase_ = factorial(__lowercase) UpperCamelCase_ = split_and_add(__lowercase) return result if __name__ == "__main__": print(solution(int(input("""Enter the Number: """).strip())))
23
1
from typing import List, Optional import numpy as np from ...processing_utils import ProcessorMixin from ...utils import to_numpy class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """EncodecFeatureExtractor""" A_ = ("""T5Tokenizer""", """T5TokenizerFast""") def __init__( self , _UpperCAmelCase , _UpperCAmelCase ) -> int: super().__init__(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = self.feature_extractor UpperCamelCase_ = False def _UpperCAmelCase ( self , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=True ) -> List[str]: return self.tokenizer.get_decoder_prompt_ids(task=_UpperCAmelCase , language=_UpperCAmelCase , no_timestamps=_UpperCAmelCase ) def __call__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: # For backward compatibility if self._in_target_context_manager: return self.current_processor(*_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = kwargs.pop('audio' , _UpperCAmelCase ) UpperCamelCase_ = kwargs.pop('sampling_rate' , _UpperCAmelCase ) UpperCamelCase_ = kwargs.pop('text' , _UpperCAmelCase ) if len(_UpperCAmelCase ) > 0: UpperCamelCase_ = args[0] UpperCamelCase_ = args[1:] if audio is None and text is None: raise ValueError('You need to specify either an `audio` or `text` input to process.' ) if text is not None: UpperCamelCase_ = self.tokenizer(_UpperCAmelCase , **_UpperCAmelCase ) if audio is not None: UpperCamelCase_ = self.feature_extractor(_UpperCAmelCase , *_UpperCAmelCase , sampling_rate=_UpperCAmelCase , **_UpperCAmelCase ) if audio is None: return inputs elif text is None: return audio_inputs else: UpperCamelCase_ = audio_inputs['input_values'] if "padding_mask" in audio_inputs: UpperCamelCase_ = audio_inputs['padding_mask'] return inputs def _UpperCAmelCase ( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> int: UpperCamelCase_ = kwargs.pop('audio' , _UpperCAmelCase ) UpperCamelCase_ = kwargs.pop('padding_mask' , _UpperCAmelCase ) if len(_UpperCAmelCase ) > 0: UpperCamelCase_ = args[0] UpperCamelCase_ = args[1:] if audio_values is not None: return self._decode_audio(_UpperCAmelCase , padding_mask=_UpperCAmelCase ) else: return self.tokenizer.batch_decode(*_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Optional[Any]: return self.tokenizer.decode(*_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> List[np.ndarray]: UpperCamelCase_ = to_numpy(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = audio_values.shape if padding_mask is None: return list(_UpperCAmelCase ) UpperCamelCase_ = to_numpy(_UpperCAmelCase ) # match the sequence length of the padding mask to the generated audio arrays by padding with the **non-padding** # token (so that the generated audio values are **not** treated as padded tokens) UpperCamelCase_ = seq_len - padding_mask.shape[-1] UpperCamelCase_ = 1 - self.feature_extractor.padding_value UpperCamelCase_ = np.pad(_UpperCAmelCase , ((0, 0), (0, difference)) , 'constant' , constant_values=_UpperCAmelCase ) UpperCamelCase_ = audio_values.tolist() for i in range(_UpperCAmelCase ): UpperCamelCase_ = np.asarray(audio_values[i] )[ padding_mask[i][None, :] != self.feature_extractor.padding_value ] UpperCamelCase_ = sliced_audio.reshape(_UpperCAmelCase , -1 ) return audio_values
23
from typing import Dict, List, Optional, Union import numpy as np 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 TensorType, is_vision_available, logging if is_vision_available(): import PIL snake_case__ : str = logging.get_logger(__name__) def _snake_case (__lowercase): if isinstance(__lowercase , (list, tuple)) and isinstance(videos[0] , (list, tuple)) and is_valid_image(videos[0][0]): return videos elif isinstance(__lowercase , (list, tuple)) and is_valid_image(videos[0]): return [videos] elif is_valid_image(__lowercase): return [[videos]] raise ValueError(f"""Could not make batched video from {videos}""") class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = ["""pixel_values"""] def __init__( self , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = True , _UpperCAmelCase = 1 / 255 , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> None: super().__init__(**_UpperCAmelCase ) UpperCamelCase_ = size if size is not None else {'shortest_edge': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else {'height': 224, 'width': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) UpperCamelCase_ = do_resize UpperCamelCase_ = size UpperCamelCase_ = do_center_crop UpperCamelCase_ = crop_size UpperCamelCase_ = resample UpperCamelCase_ = do_rescale UpperCamelCase_ = rescale_factor UpperCamelCase_ = do_normalize UpperCamelCase_ = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN UpperCamelCase_ = image_std if image_std is not None else IMAGENET_STANDARD_STD def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) if "shortest_edge" in size: UpperCamelCase_ = get_resize_output_image_size(_UpperCAmelCase , size['shortest_edge'] , default_to_square=_UpperCAmelCase ) elif "height" in size and "width" in size: UpperCamelCase_ = (size['height'], size['width']) else: raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}""" ) return resize(_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase ) 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(_UpperCAmelCase , size=(size['height'], size['width']) , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> int: return rescale(_UpperCAmelCase , scale=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: return normalize(_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , ) -> np.ndarray: 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.' ) # All transformations expect numpy arrays. UpperCamelCase_ = to_numpy_array(_UpperCAmelCase ) if do_resize: UpperCamelCase_ = self.resize(image=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase ) if do_center_crop: UpperCamelCase_ = self.center_crop(_UpperCAmelCase , size=_UpperCAmelCase ) if do_rescale: UpperCamelCase_ = self.rescale(image=_UpperCAmelCase , scale=_UpperCAmelCase ) if do_normalize: UpperCamelCase_ = self.normalize(image=_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase ) UpperCamelCase_ = to_channel_dimension_format(_UpperCAmelCase , _UpperCAmelCase ) return image def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , **_UpperCAmelCase , ) -> PIL.Image.Image: UpperCamelCase_ = do_resize if do_resize is not None else self.do_resize UpperCamelCase_ = resample if resample is not None else self.resample UpperCamelCase_ = do_center_crop if do_center_crop is not None else self.do_center_crop UpperCamelCase_ = do_rescale if do_rescale is not None else self.do_rescale UpperCamelCase_ = rescale_factor if rescale_factor is not None else self.rescale_factor UpperCamelCase_ = do_normalize if do_normalize is not None else self.do_normalize UpperCamelCase_ = image_mean if image_mean is not None else self.image_mean UpperCamelCase_ = image_std if image_std is not None else self.image_std UpperCamelCase_ = size if size is not None else self.size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else self.crop_size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) if not valid_images(_UpperCAmelCase ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) UpperCamelCase_ = make_batched(_UpperCAmelCase ) UpperCamelCase_ = [ [ self._preprocess_image( image=_UpperCAmelCase , do_resize=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , do_center_crop=_UpperCAmelCase , crop_size=_UpperCAmelCase , do_rescale=_UpperCAmelCase , rescale_factor=_UpperCAmelCase , do_normalize=_UpperCAmelCase , image_mean=_UpperCAmelCase , image_std=_UpperCAmelCase , data_format=_UpperCAmelCase , ) for img in video ] for video in videos ] UpperCamelCase_ = {'pixel_values': videos} return BatchFeature(data=_UpperCAmelCase , tensor_type=_UpperCAmelCase )
23
1
import argparse import os import numpy as np import tensorflow as tf import torch from transformers import BertModel def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = ('dense.weight', 'attention.self.query', 'attention.self.key', 'attention.self.value') UpperCamelCase_ = ( ('layer.', 'layer_'), ('word_embeddings.weight', 'word_embeddings'), ('position_embeddings.weight', 'position_embeddings'), ('token_type_embeddings.weight', 'token_type_embeddings'), ('.', '/'), ('LayerNorm/weight', 'LayerNorm/gamma'), ('LayerNorm/bias', 'LayerNorm/beta'), ('weight', 'kernel'), ) if not os.path.isdir(__lowercase): os.makedirs(__lowercase) UpperCamelCase_ = model.state_dict() def to_tf_var_name(__lowercase): for patt, repl in iter(__lowercase): UpperCamelCase_ = name.replace(__lowercase , __lowercase) return f"""bert/{name}""" def create_tf_var(__lowercase , __lowercase , __lowercase): UpperCamelCase_ = tf.dtypes.as_dtype(tensor.dtype) UpperCamelCase_ = tf.get_variable(dtype=__lowercase , shape=tensor.shape , name=__lowercase , initializer=tf.zeros_initializer()) session.run(tf.variables_initializer([tf_var])) session.run(__lowercase) return tf_var tf.reset_default_graph() with tf.Session() as session: for var_name in state_dict: UpperCamelCase_ = to_tf_var_name(__lowercase) UpperCamelCase_ = state_dict[var_name].numpy() if any(x in var_name for x in tensors_to_transpose): UpperCamelCase_ = torch_tensor.T UpperCamelCase_ = create_tf_var(tensor=__lowercase , name=__lowercase , session=__lowercase) tf.keras.backend.set_value(__lowercase , __lowercase) UpperCamelCase_ = session.run(__lowercase) print(f"""Successfully created {tf_name}: {np.allclose(__lowercase , __lowercase)}""") UpperCamelCase_ = tf.train.Saver(tf.trainable_variables()) saver.save(__lowercase , os.path.join(__lowercase , model_name.replace('-' , '_') + '.ckpt')) def _snake_case (__lowercase=None): UpperCamelCase_ = argparse.ArgumentParser() parser.add_argument('--model_name' , type=__lowercase , required=__lowercase , help='model name e.g. bert-base-uncased') parser.add_argument( '--cache_dir' , type=__lowercase , default=__lowercase , required=__lowercase , help='Directory containing pytorch model') parser.add_argument('--pytorch_model_path' , type=__lowercase , required=__lowercase , help='/path/to/<pytorch-model-name>.bin') parser.add_argument('--tf_cache_dir' , type=__lowercase , required=__lowercase , help='Directory in which to save tensorflow model') UpperCamelCase_ = parser.parse_args(__lowercase) UpperCamelCase_ = BertModel.from_pretrained( pretrained_model_name_or_path=args.model_name , state_dict=torch.load(args.pytorch_model_path) , cache_dir=args.cache_dir , ) convert_pytorch_checkpoint_to_tf(model=__lowercase , ckpt_dir=args.tf_cache_dir , model_name=args.model_name) if __name__ == "__main__": main()
23
# 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 _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 A_ = 42 class _a ( UpperCAmelCase__ , UpperCAmelCase__ ): """simple docstring""" A_ = 1 @register_to_config def __init__( self , _UpperCAmelCase = 2000 , _UpperCAmelCase = 0.1_5 , _UpperCAmelCase = 0.0_1 , _UpperCAmelCase = 1_3_4_8.0 , _UpperCAmelCase = 1e-5 , _UpperCAmelCase = 1 , ) -> Tuple: # standard deviation of the initial noise distribution UpperCamelCase_ = sigma_max # setable values UpperCamelCase_ = None self.set_sigmas(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> torch.FloatTensor: return sample def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> str: UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps UpperCamelCase_ = torch.linspace(1 , _UpperCAmelCase , _UpperCAmelCase , device=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> Any: UpperCamelCase_ = sigma_min if sigma_min is not None else self.config.sigma_min UpperCamelCase_ = sigma_max if sigma_max is not None else self.config.sigma_max UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) UpperCamelCase_ = torch.exp(torch.linspace(math.log(_UpperCAmelCase ) , math.log(_UpperCAmelCase ) , _UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: return torch.where( timesteps == 0 , torch.zeros_like(t.to(timesteps.device ) ) , self.discrete_sigmas[timesteps - 1].to(timesteps.device ) , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SdeVeOutput, Tuple]: if self.timesteps is None: raise ValueError( '`self.timesteps` is not set, you need to run \'set_timesteps\' after creating the scheduler' ) UpperCamelCase_ = timestep * torch.ones( sample.shape[0] , device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) UpperCamelCase_ = (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 UpperCamelCase_ = timesteps.to(self.discrete_sigmas.device ) UpperCamelCase_ = self.discrete_sigmas[timesteps].to(sample.device ) UpperCamelCase_ = self.get_adjacent_sigma(_UpperCAmelCase , _UpperCAmelCase ).to(sample.device ) UpperCamelCase_ = torch.zeros_like(_UpperCAmelCase ) UpperCamelCase_ = (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 UpperCamelCase_ = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): UpperCamelCase_ = diffusion.unsqueeze(-1 ) UpperCamelCase_ = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of UpperCamelCase_ = randn_tensor( sample.shape , layout=sample.layout , generator=_UpperCAmelCase , device=sample.device , dtype=sample.dtype ) UpperCamelCase_ = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? UpperCamelCase_ = 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=_UpperCAmelCase , prev_sample_mean=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SchedulerOutput, Tuple]: 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 UpperCamelCase_ = randn_tensor(sample.shape , layout=sample.layout , generator=_UpperCAmelCase ).to(sample.device ) # compute step size from the model_output, the noise, and the snr UpperCamelCase_ = torch.norm(model_output.reshape(model_output.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = torch.norm(noise.reshape(noise.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 UpperCamelCase_ = 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 UpperCamelCase_ = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): UpperCamelCase_ = step_size.unsqueeze(-1 ) UpperCamelCase_ = sample + step_size * model_output UpperCamelCase_ = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , ) -> torch.FloatTensor: # Make sure sigmas and timesteps have the same device and dtype as original_samples UpperCamelCase_ = timesteps.to(original_samples.device ) UpperCamelCase_ = self.discrete_sigmas.to(original_samples.device )[timesteps] UpperCamelCase_ = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(_UpperCAmelCase ) * sigmas[:, None, None, None] ) UpperCamelCase_ = noise + original_samples return noisy_samples def __len__( self ) -> Optional[int]: return self.config.num_train_timesteps
23
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Dict = {"""configuration_sew""": ["""SEW_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SEWConfig"""]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : List[str] = [ """SEW_PRETRAINED_MODEL_ARCHIVE_LIST""", """SEWForCTC""", """SEWForSequenceClassification""", """SEWModel""", """SEWPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_sew import SEW_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_sew import ( SEW_PRETRAINED_MODEL_ARCHIVE_LIST, SEWForCTC, SEWForSequenceClassification, SEWModel, SEWPreTrainedModel, ) else: import sys snake_case__ : Dict = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Optional[int] = { """configuration_pegasus_x""": ["""PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusXConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST""", """PegasusXForConditionalGeneration""", """PegasusXModel""", """PegasusXPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys snake_case__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
1
import math from datetime import datetime, timedelta def _snake_case (__lowercase): UpperCamelCase_ = year % 19 UpperCamelCase_ = year % 4 UpperCamelCase_ = year % 7 UpperCamelCase_ = math.floor(year / 100) UpperCamelCase_ = math.floor((13 + 8 * leap_day_inhibits) / 25) UpperCamelCase_ = leap_day_inhibits / 4 UpperCamelCase_ = ( 15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number ) % 30 UpperCamelCase_ = (4 + leap_day_inhibits - leap_day_reinstall_number) % 7 # days to be added to March 21 UpperCamelCase_ = (19 * metonic_cycle + secular_moon_shift) % 30 # PHM -> Paschal Full Moon UpperCamelCase_ = ( 2 * julian_leap_year + 4 * non_leap_year + 6 * days_to_add + century_starting_point ) % 7 if days_to_add == 29 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 19) elif days_to_add == 28 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 18) else: return datetime(__lowercase , 3 , 22) + timedelta( days=int(days_to_add + days_from_phm_to_sunday)) if __name__ == "__main__": for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3): snake_case__ : Dict = """will be""" if year > datetime.now().year else """was""" print(f'Easter in {year} {tense} {gauss_easter(year)}')
23
import datasets from .evaluate import evaluate snake_case__ : int = """\ @article{hendrycks2021cuad, title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review}, author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball}, journal={arXiv preprint arXiv:2103.06268}, year={2021} } """ snake_case__ : Union[str, Any] = """ This metric wrap the official scoring script for version 1 of the Contract Understanding Atticus Dataset (CUAD). Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions. """ snake_case__ : Any = """ Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall). Args: predictions: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair as given in the references (see below) - 'prediction_text': list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction. references: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair (see above), - 'answers': a Dict in the CUAD dataset format { 'text': list of possible texts for the answer, as a list of strings 'answer_start': list of start positions for the answer, as a list of ints } Note that answer_start values are not taken into account to compute the metric. Returns: 'exact_match': Exact match (the normalized answer exactly match the gold answer) 'f1': The F-score of predicted tokens versus the gold answer 'aupr': Area Under the Precision-Recall curve 'prec_at_80_recall': Precision at 80% recall 'prec_at_90_recall': Precision at 90% recall Examples: >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> cuad_metric = datasets.load_metric(\"cuad\") >>> results = cuad_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _a ( datasets.Metric ): """simple docstring""" def _UpperCAmelCase ( self ) -> Optional[int]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': { 'id': datasets.Value('string' ), 'prediction_text': datasets.features.Sequence(datasets.Value('string' ) ), }, 'references': { 'id': datasets.Value('string' ), 'answers': datasets.features.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), }, } ) , codebase_urls=['https://www.atticusprojectai.org/cuad'] , reference_urls=['https://www.atticusprojectai.org/cuad'] , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = {prediction['id']: prediction['prediction_text'] for prediction in predictions} UpperCamelCase_ = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] UpperCamelCase_ = evaluate(dataset=_UpperCAmelCase , predictions=_UpperCAmelCase ) return score
23
1
from . import __version__ # Backward compatibility imports, to make sure all those objects can be found in file_utils from .utils import ( CLOUDFRONT_DISTRIB_PREFIX, CONFIG_NAME, DISABLE_TELEMETRY, DUMMY_INPUTS, DUMMY_MASK, ENV_VARS_TRUE_AND_AUTO_VALUES, ENV_VARS_TRUE_VALUES, FEATURE_EXTRACTOR_NAME, FLAX_WEIGHTS_NAME, HF_MODULES_CACHE, HUGGINGFACE_CO_PREFIX, HUGGINGFACE_CO_RESOLVE_ENDPOINT, MODEL_CARD_NAME, MULTIPLE_CHOICE_DUMMY_INPUTS, PYTORCH_PRETRAINED_BERT_CACHE, PYTORCH_TRANSFORMERS_CACHE, S3_BUCKET_PREFIX, SENTENCEPIECE_UNDERLINE, SPIECE_UNDERLINE, TF2_WEIGHTS_NAME, TF_WEIGHTS_NAME, TORCH_FX_REQUIRED_VERSION, TRANSFORMERS_CACHE, TRANSFORMERS_DYNAMIC_MODULE_NAME, USE_JAX, USE_TF, USE_TORCH, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ContextManagers, DummyObject, EntryNotFoundError, ExplicitEnum, ModelOutput, PaddingStrategy, PushToHubMixin, RepositoryNotFoundError, RevisionNotFoundError, TensorType, _LazyModule, add_code_sample_docstrings, add_end_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, cached_property, copy_func, default_cache_path, define_sagemaker_information, get_cached_models, get_file_from_repo, get_full_repo_name, get_torch_version, has_file, http_user_agent, is_apex_available, is_bsa_available, is_coloredlogs_available, is_datasets_available, is_detectrona_available, is_faiss_available, is_flax_available, is_ftfy_available, is_in_notebook, is_ipex_available, is_librosa_available, is_offline_mode, is_onnx_available, is_pandas_available, is_phonemizer_available, is_protobuf_available, is_psutil_available, is_pyanvml_available, is_pyctcdecode_available, is_pytesseract_available, is_pytorch_quantization_available, is_rjieba_available, is_sagemaker_dp_enabled, is_sagemaker_mp_enabled, is_scipy_available, is_sentencepiece_available, is_seqio_available, is_sklearn_available, is_soundfile_availble, is_spacy_available, is_speech_available, is_tensor, is_tensorflow_probability_available, is_tfaonnx_available, is_tf_available, is_timm_available, is_tokenizers_available, is_torch_available, is_torch_bfaa_available, is_torch_cuda_available, is_torch_fx_available, is_torch_fx_proxy, is_torch_mps_available, is_torch_tfaa_available, is_torch_tpu_available, is_torchaudio_available, is_training_run_on_sagemaker, is_vision_available, replace_return_docstrings, requires_backends, to_numpy, to_py_obj, torch_only_method, )
23
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import datasets import datasets.config from .utils import require_beam class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> List[str]: return datasets.DatasetInfo( features=datasets.Features({'content': datasets.Value('string' )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_dummy_examples()} )] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> Any: return datasets.DatasetInfo( features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: return [ datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_nested_examples()} ) ] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) def _snake_case (): return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar'])] def _snake_case (): return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['foo', 'bar', 'foobar'])] class _a ( UpperCAmelCase__ ): """simple docstring""" @require_beam def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_dummy_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_dummy_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> List[str]: import apache_beam as beam UpperCamelCase_ = beam.io.parquetio.WriteToParquet UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) with patch('apache_beam.io.parquetio.WriteToParquet' ) as write_parquet_mock: UpperCamelCase_ = partial(_UpperCAmelCase , num_shards=2 ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) # Order is not preserved when sharding, so we just check that all the elements are there self.assertListEqual(sorted(dset['train']['content'] ) , sorted(['foo', 'bar', 'foobar'] ) ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> Any: with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase ) self.assertRaises(datasets.builder.MissingBeamOptions , builder.download_and_prepare ) @require_beam def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = len(get_test_nested_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = NestedBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual( builder.info.features , datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_nested_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_nested_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset
23
1
import argparse import json from dataclasses import dataclass, field from functools import partial from pathlib import Path from typing import Callable, Dict, List, Tuple import timm import torch import torch.nn as nn from classy_vision.models.regnet import RegNet, RegNetParams, RegNetYaagf, RegNetYaagf, RegNetYaaagf from huggingface_hub import cached_download, hf_hub_url from torch import Tensor from vissl.models.model_helpers import get_trunk_forward_outputs from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel from transformers.utils import logging logging.set_verbosity_info() snake_case__ : Optional[Any] = logging.get_logger() @dataclass class _a : """simple docstring""" A_ = 42 A_ = field(default_factory=UpperCAmelCase__ ) A_ = field(default_factory=UpperCAmelCase__ ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> str: UpperCamelCase_ = len(list(m.modules() ) ) == 1 or isinstance(_UpperCAmelCase , nn.Convad ) or isinstance(_UpperCAmelCase , nn.BatchNormad ) if has_not_submodules: self.traced.append(_UpperCAmelCase ) def __call__( self , _UpperCAmelCase ) -> List[str]: for m in self.module.modules(): self.handles.append(m.register_forward_hook(self._forward_hook ) ) self.module(_UpperCAmelCase ) [x.remove() for x in self.handles] return self @property def _UpperCAmelCase ( self ) -> List[str]: # check the len of the state_dict keys to see if we have learnable params return list(filter(lambda _UpperCAmelCase : len(list(x.state_dict().keys() ) ) > 0 , self.traced ) ) @dataclass class _a : """simple docstring""" A_ = 42 A_ = 42 A_ = 1 A_ = field(default_factory=UpperCAmelCase__ ) A_ = field(default_factory=UpperCAmelCase__ ) A_ = True def __call__( self , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = Tracker(self.dest )(_UpperCAmelCase ).parametrized UpperCamelCase_ = Tracker(self.src )(_UpperCAmelCase ).parametrized UpperCamelCase_ = list(filter(lambda _UpperCAmelCase : type(_UpperCAmelCase ) not in self.src_skip , _UpperCAmelCase ) ) UpperCamelCase_ = list(filter(lambda _UpperCAmelCase : type(_UpperCAmelCase ) not in self.dest_skip , _UpperCAmelCase ) ) if len(_UpperCAmelCase ) != len(_UpperCAmelCase ) and self.raise_if_mismatch: raise Exception( f"""Numbers of operations are different. Source module has {len(_UpperCAmelCase )} operations while""" f""" destination module has {len(_UpperCAmelCase )}.""" ) for dest_m, src_m in zip(_UpperCAmelCase , _UpperCAmelCase ): dest_m.load_state_dict(src_m.state_dict() ) if self.verbose == 1: print(f"""Transfered from={src_m} to={dest_m}""" ) class _a ( nn.Module ): """simple docstring""" def __init__( self , _UpperCAmelCase ) -> Optional[Any]: super().__init__() UpperCamelCase_ = [] # - get the stem feature_blocks.append(('conv1', model.stem) ) # - get all the feature blocks for k, v in model.trunk_output.named_children(): assert k.startswith('block' ), f"""Unexpected layer name {k}""" UpperCamelCase_ = len(_UpperCAmelCase ) + 1 feature_blocks.append((f"""res{block_index}""", v) ) UpperCamelCase_ = nn.ModuleDict(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> List[str]: return get_trunk_forward_outputs( _UpperCAmelCase , out_feat_keys=_UpperCAmelCase , feature_blocks=self._feature_blocks , ) class _a ( UpperCAmelCase__ ): """simple docstring""" def _UpperCAmelCase ( self , _UpperCAmelCase ) -> str: UpperCamelCase_ = x.split('-' ) return x_split[0] + x_split[1] + "_" + "".join(x_split[2:] ) def __getitem__( self , _UpperCAmelCase ) -> Callable[[], Tuple[nn.Module, Dict]]: # default to timm! if x not in self: UpperCamelCase_ = self.convert_name_to_timm(_UpperCAmelCase ) UpperCamelCase_ = partial(lambda: (timm.create_model(_UpperCAmelCase , pretrained=_UpperCAmelCase ).eval(), None) ) else: UpperCamelCase_ = super().__getitem__(_UpperCAmelCase ) return val class _a ( UpperCAmelCase__ ): """simple docstring""" def __getitem__( self , _UpperCAmelCase ) -> Callable[[], nn.Module]: if "seer" in x and "in1k" not in x: UpperCamelCase_ = RegNetModel else: UpperCamelCase_ = RegNetForImageClassification return val def _snake_case (__lowercase , __lowercase , __lowercase): for from_key, to_key in keys: UpperCamelCase_ = from_state_dict[from_key].clone() print(f"""Copied key={from_key} to={to_key}""") return to_state_dict def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase = True , ): print(f"""Converting {name}...""") with torch.no_grad(): UpperCamelCase_ , UpperCamelCase_ = from_model_func() UpperCamelCase_ = our_model_func(__lowercase).eval() UpperCamelCase_ = ModuleTransfer(src=__lowercase , dest=__lowercase , raise_if_mismatch=__lowercase) UpperCamelCase_ = torch.randn((1, 3, 224, 224)) module_transfer(__lowercase) if from_state_dict is not None: UpperCamelCase_ = [] # for seer - in1k finetuned we have to manually copy the head if "seer" in name and "in1k" in name: UpperCamelCase_ = [('0.clf.0.weight', 'classifier.1.weight'), ('0.clf.0.bias', 'classifier.1.bias')] UpperCamelCase_ = manually_copy_vissl_head(__lowercase , our_model.state_dict() , __lowercase) our_model.load_state_dict(__lowercase) UpperCamelCase_ = our_model(__lowercase , output_hidden_states=__lowercase) UpperCamelCase_ = ( our_outputs.logits if isinstance(__lowercase , __lowercase) else our_outputs.last_hidden_state ) UpperCamelCase_ = from_model(__lowercase) UpperCamelCase_ = from_output[-1] if type(__lowercase) is list else from_output # now since I don't want to use any config files, vissl seer model doesn't actually have an head, so let's just check the last hidden state if "seer" in name and "in1k" in name: UpperCamelCase_ = our_outputs.hidden_states[-1] assert torch.allclose(__lowercase , __lowercase), "The model logits don't match the original one." if push_to_hub: our_model.push_to_hub( repo_path_or_name=save_directory / name , commit_message='Add model' , use_temp_dir=__lowercase , ) UpperCamelCase_ = 224 if 'seer' not in name else 384 # we can use the convnext one UpperCamelCase_ = AutoImageProcessor.from_pretrained('facebook/convnext-base-224-22k-1k' , size=__lowercase) image_processor.push_to_hub( repo_path_or_name=save_directory / name , commit_message='Add image processor' , use_temp_dir=__lowercase , ) print(f"""Pushed {name}""") def _snake_case (__lowercase , __lowercase = None , __lowercase = True): UpperCamelCase_ = 'imagenet-1k-id2label.json' UpperCamelCase_ = 1000 UpperCamelCase_ = (1, num_labels) UpperCamelCase_ = 'huggingface/label-files' UpperCamelCase_ = num_labels UpperCamelCase_ = json.load(open(cached_download(hf_hub_url(__lowercase , __lowercase , repo_type='dataset')) , 'r')) UpperCamelCase_ = {int(__lowercase): v for k, v in idalabel.items()} UpperCamelCase_ = idalabel UpperCamelCase_ = {v: k for k, v in idalabel.items()} UpperCamelCase_ = partial(__lowercase , num_labels=__lowercase , idalabel=__lowercase , labelaid=__lowercase) UpperCamelCase_ = { 'regnet-x-002': ImageNetPreTrainedConfig( depths=[1, 1, 4, 7] , hidden_sizes=[24, 56, 152, 368] , groups_width=8 , layer_type='x'), 'regnet-x-004': ImageNetPreTrainedConfig( depths=[1, 2, 7, 12] , hidden_sizes=[32, 64, 160, 384] , groups_width=16 , layer_type='x'), 'regnet-x-006': ImageNetPreTrainedConfig( depths=[1, 3, 5, 7] , hidden_sizes=[48, 96, 240, 528] , groups_width=24 , layer_type='x'), 'regnet-x-008': ImageNetPreTrainedConfig( depths=[1, 3, 7, 5] , hidden_sizes=[64, 128, 288, 672] , groups_width=16 , layer_type='x'), 'regnet-x-016': ImageNetPreTrainedConfig( depths=[2, 4, 10, 2] , hidden_sizes=[72, 168, 408, 912] , groups_width=24 , layer_type='x'), 'regnet-x-032': ImageNetPreTrainedConfig( depths=[2, 6, 15, 2] , hidden_sizes=[96, 192, 432, 1008] , groups_width=48 , layer_type='x'), 'regnet-x-040': ImageNetPreTrainedConfig( depths=[2, 5, 14, 2] , hidden_sizes=[80, 240, 560, 1360] , groups_width=40 , layer_type='x'), 'regnet-x-064': ImageNetPreTrainedConfig( depths=[2, 4, 10, 1] , hidden_sizes=[168, 392, 784, 1624] , groups_width=56 , layer_type='x'), 'regnet-x-080': ImageNetPreTrainedConfig( depths=[2, 5, 15, 1] , hidden_sizes=[80, 240, 720, 1920] , groups_width=120 , layer_type='x'), 'regnet-x-120': ImageNetPreTrainedConfig( depths=[2, 5, 11, 1] , hidden_sizes=[224, 448, 896, 2240] , groups_width=112 , layer_type='x'), 'regnet-x-160': ImageNetPreTrainedConfig( depths=[2, 6, 13, 1] , hidden_sizes=[256, 512, 896, 2048] , groups_width=128 , layer_type='x'), 'regnet-x-320': ImageNetPreTrainedConfig( depths=[2, 7, 13, 1] , hidden_sizes=[336, 672, 1344, 2520] , groups_width=168 , layer_type='x'), # y variant 'regnet-y-002': ImageNetPreTrainedConfig(depths=[1, 1, 4, 7] , hidden_sizes=[24, 56, 152, 368] , groups_width=8), 'regnet-y-004': ImageNetPreTrainedConfig( depths=[1, 3, 6, 6] , hidden_sizes=[48, 104, 208, 440] , groups_width=8), 'regnet-y-006': ImageNetPreTrainedConfig( depths=[1, 3, 7, 4] , hidden_sizes=[48, 112, 256, 608] , groups_width=16), 'regnet-y-008': ImageNetPreTrainedConfig( depths=[1, 3, 8, 2] , hidden_sizes=[64, 128, 320, 768] , groups_width=16), 'regnet-y-016': ImageNetPreTrainedConfig( depths=[2, 6, 17, 2] , hidden_sizes=[48, 120, 336, 888] , groups_width=24), 'regnet-y-032': ImageNetPreTrainedConfig( depths=[2, 5, 13, 1] , hidden_sizes=[72, 216, 576, 1512] , groups_width=24), 'regnet-y-040': ImageNetPreTrainedConfig( depths=[2, 6, 12, 2] , hidden_sizes=[128, 192, 512, 1088] , groups_width=64), 'regnet-y-064': ImageNetPreTrainedConfig( depths=[2, 7, 14, 2] , hidden_sizes=[144, 288, 576, 1296] , groups_width=72), 'regnet-y-080': ImageNetPreTrainedConfig( depths=[2, 4, 10, 1] , hidden_sizes=[168, 448, 896, 2016] , groups_width=56), 'regnet-y-120': ImageNetPreTrainedConfig( depths=[2, 5, 11, 1] , hidden_sizes=[224, 448, 896, 2240] , groups_width=112), 'regnet-y-160': ImageNetPreTrainedConfig( depths=[2, 4, 11, 1] , hidden_sizes=[224, 448, 1232, 3024] , groups_width=112), 'regnet-y-320': ImageNetPreTrainedConfig( depths=[2, 5, 12, 1] , hidden_sizes=[232, 696, 1392, 3712] , groups_width=232), # models created by SEER -> https://arxiv.org/abs/2202.08360 'regnet-y-320-seer': RegNetConfig(depths=[2, 5, 12, 1] , hidden_sizes=[232, 696, 1392, 3712] , groups_width=232), 'regnet-y-640-seer': RegNetConfig(depths=[2, 5, 12, 1] , hidden_sizes=[328, 984, 1968, 4920] , groups_width=328), 'regnet-y-1280-seer': RegNetConfig( depths=[2, 7, 17, 1] , hidden_sizes=[528, 1056, 2904, 7392] , groups_width=264), 'regnet-y-2560-seer': RegNetConfig( depths=[3, 7, 16, 1] , hidden_sizes=[640, 1696, 2544, 5088] , groups_width=640), 'regnet-y-10b-seer': ImageNetPreTrainedConfig( depths=[2, 7, 17, 1] , hidden_sizes=[2020, 4040, 11110, 28280] , groups_width=1010), # finetuned on imagenet 'regnet-y-320-seer-in1k': ImageNetPreTrainedConfig( depths=[2, 5, 12, 1] , hidden_sizes=[232, 696, 1392, 3712] , groups_width=232), 'regnet-y-640-seer-in1k': ImageNetPreTrainedConfig( depths=[2, 5, 12, 1] , hidden_sizes=[328, 984, 1968, 4920] , groups_width=328), 'regnet-y-1280-seer-in1k': ImageNetPreTrainedConfig( depths=[2, 7, 17, 1] , hidden_sizes=[528, 1056, 2904, 7392] , groups_width=264), 'regnet-y-2560-seer-in1k': ImageNetPreTrainedConfig( depths=[3, 7, 16, 1] , hidden_sizes=[640, 1696, 2544, 5088] , groups_width=640), 'regnet-y-10b-seer-in1k': ImageNetPreTrainedConfig( depths=[2, 7, 17, 1] , hidden_sizes=[2020, 4040, 11110, 28280] , groups_width=1010), } UpperCamelCase_ = NameToOurModelFuncMap() UpperCamelCase_ = NameToFromModelFuncMap() # add seer weights logic def load_using_classy_vision(__lowercase , __lowercase) -> Tuple[nn.Module, Dict]: UpperCamelCase_ = torch.hub.load_state_dict_from_url(__lowercase , model_dir=str(__lowercase) , map_location='cpu') UpperCamelCase_ = model_func() # check if we have a head, if yes add it UpperCamelCase_ = files['classy_state_dict']['base_model']['model'] UpperCamelCase_ = model_state_dict['trunk'] model.load_state_dict(__lowercase) return model.eval(), model_state_dict["heads"] # pretrained UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet32d/seer_regnet32gf_model_iteration244000.torch' , lambda: FakeRegNetVisslWrapper(RegNetYaagf()) , ) UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet64/seer_regnet64gf_model_final_checkpoint_phase0.torch' , lambda: FakeRegNetVisslWrapper(RegNetYaagf()) , ) UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/swav_ig1b_regnet128Gf_cnstant_bs32_node16_sinkhorn10_proto16k_syncBN64_warmup8k/model_final_checkpoint_phase0.torch' , lambda: FakeRegNetVisslWrapper(RegNetYaaagf()) , ) UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch' , lambda: FakeRegNetVisslWrapper( RegNet(RegNetParams(depth=27 , group_width=1010 , w_a=1744 , w_a=620.83 , w_m=2.52))) , ) # IN1K finetuned UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet32_finetuned_in1k_model_final_checkpoint_phase78.torch' , lambda: FakeRegNetVisslWrapper(RegNetYaagf()) , ) UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet64_finetuned_in1k_model_final_checkpoint_phase78.torch' , lambda: FakeRegNetVisslWrapper(RegNetYaagf()) , ) UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet128_finetuned_in1k_model_final_checkpoint_phase78.torch' , lambda: FakeRegNetVisslWrapper(RegNetYaaagf()) , ) UpperCamelCase_ = partial( __lowercase , 'https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch' , lambda: FakeRegNetVisslWrapper( RegNet(RegNetParams(depth=27 , group_width=1010 , w_a=1744 , w_a=620.83 , w_m=2.52))) , ) if model_name: convert_weight_and_push( __lowercase , names_to_from_model_map[model_name] , names_to_ours_model_map[model_name] , names_to_config[model_name] , __lowercase , __lowercase , ) else: for model_name, config in names_to_config.items(): convert_weight_and_push( __lowercase , names_to_from_model_map[model_name] , names_to_ours_model_map[model_name] , __lowercase , __lowercase , __lowercase , ) return config, expected_shape if __name__ == "__main__": snake_case__ : List[Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default=None, type=str, help=( """The name of the model you wish to convert, it must be one of the supported regnet* architecture,""" """ currently: regnetx-*, regnety-*. If `None`, all of them will the converted.""" ), ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=Path, required=True, help="""Path to the output PyTorch model directory.""", ) parser.add_argument( """--push_to_hub""", default=True, type=bool, required=False, help="""If True, push model and image processor to the hub.""", ) snake_case__ : Dict = parser.parse_args() snake_case__ : Path = args.pytorch_dump_folder_path pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True) convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
23
import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = AlbertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = AlbertForPreTraining(__lowercase) # Load weights from tf checkpoint load_tf_weights_in_albert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--albert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained ALBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : str = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
23
1
import enum import warnings from .. import MODEL_FOR_CAUSAL_LM_MAPPING, TF_MODEL_FOR_CAUSAL_LM_MAPPING from ..utils import add_end_docstrings, is_tf_available from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf class _a ( enum.Enum ): """simple docstring""" A_ = 0 A_ = 1 A_ = 2 @add_end_docstrings(UpperCAmelCase__ ) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """ In 1991, the remains of Russian Tsar Nicholas II and his family (except for Alexei and Maria) are discovered. The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the remainder of the story. 1883 Western Siberia, a young Grigori Rasputin is asked by his father and a group of men to perform magic. Rasputin has a vision and denounces one of the men as a horse thief. Although his father initially slaps him for making such an accusation, Rasputin watches as the man is chased outside and beaten. Twenty years later, Rasputin sees a vision of the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous, with people, even a bishop, begging for his blessing. <eod> </s> <eos> """ def __init__( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> List[str]: super().__init__(*_UpperCAmelCase , **_UpperCAmelCase ) self.check_model_type( TF_MODEL_FOR_CAUSAL_LM_MAPPING if self.framework == 'tf' else MODEL_FOR_CAUSAL_LM_MAPPING ) if "prefix" not in self._preprocess_params: # This is very specific. The logic is quite complex and needs to be done # as a "default". # It also defines both some preprocess_kwargs and generate_kwargs # which is why we cannot put them in their respective methods. UpperCamelCase_ = None if self.model.config.prefix is not None: UpperCamelCase_ = self.model.config.prefix if prefix is None and self.model.__class__.__name__ in [ "XLNetLMHeadModel", "TransfoXLLMHeadModel", "TFXLNetLMHeadModel", "TFTransfoXLLMHeadModel", ]: # For XLNet and TransformerXL we add an article to the prompt to give more state to the model. UpperCamelCase_ = self.XL_PREFIX if prefix is not None: # Recalculate some generate_kwargs linked to prefix. UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self._sanitize_parameters(prefix=_UpperCAmelCase , **self._forward_params ) UpperCamelCase_ = {**self._preprocess_params, **preprocess_params} UpperCamelCase_ = {**self._forward_params, **forward_params} def _UpperCAmelCase ( self , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , **_UpperCAmelCase , ) -> Any: UpperCamelCase_ = {} if prefix is not None: UpperCamelCase_ = prefix if prefix: UpperCamelCase_ = self.tokenizer( _UpperCAmelCase , padding=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , return_tensors=self.framework ) UpperCamelCase_ = prefix_inputs['input_ids'].shape[-1] if handle_long_generation is not None: if handle_long_generation not in {"hole"}: raise ValueError( f"""{handle_long_generation} is not a valid value for `handle_long_generation` parameter expected""" ' [None, \'hole\']' ) UpperCamelCase_ = handle_long_generation preprocess_params.update(_UpperCAmelCase ) UpperCamelCase_ = generate_kwargs UpperCamelCase_ = {} if return_full_text is not None and return_type is None: if return_text is not None: raise ValueError('`return_text` is mutually exclusive with `return_full_text`' ) if return_tensors is not None: raise ValueError('`return_full_text` is mutually exclusive with `return_tensors`' ) UpperCamelCase_ = ReturnType.FULL_TEXT if return_full_text else ReturnType.NEW_TEXT if return_tensors is not None and return_type is None: if return_text is not None: raise ValueError('`return_text` is mutually exclusive with `return_tensors`' ) UpperCamelCase_ = ReturnType.TENSORS if return_type is not None: UpperCamelCase_ = return_type if clean_up_tokenization_spaces is not None: UpperCamelCase_ = clean_up_tokenization_spaces if stop_sequence is not None: UpperCamelCase_ = self.tokenizer.encode(_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) if len(_UpperCAmelCase ) > 1: warnings.warn( 'Stopping on a multiple token sequence is not yet supported on transformers. The first token of' ' the stop sequence will be used as the stop sequence string in the interim.' ) UpperCamelCase_ = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def _UpperCAmelCase ( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> Any: # Parse arguments if self.model.__class__.__name__ in ["TransfoXLLMHeadModel"]: kwargs.update({'add_space_before_punct_symbol': True} ) return super()._parse_and_tokenize(*_UpperCAmelCase , **_UpperCAmelCase ) def __call__( self , _UpperCAmelCase , **_UpperCAmelCase ) -> Any: return super().__call__(_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase="" , _UpperCAmelCase=None , **_UpperCAmelCase ) -> Tuple: UpperCamelCase_ = self.tokenizer( prefix + prompt_text , padding=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase , return_tensors=self.framework ) UpperCamelCase_ = prompt_text if handle_long_generation == "hole": UpperCamelCase_ = inputs['input_ids'].shape[-1] if "max_new_tokens" in generate_kwargs: UpperCamelCase_ = generate_kwargs['max_new_tokens'] else: UpperCamelCase_ = generate_kwargs.get('max_length' , self.model.config.max_length ) - cur_len if new_tokens < 0: raise ValueError('We cannot infer how many new tokens are expected' ) if cur_len + new_tokens > self.tokenizer.model_max_length: UpperCamelCase_ = self.tokenizer.model_max_length - new_tokens if keep_length <= 0: raise ValueError( 'We cannot use `hole` to handle this generation the number of desired tokens exceeds the' ' models max length' ) UpperCamelCase_ = inputs['input_ids'][:, -keep_length:] if "attention_mask" in inputs: UpperCamelCase_ = inputs['attention_mask'][:, -keep_length:] return inputs def _UpperCAmelCase ( self , _UpperCAmelCase , **_UpperCAmelCase ) -> Dict: UpperCamelCase_ = model_inputs['input_ids'] UpperCamelCase_ = model_inputs.get('attention_mask' , _UpperCAmelCase ) # Allow empty prompts if input_ids.shape[1] == 0: UpperCamelCase_ = None UpperCamelCase_ = None UpperCamelCase_ = 1 else: UpperCamelCase_ = input_ids.shape[0] UpperCamelCase_ = model_inputs.pop('prompt_text' ) # If there is a prefix, we may need to adjust the generation length. Do so without permanently modifying # generate_kwargs, as some of the parameterization may come from the initialization of the pipeline. UpperCamelCase_ = generate_kwargs.pop('prefix_length' , 0 ) if prefix_length > 0: UpperCamelCase_ = 'max_new_tokens' in generate_kwargs or ( 'generation_config' in generate_kwargs and generate_kwargs['generation_config'].max_new_tokens is not None ) if not has_max_new_tokens: UpperCamelCase_ = generate_kwargs.get('max_length' ) or self.model.config.max_length generate_kwargs["max_length"] += prefix_length UpperCamelCase_ = 'min_new_tokens' in generate_kwargs or ( 'generation_config' in generate_kwargs and generate_kwargs['generation_config'].min_new_tokens is not None ) if not has_min_new_tokens and "min_length" in generate_kwargs: generate_kwargs["min_length"] += prefix_length # BS x SL UpperCamelCase_ = self.model.generate(input_ids=_UpperCAmelCase , attention_mask=_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = generated_sequence.shape[0] if self.framework == "pt": UpperCamelCase_ = generated_sequence.reshape(_UpperCAmelCase , out_b // in_b , *generated_sequence.shape[1:] ) elif self.framework == "tf": UpperCamelCase_ = tf.reshape(_UpperCAmelCase , (in_b, out_b // in_b, *generated_sequence.shape[1:]) ) return {"generated_sequence": generated_sequence, "input_ids": input_ids, "prompt_text": prompt_text} def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=ReturnType.FULL_TEXT , _UpperCAmelCase=True ) -> Optional[int]: UpperCamelCase_ = model_outputs['generated_sequence'][0] UpperCamelCase_ = model_outputs['input_ids'] UpperCamelCase_ = model_outputs['prompt_text'] UpperCamelCase_ = generated_sequence.numpy().tolist() UpperCamelCase_ = [] for sequence in generated_sequence: if return_type == ReturnType.TENSORS: UpperCamelCase_ = {'generated_token_ids': sequence} elif return_type in {ReturnType.NEW_TEXT, ReturnType.FULL_TEXT}: # Decode text UpperCamelCase_ = self.tokenizer.decode( _UpperCAmelCase , skip_special_tokens=_UpperCAmelCase , clean_up_tokenization_spaces=_UpperCAmelCase , ) # Remove PADDING prompt of the sequence if XLNet or Transfo-XL model is used if input_ids is None: UpperCamelCase_ = 0 else: UpperCamelCase_ = len( self.tokenizer.decode( input_ids[0] , skip_special_tokens=_UpperCAmelCase , clean_up_tokenization_spaces=_UpperCAmelCase , ) ) if return_type == ReturnType.FULL_TEXT: UpperCamelCase_ = prompt_text + text[prompt_length:] else: UpperCamelCase_ = text[prompt_length:] UpperCamelCase_ = {'generated_text': all_text} records.append(_UpperCAmelCase ) return records
23
from transformers import BertTokenizer, EncoderDecoderModel, SeqaSeqTrainer, SeqaSeqTrainingArguments from transformers.testing_utils import TestCasePlus, require_torch, slow from transformers.utils import is_datasets_available if is_datasets_available(): import datasets class _a ( UpperCAmelCase__ ): """simple docstring""" @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = EncoderDecoderModel.from_encoder_decoder_pretrained('prajjwal1/bert-tiny' , 'prajjwal1/bert-tiny' ) UpperCamelCase_ = BertTokenizer.from_pretrained('bert-base-uncased' ) UpperCamelCase_ = bertabert.config.encoder.vocab_size UpperCamelCase_ = tokenizer.sep_token_id UpperCamelCase_ = tokenizer.cls_token_id UpperCamelCase_ = 128 UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='train[:1%]' ) UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='validation[:1%]' ) UpperCamelCase_ = train_dataset.select(range(32 ) ) UpperCamelCase_ = val_dataset.select(range(16 ) ) UpperCamelCase_ = 4 def _map_to_encoder_decoder_inputs(_UpperCAmelCase ): # Tokenizer will automatically set [BOS] <text> [EOS] UpperCamelCase_ = tokenizer(batch['article'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=512 ) UpperCamelCase_ = tokenizer(batch['highlights'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=128 ) UpperCamelCase_ = inputs.input_ids UpperCamelCase_ = inputs.attention_mask UpperCamelCase_ = outputs.input_ids UpperCamelCase_ = outputs.input_ids.copy() UpperCamelCase_ = [ [-100 if token == tokenizer.pad_token_id else token for token in labels] for labels in batch['labels'] ] UpperCamelCase_ = outputs.attention_mask assert all(len(_UpperCAmelCase ) == 512 for x in inputs.input_ids ) assert all(len(_UpperCAmelCase ) == 128 for x in outputs.input_ids ) return batch def _compute_metrics(_UpperCAmelCase ): UpperCamelCase_ = pred.label_ids UpperCamelCase_ = pred.predictions # all unnecessary tokens are removed UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = sum([int(pred_str[i] == label_str[i] ) for i in range(len(_UpperCAmelCase ) )] ) / len(_UpperCAmelCase ) return {"accuracy": accuracy} # map train dataset UpperCamelCase_ = train_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) train_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) # same for validation dataset UpperCamelCase_ = val_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) val_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) UpperCamelCase_ = self.get_auto_remove_tmp_dir() UpperCamelCase_ = SeqaSeqTrainingArguments( output_dir=_UpperCAmelCase , per_device_train_batch_size=_UpperCAmelCase , per_device_eval_batch_size=_UpperCAmelCase , predict_with_generate=_UpperCAmelCase , evaluation_strategy='steps' , do_train=_UpperCAmelCase , do_eval=_UpperCAmelCase , warmup_steps=0 , eval_steps=2 , logging_steps=2 , ) # instantiate trainer UpperCamelCase_ = SeqaSeqTrainer( model=_UpperCAmelCase , args=_UpperCAmelCase , compute_metrics=_compute_metrics , train_dataset=_UpperCAmelCase , eval_dataset=_UpperCAmelCase , tokenizer=_UpperCAmelCase , ) # start training trainer.train()
23
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 _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 A_ = 42 class _a ( UpperCAmelCase__ , UpperCAmelCase__ ): """simple docstring""" A_ = 1 @register_to_config def __init__( self , _UpperCAmelCase = 2000 , _UpperCAmelCase = 0.1_5 , _UpperCAmelCase = 0.0_1 , _UpperCAmelCase = 1_3_4_8.0 , _UpperCAmelCase = 1e-5 , _UpperCAmelCase = 1 , ) -> Tuple: # standard deviation of the initial noise distribution UpperCamelCase_ = sigma_max # setable values UpperCamelCase_ = None self.set_sigmas(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> torch.FloatTensor: return sample def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> str: UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps UpperCamelCase_ = torch.linspace(1 , _UpperCAmelCase , _UpperCAmelCase , device=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> Any: UpperCamelCase_ = sigma_min if sigma_min is not None else self.config.sigma_min UpperCamelCase_ = sigma_max if sigma_max is not None else self.config.sigma_max UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) UpperCamelCase_ = torch.exp(torch.linspace(math.log(_UpperCAmelCase ) , math.log(_UpperCAmelCase ) , _UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: return torch.where( timesteps == 0 , torch.zeros_like(t.to(timesteps.device ) ) , self.discrete_sigmas[timesteps - 1].to(timesteps.device ) , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SdeVeOutput, Tuple]: if self.timesteps is None: raise ValueError( '`self.timesteps` is not set, you need to run \'set_timesteps\' after creating the scheduler' ) UpperCamelCase_ = timestep * torch.ones( sample.shape[0] , device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) UpperCamelCase_ = (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 UpperCamelCase_ = timesteps.to(self.discrete_sigmas.device ) UpperCamelCase_ = self.discrete_sigmas[timesteps].to(sample.device ) UpperCamelCase_ = self.get_adjacent_sigma(_UpperCAmelCase , _UpperCAmelCase ).to(sample.device ) UpperCamelCase_ = torch.zeros_like(_UpperCAmelCase ) UpperCamelCase_ = (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 UpperCamelCase_ = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): UpperCamelCase_ = diffusion.unsqueeze(-1 ) UpperCamelCase_ = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of UpperCamelCase_ = randn_tensor( sample.shape , layout=sample.layout , generator=_UpperCAmelCase , device=sample.device , dtype=sample.dtype ) UpperCamelCase_ = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? UpperCamelCase_ = 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=_UpperCAmelCase , prev_sample_mean=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SchedulerOutput, Tuple]: 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 UpperCamelCase_ = randn_tensor(sample.shape , layout=sample.layout , generator=_UpperCAmelCase ).to(sample.device ) # compute step size from the model_output, the noise, and the snr UpperCamelCase_ = torch.norm(model_output.reshape(model_output.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = torch.norm(noise.reshape(noise.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 UpperCamelCase_ = 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 UpperCamelCase_ = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): UpperCamelCase_ = step_size.unsqueeze(-1 ) UpperCamelCase_ = sample + step_size * model_output UpperCamelCase_ = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , ) -> torch.FloatTensor: # Make sure sigmas and timesteps have the same device and dtype as original_samples UpperCamelCase_ = timesteps.to(original_samples.device ) UpperCamelCase_ = self.discrete_sigmas.to(original_samples.device )[timesteps] UpperCamelCase_ = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(_UpperCAmelCase ) * sigmas[:, None, None, None] ) UpperCamelCase_ = noise + original_samples return noisy_samples def __len__( self ) -> Optional[int]: return self.config.num_train_timesteps
23
import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType ######################################################################## # This is a fully working simple example to use Accelerate # and perform gradient accumulation # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## snake_case__ : Dict = 1_6 snake_case__ : List[str] = 3_2 def _snake_case (__lowercase , __lowercase = 16): UpperCamelCase_ = AutoTokenizer.from_pretrained('bert-base-cased') UpperCamelCase_ = load_dataset('glue' , 'mrpc') def tokenize_function(__lowercase): # max_length=None => use the model max length (it's actually the default) UpperCamelCase_ = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=__lowercase , max_length=__lowercase) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): UpperCamelCase_ = datasets.map( __lowercase , batched=__lowercase , remove_columns=['idx', 'sentence1', 'sentence2'] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library UpperCamelCase_ = tokenized_datasets.rename_column('label' , 'labels') def collate_fn(__lowercase): # On TPU it's best to pad everything to the same length or training will be very slow. UpperCamelCase_ = 128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": UpperCamelCase_ = 16 elif accelerator.mixed_precision != "no": UpperCamelCase_ = 8 else: UpperCamelCase_ = None return tokenizer.pad( __lowercase , padding='longest' , max_length=__lowercase , pad_to_multiple_of=__lowercase , return_tensors='pt' , ) # Instantiate dataloaders. UpperCamelCase_ = DataLoader( tokenized_datasets['train'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) UpperCamelCase_ = DataLoader( tokenized_datasets['validation'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) return train_dataloader, eval_dataloader # For testing only if os.environ.get("""TESTING_MOCKED_DATALOADERS""", None) == "1": from accelerate.test_utils.training import mocked_dataloaders snake_case__ : List[str] = mocked_dataloaders # noqa: F811 def _snake_case (__lowercase , __lowercase): # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS' , __lowercase) == "1": UpperCamelCase_ = 2 # New Code # UpperCamelCase_ = int(args.gradient_accumulation_steps) # Initialize accelerator UpperCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=__lowercase) if accelerator.distributed_type == DistributedType.TPU and gradient_accumulation_steps > 1: raise NotImplementedError( 'Gradient accumulation on TPUs is currently not supported. Pass `gradient_accumulation_steps=1`') # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs UpperCamelCase_ = config['lr'] UpperCamelCase_ = int(config['num_epochs']) UpperCamelCase_ = int(config['seed']) UpperCamelCase_ = int(config['batch_size']) UpperCamelCase_ = evaluate.load('glue' , 'mrpc') set_seed(__lowercase) UpperCamelCase_ , UpperCamelCase_ = get_dataloaders(__lowercase , __lowercase) # Instantiate the model (we build the model here so that the seed also control new weights initialization) UpperCamelCase_ = AutoModelForSequenceClassification.from_pretrained('bert-base-cased' , return_dict=__lowercase) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). UpperCamelCase_ = model.to(accelerator.device) # Instantiate optimizer UpperCamelCase_ = AdamW(params=model.parameters() , lr=__lowercase) # Instantiate scheduler UpperCamelCase_ = get_linear_schedule_with_warmup( optimizer=__lowercase , num_warmup_steps=100 , num_training_steps=(len(__lowercase) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare( __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # Now we train the model for epoch in range(__lowercase): model.train() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(__lowercase): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = output.loss accelerator.backward(__lowercase) optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) with torch.no_grad(): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = outputs.logits.argmax(dim=-1) UpperCamelCase_ , UpperCamelCase_ = accelerator.gather_for_metrics((predictions, batch['labels'])) metric.add_batch( predictions=__lowercase , references=__lowercase , ) UpperCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , __lowercase) def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Simple example of training script.') parser.add_argument( '--mixed_precision' , type=__lowercase , default=__lowercase , choices=['no', 'fp16', 'bf16', 'fp8'] , help='Whether to use mixed precision. Choose' 'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.' 'and an Nvidia Ampere GPU.' , ) # New Code # parser.add_argument( '--gradient_accumulation_steps' , type=__lowercase , default=1 , help='The number of minibatches to be ran before gradients are accumulated.' , ) parser.add_argument('--cpu' , action='store_true' , help='If passed, will train on the CPU.') UpperCamelCase_ = parser.parse_args() UpperCamelCase_ = {'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(__lowercase , __lowercase) if __name__ == "__main__": main()
23
1
import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import MaskaFormerConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel if is_vision_available(): from transformers import MaskaFormerImageProcessor if is_vision_available(): from PIL import Image class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=2 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=10 , _UpperCAmelCase=3 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=4 , _UpperCAmelCase=64 , ) -> List[Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = is_training UpperCamelCase_ = use_auxiliary_loss UpperCamelCase_ = num_queries UpperCamelCase_ = num_channels UpperCamelCase_ = min_size UpperCamelCase_ = max_size UpperCamelCase_ = num_labels UpperCamelCase_ = hidden_dim UpperCamelCase_ = hidden_dim def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( _UpperCAmelCase ) UpperCamelCase_ = torch.ones([self.batch_size, self.min_size, self.max_size] , device=_UpperCAmelCase ) UpperCamelCase_ = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=_UpperCAmelCase ) > 0.5 ).float() UpperCamelCase_ = (torch.rand((self.batch_size, self.num_labels) , device=_UpperCAmelCase ) > 0.5).long() UpperCamelCase_ = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = MaskaFormerConfig( hidden_size=self.hidden_dim , ) UpperCamelCase_ = self.num_queries UpperCamelCase_ = self.num_labels UpperCamelCase_ = [1, 1, 1, 1] UpperCamelCase_ = self.num_channels UpperCamelCase_ = 64 UpperCamelCase_ = 128 UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim return config def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ = {'pixel_values': pixel_values, 'pixel_mask': pixel_mask} return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = output.encoder_hidden_states UpperCamelCase_ = output.pixel_decoder_hidden_states UpperCamelCase_ = output.transformer_decoder_hidden_states self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , config.decoder_layers ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False ) -> Any: with torch.no_grad(): UpperCamelCase_ = MaskaFormerModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.hidden_dim) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() def comm_check_on_output(_UpperCAmelCase ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) UpperCamelCase_ = model( pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else () A_ = {"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {} A_ = False A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , has_text_modality=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_UpperCAmelCase ) @unittest.skip(reason='Mask2Former does not use inputs_embeds' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method' ) def _UpperCAmelCase ( self ) -> Optional[int]: pass @unittest.skip(reason='Mask2Former is not a generative model' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not use token embeddings' ) def _UpperCAmelCase ( self ) -> Optional[Any]: pass @require_torch_multi_gpu @unittest.skip( reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' ) def _UpperCAmelCase ( self ) -> int: pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Tuple: for model_name in ["facebook/mask2former-swin-small-coco-instance"]: UpperCamelCase_ = MaskaFormerModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = (self.model_tester.min_size,) * 2 UpperCamelCase_ = { 'pixel_values': torch.randn((2, 3, *size) , device=_UpperCAmelCase ), 'mask_labels': torch.randn((2, 10, *size) , device=_UpperCAmelCase ), 'class_labels': torch.zeros(2 , 10 , device=_UpperCAmelCase ).long(), } UpperCamelCase_ = self.model_tester.get_config() UpperCamelCase_ = MaskaFormerForUniversalSegmentation(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None ) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase , output_attentions=_UpperCAmelCase ) self.assertTrue(outputs.attentions is not None ) def _UpperCAmelCase ( self ) -> List[Any]: if not self.model_tester.is_training: return UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = True UpperCamelCase_ = True UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) UpperCamelCase_ = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=_UpperCAmelCase ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) snake_case__ : List[Any] = 1E-4 def _snake_case (): UpperCamelCase_ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') return image @require_vision @slow class _a ( unittest.TestCase ): """simple docstring""" @cached_property def _UpperCAmelCase ( self ) -> Optional[int]: return "facebook/mask2former-swin-small-coco-instance" @cached_property def _UpperCAmelCase ( self ) -> List[str]: return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) UpperCamelCase_ = torch.tensor( [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) # masks_queries_logits UpperCamelCase_ = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) ) UpperCamelCase_ = [ [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1], [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1], [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5], ] UpperCamelCase_ = torch.tensor(_UpperCAmelCase ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) # class_queries_logits UpperCamelCase_ = outputs.class_queries_logits self.assertEqual(class_queries_logits.shape , (1, model.config.num_queries, model.config.num_labels + 1) ) UpperCamelCase_ = torch.tensor( [ [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2], [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3], [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5], ] ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = image_processor( [np.zeros((3, 800, 1333) ), np.zeros((3, 800, 1333) )] , segmentation_maps=[np.zeros((384, 384) ).astype(np.floataa ), np.zeros((384, 384) ).astype(np.floataa )] , return_tensors='pt' , ) UpperCamelCase_ = inputs['pixel_values'].to(_UpperCAmelCase ) UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['mask_labels']] UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['class_labels']] with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None )
23
import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import MaskaFormerConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel if is_vision_available(): from transformers import MaskaFormerImageProcessor if is_vision_available(): from PIL import Image class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=2 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=10 , _UpperCAmelCase=3 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=4 , _UpperCAmelCase=64 , ) -> List[Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = is_training UpperCamelCase_ = use_auxiliary_loss UpperCamelCase_ = num_queries UpperCamelCase_ = num_channels UpperCamelCase_ = min_size UpperCamelCase_ = max_size UpperCamelCase_ = num_labels UpperCamelCase_ = hidden_dim UpperCamelCase_ = hidden_dim def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( _UpperCAmelCase ) UpperCamelCase_ = torch.ones([self.batch_size, self.min_size, self.max_size] , device=_UpperCAmelCase ) UpperCamelCase_ = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=_UpperCAmelCase ) > 0.5 ).float() UpperCamelCase_ = (torch.rand((self.batch_size, self.num_labels) , device=_UpperCAmelCase ) > 0.5).long() UpperCamelCase_ = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = MaskaFormerConfig( hidden_size=self.hidden_dim , ) UpperCamelCase_ = self.num_queries UpperCamelCase_ = self.num_labels UpperCamelCase_ = [1, 1, 1, 1] UpperCamelCase_ = self.num_channels UpperCamelCase_ = 64 UpperCamelCase_ = 128 UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim return config def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ = {'pixel_values': pixel_values, 'pixel_mask': pixel_mask} return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = output.encoder_hidden_states UpperCamelCase_ = output.pixel_decoder_hidden_states UpperCamelCase_ = output.transformer_decoder_hidden_states self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , config.decoder_layers ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False ) -> Any: with torch.no_grad(): UpperCamelCase_ = MaskaFormerModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.hidden_dim) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() def comm_check_on_output(_UpperCAmelCase ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) UpperCamelCase_ = model( pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else () A_ = {"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {} A_ = False A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , has_text_modality=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_UpperCAmelCase ) @unittest.skip(reason='Mask2Former does not use inputs_embeds' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method' ) def _UpperCAmelCase ( self ) -> Optional[int]: pass @unittest.skip(reason='Mask2Former is not a generative model' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not use token embeddings' ) def _UpperCAmelCase ( self ) -> Optional[Any]: pass @require_torch_multi_gpu @unittest.skip( reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' ) def _UpperCAmelCase ( self ) -> int: pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Tuple: for model_name in ["facebook/mask2former-swin-small-coco-instance"]: UpperCamelCase_ = MaskaFormerModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = (self.model_tester.min_size,) * 2 UpperCamelCase_ = { 'pixel_values': torch.randn((2, 3, *size) , device=_UpperCAmelCase ), 'mask_labels': torch.randn((2, 10, *size) , device=_UpperCAmelCase ), 'class_labels': torch.zeros(2 , 10 , device=_UpperCAmelCase ).long(), } UpperCamelCase_ = self.model_tester.get_config() UpperCamelCase_ = MaskaFormerForUniversalSegmentation(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None ) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase , output_attentions=_UpperCAmelCase ) self.assertTrue(outputs.attentions is not None ) def _UpperCAmelCase ( self ) -> List[Any]: if not self.model_tester.is_training: return UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = True UpperCamelCase_ = True UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) UpperCamelCase_ = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=_UpperCAmelCase ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) snake_case__ : List[Any] = 1E-4 def _snake_case (): UpperCamelCase_ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') return image @require_vision @slow class _a ( unittest.TestCase ): """simple docstring""" @cached_property def _UpperCAmelCase ( self ) -> Optional[int]: return "facebook/mask2former-swin-small-coco-instance" @cached_property def _UpperCAmelCase ( self ) -> List[str]: return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) UpperCamelCase_ = torch.tensor( [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) # masks_queries_logits UpperCamelCase_ = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) ) UpperCamelCase_ = [ [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1], [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1], [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5], ] UpperCamelCase_ = torch.tensor(_UpperCAmelCase ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) # class_queries_logits UpperCamelCase_ = outputs.class_queries_logits self.assertEqual(class_queries_logits.shape , (1, model.config.num_queries, model.config.num_labels + 1) ) UpperCamelCase_ = torch.tensor( [ [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2], [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3], [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5], ] ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = image_processor( [np.zeros((3, 800, 1333) ), np.zeros((3, 800, 1333) )] , segmentation_maps=[np.zeros((384, 384) ).astype(np.floataa ), np.zeros((384, 384) ).astype(np.floataa )] , return_tensors='pt' , ) UpperCamelCase_ = inputs['pixel_values'].to(_UpperCAmelCase ) UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['mask_labels']] UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['class_labels']] with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None )
23
1
import time from contextlib import contextmanager from pathlib import Path import pytest import requests from huggingface_hub.hf_api import HfApi, HfFolder snake_case__ : Union[str, Any] = """__DUMMY_TRANSFORMERS_USER__""" snake_case__ : Optional[int] = """Dummy User""" snake_case__ : Any = """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""" snake_case__ : List[Any] = """https://hub-ci.huggingface.co""" snake_case__ : Dict = CI_HUB_ENDPOINT + """/datasets/{repo_id}/resolve/{revision}/{path}""" snake_case__ : Dict = CI_HUB_ENDPOINT + """/{repo_id}/resolve/{revision}/{filename}""" snake_case__ : Optional[int] = Path("""~/.huggingface/hub_ci_token""").expanduser() @pytest.fixture def _snake_case (__lowercase): monkeypatch.setattr( 'huggingface_hub.file_download.HUGGINGFACE_CO_URL_TEMPLATE' , __lowercase) @pytest.fixture def _snake_case (__lowercase): monkeypatch.setattr('datasets.config.HF_ENDPOINT' , __lowercase) monkeypatch.setattr('datasets.config.HUB_DATASETS_URL' , __lowercase) @pytest.fixture def _snake_case (__lowercase): monkeypatch.setattr('huggingface_hub.hf_api.HfFolder.path_token' , __lowercase) @pytest.fixture def _snake_case (__lowercase , __lowercase): HfFolder.save_token(__lowercase) yield HfFolder.delete_token() @pytest.fixture(scope='session') def _snake_case (): return HfApi(endpoint=__lowercase) @pytest.fixture(scope='session') def _snake_case (__lowercase): UpperCamelCase_ = HfFolder.get_token() HfFolder.save_token(__lowercase) yield CI_HUB_USER_TOKEN if previous_token is not None: HfFolder.save_token(__lowercase) @pytest.fixture def _snake_case (__lowercase): def _cleanup_repo(__lowercase): hf_api.delete_repo(__lowercase , token=__lowercase , repo_type='dataset') return _cleanup_repo @pytest.fixture def _snake_case (__lowercase): @contextmanager def _temporary_repo(__lowercase): try: yield repo_id finally: cleanup_repo(__lowercase) return _temporary_repo @pytest.fixture(scope='session') def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = f"""repo_txt_data-{int(time.time() * 10e3)}""" UpperCamelCase_ = f"""{CI_HUB_USER}/{repo_name}""" hf_api.create_repo(__lowercase , token=__lowercase , repo_type='dataset' , private=__lowercase) hf_api.upload_file( token=__lowercase , path_or_fileobj=str(__lowercase) , path_in_repo='data/text_data.txt' , repo_id=__lowercase , repo_type='dataset' , ) yield repo_id try: hf_api.delete_repo(__lowercase , token=__lowercase , repo_type='dataset') except (requests.exceptions.HTTPError, ValueError): # catch http error and token invalid error pass @pytest.fixture() def _snake_case (__lowercase , __lowercase , __lowercase): return hf_private_dataset_repo_txt_data_ @pytest.fixture(scope='session') def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = f"""repo_zipped_txt_data-{int(time.time() * 10e3)}""" UpperCamelCase_ = f"""{CI_HUB_USER}/{repo_name}""" hf_api.create_repo(__lowercase , token=__lowercase , repo_type='dataset' , private=__lowercase) hf_api.upload_file( token=__lowercase , path_or_fileobj=str(__lowercase) , path_in_repo='data.zip' , repo_id=__lowercase , repo_type='dataset' , ) yield repo_id try: hf_api.delete_repo(__lowercase , token=__lowercase , repo_type='dataset') except (requests.exceptions.HTTPError, ValueError): # catch http error and token invalid error pass @pytest.fixture() def _snake_case (__lowercase , __lowercase , __lowercase): return hf_private_dataset_repo_zipped_txt_data_ @pytest.fixture(scope='session') def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = f"""repo_zipped_img_data-{int(time.time() * 10e3)}""" UpperCamelCase_ = f"""{CI_HUB_USER}/{repo_name}""" hf_api.create_repo(__lowercase , token=__lowercase , repo_type='dataset' , private=__lowercase) hf_api.upload_file( token=__lowercase , path_or_fileobj=str(__lowercase) , path_in_repo='data.zip' , repo_id=__lowercase , repo_type='dataset' , ) yield repo_id try: hf_api.delete_repo(__lowercase , token=__lowercase , repo_type='dataset') except (requests.exceptions.HTTPError, ValueError): # catch http error and token invalid error pass @pytest.fixture() def _snake_case (__lowercase , __lowercase , __lowercase): return hf_private_dataset_repo_zipped_img_data_
23
import copy from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto.configuration_auto import AutoConfig if TYPE_CHECKING: from ... import PreTrainedTokenizerBase, TensorType snake_case__ : List[str] = logging.get_logger(__name__) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """vision-encoder-decoder""" A_ = True def __init__( self , **_UpperCAmelCase ) -> Dict: super().__init__(**_UpperCAmelCase ) if "encoder" not in kwargs or "decoder" not in kwargs: raise ValueError( f"""A configuraton of type {self.model_type} cannot be instantiated because """ f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}""" ) UpperCamelCase_ = kwargs.pop('encoder' ) UpperCamelCase_ = encoder_config.pop('model_type' ) UpperCamelCase_ = kwargs.pop('decoder' ) UpperCamelCase_ = decoder_config.pop('model_type' ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = True @classmethod def _UpperCAmelCase ( cls , _UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) -> PretrainedConfig: logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config' ) UpperCamelCase_ = True UpperCamelCase_ = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = copy.deepcopy(self.__dict__ ) UpperCamelCase_ = self.encoder.to_dict() UpperCamelCase_ = self.decoder.to_dict() UpperCamelCase_ = self.__class__.model_type return output class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = version.parse("""1.11""" ) @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) @property def _UpperCAmelCase ( self ) -> float: return 1e-4 @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict({'last_hidden_state': {0: 'batch', 1: 'encoder_sequence'}} ) class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: UpperCamelCase_ = OrderedDict() UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'encoder_sequence'} return common_inputs def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = -1 , _UpperCAmelCase = -1 , _UpperCAmelCase = False , _UpperCAmelCase = None , ) -> Mapping[str, Any]: import torch UpperCamelCase_ = OrderedDict() UpperCamelCase_ = super().generate_dummy_inputs( _UpperCAmelCase , batch_size=_UpperCAmelCase , seq_length=_UpperCAmelCase , is_pair=_UpperCAmelCase , framework=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = dummy_input['input_ids'].shape UpperCamelCase_ = (batch, encoder_sequence, self._config.encoder_hidden_size) UpperCamelCase_ = dummy_input.pop('input_ids' ) UpperCamelCase_ = dummy_input.pop('attention_mask' ) UpperCamelCase_ = torch.zeros(_UpperCAmelCase ) return common_inputs class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> None: pass def _UpperCAmelCase ( self , _UpperCAmelCase ) -> OnnxConfig: return VisionEncoderDecoderEncoderOnnxConfig(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = "default" ) -> OnnxConfig: UpperCamelCase_ = encoder_config.hidden_size return VisionEncoderDecoderDecoderOnnxConfig(_UpperCAmelCase , _UpperCAmelCase )
23
1
from ...utils import ( OptionalDependencyNotAvailable, is_torch_available, is_transformers_available, is_transformers_version, ) try: if not (is_transformers_available() and is_torch_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import KandinskyPipeline, KandinskyPriorPipeline else: from .pipeline_kandinsky import KandinskyPipeline from .pipeline_kandinsky_imgaimg import KandinskyImgaImgPipeline from .pipeline_kandinsky_inpaint import KandinskyInpaintPipeline from .pipeline_kandinsky_prior import KandinskyPriorPipeline, KandinskyPriorPipelineOutput from .text_encoder import MultilingualCLIP
23
import argparse import torch from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert from transformers.utils import logging logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = MobileBertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = MobileBertForPreTraining(__lowercase) # Load weights from tf checkpoint UpperCamelCase_ = load_tf_weights_in_mobilebert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--mobilebert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained MobileBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : Optional[Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
23
1
from abc import ABC, abstractmethod from argparse import ArgumentParser class _a ( UpperCAmelCase__ ): """simple docstring""" @staticmethod @abstractmethod def _UpperCAmelCase ( _UpperCAmelCase ) -> Union[str, Any]: raise NotImplementedError() @abstractmethod def _UpperCAmelCase ( self ) -> Union[str, Any]: raise NotImplementedError()
23
import gc import unittest from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline from transformers.pipelines import PipelineException from transformers.testing_utils import ( is_pipeline_test, is_torch_available, nested_simplify, require_tf, require_torch, require_torch_gpu, slow, ) from .test_pipelines_common import ANY @is_pipeline_test class _a ( unittest.TestCase ): """simple docstring""" A_ = MODEL_FOR_MASKED_LM_MAPPING A_ = TF_MODEL_FOR_MASKED_LM_MAPPING def _UpperCAmelCase ( self ) -> List[str]: super().tearDown() # clean-up as much as possible GPU memory occupied by PyTorch gc.collect() if is_torch_available(): import torch torch.cuda.empty_cache() @require_tf def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='tf' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped'}, {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped', }, { 'sequence': 'The largest city in France is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='pt' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul'}, {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', }, {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2941, 'token_str': ' Te'}, {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask> <mask>' , top_k=2 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is Maul<mask></s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'}, ], [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is<mask> Maul</s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'}, ], ] , ) @require_torch_gpu def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = pipeline('fill-mask' , model='hf-internal-testing/tiny-random-distilbert' , device=0 , framework='pt' ) # convert model to fp16 pipe.model.half() UpperCamelCase_ = pipe('Paris is the [MASK] of France.' ) # We actually don't care about the result, we just want to make sure # it works, meaning the float16 tensor got casted back to float32 # for postprocessing. self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='pt' ) self.run_large_test(_UpperCAmelCase ) @slow @require_tf def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='tf' ) self.run_large_test(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is John', 'score': 0.0_0_8, 'token': 610, 'token_str': ' John'}, {'sequence': 'My name is Chris', 'score': 0.0_0_7, 'token': 1573, 'token_str': ' Chris'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ { 'sequence': 'The largest city in France is Paris', 'score': 0.2_5_1, 'token': 2201, 'token_str': ' Paris', }, { 'sequence': 'The largest city in France is Lyon', 'score': 0.2_1_4, 'token': 12790, 'token_str': ' Lyon', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is Patrick', 'score': 0.0_0_5, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='pt' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) @require_tf def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='tf' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: if tokenizer is None or tokenizer.mask_token_id is None: self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)' ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = [ f"""This is another {tokenizer.mask_token} test""", ] return fill_masker, examples def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = fill_masker.tokenizer UpperCamelCase_ = fill_masker.model UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token}""" , ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}"""] ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""] ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , ) with self.assertRaises(_UpperCAmelCase ): fill_masker([None] ) # No mask_token is not supported with self.assertRaises(_UpperCAmelCase ): fill_masker('This is' ) self.run_test_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_targets(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_top_k_targets(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_duplicate_targets_and_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_multiple_masks(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = sorted(vocab.keys() )[:2] # Pipeline argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , targets=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Call argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Score equivalence UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['token_str'] for top_mask in outputs] UpperCamelCase_ = [top_mask['score'] for top_mask in outputs] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ) == set(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['score'] for top_mask in unmasked_targets] self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) # Raises with invalid with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[] ) # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised if "" not in tokenizer.get_vocab(): with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[''] ) with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets='' ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , top_k=2 ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) # top_k=2, ntargets=3 UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 , targets=_UpperCAmelCase ) # If we use the most probably targets, and filter differently, we should still # have the same results UpperCamelCase_ = [el['token_str'] for el in sorted(_UpperCAmelCase , key=lambda _UpperCAmelCase : x["score"] , reverse=_UpperCAmelCase )] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ).issubset(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=3 , targets=_UpperCAmelCase ) # They should yield exactly the same result self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.get_vocab() # String duplicates + id duplicates UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = [targets[0], targets[1], targets[0], targets[2], targets[1]] UpperCamelCase_ = fill_masker(f"""My name is {tokenizer.mask_token}""" , targets=_UpperCAmelCase , top_k=10 ) # The target list contains duplicates, so we can't output more # than them self.assertEqual(len(_UpperCAmelCase ) , 3 ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , )
23
1
def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = [1] for i in range(2 , __lowercase): factorials.append(factorials[-1] * i) assert 0 <= k < factorials[-1] * n, "k out of bounds" UpperCamelCase_ = [] UpperCamelCase_ = list(range(__lowercase)) # Find permutation while factorials: UpperCamelCase_ = factorials.pop() UpperCamelCase_ , UpperCamelCase_ = divmod(__lowercase , __lowercase) permutation.append(elements[number]) elements.remove(elements[number]) permutation.append(elements[0]) return permutation if __name__ == "__main__": import doctest doctest.testmod()
23
import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, StableDiffusionSAGPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = StableDiffusionSAGPipeline A_ = TEXT_TO_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_BATCH_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) UpperCamelCase_ = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=32 , ) UpperCamelCase_ = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule='scaled_linear' , clip_sample=_UpperCAmelCase , set_alpha_to_one=_UpperCAmelCase , ) torch.manual_seed(0 ) UpperCamelCase_ = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) UpperCamelCase_ = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) UpperCamelCase_ = CLIPTextModel(_UpperCAmelCase ) UpperCamelCase_ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) UpperCamelCase_ = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=0 ) -> List[Any]: if str(_UpperCAmelCase ).startswith('mps' ): UpperCamelCase_ = torch.manual_seed(_UpperCAmelCase ) else: UpperCamelCase_ = torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase ) UpperCamelCase_ = { 'prompt': '.', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 1.0, 'sag_scale': 1.0, 'output_type': 'numpy', } return inputs def _UpperCAmelCase ( self ) -> Tuple: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Tuple: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , width=768 , height=512 , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' , ) UpperCamelCase_ = output.images assert image.shape == (1, 512, 768, 3)
23
1
import argparse import json from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig from transformers.utils import logging logging.set_verbosity_info() snake_case__ : List[Any] = logging.get_logger(__name__) def _snake_case (__lowercase): # initialize config if "resnet-50" in model_name: UpperCamelCase_ = ResNetConfig.from_pretrained('microsoft/resnet-50') elif "resnet-101" in model_name: UpperCamelCase_ = ResNetConfig.from_pretrained('microsoft/resnet-101') else: raise ValueError('Model name should include either resnet50 or resnet101') UpperCamelCase_ = DetrConfig(use_timm_backbone=__lowercase , backbone_config=__lowercase) # set label attributes UpperCamelCase_ = 'panoptic' in model_name if is_panoptic: UpperCamelCase_ = 250 else: UpperCamelCase_ = 91 UpperCamelCase_ = 'huggingface/label-files' UpperCamelCase_ = 'coco-detection-id2label.json' UpperCamelCase_ = json.load(open(hf_hub_download(__lowercase , __lowercase , repo_type='dataset') , 'r')) UpperCamelCase_ = {int(__lowercase): v for k, v in idalabel.items()} UpperCamelCase_ = idalabel UpperCamelCase_ = {v: k for k, v in idalabel.items()} return config, is_panoptic def _snake_case (__lowercase): # here we list all keys to be renamed (original name on the left, our name on the right) UpperCamelCase_ = [] # stem # fmt: off rename_keys.append(('backbone.0.body.conv1.weight', 'backbone.conv_encoder.model.embedder.embedder.convolution.weight')) rename_keys.append(('backbone.0.body.bn1.weight', 'backbone.conv_encoder.model.embedder.embedder.normalization.weight')) rename_keys.append(('backbone.0.body.bn1.bias', 'backbone.conv_encoder.model.embedder.embedder.normalization.bias')) rename_keys.append(('backbone.0.body.bn1.running_mean', 'backbone.conv_encoder.model.embedder.embedder.normalization.running_mean')) rename_keys.append(('backbone.0.body.bn1.running_var', 'backbone.conv_encoder.model.embedder.embedder.normalization.running_var')) # stages for stage_idx in range(len(config.backbone_config.depths)): for layer_idx in range(config.backbone_config.depths[stage_idx]): # shortcut if layer_idx == 0: rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var""", )) # 3 convs for i in range(3): rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean""", )) rename_keys.append( ( f"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var""", f"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var""", )) # fmt: on for i in range(config.encoder_layers): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append( ( f"""transformer.encoder.layers.{i}.self_attn.out_proj.weight""", f"""encoder.layers.{i}.self_attn.out_proj.weight""", )) rename_keys.append( (f"""transformer.encoder.layers.{i}.self_attn.out_proj.bias""", f"""encoder.layers.{i}.self_attn.out_proj.bias""")) rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.weight""", f"""encoder.layers.{i}.fc1.weight""")) rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.bias""", f"""encoder.layers.{i}.fc1.bias""")) rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.weight""", f"""encoder.layers.{i}.fc2.weight""")) rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.bias""", f"""encoder.layers.{i}.fc2.bias""")) rename_keys.append( (f"""transformer.encoder.layers.{i}.norm1.weight""", f"""encoder.layers.{i}.self_attn_layer_norm.weight""")) rename_keys.append( (f"""transformer.encoder.layers.{i}.norm1.bias""", f"""encoder.layers.{i}.self_attn_layer_norm.bias""")) rename_keys.append( (f"""transformer.encoder.layers.{i}.norm2.weight""", f"""encoder.layers.{i}.final_layer_norm.weight""")) rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.bias""", f"""encoder.layers.{i}.final_layer_norm.bias""")) # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms rename_keys.append( ( f"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", f"""decoder.layers.{i}.self_attn.out_proj.weight""", )) rename_keys.append( (f"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", f"""decoder.layers.{i}.self_attn.out_proj.bias""")) rename_keys.append( ( f"""transformer.decoder.layers.{i}.multihead_attn.out_proj.weight""", f"""decoder.layers.{i}.encoder_attn.out_proj.weight""", )) rename_keys.append( ( f"""transformer.decoder.layers.{i}.multihead_attn.out_proj.bias""", f"""decoder.layers.{i}.encoder_attn.out_proj.bias""", )) rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.weight""", f"""decoder.layers.{i}.fc1.weight""")) rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.bias""", f"""decoder.layers.{i}.fc1.bias""")) rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.weight""", f"""decoder.layers.{i}.fc2.weight""")) rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.bias""", f"""decoder.layers.{i}.fc2.bias""")) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm1.weight""", f"""decoder.layers.{i}.self_attn_layer_norm.weight""")) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm1.bias""", f"""decoder.layers.{i}.self_attn_layer_norm.bias""")) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm2.weight""", f"""decoder.layers.{i}.encoder_attn_layer_norm.weight""")) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm2.bias""", f"""decoder.layers.{i}.encoder_attn_layer_norm.bias""")) rename_keys.append( (f"""transformer.decoder.layers.{i}.norm3.weight""", f"""decoder.layers.{i}.final_layer_norm.weight""")) rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.bias""", f"""decoder.layers.{i}.final_layer_norm.bias""")) # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads rename_keys.extend( [ ('input_proj.weight', 'input_projection.weight'), ('input_proj.bias', 'input_projection.bias'), ('query_embed.weight', 'query_position_embeddings.weight'), ('transformer.decoder.norm.weight', 'decoder.layernorm.weight'), ('transformer.decoder.norm.bias', 'decoder.layernorm.bias'), ('class_embed.weight', 'class_labels_classifier.weight'), ('class_embed.bias', 'class_labels_classifier.bias'), ('bbox_embed.layers.0.weight', 'bbox_predictor.layers.0.weight'), ('bbox_embed.layers.0.bias', 'bbox_predictor.layers.0.bias'), ('bbox_embed.layers.1.weight', 'bbox_predictor.layers.1.weight'), ('bbox_embed.layers.1.bias', 'bbox_predictor.layers.1.bias'), ('bbox_embed.layers.2.weight', 'bbox_predictor.layers.2.weight'), ('bbox_embed.layers.2.bias', 'bbox_predictor.layers.2.bias'), ]) return rename_keys def _snake_case (__lowercase , __lowercase , __lowercase): UpperCamelCase_ = state_dict.pop(__lowercase) UpperCamelCase_ = val def _snake_case (__lowercase , __lowercase=False): UpperCamelCase_ = '' if is_panoptic: UpperCamelCase_ = 'detr.' # first: transformer encoder for i in range(6): # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias) UpperCamelCase_ = state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight""") UpperCamelCase_ = state_dict.pop(f"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias""") # next, add query, keys and values (in that order) to the state dict UpperCamelCase_ = in_proj_weight[:256, :] UpperCamelCase_ = in_proj_bias[:256] UpperCamelCase_ = in_proj_weight[256:512, :] UpperCamelCase_ = in_proj_bias[256:512] UpperCamelCase_ = in_proj_weight[-256:, :] UpperCamelCase_ = in_proj_bias[-256:] # next: transformer decoder (which is a bit more complex because it also includes cross-attention) for i in range(6): # read in weights + bias of input projection layer of self-attention UpperCamelCase_ = state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight""") UpperCamelCase_ = state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias""") # next, add query, keys and values (in that order) to the state dict UpperCamelCase_ = in_proj_weight[:256, :] UpperCamelCase_ = in_proj_bias[:256] UpperCamelCase_ = in_proj_weight[256:512, :] UpperCamelCase_ = in_proj_bias[256:512] UpperCamelCase_ = in_proj_weight[-256:, :] UpperCamelCase_ = in_proj_bias[-256:] # read in weights + bias of input projection layer of cross-attention UpperCamelCase_ = state_dict.pop( f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight""") UpperCamelCase_ = state_dict.pop(f"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias""") # next, add query, keys and values (in that order) of cross-attention to the state dict UpperCamelCase_ = in_proj_weight_cross_attn[:256, :] UpperCamelCase_ = in_proj_bias_cross_attn[:256] UpperCamelCase_ = in_proj_weight_cross_attn[256:512, :] UpperCamelCase_ = in_proj_bias_cross_attn[256:512] UpperCamelCase_ = in_proj_weight_cross_attn[-256:, :] UpperCamelCase_ = in_proj_bias_cross_attn[-256:] def _snake_case (): UpperCamelCase_ = 'http://images.cocodataset.org/val2017/000000039769.jpg' UpperCamelCase_ = Image.open(requests.get(__lowercase , stream=__lowercase).raw) return im @torch.no_grad() def _snake_case (__lowercase , __lowercase=None , __lowercase=False): UpperCamelCase_ , UpperCamelCase_ = get_detr_config(__lowercase) # load original model from torch hub UpperCamelCase_ = { 'detr-resnet-50': 'detr_resnet50', 'detr-resnet-101': 'detr_resnet101', } logger.info(f"""Converting model {model_name}...""") UpperCamelCase_ = torch.hub.load('facebookresearch/detr' , model_name_to_original_name[model_name] , pretrained=__lowercase).eval() UpperCamelCase_ = detr.state_dict() # rename keys for src, dest in create_rename_keys(__lowercase): if is_panoptic: UpperCamelCase_ = 'detr.' + src rename_key(__lowercase , __lowercase , __lowercase) # query, key and value matrices need special treatment read_in_q_k_v(__lowercase , is_panoptic=__lowercase) # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them UpperCamelCase_ = 'detr.model.' if is_panoptic else 'model.' for key in state_dict.copy().keys(): if is_panoptic: if ( key.startswith('detr') and not key.startswith('class_labels_classifier') and not key.startswith('bbox_predictor') ): UpperCamelCase_ = state_dict.pop(__lowercase) UpperCamelCase_ = val elif "class_labels_classifier" in key or "bbox_predictor" in key: UpperCamelCase_ = state_dict.pop(__lowercase) UpperCamelCase_ = val elif key.startswith('bbox_attention') or key.startswith('mask_head'): continue else: UpperCamelCase_ = state_dict.pop(__lowercase) UpperCamelCase_ = val else: if not key.startswith('class_labels_classifier') and not key.startswith('bbox_predictor'): UpperCamelCase_ = state_dict.pop(__lowercase) UpperCamelCase_ = val # finally, create HuggingFace model and load state dict UpperCamelCase_ = DetrForSegmentation(__lowercase) if is_panoptic else DetrForObjectDetection(__lowercase) model.load_state_dict(__lowercase) model.eval() # verify our conversion on an image UpperCamelCase_ = 'coco_panoptic' if is_panoptic else 'coco_detection' UpperCamelCase_ = DetrImageProcessor(format=__lowercase) UpperCamelCase_ = processor(images=prepare_img() , return_tensors='pt') UpperCamelCase_ = encoding['pixel_values'] UpperCamelCase_ = detr(__lowercase) UpperCamelCase_ = model(__lowercase) assert torch.allclose(outputs.logits , original_outputs['pred_logits'] , atol=1e-3) assert torch.allclose(outputs.pred_boxes , original_outputs['pred_boxes'] , atol=1e-3) if is_panoptic: assert torch.allclose(outputs.pred_masks , original_outputs['pred_masks'] , atol=1e-4) print('Looks ok!') if pytorch_dump_folder_path is not None: # Save model and image processor logger.info(f"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}...""") Path(__lowercase).mkdir(exist_ok=__lowercase) model.save_pretrained(__lowercase) processor.save_pretrained(__lowercase) if push_to_hub: # Upload model and image processor to the hub logger.info('Uploading PyTorch model and image processor to the hub...') model.push_to_hub(f"""nielsr/{model_name}""") processor.push_to_hub(f"""nielsr/{model_name}""") if __name__ == "__main__": snake_case__ : Any = argparse.ArgumentParser() parser.add_argument( """--model_name""", default="""detr-resnet-50""", type=str, choices=["""detr-resnet-50""", """detr-resnet-101"""], help="""Name of the DETR model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model.""" ) parser.add_argument("""--push_to_hub""", action="""store_true""", help="""Whether to push the model to the hub or not.""") snake_case__ : List[str] = parser.parse_args() convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
23
from __future__ import annotations from sys import maxsize from typing import Generic, TypeVar snake_case__ : List[str] = TypeVar("""T""") def _snake_case (__lowercase): return (position - 1) // 2 def _snake_case (__lowercase): return (2 * position) + 1 def _snake_case (__lowercase): return (2 * position) + 2 class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = [] UpperCamelCase_ = {} UpperCamelCase_ = 0 def __len__( self ) -> int: return self.elements def __repr__( self ) -> str: return str(self.heap ) def _UpperCAmelCase ( self ) -> bool: # Check if the priority queue is empty return self.elements == 0 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an element with given priority to the queue self.heap.append((elem, weight) ) UpperCamelCase_ = self.elements self.elements += 1 self._bubble_up(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> T: # Remove and return the element with lowest weight (highest priority) if self.elements > 1: self._swap_nodes(0 , self.elements - 1 ) UpperCamelCase_ , UpperCamelCase_ = self.heap.pop() del self.position_map[elem] self.elements -= 1 if self.elements > 0: UpperCamelCase_ , UpperCamelCase_ = self.heap[0] self._bubble_down(_UpperCAmelCase ) return elem def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Update the weight of the given key UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ = (elem, weight) if position > 0: UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._bubble_up(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (upward movement) [to be used internally # only] UpperCamelCase_ = self.position_map[elem] if curr_pos == 0: return None UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_up(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (downward movement) [to be used # internally only] UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ = get_child_left_position(_UpperCAmelCase ) UpperCamelCase_ = get_child_right_position(_UpperCAmelCase ) if child_left_position < self.elements and child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < child_left_weight and child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) if child_left_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] if child_left_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) else: return None if child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Swap the nodes at the given positions UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ , UpperCamelCase_ = ( self.heap[nodea_pos], self.heap[nodea_pos], ) UpperCamelCase_ = nodea_pos UpperCamelCase_ = nodea_pos class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = {} UpperCamelCase_ = 0 def __repr__( self ) -> str: return str(self.connections ) def __len__( self ) -> int: return self.nodes def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Add a node in the graph if it is not in the graph if node not in self.connections: UpperCamelCase_ = {} self.nodes += 1 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an edge between 2 nodes in the graph self.add_node(_UpperCAmelCase ) self.add_node(_UpperCAmelCase ) UpperCamelCase_ = weight UpperCamelCase_ = weight def _snake_case (__lowercase , ): UpperCamelCase_ = {node: maxsize for node in graph.connections} UpperCamelCase_ = {node: None for node in graph.connections} UpperCamelCase_ = MinPriorityQueue() for node, weight in dist.items(): priority_queue.push(__lowercase , __lowercase) if priority_queue.is_empty(): return dist, parent # initialization UpperCamelCase_ = priority_queue.extract_min() UpperCamelCase_ = 0 for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node # running prim's algorithm while not priority_queue.is_empty(): UpperCamelCase_ = priority_queue.extract_min() for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node return dist, parent
23
1
def _snake_case (__lowercase): UpperCamelCase_ = 0 for ch in input_str: UpperCamelCase_ = ord(__lowercase) UpperCamelCase_ = pow(2 , __lowercase) # If we already turned on bit for current character's unicode if bitmap >> ch_unicode & 1 == 1: return False bitmap |= ch_bit_index_on return True if __name__ == "__main__": import doctest doctest.testmod()
23
from __future__ import annotations import sys from collections import deque from typing import Generic, TypeVar snake_case__ : Dict = TypeVar("""T""") class _a ( Generic[T] ): """simple docstring""" A_ = 42 # Cache store of keys A_ = 42 # References of the keys in cache A_ = 10 # Maximum capacity of cache def __init__( self , _UpperCAmelCase ) -> None: UpperCamelCase_ = deque() UpperCamelCase_ = set() if not n: UpperCamelCase_ = sys.maxsize elif n < 0: raise ValueError('n should be an integer greater than 0.' ) else: UpperCamelCase_ = n def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: if x not in self.key_reference: if len(self.dq_store ) == LRUCache._MAX_CAPACITY: UpperCamelCase_ = self.dq_store.pop() self.key_reference.remove(_UpperCAmelCase ) else: self.dq_store.remove(_UpperCAmelCase ) self.dq_store.appendleft(_UpperCAmelCase ) self.key_reference.add(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> None: for k in self.dq_store: print(_UpperCAmelCase ) def __repr__( self ) -> str: return f"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store )}""" if __name__ == "__main__": import doctest doctest.testmod() snake_case__ : LRUCache[str | int] = LRUCache(4) lru_cache.refer("""A""") lru_cache.refer(2) lru_cache.refer(3) lru_cache.refer("""A""") lru_cache.refer(4) lru_cache.refer(5) lru_cache.display() print(lru_cache) assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"
23
1
from __future__ import annotations import typing from collections.abc import Iterable import numpy as np snake_case__ : Union[str, Any] = typing.Union[Iterable[float], Iterable[int], np.ndarray] # noqa: UP007 snake_case__ : Any = typing.Union[np.floataa, int, float] # noqa: UP007 def _snake_case (__lowercase , __lowercase): return np.sqrt(np.sum((np.asarray(__lowercase) - np.asarray(__lowercase)) ** 2)) def _snake_case (__lowercase , __lowercase): return sum((va - va) ** 2 for va, va in zip(__lowercase , __lowercase)) ** (1 / 2) if __name__ == "__main__": def _snake_case (): from timeit import timeit print('Without Numpy') print( timeit( 'euclidean_distance_no_np([1, 2, 3], [4, 5, 6])' , number=10000 , globals=globals() , )) print('With Numpy') print( timeit( 'euclidean_distance([1, 2, 3], [4, 5, 6])' , number=10000 , globals=globals() , )) benchmark()
23
import numpy as np def _snake_case (__lowercase): return 1 / (1 + np.exp(-vector)) def _snake_case (__lowercase): return vector * sigmoid(__lowercase) if __name__ == "__main__": import doctest doctest.testmod()
23
1
import json from typing import Dict, List, Optional, Tuple, Union from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding, EncodedInput from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import PaddingStrategy, logging from .tokenization_led import LEDTokenizer snake_case__ : Union[str, Any] = logging.get_logger(__name__) snake_case__ : Optional[Any] = {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""} snake_case__ : Optional[int] = { """vocab_file""": { """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json""", }, """merges_file""": { """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt""", }, """tokenizer_file""": { """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json""", }, } snake_case__ : Tuple = { """allenai/led-base-16384""": 1_6_3_8_4, } class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = VOCAB_FILES_NAMES A_ = PRETRAINED_VOCAB_FILES_MAP A_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A_ = LEDTokenizer A_ = ["""input_ids""", """attention_mask"""] def __init__( self , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase="replace" , _UpperCAmelCase="<s>" , _UpperCAmelCase="</s>" , _UpperCAmelCase="</s>" , _UpperCAmelCase="<s>" , _UpperCAmelCase="<unk>" , _UpperCAmelCase="<pad>" , _UpperCAmelCase="<mask>" , _UpperCAmelCase=False , _UpperCAmelCase=True , **_UpperCAmelCase , ) -> Tuple: super().__init__( _UpperCAmelCase , _UpperCAmelCase , tokenizer_file=_UpperCAmelCase , errors=_UpperCAmelCase , bos_token=_UpperCAmelCase , eos_token=_UpperCAmelCase , sep_token=_UpperCAmelCase , cls_token=_UpperCAmelCase , unk_token=_UpperCAmelCase , pad_token=_UpperCAmelCase , mask_token=_UpperCAmelCase , add_prefix_space=_UpperCAmelCase , trim_offsets=_UpperCAmelCase , **_UpperCAmelCase , ) UpperCamelCase_ = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get('add_prefix_space' , _UpperCAmelCase ) != add_prefix_space: UpperCamelCase_ = getattr(_UpperCAmelCase , pre_tok_state.pop('type' ) ) UpperCamelCase_ = add_prefix_space UpperCamelCase_ = pre_tok_class(**_UpperCAmelCase ) UpperCamelCase_ = add_prefix_space # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__` UpperCamelCase_ = 'post_processor' UpperCamelCase_ = getattr(self.backend_tokenizer , _UpperCAmelCase , _UpperCAmelCase ) if tokenizer_component_instance: UpperCamelCase_ = 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: UpperCamelCase_ = tuple(state['sep'] ) if "cls" in state: UpperCamelCase_ = tuple(state['cls'] ) UpperCamelCase_ = False if state.get('add_prefix_space' , _UpperCAmelCase ) != add_prefix_space: UpperCamelCase_ = add_prefix_space UpperCamelCase_ = True if state.get('trim_offsets' , _UpperCAmelCase ) != trim_offsets: UpperCamelCase_ = trim_offsets UpperCamelCase_ = True if changes_to_apply: UpperCamelCase_ = getattr(_UpperCAmelCase , state.pop('type' ) ) UpperCamelCase_ = component_class(**_UpperCAmelCase ) setattr(self.backend_tokenizer , _UpperCAmelCase , _UpperCAmelCase ) @property # Copied from transformers.models.bart.tokenization_bart_fast.BartTokenizerFast.mask_token with BART->LED def _UpperCAmelCase ( self ) -> str: 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 _UpperCAmelCase ( self , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = AddedToken(_UpperCAmelCase , lstrip=_UpperCAmelCase , rstrip=_UpperCAmelCase ) if isinstance(_UpperCAmelCase , _UpperCAmelCase ) else value UpperCamelCase_ = value def _UpperCAmelCase ( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> BatchEncoding: UpperCamelCase_ = kwargs.get('is_split_into_words' , _UpperCAmelCase ) if is_split_into_words and not self.add_prefix_space: raise ValueError( f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._batch_encode_plus(*_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , *_UpperCAmelCase , **_UpperCAmelCase ) -> BatchEncoding: UpperCamelCase_ = kwargs.get('is_split_into_words' , _UpperCAmelCase ) if is_split_into_words and not self.add_prefix_space: raise ValueError( f"""You need to instantiate {self.__class__.__name__} with add_prefix_space=True """ 'to use it with pretokenized inputs.' ) return super()._encode_plus(*_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> Tuple[str]: UpperCamelCase_ = self._tokenizer.model.save(_UpperCAmelCase , name=_UpperCAmelCase ) return tuple(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=None ) -> Optional[Any]: UpperCamelCase_ = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> List[int]: UpperCamelCase_ = [self.sep_token_id] UpperCamelCase_ = [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 _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = PaddingStrategy.DO_NOT_PAD , _UpperCAmelCase = None , _UpperCAmelCase = None , ) -> dict: UpperCamelCase_ = super()._pad( encoded_inputs=_UpperCAmelCase , max_length=_UpperCAmelCase , padding_strategy=_UpperCAmelCase , pad_to_multiple_of=_UpperCAmelCase , return_attention_mask=_UpperCAmelCase , ) # Load from model defaults if return_attention_mask is None: UpperCamelCase_ = 'attention_mask' in self.model_input_names if return_attention_mask and "global_attention_mask" in encoded_inputs: UpperCamelCase_ = encoded_inputs[self.model_input_names[0]] # `global_attention_mask` need to have the same length as other (sequential) inputs. UpperCamelCase_ = len(encoded_inputs['global_attention_mask'] ) != len(_UpperCAmelCase ) if needs_to_be_padded: UpperCamelCase_ = len(_UpperCAmelCase ) - len(encoded_inputs['global_attention_mask'] ) if self.padding_side == "right": # Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend` UpperCamelCase_ = ( encoded_inputs['global_attention_mask'] + [-1] * difference ) elif self.padding_side == "left": UpperCamelCase_ = [-1] * difference + encoded_inputs[ 'global_attention_mask' ] else: raise ValueError('Invalid padding strategy:' + str(self.padding_side ) ) return encoded_inputs
23
import math from datetime import datetime, timedelta def _snake_case (__lowercase): UpperCamelCase_ = year % 19 UpperCamelCase_ = year % 4 UpperCamelCase_ = year % 7 UpperCamelCase_ = math.floor(year / 100) UpperCamelCase_ = math.floor((13 + 8 * leap_day_inhibits) / 25) UpperCamelCase_ = leap_day_inhibits / 4 UpperCamelCase_ = ( 15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number ) % 30 UpperCamelCase_ = (4 + leap_day_inhibits - leap_day_reinstall_number) % 7 # days to be added to March 21 UpperCamelCase_ = (19 * metonic_cycle + secular_moon_shift) % 30 # PHM -> Paschal Full Moon UpperCamelCase_ = ( 2 * julian_leap_year + 4 * non_leap_year + 6 * days_to_add + century_starting_point ) % 7 if days_to_add == 29 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 19) elif days_to_add == 28 and days_from_phm_to_sunday == 6: return datetime(__lowercase , 4 , 18) else: return datetime(__lowercase , 3 , 22) + timedelta( days=int(days_to_add + days_from_phm_to_sunday)) if __name__ == "__main__": for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3): snake_case__ : Dict = """will be""" if year > datetime.now().year else """was""" print(f'Easter in {year} {tense} {gauss_easter(year)}')
23
1
import gc import unittest from diffusers import FlaxDPMSolverMultistepScheduler, FlaxStableDiffusionPipeline from diffusers.utils import is_flax_available, slow from diffusers.utils.testing_utils import require_flax if is_flax_available(): import jax import jax.numpy as jnp from flax.jax_utils import replicate from flax.training.common_utils import shard @slow @require_flax class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Union[str, Any]: # clean up the VRAM after each test super().tearDown() gc.collect() def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = FlaxStableDiffusionPipeline.from_pretrained( 'stabilityai/stable-diffusion-2' , revision='bf16' , dtype=jnp.bfloataa , ) UpperCamelCase_ = 'A painting of a squirrel eating a burger' UpperCamelCase_ = jax.device_count() UpperCamelCase_ = num_samples * [prompt] UpperCamelCase_ = sd_pipe.prepare_inputs(_UpperCAmelCase ) UpperCamelCase_ = replicate(_UpperCAmelCase ) UpperCamelCase_ = shard(_UpperCAmelCase ) UpperCamelCase_ = jax.random.PRNGKey(0 ) UpperCamelCase_ = jax.random.split(_UpperCAmelCase , jax.device_count() ) UpperCamelCase_ = sd_pipe(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , num_inference_steps=25 , jit=_UpperCAmelCase )[0] assert images.shape == (jax.device_count(), 1, 768, 768, 3) UpperCamelCase_ = images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:] ) UpperCamelCase_ = images[0, 253:256, 253:256, -1] UpperCamelCase_ = jnp.asarray(jax.device_get(image_slice.flatten() ) ) UpperCamelCase_ = jnp.array([0.4_2_3_8, 0.4_4_1_4, 0.4_3_9_5, 0.4_4_5_3, 0.4_6_2_9, 0.4_5_9_0, 0.4_5_3_1, 0.4_5_5_0_8, 0.4_5_1_2] ) print(f"""output_slice: {output_slice}""" ) assert jnp.abs(output_slice - expected_slice ).max() < 1e-2 def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = 'stabilityai/stable-diffusion-2' UpperCamelCase_ , UpperCamelCase_ = FlaxDPMSolverMultistepScheduler.from_pretrained(_UpperCAmelCase , subfolder='scheduler' ) UpperCamelCase_ , UpperCamelCase_ = FlaxStableDiffusionPipeline.from_pretrained( _UpperCAmelCase , scheduler=_UpperCAmelCase , revision='bf16' , dtype=jnp.bfloataa , ) UpperCamelCase_ = scheduler_params UpperCamelCase_ = 'A painting of a squirrel eating a burger' UpperCamelCase_ = jax.device_count() UpperCamelCase_ = num_samples * [prompt] UpperCamelCase_ = sd_pipe.prepare_inputs(_UpperCAmelCase ) UpperCamelCase_ = replicate(_UpperCAmelCase ) UpperCamelCase_ = shard(_UpperCAmelCase ) UpperCamelCase_ = jax.random.PRNGKey(0 ) UpperCamelCase_ = jax.random.split(_UpperCAmelCase , jax.device_count() ) UpperCamelCase_ = sd_pipe(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , num_inference_steps=25 , jit=_UpperCAmelCase )[0] assert images.shape == (jax.device_count(), 1, 768, 768, 3) UpperCamelCase_ = images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:] ) UpperCamelCase_ = images[0, 253:256, 253:256, -1] UpperCamelCase_ = jnp.asarray(jax.device_get(image_slice.flatten() ) ) UpperCamelCase_ = jnp.array([0.4_3_3_6, 0.4_2_9_6_9, 0.4_4_5_3, 0.4_1_9_9, 0.4_2_9_7, 0.4_5_3_1, 0.4_4_3_4, 0.4_4_3_4, 0.4_2_9_7] ) print(f"""output_slice: {output_slice}""" ) assert jnp.abs(output_slice - expected_slice ).max() < 1e-2
23
import requests def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = {'Content-Type': 'application/json'} UpperCamelCase_ = requests.post(__lowercase , json={'text': message_body} , headers=__lowercase) if response.status_code != 200: UpperCamelCase_ = ( 'Request to slack returned an error ' f"""{response.status_code}, the response is:\n{response.text}""" ) raise ValueError(__lowercase) if __name__ == "__main__": # Set the slack url to the one provided by Slack when you create the webhook at # https://my.slack.com/services/new/incoming-webhook/ send_slack_message("""<YOUR MESSAGE BODY>""", """<SLACK CHANNEL URL>""")
23
1
import argparse import torch from transformers import GPTaLMHeadModel, RobertaForMaskedLM if __name__ == "__main__": snake_case__ : Union[str, Any] = argparse.ArgumentParser( description=( """Extraction some layers of the full RobertaForMaskedLM or GPT2LMHeadModel for Transfer Learned""" """ Distillation""" ) ) parser.add_argument("""--model_type""", default="""roberta""", choices=["""roberta""", """gpt2"""]) parser.add_argument("""--model_name""", default="""roberta-large""", type=str) parser.add_argument("""--dump_checkpoint""", default="""serialization_dir/tf_roberta_048131723.pth""", type=str) parser.add_argument("""--vocab_transform""", action="""store_true""") snake_case__ : Dict = parser.parse_args() if args.model_type == "roberta": snake_case__ : Any = RobertaForMaskedLM.from_pretrained(args.model_name) snake_case__ : Dict = """roberta""" elif args.model_type == "gpt2": snake_case__ : Optional[int] = GPTaLMHeadModel.from_pretrained(args.model_name) snake_case__ : List[str] = """transformer""" snake_case__ : List[Any] = model.state_dict() snake_case__ : Optional[int] = {} # Embeddings # if args.model_type == "gpt2": for param_name in ["wte.weight", "wpe.weight"]: snake_case__ : int = state_dict[f'{prefix}.{param_name}'] else: for w in ["word_embeddings", "position_embeddings", "token_type_embeddings"]: snake_case__ : Optional[Any] = f'{prefix}.embeddings.{w}.weight' snake_case__ : Optional[int] = state_dict[param_name] for w in ["weight", "bias"]: snake_case__ : Optional[int] = f'{prefix}.embeddings.LayerNorm.{w}' snake_case__ : List[str] = state_dict[param_name] # Transformer Blocks # snake_case__ : Optional[Any] = 0 for teacher_idx in [0, 2, 4, 7, 9, 1_1]: if args.model_type == "gpt2": for layer in ["ln_1", "attn.c_attn", "attn.c_proj", "ln_2", "mlp.c_fc", "mlp.c_proj"]: for w in ["weight", "bias"]: snake_case__ : Union[str, Any] = state_dict[ f'{prefix}.h.{teacher_idx}.{layer}.{w}' ] snake_case__ : Optional[Any] = state_dict[f'{prefix}.h.{teacher_idx}.attn.bias'] else: for layer in [ "attention.self.query", "attention.self.key", "attention.self.value", "attention.output.dense", "attention.output.LayerNorm", "intermediate.dense", "output.dense", "output.LayerNorm", ]: for w in ["weight", "bias"]: snake_case__ : int = state_dict[ f'{prefix}.encoder.layer.{teacher_idx}.{layer}.{w}' ] std_idx += 1 # Language Modeling Head ###s if args.model_type == "roberta": for layer in ["lm_head.decoder.weight", "lm_head.bias"]: snake_case__ : Optional[int] = state_dict[f'{layer}'] if args.vocab_transform: for w in ["weight", "bias"]: snake_case__ : List[str] = state_dict[f'lm_head.dense.{w}'] snake_case__ : Dict = state_dict[f'lm_head.layer_norm.{w}'] elif args.model_type == "gpt2": for w in ["weight", "bias"]: snake_case__ : Optional[int] = state_dict[f'{prefix}.ln_f.{w}'] snake_case__ : str = state_dict["""lm_head.weight"""] print(f'N layers selected for distillation: {std_idx}') print(f'Number of params transferred for distillation: {len(compressed_sd.keys())}') print(f'Save transferred checkpoint to {args.dump_checkpoint}.') torch.save(compressed_sd, args.dump_checkpoint)
23
import re from pathlib import Path from unittest import TestCase import pytest @pytest.mark.integration class _a ( UpperCAmelCase__ ): """simple docstring""" def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)' ) UpperCamelCase_ = input_file.read() UpperCamelCase_ = regexp.search(_UpperCAmelCase ) return match def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Dict: with open(_UpperCAmelCase , encoding='utf-8' ) as input_file: UpperCamelCase_ = re.compile(R'#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()' , re.DOTALL ) UpperCamelCase_ = input_file.read() # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search` UpperCamelCase_ = regexp.finditer(_UpperCAmelCase ) UpperCamelCase_ = [match for match in matches if match is not None and match.group(1 ) is not None] return matches[0] if matches else None def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_encoding_on_file_open(str(_UpperCAmelCase ) ): raise AssertionError(f"""open(...) must use utf-8 encoding in {dataset}""" ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = Path('./datasets' ) UpperCamelCase_ = list(dataset_paths.absolute().glob('**/*.py' ) ) for dataset in dataset_files: if self._no_print_statements(str(_UpperCAmelCase ) ): raise AssertionError(f"""print statement found in {dataset}. Use datasets.logger/logging instead.""" )
23
1
from bisect import bisect from itertools import accumulate def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase): UpperCamelCase_ = sorted(zip(__lowercase , __lowercase) , key=lambda __lowercase: x[0] / x[1] , reverse=__lowercase) UpperCamelCase_ , UpperCamelCase_ = [i[0] for i in r], [i[1] for i in r] UpperCamelCase_ = list(accumulate(__lowercase)) UpperCamelCase_ = bisect(__lowercase , __lowercase) return ( 0 if k == 0 else sum(vl[:k]) + (w - acc[k - 1]) * (vl[k]) / (wt[k]) if k != n else sum(vl[:k]) ) if __name__ == "__main__": import doctest doctest.testmod()
23
import argparse import random import joblib import numpy as np import torch from igf.igf import ( SecondaryLearner, collect_objective_set, compute_perplexity, generate_datasets, load_gpta, recopy_gpta, set_seed, train_secondary_learner, ) from torch.utils.data import DataLoader, RandomSampler from transformers import GPTaLMHeadModel def _snake_case (__lowercase=32 , __lowercase=10 , __lowercase=100 , __lowercase=1026 , __lowercase=True , __lowercase="data/tokenized_stories_train_wikitext103.jbl" , __lowercase="igf_context_pairs.jbl" , ): set_seed(3) # generate train_data and objective_set UpperCamelCase_ , UpperCamelCase_ = generate_datasets( __lowercase , __lowercase , number=__lowercase , min_len=1026 , trim=__lowercase) # keeps model same across runs set_seed(4) # model, lm_optimizer, lm_scheduler = recopy_gpt2(model, device, max_steps) # store original model weights # can we train on GPU? UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # load pretrained model UpperCamelCase_ = load_gpta('gpt2').to(__lowercase) print('computing perplexity on objective set') UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase).item() print('perplexity on objective set:' , __lowercase) # collect igf pairs and save to file demo.jbl collect_objective_set(__lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # clean up, delete model and data we don't need anymore del model, train_data, objective_set torch.cuda.empty_cache() def _snake_case (__lowercase , __lowercase=15 , __lowercase=128 , __lowercase=100 , __lowercase="igf_model.pt" , ): set_seed(42) # Load pre-trained model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') # Initialize secondary learner to use embedding weights of model UpperCamelCase_ = SecondaryLearner(__lowercase) # Train secondary learner UpperCamelCase_ = train_secondary_learner( __lowercase , __lowercase , max_epochs=__lowercase , batch_size=__lowercase , eval_freq=100 , igf_model_path=__lowercase , ) del model, secondary_learner_train_data torch.cuda.empty_cache() return secondary_learner def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=32 , __lowercase=1000 , __lowercase=16 , __lowercase=1.0 , __lowercase=recopy_gpta , __lowercase=None , __lowercase=10 , __lowercase="gpt2_finetuned.pt" , ): UpperCamelCase_ = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') UpperCamelCase_ = RandomSampler(__lowercase) UpperCamelCase_ = DataLoader(__lowercase , sampler=__lowercase) UpperCamelCase_ = max_steps // (len(__lowercase)) + 1 UpperCamelCase_ = 0 UpperCamelCase_ = torch.zeros((1, context_len) , dtype=torch.long , device=__lowercase) UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = recopy_model(__lowercase , __lowercase , __lowercase) model.train() if secondary_learner is not None: secondary_learner.to(__lowercase) secondary_learner.eval() UpperCamelCase_ = [] UpperCamelCase_ = 0 UpperCamelCase_ = [] UpperCamelCase_ = [] # Compute the performance of the transformer model at the beginning UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) for epoch in range(int(__lowercase)): for step, example in enumerate(__lowercase): torch.cuda.empty_cache() UpperCamelCase_ = random.randint(0 , example.size(2) - context_len - 1) UpperCamelCase_ = example[0, 0, start : start + context_len] lm_optimizer.zero_grad() UpperCamelCase_ = model(__lowercase , labels=__lowercase) UpperCamelCase_ = True if secondary_learner is not None: UpperCamelCase_ = secondary_learner.forward( torch.tensor(__lowercase , dtype=torch.long , device=__lowercase).unsqueeze(0))[0].item() observed_qs.append(float(__lowercase)) # Here we implement the simple non-constant threshold for the predicted IG(X) value # We will decay the selectivity of our secondary learner filter from # 1 standard deviation above average to 1 below average after 10 batches. if global_step == 10: UpperCamelCase_ = -1 if predicted_q < threshold: UpperCamelCase_ = False # If we passed the filter, add the context to the batch! if do_backprop: contexts.append(np.array(context.cpu())) UpperCamelCase_ = outputs[0] lm_loss.backward() examples += 1 del outputs # Once the batch is filled with enough contexts, backprop on the batch. if examples == batch_size: torch.cuda.empty_cache() UpperCamelCase_ = 0 # Do LM backprop torch.nn.utils.clip_grad_norm_(model.parameters() , 3.0) lm_optimizer.step() lm_scheduler.step() # Update learning rate schedule global_step += 1 # Compute the performance of the transformer model at this batch if global_step % eval_interval == 0: UpperCamelCase_ = compute_perplexity(__lowercase , __lowercase , __lowercase) test_perps.append(__lowercase) print('Test perplexity, step' , __lowercase , ':' , __lowercase) # Break out of the loop after 60 batches if max_steps > 0 and global_step > 60: break if max_steps > 0 and global_step > 60: break # save finetuned transformer model torch.save(model.state_dict() , __lowercase) torch.cuda.empty_cache() # Do some cleaning up so we can reinitialize for the next run of this function del lm_optimizer del lm_scheduler return model def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Fine-tune a transformer model with IGF on a language modeling task') # Required parameters parser.add_argument( '--data_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The input data dir. Should contain data files for WikiText.' , ) parser.add_argument( '--model_name_or_path' , default=__lowercase , type=__lowercase , required=__lowercase , help='Path to pretrained model or model identifier from huggingface.co/models' , ) parser.add_argument( '--data_file' , type=__lowercase , default=__lowercase , help=( 'A jbl file containing tokenized data which can be split as objective dataset, ' 'train_dataset and test_dataset.' ) , ) parser.add_argument( '--igf_data_file' , type=__lowercase , default=__lowercase , help='A jbl file containing the context and information gain pairs to train secondary learner.' , ) parser.add_argument( '--output_dir' , default=__lowercase , type=__lowercase , required=__lowercase , help='The output directory where the final fine-tuned model is stored.' , ) parser.add_argument( '--tokenizer_name' , default=__lowercase , type=__lowercase , help='Pretrained tokenizer name or path if not the same as model_name' , ) parser.add_argument('--seed' , type=__lowercase , default=__lowercase , help='A seed for reproducible training.') parser.add_argument( '--context_len' , default=32 , type=__lowercase , help=( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) , ) parser.add_argument( '--size_objective_set' , default=100 , type=__lowercase , help='number of articles that are long enough to be used as our objective set' , ) parser.add_argument( '--eval_freq' , default=100 , type=__lowercase , help='secondary model evaluation is triggered at eval_freq') parser.add_argument('--max_steps' , default=1000 , type=__lowercase , help='To calculate training epochs') parser.add_argument( '--secondary_learner_batch_size' , default=128 , type=__lowercase , help='batch size of training data for secondary learner' , ) parser.add_argument( '--batch_size' , default=16 , type=__lowercase , help='batch size of training data of language model(gpt2) ') parser.add_argument( '--eval_interval' , default=10 , type=__lowercase , help=( 'decay the selectivity of our secondary learner filter from' '1 standard deviation above average to 1 below average after 10 batches' ) , ) parser.add_argument( '--number' , default=100 , type=__lowercase , help='The number of examples split to be used as objective_set/test_data') parser.add_argument( '--min_len' , default=1026 , type=__lowercase , help='The minimum length of the article to be used as objective set') parser.add_argument( '--secondary_learner_max_epochs' , default=15 , type=__lowercase , help='number of epochs to train secondary learner') parser.add_argument('--trim' , default=__lowercase , type=__lowercase , help='truncate the example if it exceeds context length') parser.add_argument( '--threshold' , default=1.0 , type=__lowercase , help=( 'The threshold value used by secondary learner to filter the train_data and allow only' ' informative data as input to the model' ) , ) parser.add_argument('--finetuned_model_name' , default='gpt2_finetuned.pt' , type=__lowercase , help='finetuned_model_name') parser.add_argument( '--recopy_model' , default=__lowercase , type=__lowercase , help='Reset the model to the original pretrained GPT-2 weights after each iteration' , ) # function calls # Collecting *n* pairs of context and information gain(X, IG(X)) for training the secondary learner generate_n_pairs( context_len=32 , max_steps=10 , size_objective_set=100 , min_len=1026 , trim=__lowercase , data_file='data/tokenized_stories_train_wikitext103.jbl' , igf_data_file='igf_context_pairs.jbl' , ) # Load train data for secondary learner UpperCamelCase_ = joblib.load('data/IGF_values.jbl') # Train secondary learner UpperCamelCase_ = training_secondary_learner( __lowercase , secondary_learner_max_epochs=15 , secondary_learner_batch_size=128 , eval_freq=100 , igf_model_path='igf_model.pt' , ) # load pretrained gpt2 model UpperCamelCase_ = GPTaLMHeadModel.from_pretrained('gpt2') set_seed(42) # Generate train and test data to train and evaluate gpt2 model UpperCamelCase_ , UpperCamelCase_ = generate_datasets( context_len=32 , file='data/tokenized_stories_train_wikitext103.jbl' , number=100 , min_len=1026 , trim=__lowercase) # fine-tuning of the gpt2 model using igf (Information Gain Filtration) finetune( __lowercase , __lowercase , __lowercase , context_len=32 , max_steps=1000 , batch_size=16 , threshold=1.0 , recopy_model=__lowercase , secondary_learner=__lowercase , eval_interval=10 , finetuned_model_name='gpt2_finetuned.pt' , ) if __name__ == "__main__": main()
23
1
import os import sys import tempfile import torch from .state import AcceleratorState from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment def _snake_case (__lowercase , __lowercase=() , __lowercase=None , __lowercase="no" , __lowercase="29500"): UpperCamelCase_ = False UpperCamelCase_ = False if any(key.startswith('KAGGLE') for key in os.environ.keys()): UpperCamelCase_ = True elif "IPython" in sys.modules: UpperCamelCase_ = 'google.colab' in str(sys.modules['IPython'].get_ipython()) try: UpperCamelCase_ = 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' , __lowercase) 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: UpperCamelCase_ = 8 UpperCamelCase_ = PrepareForLaunch(__lowercase , distributed_type='TPU') print(f"""Launching a training on {num_processes} TPU cores.""") xmp.spawn(__lowercase , args=__lowercase , nprocs=__lowercase , 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(*__lowercase) 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=__lowercase , master_addr='127.0.01' , master_port=__lowercase , mixed_precision=__lowercase): UpperCamelCase_ = PrepareForLaunch(__lowercase , distributed_type='MULTI_GPU') print(f"""Launching training on {num_processes} GPUs.""") try: start_processes(__lowercase , args=__lowercase , nprocs=__lowercase , 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(): UpperCamelCase_ = '1' print('Launching training on MPS.') elif torch.cuda.is_available(): print('Launching training on one GPU.') else: print('Launching training on CPU.') function(*__lowercase) def _snake_case (__lowercase , __lowercase=() , __lowercase=2): 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=__lowercase , master_addr='127.0.01' , master_port='29500' , accelerate_mixed_precision='no' , accelerate_debug_rdv_file=tmp_file.name , accelerate_use_cpu='yes' , ): UpperCamelCase_ = PrepareForLaunch(__lowercase , debug=__lowercase) start_processes(__lowercase , args=__lowercase , nprocs=__lowercase , start_method='fork')
23
from __future__ import annotations import unittest from transformers import AutoTokenizer, MBartConfig, is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel @require_tf class _a : """simple docstring""" A_ = MBartConfig A_ = {} A_ = """gelu""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=99 , _UpperCAmelCase=32 , _UpperCAmelCase=2 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=20 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , ) -> Union[str, Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = eos_token_id UpperCamelCase_ = pad_token_id UpperCamelCase_ = bos_token_id def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) UpperCamelCase_ = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ) , 1 ) UpperCamelCase_ = tf.concat([input_ids, eos_tensor] , axis=1 ) UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) UpperCamelCase_ = prepare_mbart_inputs_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = TFMBartModel(config=_UpperCAmelCase ).get_decoder() UpperCamelCase_ = inputs_dict['input_ids'] UpperCamelCase_ = input_ids[:1, :] UpperCamelCase_ = inputs_dict['attention_mask'][:1, :] UpperCamelCase_ = inputs_dict['head_mask'] UpperCamelCase_ = 1 # first forward pass UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , head_mask=_UpperCAmelCase , use_cache=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = outputs.to_tuple() UpperCamelCase_ = past_key_values[1] def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , ): if attention_mask is None: UpperCamelCase_ = tf.cast(tf.math.not_equal(__lowercase , config.pad_token_id) , tf.inta) if decoder_attention_mask is None: UpperCamelCase_ = tf.concat( [ tf.ones(decoder_input_ids[:, :1].shape , dtype=tf.inta), tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id) , tf.inta), ] , axis=-1 , ) if head_mask is None: UpperCamelCase_ = tf.ones((config.encoder_layers, config.encoder_attention_heads)) if decoder_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) if cross_attn_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } @require_tf class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else () A_ = (TFMBartForConditionalGeneration,) if is_tf_available() else () A_ = ( { """conversational""": TFMBartForConditionalGeneration, """feature-extraction""": TFMBartModel, """summarization""": TFMBartForConditionalGeneration, """text2text-generation""": TFMBartForConditionalGeneration, """translation""": TFMBartForConditionalGeneration, } if is_tf_available() else {} ) A_ = True A_ = False A_ = False def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: if pipeline_test_casse_name != "FeatureExtractionPipelineTests": # Exception encountered when calling layer '...' return True return False def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = TFMBartModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase ) @require_sentencepiece @require_tokenizers @require_tf class _a ( unittest.TestCase ): """simple docstring""" A_ = [ """ UN Chief Says There Is No Military Solution in Syria""", ] A_ = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", ] A_ = """facebook/mbart-large-en-ro""" @cached_property def _UpperCAmelCase ( self ) -> Any: return AutoTokenizer.from_pretrained(self.model_name ) @cached_property def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name ) return model def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> int: UpperCamelCase_ = self.translate_src_text(**_UpperCAmelCase ) self.assertListEqual(self.expected_text , _UpperCAmelCase ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> List[str]: UpperCamelCase_ = self.tokenizer(self.src_text , **_UpperCAmelCase , return_tensors='tf' ) UpperCamelCase_ = self.model.generate( model_inputs.input_ids , attention_mask=model_inputs.attention_mask , num_beams=2 ) UpperCamelCase_ = self.tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) return generated_words @slow def _UpperCAmelCase ( self ) -> List[Any]: self._assert_generated_batch_equal_expected()
23
1
# Copyright 2021 The HuggingFace 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. from pathlib import Path import torch from ...utils import is_npu_available, is_xpu_available from .config_args import ClusterConfig, default_json_config_file from .config_utils import SubcommandHelpFormatter snake_case__ : Any = """Create a default config file for Accelerate with only a few flags set.""" def _snake_case (__lowercase="no" , __lowercase = default_json_config_file , __lowercase = False): UpperCamelCase_ = Path(__lowercase) path.parent.mkdir(parents=__lowercase , exist_ok=__lowercase) if path.exists(): print( f"""Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`.""") return False UpperCamelCase_ = mixed_precision.lower() if mixed_precision not in ["no", "fp16", "bf16", "fp8"]: raise ValueError( f"""`mixed_precision` should be one of 'no', 'fp16', 'bf16', or 'fp8'. Received {mixed_precision}""") UpperCamelCase_ = { 'compute_environment': 'LOCAL_MACHINE', 'mixed_precision': mixed_precision, } if torch.cuda.is_available(): UpperCamelCase_ = torch.cuda.device_count() UpperCamelCase_ = num_gpus UpperCamelCase_ = False if num_gpus > 1: UpperCamelCase_ = 'MULTI_GPU' else: UpperCamelCase_ = 'NO' elif is_xpu_available() and use_xpu: UpperCamelCase_ = torch.xpu.device_count() UpperCamelCase_ = num_xpus UpperCamelCase_ = False if num_xpus > 1: UpperCamelCase_ = 'MULTI_XPU' else: UpperCamelCase_ = 'NO' elif is_npu_available(): UpperCamelCase_ = torch.npu.device_count() UpperCamelCase_ = num_npus UpperCamelCase_ = False if num_npus > 1: UpperCamelCase_ = 'MULTI_NPU' else: UpperCamelCase_ = 'NO' else: UpperCamelCase_ = 0 UpperCamelCase_ = True UpperCamelCase_ = 1 UpperCamelCase_ = 'NO' UpperCamelCase_ = ClusterConfig(**__lowercase) config.to_json_file(__lowercase) return path def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = parser.add_parser('default' , parents=__lowercase , help=__lowercase , formatter_class=__lowercase) parser.add_argument( '--config_file' , default=__lowercase , help=( 'The path to use to store the config file. Will default to a file named default_config.yaml in the cache ' 'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have ' 'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed ' 'with \'huggingface\'.' ) , dest='save_location' , ) parser.add_argument( '--mixed_precision' , choices=['no', 'fp16', 'bf16'] , type=__lowercase , help='Whether or not to use mixed precision training. ' 'Choose between FP16 and BF16 (bfloat16) training. ' 'BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.' , default='no' , ) parser.set_defaults(func=__lowercase) return parser def _snake_case (__lowercase): UpperCamelCase_ = write_basic_config(args.mixed_precision , args.save_location) if config_file: print(f"""accelerate configuration saved at {config_file}""")
23
def _snake_case (__lowercase): UpperCamelCase_ = 1 for i in range(1 , num + 1): fact *= i return fact def _snake_case (__lowercase): UpperCamelCase_ = 0 while number > 0: UpperCamelCase_ = number % 10 sum_of_digits += last_digit UpperCamelCase_ = number // 10 # Removing the last_digit from the given number return sum_of_digits def _snake_case (__lowercase = 100): UpperCamelCase_ = factorial(__lowercase) UpperCamelCase_ = split_and_add(__lowercase) return result if __name__ == "__main__": print(solution(int(input("""Enter the Number: """).strip())))
23
1
import unittest from transformers import AutoConfig, AutoTokenizer, BertConfig, TensorType, is_flax_available from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, slow if is_flax_available(): import jax from transformers.models.auto.modeling_flax_auto import FlaxAutoModel from transformers.models.bert.modeling_flax_bert import FlaxBertModel from transformers.models.roberta.modeling_flax_roberta import FlaxRobertaModel @require_flax class _a ( unittest.TestCase ): """simple docstring""" @slow def _UpperCAmelCase ( self ) -> Any: for model_name in ["bert-base-cased", "bert-large-uncased"]: with self.subTest(_UpperCAmelCase ): UpperCamelCase_ = AutoConfig.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = FlaxAutoModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Tuple: for model_name in ["roberta-base", "roberta-large"]: with self.subTest(_UpperCAmelCase ): UpperCamelCase_ = AutoConfig.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = FlaxAutoModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Dict: for model_name in ["bert-base-cased", "bert-large-uncased"]: UpperCamelCase_ = AutoTokenizer.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = FlaxBertModel.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = tokenizer('Do you support jax jitted function?' , return_tensors=TensorType.JAX ) @jax.jit def eval(**_UpperCAmelCase ): return model(**_UpperCAmelCase ) eval(**_UpperCAmelCase ).block_until_ready() @slow def _UpperCAmelCase ( self ) -> List[Any]: for model_name in ["roberta-base", "roberta-large"]: UpperCamelCase_ = AutoTokenizer.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = FlaxRobertaModel.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = tokenizer('Do you support jax jitted function?' , return_tensors=TensorType.JAX ) @jax.jit def eval(**_UpperCAmelCase ): return model(**_UpperCAmelCase ) eval(**_UpperCAmelCase ).block_until_ready() def _UpperCAmelCase ( self ) -> List[Any]: with self.assertRaisesRegex( _UpperCAmelCase , 'bert-base is not a local folder and is not a valid model identifier' ): UpperCamelCase_ = FlaxAutoModel.from_pretrained('bert-base' ) def _UpperCAmelCase ( self ) -> Optional[Any]: with self.assertRaisesRegex( _UpperCAmelCase , R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)' ): UpperCamelCase_ = FlaxAutoModel.from_pretrained(_UpperCAmelCase , revision='aaaaaa' ) def _UpperCAmelCase ( self ) -> int: with self.assertRaisesRegex( _UpperCAmelCase , 'hf-internal-testing/config-no-model does not appear to have a file named flax_model.msgpack' , ): UpperCamelCase_ = FlaxAutoModel.from_pretrained('hf-internal-testing/config-no-model' ) def _UpperCAmelCase ( self ) -> int: with self.assertRaisesRegex(_UpperCAmelCase , 'Use `from_pt=True` to load this model' ): UpperCamelCase_ = FlaxAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only' )
23
from typing import Dict, List, Optional, Union import numpy as np 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 TensorType, is_vision_available, logging if is_vision_available(): import PIL snake_case__ : str = logging.get_logger(__name__) def _snake_case (__lowercase): if isinstance(__lowercase , (list, tuple)) and isinstance(videos[0] , (list, tuple)) and is_valid_image(videos[0][0]): return videos elif isinstance(__lowercase , (list, tuple)) and is_valid_image(videos[0]): return [videos] elif is_valid_image(__lowercase): return [[videos]] raise ValueError(f"""Could not make batched video from {videos}""") class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = ["""pixel_values"""] def __init__( self , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = True , _UpperCAmelCase = 1 / 255 , _UpperCAmelCase = True , _UpperCAmelCase = None , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> None: super().__init__(**_UpperCAmelCase ) UpperCamelCase_ = size if size is not None else {'shortest_edge': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else {'height': 224, 'width': 224} UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) UpperCamelCase_ = do_resize UpperCamelCase_ = size UpperCamelCase_ = do_center_crop UpperCamelCase_ = crop_size UpperCamelCase_ = resample UpperCamelCase_ = do_rescale UpperCamelCase_ = rescale_factor UpperCamelCase_ = do_normalize UpperCamelCase_ = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN UpperCamelCase_ = image_std if image_std is not None else IMAGENET_STANDARD_STD def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = PILImageResampling.BILINEAR , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) if "shortest_edge" in size: UpperCamelCase_ = get_resize_output_image_size(_UpperCAmelCase , size['shortest_edge'] , default_to_square=_UpperCAmelCase ) elif "height" in size and "width" in size: UpperCamelCase_ = (size['height'], size['width']) else: raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}""" ) return resize(_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: UpperCamelCase_ = get_size_dict(_UpperCAmelCase ) 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(_UpperCAmelCase , size=(size['height'], size['width']) , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> int: return rescale(_UpperCAmelCase , scale=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , **_UpperCAmelCase , ) -> np.ndarray: return normalize(_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase , data_format=_UpperCAmelCase , **_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , ) -> np.ndarray: 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.' ) # All transformations expect numpy arrays. UpperCamelCase_ = to_numpy_array(_UpperCAmelCase ) if do_resize: UpperCamelCase_ = self.resize(image=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase ) if do_center_crop: UpperCamelCase_ = self.center_crop(_UpperCAmelCase , size=_UpperCAmelCase ) if do_rescale: UpperCamelCase_ = self.rescale(image=_UpperCAmelCase , scale=_UpperCAmelCase ) if do_normalize: UpperCamelCase_ = self.normalize(image=_UpperCAmelCase , mean=_UpperCAmelCase , std=_UpperCAmelCase ) UpperCamelCase_ = to_channel_dimension_format(_UpperCAmelCase , _UpperCAmelCase ) return image def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = ChannelDimension.FIRST , **_UpperCAmelCase , ) -> PIL.Image.Image: UpperCamelCase_ = do_resize if do_resize is not None else self.do_resize UpperCamelCase_ = resample if resample is not None else self.resample UpperCamelCase_ = do_center_crop if do_center_crop is not None else self.do_center_crop UpperCamelCase_ = do_rescale if do_rescale is not None else self.do_rescale UpperCamelCase_ = rescale_factor if rescale_factor is not None else self.rescale_factor UpperCamelCase_ = do_normalize if do_normalize is not None else self.do_normalize UpperCamelCase_ = image_mean if image_mean is not None else self.image_mean UpperCamelCase_ = image_std if image_std is not None else self.image_std UpperCamelCase_ = size if size is not None else self.size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , default_to_square=_UpperCAmelCase ) UpperCamelCase_ = crop_size if crop_size is not None else self.crop_size UpperCamelCase_ = get_size_dict(_UpperCAmelCase , param_name='crop_size' ) if not valid_images(_UpperCAmelCase ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) UpperCamelCase_ = make_batched(_UpperCAmelCase ) UpperCamelCase_ = [ [ self._preprocess_image( image=_UpperCAmelCase , do_resize=_UpperCAmelCase , size=_UpperCAmelCase , resample=_UpperCAmelCase , do_center_crop=_UpperCAmelCase , crop_size=_UpperCAmelCase , do_rescale=_UpperCAmelCase , rescale_factor=_UpperCAmelCase , do_normalize=_UpperCAmelCase , image_mean=_UpperCAmelCase , image_std=_UpperCAmelCase , data_format=_UpperCAmelCase , ) for img in video ] for video in videos ] UpperCamelCase_ = {'pixel_values': videos} return BatchFeature(data=_UpperCAmelCase , tensor_type=_UpperCAmelCase )
23
1
import argparse import requests import torch from PIL import Image from transformers import SwinConfig, SwinForMaskedImageModeling, ViTImageProcessor def _snake_case (__lowercase): UpperCamelCase_ = SwinConfig(image_size=192) if "base" in model_name: UpperCamelCase_ = 6 UpperCamelCase_ = 128 UpperCamelCase_ = (2, 2, 18, 2) UpperCamelCase_ = (4, 8, 16, 32) elif "large" in model_name: UpperCamelCase_ = 12 UpperCamelCase_ = 192 UpperCamelCase_ = (2, 2, 18, 2) UpperCamelCase_ = (6, 12, 24, 48) else: raise ValueError('Model not supported, only supports base and large variants') UpperCamelCase_ = window_size UpperCamelCase_ = embed_dim UpperCamelCase_ = depths UpperCamelCase_ = num_heads return config def _snake_case (__lowercase): if "encoder.mask_token" in name: UpperCamelCase_ = name.replace('encoder.mask_token' , 'embeddings.mask_token') if "encoder.patch_embed.proj" in name: UpperCamelCase_ = name.replace('encoder.patch_embed.proj' , 'embeddings.patch_embeddings.projection') if "encoder.patch_embed.norm" in name: UpperCamelCase_ = name.replace('encoder.patch_embed.norm' , 'embeddings.norm') if "attn.proj" in name: UpperCamelCase_ = name.replace('attn.proj' , 'attention.output.dense') if "attn" in name: UpperCamelCase_ = name.replace('attn' , 'attention.self') if "norm1" in name: UpperCamelCase_ = name.replace('norm1' , 'layernorm_before') if "norm2" in name: UpperCamelCase_ = name.replace('norm2' , 'layernorm_after') if "mlp.fc1" in name: UpperCamelCase_ = name.replace('mlp.fc1' , 'intermediate.dense') if "mlp.fc2" in name: UpperCamelCase_ = name.replace('mlp.fc2' , 'output.dense') if name == "encoder.norm.weight": UpperCamelCase_ = 'layernorm.weight' if name == "encoder.norm.bias": UpperCamelCase_ = 'layernorm.bias' if "decoder" in name: pass else: UpperCamelCase_ = 'swin.' + name return name def _snake_case (__lowercase , __lowercase): for key in orig_state_dict.copy().keys(): UpperCamelCase_ = orig_state_dict.pop(__lowercase) if "attn_mask" in key: pass elif "qkv" in key: UpperCamelCase_ = key.split('.') UpperCamelCase_ = int(key_split[2]) UpperCamelCase_ = int(key_split[4]) UpperCamelCase_ = model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size if "weight" in key: UpperCamelCase_ = val[:dim, :] UpperCamelCase_ = val[ dim : dim * 2, : ] UpperCamelCase_ = val[-dim:, :] else: UpperCamelCase_ = val[ :dim ] UpperCamelCase_ = val[ dim : dim * 2 ] UpperCamelCase_ = val[ -dim: ] else: UpperCamelCase_ = val return orig_state_dict def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase): UpperCamelCase_ = torch.load(__lowercase , map_location='cpu')['model'] UpperCamelCase_ = get_swin_config(__lowercase) UpperCamelCase_ = SwinForMaskedImageModeling(__lowercase) model.eval() UpperCamelCase_ = convert_state_dict(__lowercase , __lowercase) model.load_state_dict(__lowercase) UpperCamelCase_ = 'http://images.cocodataset.org/val2017/000000039769.jpg' UpperCamelCase_ = ViTImageProcessor(size={'height': 192, 'width': 192}) UpperCamelCase_ = Image.open(requests.get(__lowercase , stream=__lowercase).raw) UpperCamelCase_ = image_processor(images=__lowercase , return_tensors='pt') with torch.no_grad(): UpperCamelCase_ = model(**__lowercase).logits print(outputs.keys()) print('Looks ok!') if pytorch_dump_folder_path is not None: print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""") model.save_pretrained(__lowercase) print(f"""Saving image processor to {pytorch_dump_folder_path}""") image_processor.save_pretrained(__lowercase) if push_to_hub: print(f"""Pushing model and image processor for {model_name} to hub""") model.push_to_hub(f"""microsoft/{model_name}""") image_processor.push_to_hub(f"""microsoft/{model_name}""") if __name__ == "__main__": snake_case__ : List[Any] = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default="""swin-base-simmim-window6-192""", type=str, choices=["""swin-base-simmim-window6-192""", """swin-large-simmim-window12-192"""], help="""Name of the Swin SimMIM model you'd like to convert.""", ) parser.add_argument( """--checkpoint_path""", default="""/Users/nielsrogge/Documents/SwinSimMIM/simmim_pretrain__swin_base__img192_window6__100ep.pth""", type=str, help="""Path to the original PyTorch checkpoint (.pth file).""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) parser.add_argument( """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub.""" ) snake_case__ : Tuple = parser.parse_args() convert_swin_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
23
# 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 _a ( UpperCAmelCase__ ): """simple docstring""" A_ = 42 A_ = 42 class _a ( UpperCAmelCase__ , UpperCAmelCase__ ): """simple docstring""" A_ = 1 @register_to_config def __init__( self , _UpperCAmelCase = 2000 , _UpperCAmelCase = 0.1_5 , _UpperCAmelCase = 0.0_1 , _UpperCAmelCase = 1_3_4_8.0 , _UpperCAmelCase = 1e-5 , _UpperCAmelCase = 1 , ) -> Tuple: # standard deviation of the initial noise distribution UpperCamelCase_ = sigma_max # setable values UpperCamelCase_ = None self.set_sigmas(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> torch.FloatTensor: return sample def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> str: UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps UpperCamelCase_ = torch.linspace(1 , _UpperCAmelCase , _UpperCAmelCase , device=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = None , _UpperCAmelCase = None ) -> Any: UpperCamelCase_ = sigma_min if sigma_min is not None else self.config.sigma_min UpperCamelCase_ = sigma_max if sigma_max is not None else self.config.sigma_max UpperCamelCase_ = sampling_eps if sampling_eps is not None else self.config.sampling_eps if self.timesteps is None: self.set_timesteps(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = sigma_min * (sigma_max / sigma_min) ** (self.timesteps / sampling_eps) UpperCamelCase_ = torch.exp(torch.linspace(math.log(_UpperCAmelCase ) , math.log(_UpperCAmelCase ) , _UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor([sigma_min * (sigma_max / sigma_min) ** t for t in self.timesteps] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: return torch.where( timesteps == 0 , torch.zeros_like(t.to(timesteps.device ) ) , self.discrete_sigmas[timesteps - 1].to(timesteps.device ) , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SdeVeOutput, Tuple]: if self.timesteps is None: raise ValueError( '`self.timesteps` is not set, you need to run \'set_timesteps\' after creating the scheduler' ) UpperCamelCase_ = timestep * torch.ones( sample.shape[0] , device=sample.device ) # torch.repeat_interleave(timestep, sample.shape[0]) UpperCamelCase_ = (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 UpperCamelCase_ = timesteps.to(self.discrete_sigmas.device ) UpperCamelCase_ = self.discrete_sigmas[timesteps].to(sample.device ) UpperCamelCase_ = self.get_adjacent_sigma(_UpperCAmelCase , _UpperCAmelCase ).to(sample.device ) UpperCamelCase_ = torch.zeros_like(_UpperCAmelCase ) UpperCamelCase_ = (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 UpperCamelCase_ = diffusion.flatten() while len(diffusion.shape ) < len(sample.shape ): UpperCamelCase_ = diffusion.unsqueeze(-1 ) UpperCamelCase_ = drift - diffusion**2 * model_output # equation 6: sample noise for the diffusion term of UpperCamelCase_ = randn_tensor( sample.shape , layout=sample.layout , generator=_UpperCAmelCase , device=sample.device , dtype=sample.dtype ) UpperCamelCase_ = sample - drift # subtract because `dt` is a small negative timestep # TODO is the variable diffusion the correct scaling term for the noise? UpperCamelCase_ = 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=_UpperCAmelCase , prev_sample_mean=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = True , ) -> Union[SchedulerOutput, Tuple]: 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 UpperCamelCase_ = randn_tensor(sample.shape , layout=sample.layout , generator=_UpperCAmelCase ).to(sample.device ) # compute step size from the model_output, the noise, and the snr UpperCamelCase_ = torch.norm(model_output.reshape(model_output.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = torch.norm(noise.reshape(noise.shape[0] , -1 ) , dim=-1 ).mean() UpperCamelCase_ = (self.config.snr * noise_norm / grad_norm) ** 2 * 2 UpperCamelCase_ = 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 UpperCamelCase_ = step_size.flatten() while len(step_size.shape ) < len(sample.shape ): UpperCamelCase_ = step_size.unsqueeze(-1 ) UpperCamelCase_ = sample + step_size * model_output UpperCamelCase_ = prev_sample_mean + ((step_size * 2) ** 0.5) * noise if not return_dict: return (prev_sample,) return SchedulerOutput(prev_sample=_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , ) -> torch.FloatTensor: # Make sure sigmas and timesteps have the same device and dtype as original_samples UpperCamelCase_ = timesteps.to(original_samples.device ) UpperCamelCase_ = self.discrete_sigmas.to(original_samples.device )[timesteps] UpperCamelCase_ = ( noise * sigmas[:, None, None, None] if noise is not None else torch.randn_like(_UpperCAmelCase ) * sigmas[:, None, None, None] ) UpperCamelCase_ = noise + original_samples return noisy_samples def __len__( self ) -> Optional[int]: return self.config.num_train_timesteps
23
1
from __future__ import annotations import unittest from transformers import AutoTokenizer, MBartConfig, is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel @require_tf class _a : """simple docstring""" A_ = MBartConfig A_ = {} A_ = """gelu""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=99 , _UpperCAmelCase=32 , _UpperCAmelCase=2 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=20 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , ) -> Union[str, Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = eos_token_id UpperCamelCase_ = pad_token_id UpperCamelCase_ = bos_token_id def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) UpperCamelCase_ = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ) , 1 ) UpperCamelCase_ = tf.concat([input_ids, eos_tensor] , axis=1 ) UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) UpperCamelCase_ = prepare_mbart_inputs_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = TFMBartModel(config=_UpperCAmelCase ).get_decoder() UpperCamelCase_ = inputs_dict['input_ids'] UpperCamelCase_ = input_ids[:1, :] UpperCamelCase_ = inputs_dict['attention_mask'][:1, :] UpperCamelCase_ = inputs_dict['head_mask'] UpperCamelCase_ = 1 # first forward pass UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , head_mask=_UpperCAmelCase , use_cache=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = outputs.to_tuple() UpperCamelCase_ = past_key_values[1] def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , ): if attention_mask is None: UpperCamelCase_ = tf.cast(tf.math.not_equal(__lowercase , config.pad_token_id) , tf.inta) if decoder_attention_mask is None: UpperCamelCase_ = tf.concat( [ tf.ones(decoder_input_ids[:, :1].shape , dtype=tf.inta), tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id) , tf.inta), ] , axis=-1 , ) if head_mask is None: UpperCamelCase_ = tf.ones((config.encoder_layers, config.encoder_attention_heads)) if decoder_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) if cross_attn_head_mask is None: UpperCamelCase_ = tf.ones((config.decoder_layers, config.decoder_attention_heads)) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } @require_tf class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else () A_ = (TFMBartForConditionalGeneration,) if is_tf_available() else () A_ = ( { """conversational""": TFMBartForConditionalGeneration, """feature-extraction""": TFMBartModel, """summarization""": TFMBartForConditionalGeneration, """text2text-generation""": TFMBartForConditionalGeneration, """translation""": TFMBartForConditionalGeneration, } if is_tf_available() else {} ) A_ = True A_ = False A_ = False def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: if pipeline_test_casse_name != "FeatureExtractionPipelineTests": # Exception encountered when calling layer '...' return True return False def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = TFMBartModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase ) @require_sentencepiece @require_tokenizers @require_tf class _a ( unittest.TestCase ): """simple docstring""" A_ = [ """ UN Chief Says There Is No Military Solution in Syria""", ] A_ = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", ] A_ = """facebook/mbart-large-en-ro""" @cached_property def _UpperCAmelCase ( self ) -> Any: return AutoTokenizer.from_pretrained(self.model_name ) @cached_property def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name ) return model def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> int: UpperCamelCase_ = self.translate_src_text(**_UpperCAmelCase ) self.assertListEqual(self.expected_text , _UpperCAmelCase ) def _UpperCAmelCase ( self , **_UpperCAmelCase ) -> List[str]: UpperCamelCase_ = self.tokenizer(self.src_text , **_UpperCAmelCase , return_tensors='tf' ) UpperCamelCase_ = self.model.generate( model_inputs.input_ids , attention_mask=model_inputs.attention_mask , num_beams=2 ) UpperCamelCase_ = self.tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) return generated_words @slow def _UpperCAmelCase ( self ) -> List[Any]: self._assert_generated_batch_equal_expected()
23
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Optional[int] = { """configuration_pegasus_x""": ["""PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusXConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST""", """PegasusXForConditionalGeneration""", """PegasusXModel""", """PegasusXPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys snake_case__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
1
from sklearn.metrics import fa_score, matthews_corrcoef import datasets from .record_evaluation import evaluate as evaluate_record snake_case__ : int = """\ @article{wang2019superglue, title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems}, author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R}, journal={arXiv preprint arXiv:1905.00537}, year={2019} } """ snake_case__ : Dict = """\ SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after GLUE with a new set of more difficult language understanding tasks, improved resources, and a new public leaderboard. """ snake_case__ : Dict = """ Compute SuperGLUE evaluation metric associated to each SuperGLUE dataset. Args: predictions: list of predictions to score. Depending on the SuperGlUE subset: - for 'record': list of question-answer dictionaries with the following keys: - 'idx': index of the question as specified by the dataset - 'prediction_text': the predicted answer text - for 'multirc': list of question-answer dictionaries with the following keys: - 'idx': index of the question-answer pair as specified by the dataset - 'prediction': the predicted answer label - otherwise: list of predicted labels references: list of reference labels. Depending on the SuperGLUE subset: - for 'record': list of question-answers dictionaries with the following keys: - 'idx': index of the question as specified by the dataset - 'answers': list of possible answers - otherwise: list of reference labels Returns: depending on the SuperGLUE subset: - for 'record': - 'exact_match': Exact match between answer and gold answer - 'f1': F1 score - for 'multirc': - 'exact_match': Exact match between answer and gold answer - 'f1_m': Per-question macro-F1 score - 'f1_a': Average F1 score over all answers - for 'axb': 'matthews_correlation': Matthew Correlation - for 'cb': - 'accuracy': Accuracy - 'f1': F1 score - for all others: - 'accuracy': Accuracy Examples: >>> super_glue_metric = datasets.load_metric('super_glue', 'copa') # any of [\"copa\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"boolq\", \"axg\"] >>> predictions = [0, 1] >>> references = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'cb') >>> predictions = [0, 1] >>> references = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'accuracy': 1.0, 'f1': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'record') >>> predictions = [{'idx': {'passage': 0, 'query': 0}, 'prediction_text': 'answer'}] >>> references = [{'idx': {'passage': 0, 'query': 0}, 'answers': ['answer', 'another_answer']}] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 1.0, 'f1': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'multirc') >>> predictions = [{'idx': {'answer': 0, 'paragraph': 0, 'question': 0}, 'prediction': 0}, {'idx': {'answer': 1, 'paragraph': 2, 'question': 3}, 'prediction': 1}] >>> references = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 1.0, 'f1_m': 1.0, 'f1_a': 1.0} >>> super_glue_metric = datasets.load_metric('super_glue', 'axb') >>> references = [0, 1] >>> predictions = [0, 1] >>> results = super_glue_metric.compute(predictions=predictions, references=references) >>> print(results) {'matthews_correlation': 1.0} """ def _snake_case (__lowercase , __lowercase): return float((preds == labels).mean()) def _snake_case (__lowercase , __lowercase , __lowercase="binary"): UpperCamelCase_ = simple_accuracy(__lowercase , __lowercase) UpperCamelCase_ = float(fa_score(y_true=__lowercase , y_pred=__lowercase , average=__lowercase)) return { "accuracy": acc, "f1": fa, } def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = {} for id_pred, label in zip(__lowercase , __lowercase): UpperCamelCase_ = f"""{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}""" UpperCamelCase_ = id_pred['prediction'] if question_id in question_map: question_map[question_id].append((pred, label)) else: UpperCamelCase_ = [(pred, label)] UpperCamelCase_ , UpperCamelCase_ = [], [] for question, preds_labels in question_map.items(): UpperCamelCase_ , UpperCamelCase_ = zip(*__lowercase) UpperCamelCase_ = fa_score(y_true=__lowercase , y_pred=__lowercase , average='macro') fas.append(__lowercase) UpperCamelCase_ = int(sum(pred == label for pred, label in preds_labels) == len(__lowercase)) ems.append(__lowercase) UpperCamelCase_ = float(sum(__lowercase) / len(__lowercase)) UpperCamelCase_ = sum(__lowercase) / len(__lowercase) UpperCamelCase_ = float(fa_score(y_true=__lowercase , y_pred=[id_pred['prediction'] for id_pred in ids_preds])) return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a} @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _a ( datasets.Metric ): """simple docstring""" def _UpperCAmelCase ( self ) -> Optional[Any]: if self.config_name not in [ "boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg", ]: raise KeyError( 'You should supply a configuration name selected in ' '["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]' ) return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , codebase_urls=[] , reference_urls=[] , format='numpy' if not self.config_name == 'record' and not self.config_name == 'multirc' else None , ) def _UpperCAmelCase ( self ) -> str: if self.config_name == "record": return { "predictions": { "idx": { "passage": datasets.Value('int64' ), "query": datasets.Value('int64' ), }, "prediction_text": datasets.Value('string' ), }, "references": { "idx": { "passage": datasets.Value('int64' ), "query": datasets.Value('int64' ), }, "answers": datasets.Sequence(datasets.Value('string' ) ), }, } elif self.config_name == "multirc": return { "predictions": { "idx": { "answer": datasets.Value('int64' ), "paragraph": datasets.Value('int64' ), "question": datasets.Value('int64' ), }, "prediction": datasets.Value('int64' ), }, "references": datasets.Value('int64' ), } else: return { "predictions": datasets.Value('int64' ), "references": datasets.Value('int64' ), } def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: if self.config_name == "axb": return {"matthews_correlation": matthews_corrcoef(_UpperCAmelCase , _UpperCAmelCase )} elif self.config_name == "cb": return acc_and_fa(_UpperCAmelCase , _UpperCAmelCase , fa_avg='macro' ) elif self.config_name == "record": UpperCamelCase_ = [ { 'qas': [ {'id': ref['idx']['query'], 'answers': [{'text': ans} for ans in ref['answers']]} for ref in references ] } ] UpperCamelCase_ = {pred['idx']['query']: pred['prediction_text'] for pred in predictions} return evaluate_record(_UpperCAmelCase , _UpperCAmelCase )[0] elif self.config_name == "multirc": return evaluate_multirc(_UpperCAmelCase , _UpperCAmelCase ) elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]: return {"accuracy": simple_accuracy(_UpperCAmelCase , _UpperCAmelCase )} else: raise KeyError( 'You should supply a configuration name selected in ' '["boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg",]' )
23
import datasets from .evaluate import evaluate snake_case__ : int = """\ @article{hendrycks2021cuad, title={CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review}, author={Dan Hendrycks and Collin Burns and Anya Chen and Spencer Ball}, journal={arXiv preprint arXiv:2103.06268}, year={2021} } """ snake_case__ : Union[str, Any] = """ This metric wrap the official scoring script for version 1 of the Contract Understanding Atticus Dataset (CUAD). Contract Understanding Atticus Dataset (CUAD) v1 is a corpus of more than 13,000 labels in 510 commercial legal contracts that have been manually labeled to identify 41 categories of important clauses that lawyers look for when reviewing contracts in connection with corporate transactions. """ snake_case__ : Any = """ Computes CUAD scores (EM, F1, AUPR, Precision@80%Recall, and Precision@90%Recall). Args: predictions: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair as given in the references (see below) - 'prediction_text': list of possible texts for the answer, as a list of strings depending on a threshold on the confidence probability of each prediction. references: List of question-answers dictionaries with the following key-values: - 'id': id of the question-answer pair (see above), - 'answers': a Dict in the CUAD dataset format { 'text': list of possible texts for the answer, as a list of strings 'answer_start': list of start positions for the answer, as a list of ints } Note that answer_start values are not taken into account to compute the metric. Returns: 'exact_match': Exact match (the normalized answer exactly match the gold answer) 'f1': The F-score of predicted tokens versus the gold answer 'aupr': Area Under the Precision-Recall curve 'prec_at_80_recall': Precision at 80% recall 'prec_at_90_recall': Precision at 90% recall Examples: >>> predictions = [{'prediction_text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.'], 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> references = [{'answers': {'answer_start': [143, 49], 'text': ['The seller:', 'The buyer/End-User: Shenzhen LOHAS Supply Chain Management Co., Ltd.']}, 'id': 'LohaCompanyltd_20191209_F-1_EX-10.16_11917878_EX-10.16_Supply Agreement__Parties'}] >>> cuad_metric = datasets.load_metric(\"cuad\") >>> results = cuad_metric.compute(predictions=predictions, references=references) >>> print(results) {'exact_match': 100.0, 'f1': 100.0, 'aupr': 0.0, 'prec_at_80_recall': 1.0, 'prec_at_90_recall': 1.0} """ @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _a ( datasets.Metric ): """simple docstring""" def _UpperCAmelCase ( self ) -> Optional[int]: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { 'predictions': { 'id': datasets.Value('string' ), 'prediction_text': datasets.features.Sequence(datasets.Value('string' ) ), }, 'references': { 'id': datasets.Value('string' ), 'answers': datasets.features.Sequence( { 'text': datasets.Value('string' ), 'answer_start': datasets.Value('int32' ), } ), }, } ) , codebase_urls=['https://www.atticusprojectai.org/cuad'] , reference_urls=['https://www.atticusprojectai.org/cuad'] , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: UpperCamelCase_ = {prediction['id']: prediction['prediction_text'] for prediction in predictions} UpperCamelCase_ = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] UpperCamelCase_ = evaluate(dataset=_UpperCAmelCase , predictions=_UpperCAmelCase ) return score
23
1
from typing import List, Optional, Tuple from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_herbert import HerbertTokenizer snake_case__ : List[str] = logging.get_logger(__name__) snake_case__ : Optional[Any] = {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""} snake_case__ : Any = { """vocab_file""": { """allegro/herbert-base-cased""": """https://huggingface.co/allegro/herbert-base-cased/resolve/main/vocab.json""" }, """merges_file""": { """allegro/herbert-base-cased""": """https://huggingface.co/allegro/herbert-base-cased/resolve/main/merges.txt""" }, } snake_case__ : str = {"""allegro/herbert-base-cased""": 5_1_4} snake_case__ : Union[str, Any] = {} class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = VOCAB_FILES_NAMES A_ = PRETRAINED_VOCAB_FILES_MAP A_ = PRETRAINED_INIT_CONFIGURATION A_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES A_ = HerbertTokenizer def __init__( self , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase="<s>" , _UpperCAmelCase="<unk>" , _UpperCAmelCase="<pad>" , _UpperCAmelCase="<mask>" , _UpperCAmelCase="</s>" , **_UpperCAmelCase , ) -> Optional[int]: super().__init__( _UpperCAmelCase , _UpperCAmelCase , tokenizer_file=_UpperCAmelCase , cls_token=_UpperCAmelCase , unk_token=_UpperCAmelCase , pad_token=_UpperCAmelCase , mask_token=_UpperCAmelCase , sep_token=_UpperCAmelCase , **_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> List[int]: UpperCamelCase_ = [self.cls_token_id] UpperCamelCase_ = [self.sep_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None , _UpperCAmelCase = False ) -> List[int]: if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=_UpperCAmelCase , token_ids_a=_UpperCAmelCase , already_has_special_tokens=_UpperCAmelCase ) if token_ids_a is None: return [1] + ([0] * len(_UpperCAmelCase )) + [1] return [1] + ([0] * len(_UpperCAmelCase )) + [1] + ([0] * len(_UpperCAmelCase )) + [1] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> List[int]: UpperCamelCase_ = [self.sep_token_id] UpperCamelCase_ = [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 _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = None ) -> Tuple[str]: UpperCamelCase_ = self._tokenizer.model.save(_UpperCAmelCase , name=_UpperCAmelCase ) return tuple(_UpperCAmelCase )
23
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import datasets import datasets.config from .utils import require_beam class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> List[str]: return datasets.DatasetInfo( features=datasets.Features({'content': datasets.Value('string' )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_dummy_examples()} )] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) class _a ( datasets.BeamBasedBuilder ): """simple docstring""" def _UpperCAmelCase ( self ) -> Any: return datasets.DatasetInfo( features=datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) , supervised_keys=_UpperCAmelCase , ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: return [ datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'examples': get_test_nested_examples()} ) ] def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: import apache_beam as beam return pipeline | "Load Examples" >> beam.Create(_UpperCAmelCase ) def _snake_case (): return [(i, {"content": content}) for i, content in enumerate(['foo', 'bar', 'foobar'])] def _snake_case (): return [(i, {"a": {"b": [content]}}) for i, content in enumerate(['foo', 'bar', 'foobar'])] class _a ( UpperCAmelCase__ ): """simple docstring""" @require_beam def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_dummy_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_dummy_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> List[str]: import apache_beam as beam UpperCamelCase_ = beam.io.parquetio.WriteToParquet UpperCamelCase_ = len(get_test_dummy_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) with patch('apache_beam.io.parquetio.WriteToParquet' ) as write_parquet_mock: UpperCamelCase_ = partial(_UpperCAmelCase , num_shards=2 ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertTrue( os.path.exists( os.path.join( _UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train-00000-of-00002.arrow""" ) ) ) self.assertDictEqual(builder.info.features , datasets.Features({'content': datasets.Value('string' )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) # Order is not preserved when sharding, so we just check that all the elements are there self.assertListEqual(sorted(dset['train']['content'] ) , sorted(['foo', 'bar', 'foobar'] ) ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset @require_beam def _UpperCAmelCase ( self ) -> Any: with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = DummyBeamDataset(cache_dir=_UpperCAmelCase ) self.assertRaises(datasets.builder.MissingBeamOptions , builder.download_and_prepare ) @require_beam def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = len(get_test_nested_examples() ) with tempfile.TemporaryDirectory() as tmp_cache_dir: UpperCamelCase_ = NestedBeamDataset(cache_dir=_UpperCAmelCase , beam_runner='DirectRunner' ) builder.download_and_prepare() self.assertTrue( os.path.exists( os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , f"""{builder.name}-train.arrow""" ) ) ) self.assertDictEqual( builder.info.features , datasets.Features({'a': datasets.Sequence({'b': datasets.Value('string' )} )} ) ) UpperCamelCase_ = builder.as_dataset() self.assertEqual(dset['train'].num_rows , _UpperCAmelCase ) self.assertEqual(dset['train'].info.splits['train'].num_examples , _UpperCAmelCase ) self.assertDictEqual(dset['train'][0] , get_test_nested_examples()[0][1] ) self.assertDictEqual( dset['train'][expected_num_examples - 1] , get_test_nested_examples()[expected_num_examples - 1][1] ) self.assertTrue( os.path.exists(os.path.join(_UpperCAmelCase , builder.name , 'default' , '0.0.0' , 'dataset_info.json' ) ) ) del dset
23
1
import tempfile import unittest import numpy as np import transformers from transformers import GPTaTokenizer, GPTJConfig, is_flax_available, is_torch_available from transformers.testing_utils import is_pt_flax_cross_test, require_flax, tooslow from ...generation.test_flax_utils import FlaxGenerationTesterMixin from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask if is_flax_available(): import jax import jax.numpy as jnp from transformers.modeling_flax_pytorch_utils import ( convert_pytorch_state_dict_to_flax, load_flax_weights_in_pytorch_model, ) from transformers.models.gptj.modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel if is_torch_available(): import torch class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=14 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=True , _UpperCAmelCase=99 , _UpperCAmelCase=32 , _UpperCAmelCase=4 , _UpperCAmelCase=4 , _UpperCAmelCase=4 , _UpperCAmelCase=37 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=512 , _UpperCAmelCase=0.0_2 , ) -> Dict: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_input_mask UpperCamelCase_ = use_token_type_ids UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = rotary_dim UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = initializer_range UpperCamelCase_ = None UpperCamelCase_ = vocab_size - 1 UpperCamelCase_ = vocab_size - 1 UpperCamelCase_ = vocab_size - 1 def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCamelCase_ = None if self.use_input_mask: UpperCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) UpperCamelCase_ = GPTJConfig( vocab_size=self.vocab_size , n_embd=self.hidden_size , n_layer=self.num_hidden_layers , n_head=self.num_attention_heads , n_positions=self.max_position_embeddings , use_cache=_UpperCAmelCase , bos_token_id=self.bos_token_id , eos_token_id=self.eos_token_id , pad_token_id=self.pad_token_id , rotary_dim=self.rotary_dim , ) return (config, input_ids, input_mask) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = config_and_inputs UpperCamelCase_ = {'input_ids': input_ids, 'attention_mask': attention_mask} return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = 20 UpperCamelCase_ = model_class_name(_UpperCAmelCase ) UpperCamelCase_ = model.init_cache(input_ids.shape[0] , _UpperCAmelCase ) UpperCamelCase_ = jnp.ones((input_ids.shape[0], max_decoder_length) , dtype='i4' ) UpperCamelCase_ = jnp.broadcast_to( jnp.arange(input_ids.shape[-1] - 1 )[None, :] , (input_ids.shape[0], input_ids.shape[-1] - 1) ) UpperCamelCase_ = model( input_ids[:, :-1] , attention_mask=_UpperCAmelCase , past_key_values=_UpperCAmelCase , position_ids=_UpperCAmelCase , ) UpperCamelCase_ = jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]] , dtype='i4' ) UpperCamelCase_ = model( input_ids[:, -1:] , attention_mask=_UpperCAmelCase , past_key_values=outputs_cache.past_key_values , position_ids=_UpperCAmelCase , ) UpperCamelCase_ = model(_UpperCAmelCase ) UpperCamelCase_ = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = 20 UpperCamelCase_ = model_class_name(_UpperCAmelCase ) UpperCamelCase_ = jnp.concatenate( [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1]) )] , axis=-1 , ) UpperCamelCase_ = model.init_cache(input_ids.shape[0] , _UpperCAmelCase ) UpperCamelCase_ = jnp.broadcast_to( jnp.arange(input_ids.shape[-1] - 1 )[None, :] , (input_ids.shape[0], input_ids.shape[-1] - 1) ) UpperCamelCase_ = model( input_ids[:, :-1] , attention_mask=_UpperCAmelCase , past_key_values=_UpperCAmelCase , position_ids=_UpperCAmelCase , ) UpperCamelCase_ = jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]] , dtype='i4' ) UpperCamelCase_ = model( input_ids[:, -1:] , past_key_values=outputs_cache.past_key_values , attention_mask=_UpperCAmelCase , position_ids=_UpperCAmelCase , ) UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase ) UpperCamelCase_ = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) @require_flax class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (FlaxGPTJModel, FlaxGPTJForCausalLM) if is_flax_available() else () A_ = (FlaxGPTJForCausalLM,) if is_flax_available() else () def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = FlaxGPTJModelTester(self ) def _UpperCAmelCase ( self ) -> Any: for model_class_name in self.all_model_classes: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.check_use_cache_forward(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: for model_class_name in self.all_model_classes: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.check_use_cache_forward_with_attn_mask( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) @tooslow def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = GPTaTokenizer.from_pretrained('gpt2' , pad_token='<|endoftext|>' , padding_side='left' ) UpperCamelCase_ = tokenizer(['Hello this is a long string', 'Hey'] , return_tensors='np' , padding=_UpperCAmelCase , truncation=_UpperCAmelCase ) UpperCamelCase_ = FlaxGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B' ) UpperCamelCase_ = False UpperCamelCase_ = model.config.eos_token_id UpperCamelCase_ = jax.jit(model.generate ) UpperCamelCase_ = jit_generate( inputs['input_ids'] , attention_mask=inputs['attention_mask'] , pad_token_id=tokenizer.pad_token_id ).sequences UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = [ 'Hello this is a long string of text.\n\nI\'m trying to get the text of the', 'Hey, I\'m a little late to the party. I\'m going to', ] self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) @is_pt_flax_cross_test def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): # prepare inputs UpperCamelCase_ = self._prepare_for_class(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = {k: torch.tensor(v.tolist() ) for k, v in prepared_inputs_dict.items()} # load corresponding PyTorch class UpperCamelCase_ = model_class.__name__[4:] # Skip the "Flax" at the beginning UpperCamelCase_ = getattr(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = pt_inputs['input_ids'].shape UpperCamelCase_ = np.random.randint(0 , seq_length - 1 , size=(batch_size,) ) for batch_idx, start_index in enumerate(_UpperCAmelCase ): UpperCamelCase_ = 0 UpperCamelCase_ = 1 UpperCamelCase_ = 0 UpperCamelCase_ = 1 UpperCamelCase_ = pt_model_class(_UpperCAmelCase ).eval() UpperCamelCase_ = model_class(_UpperCAmelCase , dtype=jnp.floataa ) UpperCamelCase_ = convert_pytorch_state_dict_to_flax(pt_model.state_dict() , _UpperCAmelCase ) UpperCamelCase_ = fx_state with torch.no_grad(): UpperCamelCase_ = pt_model(**_UpperCAmelCase ).to_tuple() UpperCamelCase_ = fx_model(**_UpperCAmelCase ).to_tuple() self.assertEqual(len(_UpperCAmelCase ) , len(_UpperCAmelCase ) , 'Output lengths differ between Flax and PyTorch' ) for fx_output, pt_output in zip(_UpperCAmelCase , _UpperCAmelCase ): self.assert_almost_equals(fx_output[:, -1] , pt_output[:, -1].numpy() , 4e-2 ) with tempfile.TemporaryDirectory() as tmpdirname: pt_model.save_pretrained(_UpperCAmelCase ) UpperCamelCase_ = model_class.from_pretrained(_UpperCAmelCase , from_pt=_UpperCAmelCase ) UpperCamelCase_ = fx_model_loaded(**_UpperCAmelCase ).to_tuple() self.assertEqual( len(_UpperCAmelCase ) , len(_UpperCAmelCase ) , 'Output lengths differ between Flax and PyTorch' ) for fx_output_loaded, pt_output in zip(_UpperCAmelCase , _UpperCAmelCase ): self.assert_almost_equals(fx_output_loaded[:, -1] , pt_output[:, -1].numpy() , 4e-2 ) @is_pt_flax_cross_test def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): # prepare inputs UpperCamelCase_ = self._prepare_for_class(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = {k: torch.tensor(v.tolist() ) for k, v in prepared_inputs_dict.items()} # load corresponding PyTorch class UpperCamelCase_ = model_class.__name__[4:] # Skip the "Flax" at the beginning UpperCamelCase_ = getattr(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = pt_model_class(_UpperCAmelCase ).eval() UpperCamelCase_ = model_class(_UpperCAmelCase , dtype=jnp.floataa ) UpperCamelCase_ = load_flax_weights_in_pytorch_model(_UpperCAmelCase , fx_model.params ) UpperCamelCase_ , UpperCamelCase_ = pt_inputs['input_ids'].shape UpperCamelCase_ = np.random.randint(0 , seq_length - 1 , size=(batch_size,) ) for batch_idx, start_index in enumerate(_UpperCAmelCase ): UpperCamelCase_ = 0 UpperCamelCase_ = 1 UpperCamelCase_ = 0 UpperCamelCase_ = 1 # make sure weights are tied in PyTorch pt_model.tie_weights() with torch.no_grad(): UpperCamelCase_ = pt_model(**_UpperCAmelCase ).to_tuple() UpperCamelCase_ = fx_model(**_UpperCAmelCase ).to_tuple() self.assertEqual(len(_UpperCAmelCase ) , len(_UpperCAmelCase ) , 'Output lengths differ between Flax and PyTorch' ) for fx_output, pt_output in zip(_UpperCAmelCase , _UpperCAmelCase ): self.assert_almost_equals(fx_output[:, -1] , pt_output[:, -1].numpy() , 4e-2 ) with tempfile.TemporaryDirectory() as tmpdirname: fx_model.save_pretrained(_UpperCAmelCase ) UpperCamelCase_ = pt_model_class.from_pretrained(_UpperCAmelCase , from_flax=_UpperCAmelCase ) with torch.no_grad(): UpperCamelCase_ = pt_model_loaded(**_UpperCAmelCase ).to_tuple() self.assertEqual( len(_UpperCAmelCase ) , len(_UpperCAmelCase ) , 'Output lengths differ between Flax and PyTorch' ) for fx_output, pt_output in zip(_UpperCAmelCase , _UpperCAmelCase ): self.assert_almost_equals(fx_output[:, -1] , pt_output[:, -1].numpy() , 4e-2 ) @tooslow def _UpperCAmelCase ( self ) -> Optional[int]: for model_class_name in self.all_model_classes: UpperCamelCase_ = model_class_name.from_pretrained('EleutherAI/gpt-j-6B' ) UpperCamelCase_ = model(np.ones((1, 1) ) ) self.assertIsNotNone(_UpperCAmelCase )
23
import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = AlbertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = AlbertForPreTraining(__lowercase) # Load weights from tf checkpoint load_tf_weights_in_albert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--albert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained ALBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : str = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
23
1
import datetime import platform import subprocess from typing import Optional, Tuple, Union import numpy as np def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = f"""{sampling_rate}""" UpperCamelCase_ = '1' UpperCamelCase_ = 'f32le' UpperCamelCase_ = [ 'ffmpeg', '-i', 'pipe:0', '-ac', ac, '-ar', ar, '-f', format_for_conversion, '-hide_banner', '-loglevel', 'quiet', 'pipe:1', ] try: with subprocess.Popen(__lowercase , stdin=subprocess.PIPE , stdout=subprocess.PIPE) as ffmpeg_process: UpperCamelCase_ = ffmpeg_process.communicate(__lowercase) except FileNotFoundError as error: raise ValueError('ffmpeg was not found but is required to load audio files from filename') from error UpperCamelCase_ = output_stream[0] UpperCamelCase_ = np.frombuffer(__lowercase , np.floataa) if audio.shape[0] == 0: raise ValueError('Malformed soundfile') return audio def _snake_case (__lowercase , __lowercase , __lowercase = "f32le" , ): UpperCamelCase_ = f"""{sampling_rate}""" UpperCamelCase_ = '1' if format_for_conversion == "s16le": UpperCamelCase_ = 2 elif format_for_conversion == "f32le": UpperCamelCase_ = 4 else: raise ValueError(f"""Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`""") UpperCamelCase_ = platform.system() if system == "Linux": UpperCamelCase_ = 'alsa' UpperCamelCase_ = 'default' elif system == "Darwin": UpperCamelCase_ = 'avfoundation' UpperCamelCase_ = ':0' elif system == "Windows": UpperCamelCase_ = 'dshow' UpperCamelCase_ = 'default' UpperCamelCase_ = [ 'ffmpeg', '-f', format_, '-i', input_, '-ac', ac, '-ar', ar, '-f', format_for_conversion, '-fflags', 'nobuffer', '-hide_banner', '-loglevel', 'quiet', 'pipe:1', ] UpperCamelCase_ = int(round(sampling_rate * chunk_length_s)) * size_of_sample UpperCamelCase_ = _ffmpeg_stream(__lowercase , __lowercase) for item in iterator: yield item def _snake_case (__lowercase , __lowercase , __lowercase = None , __lowercase = None , __lowercase = "f32le" , ): if stream_chunk_s is not None: UpperCamelCase_ = stream_chunk_s else: UpperCamelCase_ = chunk_length_s UpperCamelCase_ = ffmpeg_microphone(__lowercase , __lowercase , format_for_conversion=__lowercase) if format_for_conversion == "s16le": UpperCamelCase_ = np.intaa UpperCamelCase_ = 2 elif format_for_conversion == "f32le": UpperCamelCase_ = np.floataa UpperCamelCase_ = 4 else: raise ValueError(f"""Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`""") if stride_length_s is None: UpperCamelCase_ = chunk_length_s / 6 UpperCamelCase_ = int(round(sampling_rate * chunk_length_s)) * size_of_sample if isinstance(__lowercase , (int, float)): UpperCamelCase_ = [stride_length_s, stride_length_s] UpperCamelCase_ = int(round(sampling_rate * stride_length_s[0])) * size_of_sample UpperCamelCase_ = int(round(sampling_rate * stride_length_s[1])) * size_of_sample UpperCamelCase_ = datetime.datetime.now() UpperCamelCase_ = datetime.timedelta(seconds=__lowercase) for item in chunk_bytes_iter(__lowercase , __lowercase , stride=(stride_left, stride_right) , stream=__lowercase): # Put everything back in numpy scale UpperCamelCase_ = np.frombuffer(item['raw'] , dtype=__lowercase) UpperCamelCase_ = ( item['stride'][0] // size_of_sample, item['stride'][1] // size_of_sample, ) UpperCamelCase_ = sampling_rate audio_time += delta if datetime.datetime.now() > audio_time + 10 * delta: # We're late !! SKIP continue yield item def _snake_case (__lowercase , __lowercase , __lowercase , __lowercase = False): UpperCamelCase_ = B'' UpperCamelCase_ , UpperCamelCase_ = stride if stride_left + stride_right >= chunk_len: raise ValueError( f"""Stride needs to be strictly smaller than chunk_len: ({stride_left}, {stride_right}) vs {chunk_len}""") UpperCamelCase_ = 0 for raw in iterator: acc += raw if stream and len(__lowercase) < chunk_len: UpperCamelCase_ = (_stride_left, 0) yield {"raw": acc[:chunk_len], "stride": stride, "partial": True} else: while len(__lowercase) >= chunk_len: # We are flushing the accumulator UpperCamelCase_ = (_stride_left, stride_right) UpperCamelCase_ = {'raw': acc[:chunk_len], 'stride': stride} if stream: UpperCamelCase_ = False yield item UpperCamelCase_ = stride_left UpperCamelCase_ = acc[chunk_len - stride_left - stride_right :] # Last chunk if len(__lowercase) > stride_left: UpperCamelCase_ = {'raw': acc, 'stride': (_stride_left, 0)} if stream: UpperCamelCase_ = False yield item def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = 2**24 # 16Mo try: with subprocess.Popen(__lowercase , stdout=subprocess.PIPE , bufsize=__lowercase) as ffmpeg_process: while True: UpperCamelCase_ = ffmpeg_process.stdout.read(__lowercase) if raw == b"": break yield raw except FileNotFoundError as error: raise ValueError('ffmpeg was not found but is required to stream audio files from filename') from error
23
from transformers import BertTokenizer, EncoderDecoderModel, SeqaSeqTrainer, SeqaSeqTrainingArguments from transformers.testing_utils import TestCasePlus, require_torch, slow from transformers.utils import is_datasets_available if is_datasets_available(): import datasets class _a ( UpperCAmelCase__ ): """simple docstring""" @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = EncoderDecoderModel.from_encoder_decoder_pretrained('prajjwal1/bert-tiny' , 'prajjwal1/bert-tiny' ) UpperCamelCase_ = BertTokenizer.from_pretrained('bert-base-uncased' ) UpperCamelCase_ = bertabert.config.encoder.vocab_size UpperCamelCase_ = tokenizer.sep_token_id UpperCamelCase_ = tokenizer.cls_token_id UpperCamelCase_ = 128 UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='train[:1%]' ) UpperCamelCase_ = datasets.load_dataset('cnn_dailymail' , '3.0.0' , split='validation[:1%]' ) UpperCamelCase_ = train_dataset.select(range(32 ) ) UpperCamelCase_ = val_dataset.select(range(16 ) ) UpperCamelCase_ = 4 def _map_to_encoder_decoder_inputs(_UpperCAmelCase ): # Tokenizer will automatically set [BOS] <text> [EOS] UpperCamelCase_ = tokenizer(batch['article'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=512 ) UpperCamelCase_ = tokenizer(batch['highlights'] , padding='max_length' , truncation=_UpperCAmelCase , max_length=128 ) UpperCamelCase_ = inputs.input_ids UpperCamelCase_ = inputs.attention_mask UpperCamelCase_ = outputs.input_ids UpperCamelCase_ = outputs.input_ids.copy() UpperCamelCase_ = [ [-100 if token == tokenizer.pad_token_id else token for token in labels] for labels in batch['labels'] ] UpperCamelCase_ = outputs.attention_mask assert all(len(_UpperCAmelCase ) == 512 for x in inputs.input_ids ) assert all(len(_UpperCAmelCase ) == 128 for x in outputs.input_ids ) return batch def _compute_metrics(_UpperCAmelCase ): UpperCamelCase_ = pred.label_ids UpperCamelCase_ = pred.predictions # all unnecessary tokens are removed UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = sum([int(pred_str[i] == label_str[i] ) for i in range(len(_UpperCAmelCase ) )] ) / len(_UpperCAmelCase ) return {"accuracy": accuracy} # map train dataset UpperCamelCase_ = train_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) train_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) # same for validation dataset UpperCamelCase_ = val_dataset.map( _map_to_encoder_decoder_inputs , batched=_UpperCAmelCase , batch_size=_UpperCAmelCase , remove_columns=['article', 'highlights'] , ) val_dataset.set_format( type='torch' , columns=['input_ids', 'attention_mask', 'decoder_input_ids', 'decoder_attention_mask', 'labels'] , ) UpperCamelCase_ = self.get_auto_remove_tmp_dir() UpperCamelCase_ = SeqaSeqTrainingArguments( output_dir=_UpperCAmelCase , per_device_train_batch_size=_UpperCAmelCase , per_device_eval_batch_size=_UpperCAmelCase , predict_with_generate=_UpperCAmelCase , evaluation_strategy='steps' , do_train=_UpperCAmelCase , do_eval=_UpperCAmelCase , warmup_steps=0 , eval_steps=2 , logging_steps=2 , ) # instantiate trainer UpperCamelCase_ = SeqaSeqTrainer( model=_UpperCAmelCase , args=_UpperCAmelCase , compute_metrics=_compute_metrics , train_dataset=_UpperCAmelCase , eval_dataset=_UpperCAmelCase , tokenizer=_UpperCAmelCase , ) # start training trainer.train()
23
1
import os import time import numpy as np import onnxruntime as ort snake_case__ : Tuple = """1""" snake_case__ : Optional[int] = """0""" snake_case__ : Any = """1""" snake_case__ : List[str] = ort.SessionOptions() snake_case__ : List[str] = ort.GraphOptimizationLevel.ORT_DISABLE_ALL print("""Create inference session...""") snake_case__ : List[Any] = ["""TensorrtExecutionProvider""", """CUDAExecutionProvider"""] snake_case__ : str = ort.InferenceSession("""model.onnx""", sess_options=sess_opt, providers=execution_provider) snake_case__ : List[str] = ort.RunOptions() snake_case__ : Optional[int] = 1_2_8 snake_case__ : Optional[int] = 1 snake_case__ : Union[str, Any] = np.ones((batch, sequence), dtype=np.intaa) snake_case__ : int = np.ones((batch, sequence), dtype=np.intaa) snake_case__ : Tuple = np.ones((batch, sequence), dtype=np.intaa) print("""Warm up phase...""") sess.run( None, { sess.get_inputs()[0].name: input_ids, sess.get_inputs()[1].name: attention_mask, sess.get_inputs()[2].name: token_type_ids, }, run_options=run_opt, ) print("""Start inference...""") snake_case__ : str = time.time() snake_case__ : Tuple = 2_0_0_0 snake_case__ : Dict = {} for iter in range(max_iters): snake_case__ : Tuple = sess.run( None, { sess.get_inputs()[0].name: input_ids, sess.get_inputs()[1].name: attention_mask, sess.get_inputs()[2].name: token_type_ids, }, run_options=run_opt, ) print("""Average Inference Time = {:.3f} ms""".format((time.time() - start_time) * 1_0_0_0 / max_iters))
23
import argparse import os import evaluate import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType ######################################################################## # This is a fully working simple example to use Accelerate # and perform gradient accumulation # # This example trains a Bert base model on GLUE MRPC # in any of the following settings (with the same script): # - single CPU or single GPU # - multi GPUS (using PyTorch distributed mode) # - (multi) TPUs # - fp16 (mixed-precision) or fp32 (normal precision) # # To run it in each of these various modes, follow the instructions # in the readme for examples: # https://github.com/huggingface/accelerate/tree/main/examples # ######################################################################## snake_case__ : Dict = 1_6 snake_case__ : List[str] = 3_2 def _snake_case (__lowercase , __lowercase = 16): UpperCamelCase_ = AutoTokenizer.from_pretrained('bert-base-cased') UpperCamelCase_ = load_dataset('glue' , 'mrpc') def tokenize_function(__lowercase): # max_length=None => use the model max length (it's actually the default) UpperCamelCase_ = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=__lowercase , max_length=__lowercase) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset # starting with the main process first: with accelerator.main_process_first(): UpperCamelCase_ = datasets.map( __lowercase , batched=__lowercase , remove_columns=['idx', 'sentence1', 'sentence2'] , ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library UpperCamelCase_ = tokenized_datasets.rename_column('label' , 'labels') def collate_fn(__lowercase): # On TPU it's best to pad everything to the same length or training will be very slow. UpperCamelCase_ = 128 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": UpperCamelCase_ = 16 elif accelerator.mixed_precision != "no": UpperCamelCase_ = 8 else: UpperCamelCase_ = None return tokenizer.pad( __lowercase , padding='longest' , max_length=__lowercase , pad_to_multiple_of=__lowercase , return_tensors='pt' , ) # Instantiate dataloaders. UpperCamelCase_ = DataLoader( tokenized_datasets['train'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) UpperCamelCase_ = DataLoader( tokenized_datasets['validation'] , shuffle=__lowercase , collate_fn=__lowercase , batch_size=__lowercase) return train_dataloader, eval_dataloader # For testing only if os.environ.get("""TESTING_MOCKED_DATALOADERS""", None) == "1": from accelerate.test_utils.training import mocked_dataloaders snake_case__ : List[str] = mocked_dataloaders # noqa: F811 def _snake_case (__lowercase , __lowercase): # For testing only if os.environ.get('TESTING_MOCKED_DATALOADERS' , __lowercase) == "1": UpperCamelCase_ = 2 # New Code # UpperCamelCase_ = int(args.gradient_accumulation_steps) # Initialize accelerator UpperCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , gradient_accumulation_steps=__lowercase) if accelerator.distributed_type == DistributedType.TPU and gradient_accumulation_steps > 1: raise NotImplementedError( 'Gradient accumulation on TPUs is currently not supported. Pass `gradient_accumulation_steps=1`') # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs UpperCamelCase_ = config['lr'] UpperCamelCase_ = int(config['num_epochs']) UpperCamelCase_ = int(config['seed']) UpperCamelCase_ = int(config['batch_size']) UpperCamelCase_ = evaluate.load('glue' , 'mrpc') set_seed(__lowercase) UpperCamelCase_ , UpperCamelCase_ = get_dataloaders(__lowercase , __lowercase) # Instantiate the model (we build the model here so that the seed also control new weights initialization) UpperCamelCase_ = AutoModelForSequenceClassification.from_pretrained('bert-base-cased' , return_dict=__lowercase) # We could avoid this line since the accelerator is set with `device_placement=True` (default value). # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that). UpperCamelCase_ = model.to(accelerator.device) # Instantiate optimizer UpperCamelCase_ = AdamW(params=model.parameters() , lr=__lowercase) # Instantiate scheduler UpperCamelCase_ = get_linear_schedule_with_warmup( optimizer=__lowercase , num_warmup_steps=100 , num_training_steps=(len(__lowercase) * num_epochs) , ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = accelerator.prepare( __lowercase , __lowercase , __lowercase , __lowercase , __lowercase) # Now we train the model for epoch in range(__lowercase): model.train() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) # New code # # We use the new `accumulate` context manager to perform gradient accumulation # We also currently do not support TPUs nor advise it as bugs were found on the XLA side when running our tests. with accelerator.accumulate(__lowercase): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = output.loss accelerator.backward(__lowercase) optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(__lowercase): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device) with torch.no_grad(): UpperCamelCase_ = model(**__lowercase) UpperCamelCase_ = outputs.logits.argmax(dim=-1) UpperCamelCase_ , UpperCamelCase_ = accelerator.gather_for_metrics((predictions, batch['labels'])) metric.add_batch( predictions=__lowercase , references=__lowercase , ) UpperCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f"""epoch {epoch}:""" , __lowercase) def _snake_case (): UpperCamelCase_ = argparse.ArgumentParser(description='Simple example of training script.') parser.add_argument( '--mixed_precision' , type=__lowercase , default=__lowercase , choices=['no', 'fp16', 'bf16', 'fp8'] , help='Whether to use mixed precision. Choose' 'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.' 'and an Nvidia Ampere GPU.' , ) # New Code # parser.add_argument( '--gradient_accumulation_steps' , type=__lowercase , default=1 , help='The number of minibatches to be ran before gradients are accumulated.' , ) parser.add_argument('--cpu' , action='store_true' , help='If passed, will train on the CPU.') UpperCamelCase_ = parser.parse_args() UpperCamelCase_ = {'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(__lowercase , __lowercase) if __name__ == "__main__": main()
23
1
import unittest import numpy as np import timeout_decorator # noqa from transformers import BlenderbotConfig, is_flax_available from transformers.testing_utils import jax_device, require_flax, slow from ...generation.test_flax_utils import FlaxGenerationTesterMixin from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor if is_flax_available(): import os # The slow tests are often failing with OOM error on GPU # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html snake_case__ : List[str] = """platform""" import jax import jax.numpy as jnp from transformers import BlenderbotTokenizer from transformers.models.blenderbot.modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, shift_tokens_right, ) def _snake_case (__lowercase , __lowercase , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , __lowercase=None , ): if attention_mask is None: UpperCamelCase_ = np.where(input_ids != config.pad_token_id , 1 , 0) if decoder_attention_mask is None: UpperCamelCase_ = np.where(decoder_input_ids != config.pad_token_id , 1 , 0) if head_mask is None: UpperCamelCase_ = np.ones((config.encoder_layers, config.encoder_attention_heads)) if decoder_head_mask is None: UpperCamelCase_ = np.ones((config.decoder_layers, config.decoder_attention_heads)) if cross_attn_head_mask is None: UpperCamelCase_ = np.ones((config.decoder_layers, config.decoder_attention_heads)) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": attention_mask, } class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=99 , _UpperCAmelCase=16 , _UpperCAmelCase=2 , _UpperCAmelCase=4 , _UpperCAmelCase=4 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=32 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , _UpperCAmelCase=0.0_2 , ) -> List[str]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = eos_token_id UpperCamelCase_ = pad_token_id UpperCamelCase_ = bos_token_id UpperCamelCase_ = initializer_range def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = np.clip(ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) , 3 , self.vocab_size ) UpperCamelCase_ = np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1) , dtype=np.intaa )) , -1 ) UpperCamelCase_ = shift_tokens_right(_UpperCAmelCase , 1 , 2 ) UpperCamelCase_ = BlenderbotConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_id=self.eos_token_id , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , initializer_range=self.initializer_range , use_cache=_UpperCAmelCase , ) UpperCamelCase_ = prepare_blenderbot_inputs_dict(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) return config, inputs_dict def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = 20 UpperCamelCase_ = model_class_name(_UpperCAmelCase ) UpperCamelCase_ = model.encode(inputs_dict['input_ids'] ) UpperCamelCase_ , UpperCamelCase_ = ( inputs_dict['decoder_input_ids'], inputs_dict['decoder_attention_mask'], ) UpperCamelCase_ = model.init_cache(decoder_input_ids.shape[0] , _UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) , dtype='i4' ) UpperCamelCase_ = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) UpperCamelCase_ = model.decode( decoder_input_ids[:, :-1] , _UpperCAmelCase , decoder_attention_mask=_UpperCAmelCase , past_key_values=_UpperCAmelCase , decoder_position_ids=_UpperCAmelCase , ) UpperCamelCase_ = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype='i4' ) UpperCamelCase_ = model.decode( decoder_input_ids[:, -1:] , _UpperCAmelCase , decoder_attention_mask=_UpperCAmelCase , past_key_values=outputs_cache.past_key_values , decoder_position_ids=_UpperCAmelCase , ) UpperCamelCase_ = model.decode(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = 20 UpperCamelCase_ = model_class_name(_UpperCAmelCase ) UpperCamelCase_ = model.encode(inputs_dict['input_ids'] ) UpperCamelCase_ , UpperCamelCase_ = ( inputs_dict['decoder_input_ids'], inputs_dict['decoder_attention_mask'], ) UpperCamelCase_ = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] , axis=-1 , ) UpperCamelCase_ = model.init_cache(decoder_input_ids.shape[0] , _UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) UpperCamelCase_ = model.decode( decoder_input_ids[:, :-1] , _UpperCAmelCase , decoder_attention_mask=_UpperCAmelCase , past_key_values=_UpperCAmelCase , decoder_position_ids=_UpperCAmelCase , ) UpperCamelCase_ = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype='i4' ) UpperCamelCase_ = model.decode( decoder_input_ids[:, -1:] , _UpperCAmelCase , past_key_values=outputs_cache.past_key_values , decoder_attention_mask=_UpperCAmelCase , decoder_position_ids=_UpperCAmelCase , ) UpperCamelCase_ = model.decode(_UpperCAmelCase , _UpperCAmelCase , decoder_attention_mask=_UpperCAmelCase ) UpperCamelCase_ = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) @require_flax class _a ( unittest.TestCase ): """simple docstring""" A_ = 99 def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = np.array( [ [71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 82, 2], [5, 97, 17, 39, 94, 40, 2], [76, 83, 94, 25, 70, 78, 2], [87, 59, 41, 35, 48, 66, 2], [55, 13, 16, 58, 5, 2, 1], # note padding [64, 27, 31, 51, 12, 75, 2], [52, 64, 86, 17, 83, 39, 2], [48, 61, 9, 24, 71, 82, 2], [26, 1, 60, 48, 22, 13, 2], [21, 5, 62, 28, 14, 76, 2], [45, 98, 37, 86, 59, 48, 2], [70, 70, 50, 9, 28, 0, 2], ] , dtype=np.intaa , ) UpperCamelCase_ = input_ids.shape[0] UpperCamelCase_ = BlenderbotConfig( vocab_size=self.vocab_size , d_model=24 , encoder_layers=2 , decoder_layers=2 , encoder_attention_heads=2 , decoder_attention_heads=2 , encoder_ffn_dim=32 , decoder_ffn_dim=32 , max_position_embeddings=48 , eos_token_id=2 , pad_token_id=1 , bos_token_id=0 , ) return config, input_ids, batch_size def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self._get_config_and_data() UpperCamelCase_ = FlaxBlenderbotForConditionalGeneration(_UpperCAmelCase ) UpperCamelCase_ = lm_model(input_ids=_UpperCAmelCase ) UpperCamelCase_ = (batch_size, input_ids.shape[1], config.vocab_size) self.assertEqual(outputs['logits'].shape , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = BlenderbotConfig( vocab_size=self.vocab_size , d_model=14 , encoder_layers=2 , decoder_layers=2 , encoder_attention_heads=2 , decoder_attention_heads=2 , encoder_ffn_dim=8 , decoder_ffn_dim=8 , max_position_embeddings=48 , ) UpperCamelCase_ = FlaxBlenderbotForConditionalGeneration(_UpperCAmelCase ) UpperCamelCase_ = np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]] , dtype=np.intaa ) UpperCamelCase_ = np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]] , dtype=np.intaa ) UpperCamelCase_ = lm_model(input_ids=_UpperCAmelCase , decoder_input_ids=_UpperCAmelCase ) UpperCamelCase_ = (*summary.shape, config.vocab_size) self.assertEqual(outputs['logits'].shape , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]] , dtype=np.intaa ) UpperCamelCase_ = shift_tokens_right(_UpperCAmelCase , 1 , 2 ) UpperCamelCase_ = np.equal(_UpperCAmelCase , 1 ).astype(np.floataa ).sum() UpperCamelCase_ = np.equal(_UpperCAmelCase , 1 ).astype(np.floataa ).sum() self.assertEqual(shifted.shape , input_ids.shape ) self.assertEqual(_UpperCAmelCase , n_pad_before - 1 ) self.assertTrue(np.equal(shifted[:, 0] , 2 ).all() ) @require_flax class _a ( UpperCAmelCase__ , unittest.TestCase , UpperCAmelCase__ ): """simple docstring""" A_ = True A_ = ( ( FlaxBlenderbotModel, FlaxBlenderbotForConditionalGeneration, ) if is_flax_available() else () ) A_ = (FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else () def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = FlaxBlenderbotModelTester(self ) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): UpperCamelCase_ = self._prepare_for_class(_UpperCAmelCase , _UpperCAmelCase ) UpperCamelCase_ = model_class(_UpperCAmelCase ) @jax.jit def encode_jitted(_UpperCAmelCase , _UpperCAmelCase=None , **_UpperCAmelCase ): return model.encode(input_ids=_UpperCAmelCase , attention_mask=_UpperCAmelCase ) with self.subTest('JIT Enabled' ): UpperCamelCase_ = encode_jitted(**_UpperCAmelCase ).to_tuple() with self.subTest('JIT Disabled' ): with jax.disable_jit(): UpperCamelCase_ = encode_jitted(**_UpperCAmelCase ).to_tuple() self.assertEqual(len(_UpperCAmelCase ) , len(_UpperCAmelCase ) ) for jitted_output, output in zip(_UpperCAmelCase , _UpperCAmelCase ): self.assertEqual(jitted_output.shape , output.shape ) def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = model.encode(inputs_dict['input_ids'] , inputs_dict['attention_mask'] ) UpperCamelCase_ = { 'decoder_input_ids': inputs_dict['decoder_input_ids'], 'decoder_attention_mask': inputs_dict['decoder_attention_mask'], 'encoder_outputs': encoder_outputs, } @jax.jit def decode_jitted(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): return model.decode( decoder_input_ids=_UpperCAmelCase , decoder_attention_mask=_UpperCAmelCase , encoder_outputs=_UpperCAmelCase , ) with self.subTest('JIT Enabled' ): UpperCamelCase_ = decode_jitted(**_UpperCAmelCase ).to_tuple() with self.subTest('JIT Disabled' ): with jax.disable_jit(): UpperCamelCase_ = decode_jitted(**_UpperCAmelCase ).to_tuple() self.assertEqual(len(_UpperCAmelCase ) , len(_UpperCAmelCase ) ) for jitted_output, output in zip(_UpperCAmelCase , _UpperCAmelCase ): self.assertEqual(jitted_output.shape , output.shape ) @slow def _UpperCAmelCase ( self ) -> List[str]: for model_class_name in self.all_model_classes: UpperCamelCase_ = model_class_name.from_pretrained('facebook/blenderbot-400M-distill' ) # FlaxBlenderbotForSequenceClassification expects eos token in input_ids UpperCamelCase_ = np.ones((1, 1) ) * model.config.eos_token_id UpperCamelCase_ = model(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) @unittest.skipUnless(jax_device != 'cpu' , '3B test too slow on CPU.' ) @slow def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = {'num_beams': 1, 'early_stopping': True, 'min_length': 15, 'max_length': 25} UpperCamelCase_ = {'skip_special_tokens': True, 'clean_up_tokenization_spaces': True} UpperCamelCase_ = FlaxBlenderbotForConditionalGeneration.from_pretrained('facebook/blenderbot-3B' , from_pt=_UpperCAmelCase ) UpperCamelCase_ = BlenderbotTokenizer.from_pretrained('facebook/blenderbot-3B' ) UpperCamelCase_ = ['Sam'] UpperCamelCase_ = tokenizer(_UpperCAmelCase , return_tensors='jax' ) UpperCamelCase_ = model.generate(**_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = 'Sam is a great name. It means "sun" in Gaelic.' UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , **_UpperCAmelCase ) assert generated_txt[0].strip() == tgt_text
23
import inspect import unittest import numpy as np from tests.test_modeling_common import floats_tensor from transformers import MaskaFormerConfig, is_torch_available, is_vision_available from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import cached_property from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel if is_vision_available(): from transformers import MaskaFormerImageProcessor if is_vision_available(): from PIL import Image class _a : """simple docstring""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=2 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=10 , _UpperCAmelCase=3 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=32 * 8 , _UpperCAmelCase=4 , _UpperCAmelCase=64 , ) -> List[Any]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = is_training UpperCamelCase_ = use_auxiliary_loss UpperCamelCase_ = num_queries UpperCamelCase_ = num_channels UpperCamelCase_ = min_size UpperCamelCase_ = max_size UpperCamelCase_ = num_labels UpperCamelCase_ = hidden_dim UpperCamelCase_ = hidden_dim def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to( _UpperCAmelCase ) UpperCamelCase_ = torch.ones([self.batch_size, self.min_size, self.max_size] , device=_UpperCAmelCase ) UpperCamelCase_ = ( torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size] , device=_UpperCAmelCase ) > 0.5 ).float() UpperCamelCase_ = (torch.rand((self.batch_size, self.num_labels) , device=_UpperCAmelCase ) > 0.5).long() UpperCamelCase_ = self.get_config() return config, pixel_values, pixel_mask, mask_labels, class_labels def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = MaskaFormerConfig( hidden_size=self.hidden_dim , ) UpperCamelCase_ = self.num_queries UpperCamelCase_ = self.num_labels UpperCamelCase_ = [1, 1, 1, 1] UpperCamelCase_ = self.num_channels UpperCamelCase_ = 64 UpperCamelCase_ = 128 UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim UpperCamelCase_ = self.hidden_dim return config def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ = {'pixel_values': pixel_values, 'pixel_mask': pixel_mask} return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = output.encoder_hidden_states UpperCamelCase_ = output.pixel_decoder_hidden_states UpperCamelCase_ = output.transformer_decoder_hidden_states self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , len(config.backbone_config.depths ) ) self.parent.assertTrue(len(_UpperCAmelCase ) , config.decoder_layers ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False ) -> Any: with torch.no_grad(): UpperCamelCase_ = MaskaFormerModel(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) self.parent.assertEqual( output.transformer_decoder_last_hidden_state.shape , (self.batch_size, self.num_queries, self.hidden_dim) , ) # let's ensure the other two hidden state exists self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(output.encoder_last_hidden_state is not None ) if output_hidden_states: self.check_output_hidden_state(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation(config=_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.eval() def comm_check_on_output(_UpperCAmelCase ): # let's still check that all the required stuff is there self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None ) self.parent.assertTrue(result.encoder_last_hidden_state is not None ) # okay, now we need to check the logits shape # due to the encoder compression, masks have a //4 spatial size self.parent.assertEqual( result.masks_queries_logits.shape , (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4) , ) # + 1 for null class self.parent.assertEqual( result.class_queries_logits.shape , (self.batch_size, self.num_queries, self.num_labels + 1) ) with torch.no_grad(): UpperCamelCase_ = model(pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase ) UpperCamelCase_ = model(_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) UpperCamelCase_ = model( pixel_values=_UpperCAmelCase , pixel_mask=_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) comm_check_on_output(_UpperCAmelCase ) self.parent.assertTrue(result.loss is not None ) self.parent.assertEqual(result.loss.shape , torch.Size([1] ) ) @require_torch class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else () A_ = {"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {} A_ = False A_ = False A_ = False A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase , has_text_modality=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_UpperCAmelCase ) @unittest.skip(reason='Mask2Former does not use inputs_embeds' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not have a get_input_embeddings method' ) def _UpperCAmelCase ( self ) -> Optional[int]: pass @unittest.skip(reason='Mask2Former is not a generative model' ) def _UpperCAmelCase ( self ) -> Any: pass @unittest.skip(reason='Mask2Former does not use token embeddings' ) def _UpperCAmelCase ( self ) -> Optional[Any]: pass @require_torch_multi_gpu @unittest.skip( reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' ) def _UpperCAmelCase ( self ) -> int: pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def _UpperCAmelCase ( self ) -> str: pass def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ['pixel_values'] self.assertListEqual(arg_names[:1] , _UpperCAmelCase ) @slow def _UpperCAmelCase ( self ) -> Tuple: for model_name in ["facebook/mask2former-swin-small-coco-instance"]: UpperCamelCase_ = MaskaFormerModel.from_pretrained(_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = (self.model_tester.min_size,) * 2 UpperCamelCase_ = { 'pixel_values': torch.randn((2, 3, *size) , device=_UpperCAmelCase ), 'mask_labels': torch.randn((2, 10, *size) , device=_UpperCAmelCase ), 'class_labels': torch.zeros(2 , 10 , device=_UpperCAmelCase ).long(), } UpperCamelCase_ = self.model_tester.get_config() UpperCamelCase_ = MaskaFormerForUniversalSegmentation(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None ) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase , **_UpperCAmelCase , output_hidden_states=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) UpperCamelCase_ = model(**_UpperCAmelCase , output_attentions=_UpperCAmelCase ) self.assertTrue(outputs.attentions is not None ) def _UpperCAmelCase ( self ) -> List[Any]: if not self.model_tester.is_training: return UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = model_class(_UpperCAmelCase ) model.to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ).loss loss.backward() def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = self.all_model_classes[1] UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() UpperCamelCase_ = True UpperCamelCase_ = True UpperCamelCase_ = model_class(_UpperCAmelCase ).to(_UpperCAmelCase ) model.train() UpperCamelCase_ = model(_UpperCAmelCase , mask_labels=_UpperCAmelCase , class_labels=_UpperCAmelCase ) UpperCamelCase_ = outputs.encoder_hidden_states[0] encoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.pixel_decoder_hidden_states[0] pixel_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.transformer_decoder_hidden_states[0] transformer_decoder_hidden_states.retain_grad() UpperCamelCase_ = outputs.attentions[0] attentions.retain_grad() outputs.loss.backward(retain_graph=_UpperCAmelCase ) self.assertIsNotNone(encoder_hidden_states.grad ) self.assertIsNotNone(pixel_decoder_hidden_states.grad ) self.assertIsNotNone(transformer_decoder_hidden_states.grad ) self.assertIsNotNone(attentions.grad ) snake_case__ : List[Any] = 1E-4 def _snake_case (): UpperCamelCase_ = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png') return image @require_vision @slow class _a ( unittest.TestCase ): """simple docstring""" @cached_property def _UpperCAmelCase ( self ) -> Optional[int]: return "facebook/mask2former-swin-small-coco-instance" @cached_property def _UpperCAmelCase ( self ) -> List[str]: return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) UpperCamelCase_ = torch.tensor( [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.encoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) UpperCamelCase_ = torch.tensor( [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]] ).to(_UpperCAmelCase ) self.assertTrue( torch.allclose( outputs.transformer_decoder_last_hidden_state[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(_UpperCAmelCase , return_tensors='pt' ).to(_UpperCAmelCase ) UpperCamelCase_ = inputs['pixel_values'].shape # check size is divisible by 32 self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0 ) # check size self.assertEqual(_UpperCAmelCase , (1, 3, 384, 384) ) with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) # masks_queries_logits UpperCamelCase_ = outputs.masks_queries_logits self.assertEqual( masks_queries_logits.shape , (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) ) UpperCamelCase_ = [ [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1], [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1], [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5], ] UpperCamelCase_ = torch.tensor(_UpperCAmelCase ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) # class_queries_logits UpperCamelCase_ = outputs.class_queries_logits self.assertEqual(class_queries_logits.shape , (1, model.config.num_queries, model.config.num_labels + 1) ) UpperCamelCase_ = torch.tensor( [ [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2], [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3], [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5], ] ).to(_UpperCAmelCase ) self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , _UpperCAmelCase , atol=_UpperCAmelCase ) ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(_UpperCAmelCase ).eval() UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = image_processor( [np.zeros((3, 800, 1333) ), np.zeros((3, 800, 1333) )] , segmentation_maps=[np.zeros((384, 384) ).astype(np.floataa ), np.zeros((384, 384) ).astype(np.floataa )] , return_tensors='pt' , ) UpperCamelCase_ = inputs['pixel_values'].to(_UpperCAmelCase ) UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['mask_labels']] UpperCamelCase_ = [el.to(_UpperCAmelCase ) for el in inputs['class_labels']] with torch.no_grad(): UpperCamelCase_ = model(**_UpperCAmelCase ) self.assertTrue(outputs.loss is not None )
23
1
from __future__ import annotations import unittest import numpy as np from transformers import OPTConfig, is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import GPTaTokenizer, TFOPTForCausalLM, TFOPTModel def _snake_case (__lowercase , __lowercase , __lowercase=None , __lowercase=None): if attention_mask is None: UpperCamelCase_ = tf.cast(tf.math.not_equal(__lowercase , config.pad_token_id) , tf.inta) return {"input_ids": input_ids, "attention_mask": attention_mask} @require_tf class _a : """simple docstring""" A_ = OPTConfig A_ = {} A_ = """gelu""" def __init__( self , _UpperCAmelCase , _UpperCAmelCase=13 , _UpperCAmelCase=7 , _UpperCAmelCase=True , _UpperCAmelCase=False , _UpperCAmelCase=99 , _UpperCAmelCase=16 , _UpperCAmelCase=2 , _UpperCAmelCase=4 , _UpperCAmelCase=4 , _UpperCAmelCase="gelu" , _UpperCAmelCase=0.1 , _UpperCAmelCase=0.1 , _UpperCAmelCase=20 , _UpperCAmelCase=2 , _UpperCAmelCase=1 , _UpperCAmelCase=0 , _UpperCAmelCase=16 , _UpperCAmelCase=16 , ) -> Optional[int]: UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = seq_length UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = vocab_size UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = max_position_embeddings UpperCamelCase_ = eos_token_id UpperCamelCase_ = pad_token_id UpperCamelCase_ = bos_token_id UpperCamelCase_ = embed_dim UpperCamelCase_ = word_embed_proj_dim UpperCamelCase_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) UpperCamelCase_ = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size ) , 1 ) UpperCamelCase_ = tf.concat([input_ids, eos_tensor] , axis=1 ) UpperCamelCase_ = self.config_cls( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_id=self.eos_token_id , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , embed_dim=self.embed_dim , word_embed_proj_dim=self.word_embed_proj_dim , is_encoder_decoder=_UpperCAmelCase , **self.config_updates , ) UpperCamelCase_ = prepare_opt_inputs_dict(_UpperCAmelCase , _UpperCAmelCase ) return config, inputs_dict def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = TFOPTModel(config=_UpperCAmelCase ) UpperCamelCase_ = inputs_dict['input_ids'] UpperCamelCase_ = input_ids[:1, :] UpperCamelCase_ = inputs_dict['attention_mask'][:1, :] UpperCamelCase_ = 1 # first forward pass UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , use_cache=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids UpperCamelCase_ = ids_tensor((self.batch_size, 3) , config.vocab_size ) UpperCamelCase_ = tf.cast(ids_tensor((self.batch_size, 3) , 2 ) , tf.inta ) # append to next input_ids and UpperCamelCase_ = tf.concat([input_ids, next_tokens] , axis=-1 ) UpperCamelCase_ = tf.concat([attention_mask, next_attn_mask] , axis=-1 ) UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase )[0] UpperCamelCase_ = model(_UpperCAmelCase , attention_mask=_UpperCAmelCase , past_key_values=_UpperCAmelCase )[0] self.parent.assertEqual(next_tokens.shape[1] , output_from_past.shape[1] ) # select random slice UpperCamelCase_ = int(ids_tensor((1,) , output_from_past.shape[-1] ) ) UpperCamelCase_ = output_from_no_past[:, -3:, random_slice_idx] UpperCamelCase_ = output_from_past[:, :, random_slice_idx] # test that outputs are equal for slice tf.debugging.assert_near(_UpperCAmelCase , _UpperCAmelCase , rtol=1e-3 ) @require_tf class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = (TFOPTModel, TFOPTForCausalLM) if is_tf_available() else () A_ = (TFOPTForCausalLM,) if is_tf_available() else () A_ = ( {"""feature-extraction""": TFOPTModel, """text-generation""": TFOPTForCausalLM} if is_tf_available() else {} ) A_ = False A_ = False A_ = False A_ = 10 def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = TFOPTModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: self.config_tester.run_common_tests() def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_decoder_model_past_large_inputs(*_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() def _get_word_embedding_weight(_UpperCAmelCase , _UpperCAmelCase ): if hasattr(_UpperCAmelCase , 'weight' ): return embedding_layer.weight else: # Here we build the word embeddings weights if not exists. # And then we retry to get the attribute once built. model.build() if hasattr(_UpperCAmelCase , 'weight' ): return embedding_layer.weight else: return None for model_class in self.all_model_classes: for size in [config.vocab_size - 10, config.vocab_size + 10]: # build the embeddings UpperCamelCase_ = model_class(config=_UpperCAmelCase ) UpperCamelCase_ = _get_word_embedding_weight(_UpperCAmelCase , model.get_input_embeddings() ) UpperCamelCase_ = _get_word_embedding_weight(_UpperCAmelCase , model.get_output_embeddings() ) # reshape the embeddings model.resize_token_embeddings(_UpperCAmelCase ) UpperCamelCase_ = _get_word_embedding_weight(_UpperCAmelCase , model.get_input_embeddings() ) UpperCamelCase_ = _get_word_embedding_weight(_UpperCAmelCase , model.get_output_embeddings() ) # check that the resized embeddings size matches the desired size. UpperCamelCase_ = size if size is not None else config.vocab_size self.assertEqual(new_input_embeddings.shape[0] , _UpperCAmelCase ) # check that weights remain the same after resizing UpperCamelCase_ = True for pa, pa in zip(old_input_embeddings.value() , new_input_embeddings.value() ): if tf.math.reduce_sum(tf.math.abs(pa - pa ) ) > 0: UpperCamelCase_ = False self.assertTrue(_UpperCAmelCase ) if old_output_embeddings is not None and new_output_embeddings is not None: self.assertEqual(new_output_embeddings.shape[0] , _UpperCAmelCase ) UpperCamelCase_ = True for pa, pa in zip(old_output_embeddings.value() , new_output_embeddings.value() ): if tf.math.reduce_sum(tf.math.abs(pa - pa ) ) > 0: UpperCamelCase_ = False self.assertTrue(_UpperCAmelCase ) def _snake_case (__lowercase): return tf.constant(__lowercase , dtype=tf.intaa) @require_tf class _a ( unittest.TestCase ): """simple docstring""" A_ = 99 def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = tf.ones((4, 1) , dtype=tf.intaa ) * 2 UpperCamelCase_ = tf.concat([ids_tensor((4, 6) , self.vocab_size - 3 ) + 3, eos_column_vector] , axis=1 ) UpperCamelCase_ = input_ids.shape[0] UpperCamelCase_ = OPTConfig( vocab_size=self.vocab_size , hidden_size=24 , num_hidden_layers=2 , num_attention_heads=2 , ffn_dim=32 , max_position_embeddings=48 , eos_token_id=2 , pad_token_id=1 , bos_token_id=0 , ) return config, input_ids, batch_size @require_sentencepiece @require_tf class _a ( unittest.TestCase ): """simple docstring""" @slow def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = TFOPTModel.from_pretrained('facebook/opt-350m' ) UpperCamelCase_ = _long_tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]] ) UpperCamelCase_ = tf.not_equal(_UpperCAmelCase , model.config.pad_token_id ) with tf.GradientTape(): UpperCamelCase_ = model(input_ids=_UpperCAmelCase , attention_mask=_UpperCAmelCase ).last_hidden_state UpperCamelCase_ = (1, 11, 512) self.assertEqual(output.shape , _UpperCAmelCase ) UpperCamelCase_ = tf.constant( [[-0.2_8_7_3, -1.9_2_1_8, -0.3_0_3_3], [-1.2_7_1_0, -0.1_3_3_8, -0.1_9_0_2], [0.4_0_9_5, 0.1_2_1_4, -1.3_1_2_1]] ) self.assertTrue(np.allclose(output[:, :3, :3] , _UpperCAmelCase , atol=4e-3 ) ) UpperCamelCase_ = tf.function(_UpperCAmelCase , jit_compile=_UpperCAmelCase ) UpperCamelCase_ = xla_generate(_UpperCAmelCase , _UpperCAmelCase )[0] self.assertTrue(np.allclose(output[:, :3, :3] , _UpperCAmelCase , atol=4e-2 ) ) @require_tf @slow class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Tuple: super().setUp() UpperCamelCase_ = 'facebook/opt-350m' def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = TFOPTForCausalLM.from_pretrained(self.path_model ) UpperCamelCase_ = GPTaTokenizer.from_pretrained(self.path_model ) UpperCamelCase_ = [ 'Today is a beautiful day and I want to', 'In the city of', 'Paris is the capital of France and', 'Computers and mobile phones have taken', ] # verify that prompt without BOS token is identical to Metaseq -> add_special_tokens=False UpperCamelCase_ = tokenizer(_UpperCAmelCase , return_tensors='tf' , padding=_UpperCAmelCase , add_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tf.math.reduce_mean(model(inputs.input_ids , attention_mask=inputs.attention_mask )[0] , axis=-1 ) UpperCamelCase_ = tf.constant( [ [1.3_8_5_1, -1_3.8_9_2_3, -1_0.5_2_2_9, -1_0.7_5_3_3, -0.2_3_0_9, -1_0.2_3_8_4, -0.5_3_6_5, -9.0_9_4_7, -5.1_6_7_0], [-4.7_0_7_3, -1_0.6_2_7_6, -3.9_4_1_5, -2_1.5_2_4_2, -0.2_8_2_2, -0.2_8_2_2, -0.2_8_2_2, -0.2_8_2_2, -0.2_8_2_2], [0.6_2_4_7, -3.4_2_2_9, -8.9_1_7_9, -1.4_2_9_7, -1_4.1_6_5_0, 1.4_1_4_6, -9.0_2_1_8, -0.2_7_0_3, -0.2_7_0_3], [6.4_7_8_3, -1.9_9_1_3, -1_0.7_9_2_6, -2.3_3_3_6, 1.5_0_9_2, -0.9_9_7_4, -6.8_2_1_3, 1.3_4_7_7, 1.3_4_7_7], ] ) self.assertTrue(np.allclose(_UpperCAmelCase , _UpperCAmelCase , atol=1e-4 ) ) UpperCamelCase_ = tf.function(_UpperCAmelCase , jit_compile=_UpperCAmelCase ) UpperCamelCase_ = tf.math.reduce_mean(xla_generate(inputs.input_ids , attention_mask=inputs.attention_mask )[0] , axis=-1 ) self.assertTrue(np.allclose(_UpperCAmelCase , _UpperCAmelCase , atol=1e-4 ) ) @require_tf @slow class _a ( unittest.TestCase ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> Any: return [ "Today is a beautiful day and I want", "In the city of", "Paris is the capital of France and", "Computers and mobile phones have taken", ] def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = 'facebook/opt-125m' UpperCamelCase_ = [ 'Today is a beautiful day and I want to', 'In the city of New York, the city', 'Paris is the capital of France and the capital', 'Computers and mobile phones have taken over the', ] UpperCamelCase_ = [] UpperCamelCase_ = GPTaTokenizer.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = TFOPTForCausalLM.from_pretrained(_UpperCAmelCase ) for prompt in self.prompts: UpperCamelCase_ = tokenizer(_UpperCAmelCase , return_tensors='tf' ).input_ids UpperCamelCase_ = model.generate(_UpperCAmelCase , max_length=10 ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) predicted_outputs += generated_string self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = 'facebook/opt-350m' UpperCamelCase_ = GPTaTokenizer.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = TFOPTForCausalLM.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = 'left' # use different length sentences to test batching UpperCamelCase_ = [ 'Hello, my dog is a little', 'Today, I', ] UpperCamelCase_ = tokenizer(_UpperCAmelCase , return_tensors='tf' , padding=_UpperCAmelCase ) UpperCamelCase_ = inputs['input_ids'] UpperCamelCase_ = model.generate(input_ids=_UpperCAmelCase , attention_mask=inputs['attention_mask'] ) UpperCamelCase_ = tokenizer(sentences[0] , return_tensors='tf' ).input_ids UpperCamelCase_ = model.generate(input_ids=_UpperCAmelCase ) UpperCamelCase_ = inputs_non_padded.shape[-1] - tf.math.reduce_sum( tf.cast(inputs['attention_mask'][-1] , tf.intaa ) ) UpperCamelCase_ = tokenizer(sentences[1] , return_tensors='tf' ).input_ids UpperCamelCase_ = model.generate(input_ids=_UpperCAmelCase , max_length=model.config.max_length - num_paddings ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.decode(output_non_padded[0] , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.decode(output_padded[0] , skip_special_tokens=_UpperCAmelCase ) UpperCamelCase_ = [ 'Hello, my dog is a little bit of a dork.\nI\'m a little bit', 'Today, I was in the middle of a conversation with a friend about the', ] self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase ) self.assertListEqual(_UpperCAmelCase , [non_padded_sentence, padded_sentence] ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = 'facebook/opt-350m' UpperCamelCase_ = [ 'Today is a beautiful day and I want to', 'In the city of San Francisco, the city', 'Paris is the capital of France and the capital', 'Computers and mobile phones have taken over the', ] UpperCamelCase_ = [] UpperCamelCase_ = GPTaTokenizer.from_pretrained(_UpperCAmelCase ) UpperCamelCase_ = TFOPTForCausalLM.from_pretrained(_UpperCAmelCase ) for prompt in self.prompts: UpperCamelCase_ = tokenizer(_UpperCAmelCase , return_tensors='tf' ).input_ids UpperCamelCase_ = model.generate(_UpperCAmelCase , max_length=10 ) UpperCamelCase_ = tokenizer.batch_decode(_UpperCAmelCase , skip_special_tokens=_UpperCAmelCase ) predicted_outputs += generated_string self.assertListEqual(_UpperCAmelCase , _UpperCAmelCase )
23
import copy from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto.configuration_auto import AutoConfig if TYPE_CHECKING: from ... import PreTrainedTokenizerBase, TensorType snake_case__ : List[str] = logging.get_logger(__name__) class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = """vision-encoder-decoder""" A_ = True def __init__( self , **_UpperCAmelCase ) -> Dict: super().__init__(**_UpperCAmelCase ) if "encoder" not in kwargs or "decoder" not in kwargs: raise ValueError( f"""A configuraton of type {self.model_type} cannot be instantiated because """ f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}""" ) UpperCamelCase_ = kwargs.pop('encoder' ) UpperCamelCase_ = encoder_config.pop('model_type' ) UpperCamelCase_ = kwargs.pop('decoder' ) UpperCamelCase_ = decoder_config.pop('model_type' ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = AutoConfig.for_model(_UpperCAmelCase , **_UpperCAmelCase ) UpperCamelCase_ = True @classmethod def _UpperCAmelCase ( cls , _UpperCAmelCase , _UpperCAmelCase , **_UpperCAmelCase ) -> PretrainedConfig: logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config' ) UpperCamelCase_ = True UpperCamelCase_ = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = copy.deepcopy(self.__dict__ ) UpperCamelCase_ = self.encoder.to_dict() UpperCamelCase_ = self.decoder.to_dict() UpperCamelCase_ = self.__class__.model_type return output class _a ( UpperCAmelCase__ ): """simple docstring""" A_ = version.parse("""1.11""" ) @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) @property def _UpperCAmelCase ( self ) -> float: return 1e-4 @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: return OrderedDict({'last_hidden_state': {0: 'batch', 1: 'encoder_sequence'}} ) class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> Mapping[str, Mapping[int, str]]: UpperCamelCase_ = OrderedDict() UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'past_decoder_sequence + sequence'} UpperCamelCase_ = {0: 'batch', 1: 'encoder_sequence'} return common_inputs def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase = -1 , _UpperCAmelCase = -1 , _UpperCAmelCase = False , _UpperCAmelCase = None , ) -> Mapping[str, Any]: import torch UpperCamelCase_ = OrderedDict() UpperCamelCase_ = super().generate_dummy_inputs( _UpperCAmelCase , batch_size=_UpperCAmelCase , seq_length=_UpperCAmelCase , is_pair=_UpperCAmelCase , framework=_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = dummy_input['input_ids'].shape UpperCamelCase_ = (batch, encoder_sequence, self._config.encoder_hidden_size) UpperCamelCase_ = dummy_input.pop('input_ids' ) UpperCamelCase_ = dummy_input.pop('attention_mask' ) UpperCamelCase_ = torch.zeros(_UpperCAmelCase ) return common_inputs class _a ( UpperCAmelCase__ ): """simple docstring""" @property def _UpperCAmelCase ( self ) -> None: pass def _UpperCAmelCase ( self , _UpperCAmelCase ) -> OnnxConfig: return VisionEncoderDecoderEncoderOnnxConfig(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase = "default" ) -> OnnxConfig: UpperCamelCase_ = encoder_config.hidden_size return VisionEncoderDecoderDecoderOnnxConfig(_UpperCAmelCase , _UpperCAmelCase )
23
1
import unittest from accelerate import debug_launcher from accelerate.test_utils import require_cpu, test_ops, test_script @require_cpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> int: debug_launcher(test_script.main ) def _UpperCAmelCase ( self ) -> Any: debug_launcher(test_ops.main )
23
import argparse import torch from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert from transformers.utils import logging logging.set_verbosity_info() def _snake_case (__lowercase , __lowercase , __lowercase): # Initialise PyTorch model UpperCamelCase_ = MobileBertConfig.from_json_file(__lowercase) print(f"""Building PyTorch model from configuration: {config}""") UpperCamelCase_ = MobileBertForPreTraining(__lowercase) # Load weights from tf checkpoint UpperCamelCase_ = load_tf_weights_in_mobilebert(__lowercase , __lowercase , __lowercase) # Save pytorch-model print(f"""Save PyTorch model to {pytorch_dump_path}""") torch.save(model.state_dict() , __lowercase) if __name__ == "__main__": snake_case__ : int = argparse.ArgumentParser() # Required parameters parser.add_argument( """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path.""" ) parser.add_argument( """--mobilebert_config_file""", default=None, type=str, required=True, help=( """The config json file corresponding to the pre-trained MobileBERT model. \n""" """This specifies the model architecture.""" ), ) parser.add_argument( """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model.""" ) snake_case__ : Optional[Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
23
1
import itertools import string from collections.abc import Generator, Iterable def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = iter(__lowercase) while True: UpperCamelCase_ = tuple(itertools.islice(__lowercase , __lowercase)) if not chunk: return yield chunk def _snake_case (__lowercase): UpperCamelCase_ = ''.join([c.upper() for c in dirty if c in string.ascii_letters]) UpperCamelCase_ = '' if len(__lowercase) < 2: return dirty for i in range(len(__lowercase) - 1): clean += dirty[i] if dirty[i] == dirty[i + 1]: clean += "X" clean += dirty[-1] if len(__lowercase) & 1: clean += "X" return clean def _snake_case (__lowercase): # I and J are used interchangeably to allow # us to use a 5x5 table (25 letters) UpperCamelCase_ = 'ABCDEFGHIKLMNOPQRSTUVWXYZ' # we're using a list instead of a '2d' array because it makes the math # for setting up the table and doing the actual encoding/decoding simpler UpperCamelCase_ = [] # copy key chars into the table if they are in `alphabet` ignoring duplicates for char in key.upper(): if char not in table and char in alphabet: table.append(__lowercase) # fill the rest of the table in with the remaining alphabet chars for char in alphabet: if char not in table: table.append(__lowercase) return table def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = generate_table(__lowercase) UpperCamelCase_ = prepare_input(__lowercase) UpperCamelCase_ = '' # https://en.wikipedia.org/wiki/Playfair_cipher#Description for chara, chara in chunker(__lowercase , 2): UpperCamelCase_ , UpperCamelCase_ = divmod(table.index(__lowercase) , 5) UpperCamelCase_ , UpperCamelCase_ = divmod(table.index(__lowercase) , 5) if rowa == rowa: ciphertext += table[rowa * 5 + (cola + 1) % 5] ciphertext += table[rowa * 5 + (cola + 1) % 5] elif cola == cola: ciphertext += table[((rowa + 1) % 5) * 5 + cola] ciphertext += table[((rowa + 1) % 5) * 5 + cola] else: # rectangle ciphertext += table[rowa * 5 + cola] ciphertext += table[rowa * 5 + cola] return ciphertext def _snake_case (__lowercase , __lowercase): UpperCamelCase_ = generate_table(__lowercase) UpperCamelCase_ = '' # https://en.wikipedia.org/wiki/Playfair_cipher#Description for chara, chara in chunker(__lowercase , 2): UpperCamelCase_ , UpperCamelCase_ = divmod(table.index(__lowercase) , 5) UpperCamelCase_ , UpperCamelCase_ = divmod(table.index(__lowercase) , 5) if rowa == rowa: plaintext += table[rowa * 5 + (cola - 1) % 5] plaintext += table[rowa * 5 + (cola - 1) % 5] elif cola == cola: plaintext += table[((rowa - 1) % 5) * 5 + cola] plaintext += table[((rowa - 1) % 5) * 5 + cola] else: # rectangle plaintext += table[rowa * 5 + cola] plaintext += table[rowa * 5 + cola] return plaintext
23
import gc import unittest from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline from transformers.pipelines import PipelineException from transformers.testing_utils import ( is_pipeline_test, is_torch_available, nested_simplify, require_tf, require_torch, require_torch_gpu, slow, ) from .test_pipelines_common import ANY @is_pipeline_test class _a ( unittest.TestCase ): """simple docstring""" A_ = MODEL_FOR_MASKED_LM_MAPPING A_ = TF_MODEL_FOR_MASKED_LM_MAPPING def _UpperCAmelCase ( self ) -> List[str]: super().tearDown() # clean-up as much as possible GPU memory occupied by PyTorch gc.collect() if is_torch_available(): import torch torch.cuda.empty_cache() @require_tf def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='tf' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped'}, {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped', }, { 'sequence': 'The largest city in France is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='pt' ) UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul'}, {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ { 'sequence': 'The largest city in France is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', }, {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2941, 'token_str': ' Te'}, {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, 'token_str': ' Clara'}, ] , ) UpperCamelCase_ = unmasker('My name is <mask> <mask>' , top_k=2 ) self.assertEqual( nested_simplify(_UpperCAmelCase , decimals=6 ) , [ [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is Maul<mask></s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'}, ], [ { 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul', 'sequence': '<s>My name is<mask> Maul</s>', }, {'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'}, ], ] , ) @require_torch_gpu def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = pipeline('fill-mask' , model='hf-internal-testing/tiny-random-distilbert' , device=0 , framework='pt' ) # convert model to fp16 pipe.model.half() UpperCamelCase_ = pipe('Paris is the [MASK] of France.' ) # We actually don't care about the result, we just want to make sure # it works, meaning the float16 tensor got casted back to float32 # for postprocessing. self.assertIsInstance(_UpperCAmelCase , _UpperCAmelCase ) @slow @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='pt' ) self.run_large_test(_UpperCAmelCase ) @slow @require_tf def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='tf' ) self.run_large_test(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is John', 'score': 0.0_0_8, 'token': 610, 'token_str': ' John'}, {'sequence': 'My name is Chris', 'score': 0.0_0_7, 'token': 1573, 'token_str': ' Chris'}, ] , ) UpperCamelCase_ = unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ { 'sequence': 'The largest city in France is Paris', 'score': 0.2_5_1, 'token': 2201, 'token_str': ' Paris', }, { 'sequence': 'The largest city in France is Lyon', 'score': 0.2_1_4, 'token': 12790, 'token_str': ' Lyon', }, ] , ) UpperCamelCase_ = unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(_UpperCAmelCase ) , [ {'sequence': 'My name is Patrick', 'score': 0.0_0_5, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='pt' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) @require_tf def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='tf' ) UpperCamelCase_ = None UpperCamelCase_ = None self.run_pipeline_test(_UpperCAmelCase , [] ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: if tokenizer is None or tokenizer.mask_token_id is None: self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)' ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = [ f"""This is another {tokenizer.mask_token} test""", ] return fill_masker, examples def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: UpperCamelCase_ = fill_masker.tokenizer UpperCamelCase_ = fill_masker.model UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token}""" , ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}"""] ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = fill_masker([f"""This is a {tokenizer.mask_token}""", f"""Another {tokenizer.mask_token} great test."""] ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , ) with self.assertRaises(_UpperCAmelCase ): fill_masker([None] ) # No mask_token is not supported with self.assertRaises(_UpperCAmelCase ): fill_masker('This is' ) self.run_test_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_targets(_UpperCAmelCase , _UpperCAmelCase ) self.run_test_top_k_targets(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_duplicate_targets_and_top_k(_UpperCAmelCase , _UpperCAmelCase ) self.fill_mask_with_multiple_masks(_UpperCAmelCase , _UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = sorted(vocab.keys() )[:2] # Pipeline argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , targets=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Call argument UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = {vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , _UpperCAmelCase ) UpperCamelCase_ = [tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(_UpperCAmelCase ) ) # Score equivalence UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['token_str'] for top_mask in outputs] UpperCamelCase_ = [top_mask['score'] for top_mask in outputs] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ) == set(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=_UpperCAmelCase ) UpperCamelCase_ = [top_mask['score'] for top_mask in unmasked_targets] self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) # Raises with invalid with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[] ) # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised if "" not in tokenizer.get_vocab(): with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets=[''] ) with self.assertRaises(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , targets='' ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase , top_k=2 ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ] , ) self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: UpperCamelCase_ = tokenizer.get_vocab() UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) # top_k=2, ntargets=3 UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=2 , targets=_UpperCAmelCase ) # If we use the most probably targets, and filter differently, we should still # have the same results UpperCamelCase_ = [el['token_str'] for el in sorted(_UpperCAmelCase , key=lambda _UpperCAmelCase : x["score"] , reverse=_UpperCAmelCase )] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(_UpperCAmelCase ).issubset(_UpperCAmelCase ): UpperCamelCase_ = fill_masker(f"""This is a {tokenizer.mask_token}""" , top_k=3 , targets=_UpperCAmelCase ) # They should yield exactly the same result self.assertEqual(nested_simplify(_UpperCAmelCase ) , nested_simplify(_UpperCAmelCase ) ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> Optional[int]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = tokenizer.get_vocab() # String duplicates + id duplicates UpperCamelCase_ = sorted(vocab.keys() )[:3] UpperCamelCase_ = [targets[0], targets[1], targets[0], targets[2], targets[1]] UpperCamelCase_ = fill_masker(f"""My name is {tokenizer.mask_token}""" , targets=_UpperCAmelCase , top_k=10 ) # The target list contains duplicates, so we can't output more # than them self.assertEqual(len(_UpperCAmelCase ) , 3 ) def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: UpperCamelCase_ = FillMaskPipeline(model=_UpperCAmelCase , tokenizer=_UpperCAmelCase ) UpperCamelCase_ = fill_masker( f"""This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}""" , top_k=2 ) self.assertEqual( _UpperCAmelCase , [ [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], [ {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, {'sequence': ANY(_UpperCAmelCase ), 'score': ANY(_UpperCAmelCase ), 'token': ANY(_UpperCAmelCase ), 'token_str': ANY(_UpperCAmelCase )}, ], ] , )
23
1
import gc import math import unittest import torch from diffusers import UNetaDModel from diffusers.utils import floats_tensor, logging, slow, torch_all_close, torch_device from diffusers.utils.testing_utils import enable_full_determinism from .test_modeling_common import ModelTesterMixin, UNetTesterMixin snake_case__ : Dict = logging.get_logger(__name__) enable_full_determinism() class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = UNetaDModel A_ = """sample""" @property def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = 4 UpperCamelCase_ = 3 UpperCamelCase_ = (32, 32) UpperCamelCase_ = floats_tensor((batch_size, num_channels) + sizes ).to(_UpperCAmelCase ) UpperCamelCase_ = torch.tensor([10] ).to(_UpperCAmelCase ) return {"sample": noise, "timestep": time_step} @property def _UpperCAmelCase ( self ) -> Union[str, Any]: return (3, 32, 32) @property def _UpperCAmelCase ( self ) -> Union[str, Any]: return (3, 32, 32) def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = { 'block_out_channels': (32, 64), 'down_block_types': ('DownBlock2D', 'AttnDownBlock2D'), 'up_block_types': ('AttnUpBlock2D', 'UpBlock2D'), 'attention_head_dim': 3, 'out_channels': 3, 'in_channels': 3, 'layers_per_block': 2, 'sample_size': 32, } UpperCamelCase_ = self.dummy_input return init_dict, inputs_dict class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = UNetaDModel A_ = """sample""" @property def _UpperCAmelCase ( self ) -> Union[str, Any]: UpperCamelCase_ = 4 UpperCamelCase_ = 4 UpperCamelCase_ = (32, 32) UpperCamelCase_ = floats_tensor((batch_size, num_channels) + sizes ).to(_UpperCAmelCase ) UpperCamelCase_ = torch.tensor([10] ).to(_UpperCAmelCase ) return {"sample": noise, "timestep": time_step} @property def _UpperCAmelCase ( self ) -> Any: return (4, 32, 32) @property def _UpperCAmelCase ( self ) -> str: return (4, 32, 32) def _UpperCAmelCase ( self ) -> Any: UpperCamelCase_ = { 'sample_size': 32, 'in_channels': 4, 'out_channels': 4, 'layers_per_block': 2, 'block_out_channels': (32, 64), 'attention_head_dim': 32, 'down_block_types': ('DownBlock2D', 'DownBlock2D'), 'up_block_types': ('UpBlock2D', 'UpBlock2D'), } UpperCamelCase_ = self.dummy_input return init_dict, inputs_dict def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ , UpperCamelCase_ = UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update' , output_loading_info=_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) self.assertEqual(len(loading_info['missing_keys'] ) , 0 ) model.to(_UpperCAmelCase ) UpperCamelCase_ = model(**self.dummy_input ).sample assert image is not None, "Make sure output is not None" @unittest.skipIf(torch_device != 'cuda' , 'This test is supposed to run on GPU' ) def _UpperCAmelCase ( self ) -> Tuple: UpperCamelCase_ , UpperCamelCase_ = UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update' , output_loading_info=_UpperCAmelCase ) model.to(_UpperCAmelCase ) UpperCamelCase_ = model(**self.dummy_input ).sample assert image is not None, "Make sure output is not None" @unittest.skipIf(torch_device != 'cuda' , 'This test is supposed to run on GPU' ) def _UpperCAmelCase ( self ) -> Tuple: # by defautl model loading will use accelerate as `low_cpu_mem_usage=True` UpperCamelCase_ , UpperCamelCase_ = UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update' , output_loading_info=_UpperCAmelCase ) model_accelerate.to(_UpperCAmelCase ) model_accelerate.eval() UpperCamelCase_ = torch.randn( 1 , model_accelerate.config.in_channels , model_accelerate.config.sample_size , model_accelerate.config.sample_size , generator=torch.manual_seed(0 ) , ) UpperCamelCase_ = noise.to(_UpperCAmelCase ) UpperCamelCase_ = torch.tensor([10] * noise.shape[0] ).to(_UpperCAmelCase ) UpperCamelCase_ = model_accelerate(_UpperCAmelCase , _UpperCAmelCase )['sample'] # two models don't need to stay in the device at the same time del model_accelerate torch.cuda.empty_cache() gc.collect() UpperCamelCase_ , UpperCamelCase_ = UNetaDModel.from_pretrained( 'fusing/unet-ldm-dummy-update' , output_loading_info=_UpperCAmelCase , low_cpu_mem_usage=_UpperCAmelCase ) model_normal_load.to(_UpperCAmelCase ) model_normal_load.eval() UpperCamelCase_ = model_normal_load(_UpperCAmelCase , _UpperCAmelCase )['sample'] assert torch_all_close(_UpperCAmelCase , _UpperCAmelCase , rtol=1e-3 ) def _UpperCAmelCase ( self ) -> List[str]: UpperCamelCase_ = UNetaDModel.from_pretrained('fusing/unet-ldm-dummy-update' ) model.eval() model.to(_UpperCAmelCase ) UpperCamelCase_ = torch.randn( 1 , model.config.in_channels , model.config.sample_size , model.config.sample_size , generator=torch.manual_seed(0 ) , ) UpperCamelCase_ = noise.to(_UpperCAmelCase ) UpperCamelCase_ = torch.tensor([10] * noise.shape[0] ).to(_UpperCAmelCase ) with torch.no_grad(): UpperCamelCase_ = model(_UpperCAmelCase , _UpperCAmelCase ).sample UpperCamelCase_ = output[0, -1, -3:, -3:].flatten().cpu() # fmt: off UpperCamelCase_ = torch.tensor([-1_3.3_2_5_8, -2_0.1_1_0_0, -1_5.9_8_7_3, -1_7.6_6_1_7, -2_3.0_5_9_6, -1_7.9_4_1_9, -1_3.3_6_7_5, -1_6.1_8_8_9, -1_2.3_8_0_0] ) # fmt: on self.assertTrue(torch_all_close(_UpperCAmelCase , _UpperCAmelCase , rtol=1e-3 ) ) class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = UNetaDModel A_ = """sample""" @property def _UpperCAmelCase ( self , _UpperCAmelCase=(32, 32) ) -> str: UpperCamelCase_ = 4 UpperCamelCase_ = 3 UpperCamelCase_ = floats_tensor((batch_size, num_channels) + sizes ).to(_UpperCAmelCase ) UpperCamelCase_ = torch.tensor(batch_size * [10] ).to(dtype=torch.intaa , device=_UpperCAmelCase ) return {"sample": noise, "timestep": time_step} @property def _UpperCAmelCase ( self ) -> Dict: return (3, 32, 32) @property def _UpperCAmelCase ( self ) -> Optional[int]: return (3, 32, 32) def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ = { 'block_out_channels': [32, 64, 64, 64], 'in_channels': 3, 'layers_per_block': 1, 'out_channels': 3, 'time_embedding_type': 'fourier', 'norm_eps': 1e-6, 'mid_block_scale_factor': math.sqrt(2.0 ), 'norm_num_groups': None, 'down_block_types': [ 'SkipDownBlock2D', 'AttnSkipDownBlock2D', 'SkipDownBlock2D', 'SkipDownBlock2D', ], 'up_block_types': [ 'SkipUpBlock2D', 'SkipUpBlock2D', 'AttnSkipUpBlock2D', 'SkipUpBlock2D', ], } UpperCamelCase_ = self.dummy_input return init_dict, inputs_dict @slow def _UpperCAmelCase ( self ) -> int: UpperCamelCase_ , UpperCamelCase_ = UNetaDModel.from_pretrained('google/ncsnpp-celebahq-256' , output_loading_info=_UpperCAmelCase ) self.assertIsNotNone(_UpperCAmelCase ) self.assertEqual(len(loading_info['missing_keys'] ) , 0 ) model.to(_UpperCAmelCase ) UpperCamelCase_ = self.dummy_input UpperCamelCase_ = floats_tensor((4, 3) + (256, 256) ).to(_UpperCAmelCase ) UpperCamelCase_ = noise UpperCamelCase_ = model(**_UpperCAmelCase ) assert image is not None, "Make sure output is not None" @slow def _UpperCAmelCase ( self ) -> Optional[int]: UpperCamelCase_ = UNetaDModel.from_pretrained('google/ncsnpp-celebahq-256' ) model.to(_UpperCAmelCase ) UpperCamelCase_ = 4 UpperCamelCase_ = 3 UpperCamelCase_ = (256, 256) UpperCamelCase_ = torch.ones((batch_size, num_channels) + sizes ).to(_UpperCAmelCase ) UpperCamelCase_ = torch.tensor(batch_size * [1e-4] ).to(_UpperCAmelCase ) with torch.no_grad(): UpperCamelCase_ = model(_UpperCAmelCase , _UpperCAmelCase ).sample UpperCamelCase_ = output[0, -3:, -3:, -1].flatten().cpu() # fmt: off UpperCamelCase_ = torch.tensor([-4_8_4_2.8_6_9_1, -6_4_9_9.6_6_3_1, -3_8_0_0.1_9_5_3, -7_9_7_8.2_6_8_6, -1_0_9_8_0.7_1_2_9, -2_0_0_2_8.8_5_3_5, 8_1_4_8.2_8_2_2, 2_3_4_2.2_9_0_5, 5_6_7.7_6_0_8] ) # fmt: on self.assertTrue(torch_all_close(_UpperCAmelCase , _UpperCAmelCase , rtol=1e-2 ) ) def _UpperCAmelCase ( self ) -> Optional[Any]: UpperCamelCase_ = UNetaDModel.from_pretrained('fusing/ncsnpp-ffhq-ve-dummy-update' ) model.to(_UpperCAmelCase ) UpperCamelCase_ = 4 UpperCamelCase_ = 3 UpperCamelCase_ = (32, 32) UpperCamelCase_ = torch.ones((batch_size, num_channels) + sizes ).to(_UpperCAmelCase ) UpperCamelCase_ = torch.tensor(batch_size * [1e-4] ).to(_UpperCAmelCase ) with torch.no_grad(): UpperCamelCase_ = model(_UpperCAmelCase , _UpperCAmelCase ).sample UpperCamelCase_ = output[0, -3:, -3:, -1].flatten().cpu() # fmt: off UpperCamelCase_ = torch.tensor([-0.0_3_2_5, -0.0_9_0_0, -0.0_8_6_9, -0.0_3_3_2, -0.0_7_2_5, -0.0_2_7_0, -0.0_1_0_1, 0.0_2_2_7, 0.0_2_5_6] ) # fmt: on self.assertTrue(torch_all_close(_UpperCAmelCase , _UpperCAmelCase , rtol=1e-2 ) ) def _UpperCAmelCase ( self ) -> Dict: # not required for this model pass
23
import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, StableDiffusionSAGPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin enable_full_determinism() class _a ( UpperCAmelCase__ , UpperCAmelCase__ , unittest.TestCase ): """simple docstring""" A_ = StableDiffusionSAGPipeline A_ = TEXT_TO_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_BATCH_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = TEXT_TO_IMAGE_IMAGE_PARAMS A_ = False def _UpperCAmelCase ( self ) -> Optional[Any]: torch.manual_seed(0 ) UpperCamelCase_ = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D') , up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D') , cross_attention_dim=32 , ) UpperCamelCase_ = DDIMScheduler( beta_start=0.0_0_0_8_5 , beta_end=0.0_1_2 , beta_schedule='scaled_linear' , clip_sample=_UpperCAmelCase , set_alpha_to_one=_UpperCAmelCase , ) torch.manual_seed(0 ) UpperCamelCase_ = AutoencoderKL( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'] , up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'] , latent_channels=4 , ) torch.manual_seed(0 ) UpperCamelCase_ = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=1000 , ) UpperCamelCase_ = CLIPTextModel(_UpperCAmelCase ) UpperCamelCase_ = CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip' ) UpperCamelCase_ = { 'unet': unet, 'scheduler': scheduler, 'vae': vae, 'text_encoder': text_encoder, 'tokenizer': tokenizer, 'safety_checker': None, 'feature_extractor': None, } return components def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase=0 ) -> List[Any]: if str(_UpperCAmelCase ).startswith('mps' ): UpperCamelCase_ = torch.manual_seed(_UpperCAmelCase ) else: UpperCamelCase_ = torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase ) UpperCamelCase_ = { 'prompt': '.', 'generator': generator, 'num_inference_steps': 2, 'guidance_scale': 1.0, 'sag_scale': 1.0, 'output_type': 'numpy', } return inputs def _UpperCAmelCase ( self ) -> Tuple: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class _a ( unittest.TestCase ): """simple docstring""" def _UpperCAmelCase ( self ) -> Tuple: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def _UpperCAmelCase ( self ) -> str: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('CompVis/stable-diffusion-v1-4' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.1_5_6_8, 0.1_7_3_8, 0.1_6_9_5, 0.1_6_9_3, 0.1_5_0_7, 0.1_7_0_5, 0.1_5_4_7, 0.1_7_5_1, 0.1_9_4_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> List[Any]: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' ) UpperCamelCase_ = output.images UpperCamelCase_ = image[0, -3:, -3:, -1] assert image.shape == (1, 512, 512, 3) UpperCamelCase_ = np.array([0.3_4_5_9, 0.2_8_7_6, 0.2_5_3_7, 0.3_0_0_2, 0.2_6_7_1, 0.2_1_6_0, 0.3_0_2_6, 0.2_2_6_2, 0.2_3_7_1] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def _UpperCAmelCase ( self ) -> Dict: UpperCamelCase_ = StableDiffusionSAGPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base' ) UpperCamelCase_ = sag_pipe.to(_UpperCAmelCase ) sag_pipe.set_progress_bar_config(disable=_UpperCAmelCase ) UpperCamelCase_ = '.' UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = sag_pipe( [prompt] , width=768 , height=512 , generator=_UpperCAmelCase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='np' , ) UpperCamelCase_ = output.images assert image.shape == (1, 512, 768, 3)
23
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available snake_case__ : Optional[int] = { """configuration_pegasus_x""": ["""PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusXConfig"""], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: snake_case__ : Dict = [ """PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST""", """PegasusXForConditionalGeneration""", """PegasusXModel""", """PegasusXPreTrainedModel""", ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys snake_case__ : Optional[Any] = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
23
from __future__ import annotations from sys import maxsize from typing import Generic, TypeVar snake_case__ : List[str] = TypeVar("""T""") def _snake_case (__lowercase): return (position - 1) // 2 def _snake_case (__lowercase): return (2 * position) + 1 def _snake_case (__lowercase): return (2 * position) + 2 class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = [] UpperCamelCase_ = {} UpperCamelCase_ = 0 def __len__( self ) -> int: return self.elements def __repr__( self ) -> str: return str(self.heap ) def _UpperCAmelCase ( self ) -> bool: # Check if the priority queue is empty return self.elements == 0 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an element with given priority to the queue self.heap.append((elem, weight) ) UpperCamelCase_ = self.elements self.elements += 1 self._bubble_up(_UpperCAmelCase ) def _UpperCAmelCase ( self ) -> T: # Remove and return the element with lowest weight (highest priority) if self.elements > 1: self._swap_nodes(0 , self.elements - 1 ) UpperCamelCase_ , UpperCamelCase_ = self.heap.pop() del self.position_map[elem] self.elements -= 1 if self.elements > 0: UpperCamelCase_ , UpperCamelCase_ = self.heap[0] self._bubble_down(_UpperCAmelCase ) return elem def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Update the weight of the given key UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ = (elem, weight) if position > 0: UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._bubble_up(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) else: self._bubble_down(_UpperCAmelCase ) def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (upward movement) [to be used internally # only] UpperCamelCase_ = self.position_map[elem] if curr_pos == 0: return None UpperCamelCase_ = get_parent_position(_UpperCAmelCase ) UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ , UpperCamelCase_ = self.heap[parent_position] if parent_weight > weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_up(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Place a node at the proper position (downward movement) [to be used # internally only] UpperCamelCase_ = self.position_map[elem] UpperCamelCase_ , UpperCamelCase_ = self.heap[curr_pos] UpperCamelCase_ = get_child_left_position(_UpperCAmelCase ) UpperCamelCase_ = get_child_right_position(_UpperCAmelCase ) if child_left_position < self.elements and child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < child_left_weight and child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) if child_left_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_left_position] if child_left_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) else: return None if child_right_position < self.elements: UpperCamelCase_ , UpperCamelCase_ = self.heap[child_right_position] if child_right_weight < weight: self._swap_nodes(_UpperCAmelCase , _UpperCAmelCase ) return self._bubble_down(_UpperCAmelCase ) return None def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Swap the nodes at the given positions UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ = self.heap[nodea_pos][0] UpperCamelCase_ , UpperCamelCase_ = ( self.heap[nodea_pos], self.heap[nodea_pos], ) UpperCamelCase_ = nodea_pos UpperCamelCase_ = nodea_pos class _a ( Generic[T] ): """simple docstring""" def __init__( self ) -> None: UpperCamelCase_ = {} UpperCamelCase_ = 0 def __repr__( self ) -> str: return str(self.connections ) def __len__( self ) -> int: return self.nodes def _UpperCAmelCase ( self , _UpperCAmelCase ) -> None: # Add a node in the graph if it is not in the graph if node not in self.connections: UpperCamelCase_ = {} self.nodes += 1 def _UpperCAmelCase ( self , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> None: # Add an edge between 2 nodes in the graph self.add_node(_UpperCAmelCase ) self.add_node(_UpperCAmelCase ) UpperCamelCase_ = weight UpperCamelCase_ = weight def _snake_case (__lowercase , ): UpperCamelCase_ = {node: maxsize for node in graph.connections} UpperCamelCase_ = {node: None for node in graph.connections} UpperCamelCase_ = MinPriorityQueue() for node, weight in dist.items(): priority_queue.push(__lowercase , __lowercase) if priority_queue.is_empty(): return dist, parent # initialization UpperCamelCase_ = priority_queue.extract_min() UpperCamelCase_ = 0 for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node # running prim's algorithm while not priority_queue.is_empty(): UpperCamelCase_ = priority_queue.extract_min() for neighbour in graph.connections[node]: if dist[neighbour] > dist[node] + graph.connections[node][neighbour]: UpperCamelCase_ = dist[node] + graph.connections[node][neighbour] priority_queue.update_key(__lowercase , dist[neighbour]) UpperCamelCase_ = node return dist, parent
23
1