code
stringlengths
87
55.2k
code_codestyle
int64
0
349
style_context
stringlengths
135
49.1k
style_context_codestyle
int64
0
349
label
int64
0
1
"""simple docstring""" def lowercase__ ( _UpperCAmelCase ) -> Dict: '''simple docstring''' lowercase : Union[str, Any] = [0] * len(lowerCamelCase__ ) for i in range(1 , len(lowerCamelCase__ ) ): # use last results for better performance - dynamic programming lowercase : Any = prefix_result[i - 1] while j > 0 and input_string[i] != input_string[j]: lowercase : Dict = prefix_result[j - 1] if input_string[i] == input_string[j]: j += 1 lowercase : Optional[int] = j return prefix_result def lowercase__ ( _UpperCAmelCase ) -> Optional[int]: '''simple docstring''' return max(prefix_function(lowerCamelCase__ ) ) if __name__ == "__main__": import doctest doctest.testmod()
255
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) __A ={'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizer'''] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''XGLMForCausalLM''', '''XGLMModel''', '''XGLMPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''FlaxXGLMForCausalLM''', '''FlaxXGLMModel''', '''FlaxXGLMPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFXGLMForCausalLM''', '''TFXGLMModel''', '''TFXGLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm import XGLMTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm_fast import XGLMTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_xglm import ( TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFXGLMForCausalLM, TFXGLMModel, TFXGLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure)
19
0
'''simple docstring''' from sklearn.metrics import matthews_corrcoef import datasets a_ = '\nCompute the Matthews correlation coefficient (MCC)\n\nThe Matthews correlation coefficient is used in machine learning as a\nmeasure of the quality of binary and multiclass classifications. It takes\ninto account true and false positives and negatives and is generally\nregarded as a balanced measure which can be used even if the classes are of\nvery different sizes. The MCC is in essence a correlation coefficient value\nbetween -1 and +1. A coefficient of +1 represents a perfect prediction, 0\nan average random prediction and -1 an inverse prediction. The statistic\nis also known as the phi coefficient. [source: Wikipedia]\n' a_ = '\nArgs:\n predictions (list of int): Predicted labels, as returned by a model.\n references (list of int): Ground truth labels.\n sample_weight (list of int, float, or bool): Sample weights. Defaults to `None`.\nReturns:\n matthews_correlation (dict containing float): Matthews correlation.\nExamples:\n Example 1, a basic example with only predictions and references as inputs:\n >>> matthews_metric = datasets.load_metric("matthews_correlation")\n >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n ... predictions=[1, 2, 2, 0, 3, 3])\n >>> print(round(results[\'matthews_correlation\'], 2))\n 0.54\n\n Example 2, the same example as above, but also including sample weights:\n >>> matthews_metric = datasets.load_metric("matthews_correlation")\n >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n ... predictions=[1, 2, 2, 0, 3, 3],\n ... sample_weight=[0.5, 3, 1, 1, 1, 2])\n >>> print(round(results[\'matthews_correlation\'], 2))\n 0.1\n\n Example 3, the same example as above, but with sample weights that cause a negative correlation:\n >>> matthews_metric = datasets.load_metric("matthews_correlation")\n >>> results = matthews_metric.compute(references=[1, 3, 2, 0, 3, 2],\n ... predictions=[1, 2, 2, 0, 3, 3],\n ... sample_weight=[0.5, 1, 0, 0, 0, 1])\n >>> print(round(results[\'matthews_correlation\'], 2))\n -0.25\n' a_ = '\\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __SCREAMING_SNAKE_CASE ( datasets.Metric ): def __magic_name__ ( self : List[str] ) -> Any: return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Value('''int32''' ), '''references''': datasets.Value('''int32''' ), } ) , reference_urls=[ '''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html''' ] , ) def __magic_name__ ( self : Union[str, Any] , __lowercase : List[Any] , __lowercase : Any , __lowercase : Union[str, Any]=None ) -> Optional[Any]: return { "matthews_correlation": float(matthews_corrcoef(__lowercase , __lowercase , sample_weight=__lowercase ) ), }
152
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __A ={'''configuration_wavlm''': ['''WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WavLMConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''WavLMForAudioFrameClassification''', '''WavLMForCTC''', '''WavLMForSequenceClassification''', '''WavLMForXVector''', '''WavLMModel''', '''WavLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_wavlm import ( WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST, WavLMForAudioFrameClassification, WavLMForCTC, WavLMForSequenceClassification, WavLMForXVector, WavLMModel, WavLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_mobilebert import MobileBertTokenizer A_ :Optional[int] = logging.get_logger(__name__) A_ :List[str] = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''} A_ :str = { '''vocab_file''': {'''mobilebert-uncased''': '''https://huggingface.co/google/mobilebert-uncased/resolve/main/vocab.txt'''}, '''tokenizer_file''': { '''mobilebert-uncased''': '''https://huggingface.co/google/mobilebert-uncased/resolve/main/tokenizer.json''' }, } A_ :Tuple = {'''mobilebert-uncased''': 512} A_ :Optional[Any] = {} class __A ( snake_case_ ): """simple docstring""" UpperCamelCase__ : Optional[Any] =VOCAB_FILES_NAMES UpperCamelCase__ : List[str] =PRETRAINED_VOCAB_FILES_MAP UpperCamelCase__ : Tuple =PRETRAINED_INIT_CONFIGURATION UpperCamelCase__ : str =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase__ : int =MobileBertTokenizer def __init__( self , lowerCamelCase__=None , lowerCamelCase__=None , lowerCamelCase__=True , lowerCamelCase__="[UNK]" , lowerCamelCase__="[SEP]" , lowerCamelCase__="[PAD]" , lowerCamelCase__="[CLS]" , lowerCamelCase__="[MASK]" , lowerCamelCase__=True , lowerCamelCase__=None , **lowerCamelCase__ , ): """simple docstring""" super().__init__( lowerCamelCase__ , tokenizer_file=lowerCamelCase__ , do_lower_case=lowerCamelCase__ , unk_token=lowerCamelCase__ , sep_token=lowerCamelCase__ , pad_token=lowerCamelCase__ , cls_token=lowerCamelCase__ , mask_token=lowerCamelCase__ , tokenize_chinese_chars=lowerCamelCase__ , strip_accents=lowerCamelCase__ , **lowerCamelCase__ , ) __UpperCamelCase : Dict =json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get('lowercase' , lowerCamelCase__ ) != do_lower_case or normalizer_state.get('strip_accents' , lowerCamelCase__ ) != strip_accents or normalizer_state.get('handle_chinese_chars' , lowerCamelCase__ ) != tokenize_chinese_chars ): __UpperCamelCase : Optional[int] =getattr(lowerCamelCase__ , normalizer_state.pop('type' ) ) __UpperCamelCase : Union[str, Any] =do_lower_case __UpperCamelCase : List[Any] =strip_accents __UpperCamelCase : List[str] =tokenize_chinese_chars __UpperCamelCase : Tuple =normalizer_class(**lowerCamelCase__ ) __UpperCamelCase : Any =do_lower_case def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__=None ): """simple docstring""" __UpperCamelCase : Dict =[self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ = None ): """simple docstring""" __UpperCamelCase : List[Any] =[self.sep_token_id] __UpperCamelCase : Tuple =[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 __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ = None ): """simple docstring""" __UpperCamelCase : Any =self._tokenizer.model.save(lowerCamelCase__ , name=lowerCamelCase__ ) return tuple(lowerCamelCase__ )
71
# Lint as: python3 # pylint: enable=line-too-long # pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position __A ='''2.13.1''' import platform import pyarrow from packaging import version if version.parse(platform.python_version()) < version.parse('''3.7'''): raise ImportWarning( '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.''' ) if version.parse(pyarrow.__version__).major < 8: raise ImportWarning( '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n''' '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.''' ) del platform del pyarrow del version from .arrow_dataset import Dataset from .arrow_reader import ReadInstruction from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder from .combine import concatenate_datasets, interleave_datasets from .dataset_dict import DatasetDict, IterableDatasetDict from .download import * from .features import * from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled from .info import DatasetInfo, MetricInfo from .inspect import ( get_dataset_config_info, get_dataset_config_names, get_dataset_infos, get_dataset_split_names, inspect_dataset, inspect_metric, list_datasets, list_metrics, ) from .iterable_dataset import IterableDataset from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric from .metric import Metric from .splits import ( NamedSplit, NamedSplitAll, Split, SplitBase, SplitDict, SplitGenerator, SplitInfo, SubSplitInfo, percent, ) from .tasks import * from .utils import * from .utils import logging # deprecated modules from datasets import arrow_dataset as _arrow_dataset # isort:skip from datasets import utils as _utils # isort:skip from datasets.utils import download_manager as _deprecated_download_manager # isort:skip __A =concatenate_datasets __A =DownloadConfig __A =DownloadManager __A =DownloadMode __A =DownloadConfig __A =DownloadMode __A =DownloadManager del _arrow_dataset, _utils, _deprecated_download_manager
19
0
'''simple docstring''' from dataclasses import dataclass, field from typing import Optional from transformers import AutoConfig, AutoImageProcessor, AutoTokenizer, FlaxVisionEncoderDecoderModel, HfArgumentParser @dataclass class a : _lowerCAmelCase = field( metadata={"""help""": """The output directory where the model will be written."""} , ) _lowerCAmelCase = field( metadata={ """help""": ( """The encoder model checkpoint for weights initialization.""" """Don\'t set if you want to train an encoder model from scratch.""" ) } , ) _lowerCAmelCase = field( metadata={ """help""": ( """The decoder model checkpoint for weights initialization.""" """Don\'t set if you want to train a decoder model from scratch.""" ) } , ) _lowerCAmelCase = field( default=snake_case_ , metadata={"""help""": """Pretrained encoder config name or path if not the same as encoder_model_name"""} ) _lowerCAmelCase = field( default=snake_case_ , metadata={"""help""": """Pretrained decoder config name or path if not the same as decoder_model_name"""} ) def _A () -> List[Any]: '''simple docstring''' _a = HfArgumentParser((ModelArguments,) ) ((_a ) , ) = parser.parse_args_into_dataclasses() # Load pretrained model and tokenizer # Use explicit specified encoder config if model_args.encoder_config_name: _a = AutoConfig.from_pretrained(model_args.encoder_config_name ) # Use pretrained encoder model's config else: _a = AutoConfig.from_pretrained(model_args.encoder_model_name_or_path ) # Use explicit specified decoder config if model_args.decoder_config_name: _a = AutoConfig.from_pretrained(model_args.decoder_config_name ) # Use pretrained decoder model's config else: _a = AutoConfig.from_pretrained(model_args.decoder_model_name_or_path ) # necessary for `from_encoder_decoder_pretrained` when `decoder_config` is passed _a = True _a = True _a = FlaxVisionEncoderDecoderModel.from_encoder_decoder_pretrained( encoder_pretrained_model_name_or_path=model_args.encoder_model_name_or_path , decoder_pretrained_model_name_or_path=model_args.decoder_model_name_or_path , encoder_config=lowerCamelCase__ , decoder_config=lowerCamelCase__ , ) # GPT2 only has bos/eos tokens but not decoder_start/pad tokens _a = decoder_config.decoder_start_token_id _a = decoder_config.pad_token_id if decoder_start_token_id is None: _a = decoder_config.bos_token_id if pad_token_id is None: _a = decoder_config.eos_token_id # This is necessary to make Flax's generate() work _a = decoder_config.eos_token_id _a = decoder_start_token_id _a = pad_token_id _a = AutoImageProcessor.from_pretrained(model_args.encoder_model_name_or_path ) _a = AutoTokenizer.from_pretrained(model_args.decoder_model_name_or_path ) _a = tokenizer.convert_ids_to_tokens(model.config.pad_token_id ) model.save_pretrained(model_args.output_dir ) image_processor.save_pretrained(model_args.output_dir ) tokenizer.save_pretrained(model_args.output_dir ) if __name__ == "__main__": main()
168
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __A ={ '''configuration_bloom''': ['''BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BloomConfig''', '''BloomOnnxConfig'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''BloomTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''BloomForCausalLM''', '''BloomModel''', '''BloomPreTrainedModel''', '''BloomForSequenceClassification''', '''BloomForTokenClassification''', '''BloomForQuestionAnswering''', ] if TYPE_CHECKING: from .configuration_bloom import BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP, BloomConfig, BloomOnnxConfig try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_bloom_fast import BloomTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_bloom import ( BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST, BloomForCausalLM, BloomForQuestionAnswering, BloomForSequenceClassification, BloomForTokenClassification, BloomModel, BloomPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
import random def a ( A__ : Optional[Any] , A__ : Tuple , A__ : int = False ) -> Optional[int]: """simple docstring""" _lowercase ={i: [] for i in range(lowerCamelCase__ )} # if probability is greater or equal than 1, then generate a complete graph if probability >= 1: return complete_graph(lowerCamelCase__ ) # if probability is lower or equal than 0, then return a graph without edges if probability <= 0: return graph # for each couple of nodes, add an edge from u to v # if the number randomly generated is greater than probability probability for i in range(lowerCamelCase__ ): for j in range(i + 1 , lowerCamelCase__ ): if random.random() < probability: graph[i].append(lowerCamelCase__ ) if not directed: # if the graph is undirected, add an edge in from j to i, either graph[j].append(lowerCamelCase__ ) return graph def a ( A__ : Optional[Any] ) -> int: """simple docstring""" return { i: [j for j in range(lowerCamelCase__ ) if i != j] for i in range(lowerCamelCase__ ) } if __name__ == "__main__": import doctest doctest.testmod()
205
from __future__ import annotations import unittest from transformers import EsmConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers.models.esm.modeling_tf_esm import ( TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, TFEsmModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , ) -> Optional[int]: lowerCamelCase_ = parent lowerCamelCase_ = 13 lowerCamelCase_ = 7 lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = 99 lowerCamelCase_ = 32 lowerCamelCase_ = 2 lowerCamelCase_ = 4 lowerCamelCase_ = 37 lowerCamelCase_ = "gelu" lowerCamelCase_ = 0.1 lowerCamelCase_ = 0.1 lowerCamelCase_ = 512 lowerCamelCase_ = 16 lowerCamelCase_ = 2 lowerCamelCase_ = 0.0_2 lowerCamelCase_ = 3 lowerCamelCase_ = 4 lowerCamelCase_ = None def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_input_mask: lowerCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = EsmConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , pad_token_id=1 , 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 , initializer_range=self.initializer_range , ) return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def SCREAMING_SNAKE_CASE_( self ) -> List[str]: ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = self.prepare_config_and_inputs() lowerCamelCase_ = True lowerCamelCase_ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Any: lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> Tuple: lowerCamelCase_ = True lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": input_mask, "encoder_hidden_states": encoder_hidden_states, "encoder_attention_mask": encoder_attention_mask, } lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase , encoder_hidden_states=lowercase ) # Also check the case where encoder outputs are not passed lowerCamelCase_ = model(lowercase , attention_mask=lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Optional[int]: lowerCamelCase_ = TFEsmForMaskedLM(config=lowercase ) lowerCamelCase_ = model([input_ids, input_mask] ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = TFEsmForTokenClassification(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_tf class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( ( TFEsmModel, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, ) if is_tf_available() else () ) lowerCAmelCase__ = ( { 'feature-extraction': TFEsmModel, 'fill-mask': TFEsmForMaskedLM, 'text-classification': TFEsmForSequenceClassification, 'token-classification': TFEsmForTokenClassification, 'zero-shot': TFEsmForSequenceClassification, } if is_tf_available() else {} ) lowerCAmelCase__ = False lowerCAmelCase__ = False def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = TFEsmModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , hidden_size=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Dict: for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = TFEsmModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: pass @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> Any: pass def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ , lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCamelCase_ = model_class(lowercase ) assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer ) if model_class is TFEsmForMaskedLM: # Output embedding test differs from the main test because they're a matrix, not a layer lowerCamelCase_ = model.get_bias() assert isinstance(lowercase , lowercase ) for k, v in name.items(): assert isinstance(lowercase , tf.Variable ) else: lowerCamelCase_ = model.get_output_embeddings() assert x is None lowerCamelCase_ = model.get_bias() assert name is None @require_tf class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 1, 2, 3, 4, 5]] ) lowerCamelCase_ = model(lowercase )[0] lowerCamelCase_ = [1, 6, 33] self.assertEqual(list(output.numpy().shape ) , lowercase ) # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7], [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5], [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-2 ) ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] ) lowerCamelCase_ = model(lowercase )[0] # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9], [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2], [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
19
0
from collections.abc import Callable import numpy as np def _UpperCAmelCase (UpperCamelCase__ : Union[str, Any] , UpperCamelCase__ : int , UpperCamelCase__ : Any , UpperCamelCase__ : List[Any] , UpperCamelCase__ : Optional[Any] ): _A : Optional[int] = int(np.ceil((x_end - xa) / step_size ) ) _A : Optional[int] = np.zeros((n + 1,) ) _A : List[str] = ya _A : Optional[int] = xa for k in range(lowerCamelCase__ ): _A : int = y[k] + step_size * ode_func(lowerCamelCase__ , y[k] ) x += step_size return y if __name__ == "__main__": import doctest doctest.testmod()
11
import importlib.util import json import os import warnings from dataclasses import dataclass, field import torch from ..training_args import TrainingArguments from ..utils import cached_property, is_sagemaker_dp_enabled, logging __A =logging.get_logger(__name__) def lowerCamelCase_ ( ): # Get the sagemaker specific mp parameters from smp_options variable. lowerCamelCase_ = os.getenv("SM_HP_MP_PARAMETERS" , "{}" ) try: # Parse it and check the field "partitions" is included, it is required for model parallel. lowerCamelCase_ = json.loads(lowerCamelCase__ ) if "partitions" not in smp_options: return False except json.JSONDecodeError: return False # Get the sagemaker specific framework parameters from mpi_options variable. lowerCamelCase_ = os.getenv("SM_FRAMEWORK_PARAMS" , "{}" ) try: # Parse it and check the field "sagemaker_distributed_dataparallel_enabled". lowerCamelCase_ = json.loads(lowerCamelCase__ ) if not mpi_options.get("sagemaker_mpi_enabled" , lowerCamelCase__ ): return False except json.JSONDecodeError: return False # Lastly, check if the `smdistributed` module is present. return importlib.util.find_spec("smdistributed" ) is not None if is_sagemaker_model_parallel_available(): import smdistributed.modelparallel.torch as smp smp.init() @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = field( default='' , metadata={'help': 'Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'} , ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: super().__post_init__() warnings.warn( "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use " "`TrainingArguments` instead." , lowercase , ) @cached_property def SCREAMING_SNAKE_CASE_( self ) -> "torch.device": logger.info("PyTorch: setting up devices" ) if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1: logger.warning( "torch.distributed process group is initialized, but local_rank == -1. " "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch" ) if self.no_cuda: lowerCamelCase_ = torch.device("cpu" ) lowerCamelCase_ = 0 elif is_sagemaker_model_parallel_available(): lowerCamelCase_ = smp.local_rank() lowerCamelCase_ = torch.device("cuda" , lowercase ) lowerCamelCase_ = 1 elif is_sagemaker_dp_enabled(): import smdistributed.dataparallel.torch.torch_smddp # noqa: F401 torch.distributed.init_process_group(backend="smddp" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = int(os.getenv("SMDATAPARALLEL_LOCAL_RANK" ) ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 elif self.local_rank == -1: # if n_gpu is > 1 we'll use nn.DataParallel. # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0` # Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will # trigger an error that a device index is missing. Index 0 takes into account the # GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0` # will use the first GPU in that env, i.e. GPU#1 lowerCamelCase_ = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" ) # Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at # the default value. lowerCamelCase_ = torch.cuda.device_count() else: # Here, we'll use torch.distributed. # Initializes the distributed backend which will take care of synchronizing nodes/GPUs if not torch.distributed.is_initialized(): torch.distributed.init_process_group(backend="nccl" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 if device.type == "cuda": torch.cuda.set_device(lowercase ) return device @property def SCREAMING_SNAKE_CASE_( self ) -> Tuple: if is_sagemaker_model_parallel_available(): return smp.dp_size() return super().world_size @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: return not is_sagemaker_model_parallel_available() @property def SCREAMING_SNAKE_CASE_( self ) -> Dict: return False
19
0
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available __UpperCAmelCase ={} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase =["GPTSw3Tokenizer"] if TYPE_CHECKING: try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_gpt_swa import GPTSwaTokenizer else: import sys __UpperCAmelCase =_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 0 , lowerCamelCase__ = 0 ): lowerCamelCase_ = end or len(lowerCamelCase__ ) for i in range(lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = i lowerCamelCase_ = array[i] while temp_index != start and temp_index_value < array[temp_index - 1]: lowerCamelCase_ = array[temp_index - 1] temp_index -= 1 lowerCamelCase_ = temp_index_value return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): # Max Heap lowerCamelCase_ = index lowerCamelCase_ = 2 * index + 1 # Left Node lowerCamelCase_ = 2 * index + 2 # Right Node if left_index < heap_size and array[largest] < array[left_index]: lowerCamelCase_ = left_index if right_index < heap_size and array[largest] < array[right_index]: lowerCamelCase_ = right_index if largest != index: lowerCamelCase_ , lowerCamelCase_ = array[largest], array[index] heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) for i in range(n // 2 , -1 , -1 ): heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) for i in range(n - 1 , 0 , -1 ): lowerCamelCase_ , lowerCamelCase_ = array[0], array[i] heapify(lowerCamelCase__ , 0 , lowerCamelCase__ ) return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): if (array[first_index] > array[middle_index]) != ( array[first_index] > array[last_index] ): return array[first_index] elif (array[middle_index] > array[first_index]) != ( array[middle_index] > array[last_index] ): return array[middle_index] else: return array[last_index] def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = low lowerCamelCase_ = high while True: while array[i] < pivot: i += 1 j -= 1 while pivot < array[j]: j -= 1 if i >= j: return i lowerCamelCase_ , lowerCamelCase_ = array[j], array[i] i += 1 def lowerCamelCase_ ( lowerCamelCase__ ): if len(lowerCamelCase__ ) == 0: return array lowerCamelCase_ = 2 * math.ceil(math.loga(len(lowerCamelCase__ ) ) ) lowerCamelCase_ = 1_6 return intro_sort(lowerCamelCase__ , 0 , len(lowerCamelCase__ ) , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): while end - start > size_threshold: if max_depth == 0: return heap_sort(lowerCamelCase__ ) max_depth -= 1 lowerCamelCase_ = median_of_a(lowerCamelCase__ , lowerCamelCase__ , start + ((end - start) // 2) + 1 , end - 1 ) lowerCamelCase_ = partition(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) intro_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = p return insertion_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": import doctest doctest.testmod() __A =input('''Enter numbers separated by a comma : ''').strip() __A =[float(item) for item in user_input.split(''',''')] print(sort(unsorted))
19
0
from queue import Queue from typing import TYPE_CHECKING, Optional if TYPE_CHECKING: from ..models.auto import AutoTokenizer class __lowerCAmelCase : """simple docstring""" def lowerCAmelCase__ ( self : List[Any] , _lowerCAmelCase : str ) -> List[Any]: """simple docstring""" raise NotImplementedError() def lowerCAmelCase__ ( self : Optional[int] ) -> Tuple: """simple docstring""" raise NotImplementedError() class __lowerCAmelCase ( snake_case_ ): """simple docstring""" def __init__( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Tuple = False , **_lowerCAmelCase : Optional[Any] ) -> Tuple: """simple docstring""" snake_case_ = tokenizer snake_case_ = skip_prompt snake_case_ = decode_kwargs # variables used in the streaming process snake_case_ = [] snake_case_ = 0 snake_case_ = True def lowerCAmelCase__ ( self : int , _lowerCAmelCase : List[str] ) -> Union[str, Any]: """simple docstring""" if len(value.shape ) > 1 and value.shape[0] > 1: raise ValueError("TextStreamer only supports batch size 1" ) elif len(value.shape ) > 1: snake_case_ = value[0] if self.skip_prompt and self.next_tokens_are_prompt: snake_case_ = False return # Add the new token to the cache and decodes the entire thing. self.token_cache.extend(value.tolist() ) snake_case_ = self.tokenizer.decode(self.token_cache , **self.decode_kwargs ) # After the symbol for a new line, we flush the cache. if text.endswith("\n" ): snake_case_ = text[self.print_len :] snake_case_ = [] snake_case_ = 0 # If the last token is a CJK character, we print the characters. elif len(_lowerCAmelCase ) > 0 and self._is_chinese_char(ord(text[-1] ) ): snake_case_ = text[self.print_len :] self.print_len += len(_lowerCAmelCase ) # Otherwise, prints until the last space char (simple heuristic to avoid printing incomplete words, # which may change with the subsequent token -- there are probably smarter ways to do this!) else: snake_case_ = text[self.print_len : text.rfind(" " ) + 1] self.print_len += len(_lowerCAmelCase ) self.on_finalized_text(_lowerCAmelCase ) def lowerCAmelCase__ ( self : Tuple ) -> str: """simple docstring""" # Flush the cache, if it exists if len(self.token_cache ) > 0: snake_case_ = self.tokenizer.decode(self.token_cache , **self.decode_kwargs ) snake_case_ = text[self.print_len :] snake_case_ = [] snake_case_ = 0 else: snake_case_ = "" snake_case_ = True self.on_finalized_text(_lowerCAmelCase , stream_end=_lowerCAmelCase ) def lowerCAmelCase__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Any = False ) -> List[str]: """simple docstring""" print(_lowerCAmelCase , flush=_lowerCAmelCase , end="" if not stream_end else None ) def lowerCAmelCase__ ( self : Dict , _lowerCAmelCase : int ) -> str: """simple docstring""" # This defines a "chinese character" as anything in the CJK Unicode block: # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) # # Note that the CJK Unicode block is NOT all Japanese and Korean characters, # despite its name. The modern Korean Hangul alphabet is a different block, # as is Japanese Hiragana and Katakana. Those alphabets are used to write # space-separated words, so they are not treated specially and handled # like the all of the other languages. if ( (cp >= 0X4_E_0_0 and cp <= 0X9_F_F_F) or (cp >= 0X3_4_0_0 and cp <= 0X4_D_B_F) # or (cp >= 0X2_0_0_0_0 and cp <= 0X2_A_6_D_F) # or (cp >= 0X2_A_7_0_0 and cp <= 0X2_B_7_3_F) # or (cp >= 0X2_B_7_4_0 and cp <= 0X2_B_8_1_F) # or (cp >= 0X2_B_8_2_0 and cp <= 0X2_C_E_A_F) # or (cp >= 0XF_9_0_0 and cp <= 0XF_A_F_F) or (cp >= 0X2_F_8_0_0 and cp <= 0X2_F_A_1_F) # ): # return True return False class __lowerCAmelCase ( snake_case_ ): """simple docstring""" def __init__( self : int , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : int = False , _lowerCAmelCase : str = None , **_lowerCAmelCase : Optional[Any] ) -> List[str]: """simple docstring""" super().__init__(_lowerCAmelCase , _lowerCAmelCase , **_lowerCAmelCase ) snake_case_ = Queue() snake_case_ = None snake_case_ = timeout def lowerCAmelCase__ ( self : Any , _lowerCAmelCase : Any , _lowerCAmelCase : List[str] = False ) -> Dict: """simple docstring""" self.text_queue.put(_lowerCAmelCase , timeout=self.timeout ) if stream_end: self.text_queue.put(self.stop_signal , timeout=self.timeout ) def __iter__( self : Any ) -> str: """simple docstring""" return self def lowerCAmelCase__ ( self : Union[str, Any] ) -> List[Any]: """simple docstring""" snake_case_ = self.text_queue.get(timeout=self.timeout ) if value == self.stop_signal: raise StopIteration() else: return value
159
import math import time from typing import Dict, List, Optional from torch.utils.data import Dataset from transformers import SeqaSeqTrainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , *lowercase , lowercase=None , lowercase=None , **lowercase ) -> List[str]: super().__init__(*lowercase , **lowercase ) lowerCamelCase_ = eval_examples lowerCamelCase_ = post_process_function def SCREAMING_SNAKE_CASE_( self , lowercase = None , lowercase=None , lowercase = None , lowercase = "eval" , **lowercase , ) -> Dict[str, float]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = ( gen_kwargs["max_length"] if gen_kwargs.get("max_length" ) is not None else self.args.generation_max_length ) lowerCamelCase_ = ( gen_kwargs["num_beams"] if gen_kwargs.get("num_beams" ) is not None else self.args.generation_num_beams ) lowerCamelCase_ = gen_kwargs lowerCamelCase_ = self.eval_dataset if eval_dataset is None else eval_dataset lowerCamelCase_ = self.get_eval_dataloader(lowercase ) lowerCamelCase_ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Evaluation" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) else: lowerCamelCase_ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(lowercase ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) lowerCamelCase_ = self.callback_handler.on_evaluate(self.args , self.state , self.control , lowercase ) return metrics def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=None , lowercase = "test" , **lowercase ) -> Union[str, Any]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = self.get_test_dataloader(lowercase ) # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Prediction" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase , "predict" ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=lowercase )
19
0
"""simple docstring""" class _UpperCamelCase : '''simple docstring''' def __init__( self , __a , __a , __a ): __lowerCAmelCase = None __lowerCAmelCase = None __lowerCAmelCase = graph self._normalize_graph(__a , __a ) __lowerCAmelCase = len(__a ) __lowerCAmelCase = None def snake_case ( self , __a , __a ): if sources is int: __lowerCAmelCase = [sources] if sinks is int: __lowerCAmelCase = [sinks] if len(__a ) == 0 or len(__a ) == 0: return __lowerCAmelCase = sources[0] __lowerCAmelCase = sinks[0] # make fake vertex if there are more # than one source or sink if len(__a ) > 1 or len(__a ) > 1: __lowerCAmelCase = 0 for i in sources: max_input_flow += sum(self.graph[i] ) __lowerCAmelCase = len(self.graph ) + 1 for room in self.graph: room.insert(0 , 0 ) self.graph.insert(0 , [0] * size ) for i in sources: __lowerCAmelCase = max_input_flow __lowerCAmelCase = 0 __lowerCAmelCase = len(self.graph ) + 1 for room in self.graph: room.append(0 ) self.graph.append([0] * size ) for i in sinks: __lowerCAmelCase = max_input_flow __lowerCAmelCase = size - 1 def snake_case ( self ): if self.maximum_flow_algorithm is None: raise Exception("You need to set maximum flow algorithm before." ) if self.source_index is None or self.sink_index is None: return 0 self.maximum_flow_algorithm.execute() return self.maximum_flow_algorithm.getMaximumFlow() def snake_case ( self , __a ): __lowerCAmelCase = algorithm(self ) class _UpperCamelCase : '''simple docstring''' def __init__( self , __a ): __lowerCAmelCase = flow_network __lowerCAmelCase = flow_network.verticesCount __lowerCAmelCase = flow_network.sourceIndex __lowerCAmelCase = flow_network.sinkIndex # it's just a reference, so you shouldn't change # it in your algorithms, use deep copy before doing that __lowerCAmelCase = flow_network.graph __lowerCAmelCase = False def snake_case ( self ): if not self.executed: self._algorithm() __lowerCAmelCase = True def snake_case ( self ): pass class _UpperCamelCase ( snake_case_ ): '''simple docstring''' def __init__( self , __a ): super().__init__(__a ) # use this to save your result __lowerCAmelCase = -1 def snake_case ( self ): if not self.executed: raise Exception("You should execute algorithm before using its result!" ) return self.maximum_flow class _UpperCamelCase ( snake_case_ ): '''simple docstring''' def __init__( self , __a ): super().__init__(__a ) __lowerCAmelCase = [[0] * self.verticies_count for i in range(self.verticies_count )] __lowerCAmelCase = [0] * self.verticies_count __lowerCAmelCase = [0] * self.verticies_count def snake_case ( self ): __lowerCAmelCase = self.verticies_count # push some substance to graph for nextvertex_index, bandwidth in enumerate(self.graph[self.source_index] ): self.preflow[self.source_index][nextvertex_index] += bandwidth self.preflow[nextvertex_index][self.source_index] -= bandwidth self.excesses[nextvertex_index] += bandwidth # Relabel-to-front selection rule __lowerCAmelCase = [ i for i in range(self.verticies_count ) if i != self.source_index and i != self.sink_index ] # move through list __lowerCAmelCase = 0 while i < len(__a ): __lowerCAmelCase = vertices_list[i] __lowerCAmelCase = self.heights[vertex_index] self.process_vertex(__a ) if self.heights[vertex_index] > previous_height: # if it was relabeled, swap elements # and start from 0 index vertices_list.insert(0 , vertices_list.pop(__a ) ) __lowerCAmelCase = 0 else: i += 1 __lowerCAmelCase = sum(self.preflow[self.source_index] ) def snake_case ( self , __a ): while self.excesses[vertex_index] > 0: for neighbour_index in range(self.verticies_count ): # if it's neighbour and current vertex is higher if ( self.graph[vertex_index][neighbour_index] - self.preflow[vertex_index][neighbour_index] > 0 and self.heights[vertex_index] > self.heights[neighbour_index] ): self.push(__a , __a ) self.relabel(__a ) def snake_case ( self , __a , __a ): __lowerCAmelCase = min( self.excesses[from_index] , self.graph[from_index][to_index] - self.preflow[from_index][to_index] , ) self.preflow[from_index][to_index] += preflow_delta self.preflow[to_index][from_index] -= preflow_delta self.excesses[from_index] -= preflow_delta self.excesses[to_index] += preflow_delta def snake_case ( self , __a ): __lowerCAmelCase = None for to_index in range(self.verticies_count ): if ( self.graph[vertex_index][to_index] - self.preflow[vertex_index][to_index] > 0 ) and (min_height is None or self.heights[to_index] < min_height): __lowerCAmelCase = self.heights[to_index] if min_height is not None: __lowerCAmelCase = min_height + 1 if __name__ == "__main__": A : int = [0] A : List[Any] = [3] # graph = [ # [0, 0, 4, 6, 0, 0], # [0, 0, 5, 2, 0, 0], # [0, 0, 0, 0, 4, 4], # [0, 0, 0, 0, 6, 6], # [0, 0, 0, 0, 0, 0], # [0, 0, 0, 0, 0, 0], # ] A : Union[str, Any] = [[0, 7, 0, 0], [0, 0, 6, 0], [0, 0, 0, 8], [9, 0, 0, 0]] # prepare our network A : Tuple = FlowNetwork(graph, entrances, exits) # set algorithm flow_network.set_maximum_flow_algorithm(PushRelabelExecutor) # and calculate A : Union[str, Any] = flow_network.find_maximum_flow() print(f'''maximum flow is {maximum_flow}''')
57
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __A =logging.get_logger(__name__) # pylint: disable=invalid-name __A =''' Examples: ```py >>> from PIL import Image >>> import torch >>> from diffusers import DiffusionPipeline >>> from diffusers.utils import export_to_gif, load_image >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu") >>> repo = "openai/shap-e-img2img" >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16) >>> pipe = pipe.to(device) >>> guidance_scale = 3.0 >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png" >>> image = load_image(image_url).convert("RGB") >>> images = pipe( ... image, ... guidance_scale=guidance_scale, ... num_inference_steps=64, ... frame_size=256, ... ).images >>> gif_path = export_to_gif(images[0], "corgi_3d.gif") ``` ''' @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: super().__init__() self.register_modules( prior=lowercase , image_encoder=lowercase , image_processor=lowercase , scheduler=lowercase , renderer=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if latents is None: lowerCamelCase_ = randn_tensor(lowercase , generator=lowercase , device=lowercase , dtype=lowercase ) else: if latents.shape != shape: raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {shape}' ) lowerCamelCase_ = latents.to(lowercase ) lowerCamelCase_ = latents * scheduler.init_noise_sigma return latents def SCREAMING_SNAKE_CASE_( self , lowercase=0 ) -> int: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device(f'cuda:{gpu_id}' ) lowerCamelCase_ = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: if self.device != torch.device("meta" ) or not hasattr(self.image_encoder , "_hf_hook" ): return self.device for module in self.image_encoder.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: if isinstance(lowercase , lowercase ) and isinstance(image[0] , torch.Tensor ): lowerCamelCase_ = torch.cat(lowercase , axis=0 ) if image[0].ndim == 4 else torch.stack(lowercase , axis=0 ) if not isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = self.image_processor(lowercase , return_tensors="pt" ).pixel_values[0].unsqueeze(0 ) lowerCamelCase_ = image.to(dtype=self.image_encoder.dtype , device=lowercase ) lowerCamelCase_ = self.image_encoder(lowercase )["last_hidden_state"] lowerCamelCase_ = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 lowerCamelCase_ = image_embeds.repeat_interleave(lowercase , dim=0 ) if do_classifier_free_guidance: lowerCamelCase_ = torch.zeros_like(lowercase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes lowerCamelCase_ = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(lowercase ) def __call__( self , lowercase , lowercase = 1 , lowercase = 25 , lowercase = None , lowercase = None , lowercase = 4.0 , lowercase = 64 , lowercase = "pil" , lowercase = True , ) -> Union[str, Any]: if isinstance(lowercase , PIL.Image.Image ): lowerCamelCase_ = 1 elif isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = image.shape[0] elif isinstance(lowercase , lowercase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): lowerCamelCase_ = len(lowercase ) else: raise ValueError( f'`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(lowercase )}' ) lowerCamelCase_ = self._execution_device lowerCamelCase_ = batch_size * num_images_per_prompt lowerCamelCase_ = guidance_scale > 1.0 lowerCamelCase_ = self._encode_image(lowercase , lowercase , lowercase , lowercase ) # prior self.scheduler.set_timesteps(lowercase , device=lowercase ) lowerCamelCase_ = self.scheduler.timesteps lowerCamelCase_ = self.prior.config.num_embeddings lowerCamelCase_ = self.prior.config.embedding_dim lowerCamelCase_ = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , lowercase , lowercase , lowercase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim lowerCamelCase_ = latents.reshape(latents.shape[0] , lowercase , lowercase ) for i, t in enumerate(self.progress_bar(lowercase ) ): # expand the latents if we are doing classifier free guidance lowerCamelCase_ = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents lowerCamelCase_ = self.scheduler.scale_model_input(lowercase , lowercase ) lowerCamelCase_ = self.prior( lowercase , timestep=lowercase , proj_embedding=lowercase , ).predicted_image_embedding # remove the variance lowerCamelCase_ , lowerCamelCase_ = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: lowerCamelCase_ , lowerCamelCase_ = noise_pred.chunk(2 ) lowerCamelCase_ = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) lowerCamelCase_ = self.scheduler.step( lowercase , timestep=lowercase , sample=lowercase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=lowercase ) lowerCamelCase_ = [] for i, latent in enumerate(lowercase ): print() lowerCamelCase_ = self.renderer.decode( latent[None, :] , lowercase , size=lowercase , ray_batch_size=4096 , n_coarse_samples=64 , n_fine_samples=128 , ) images.append(lowercase ) lowerCamelCase_ = torch.stack(lowercase ) if output_type not in ["np", "pil"]: raise ValueError(f'Only the output types `pil` and `np` are supported not output_type={output_type}' ) lowerCamelCase_ = images.cpu().numpy() if output_type == "pil": lowerCamelCase_ = [self.numpy_to_pil(lowercase ) for image in images] # Offload last model to CPU if hasattr(self , "final_offload_hook" ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=lowercase )
19
0
import builtins import sys from ...utils.imports import _is_package_available from . import cursor, input from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor from .keymap import KEYMAP lowerCAmelCase__ : Union[str, Any] =False try: lowerCAmelCase__ : Dict =_is_package_available('''google.colab''') except ModuleNotFoundError: pass @input.register class UpperCAmelCase_ : '''simple docstring''' def __init__( self , _A = None , _A = [] ): '''simple docstring''' __SCREAMING_SNAKE_CASE = 0 __SCREAMING_SNAKE_CASE = choices __SCREAMING_SNAKE_CASE = prompt if sys.platform == "win32": __SCREAMING_SNAKE_CASE = '*' else: __SCREAMING_SNAKE_CASE = '➔ ' def _A ( self , _A , _A = "" ): '''simple docstring''' if sys.platform != "win32": writeColor(self.choices[index] , 32 , _A ) else: forceWrite(self.choices[index] , _A ) def _A ( self , _A ): '''simple docstring''' if index == self.position: forceWrite(f""" {self.arrow_char} """ ) self.write_choice(_A ) else: forceWrite(f""" {self.choices[index]}""" ) reset_cursor() def _A ( self , _A , _A = 1 ): '''simple docstring''' __SCREAMING_SNAKE_CASE = self.position if direction == Direction.DOWN: if self.position + 1 >= len(self.choices ): return self.position += num_spaces else: if self.position - 1 < 0: return self.position -= num_spaces clear_line() self.print_choice(_A ) move_cursor(_A , direction.name ) self.print_choice(self.position ) @input.mark(KEYMAP['up'] ) def _A ( self ): '''simple docstring''' self.move_direction(Direction.UP ) @input.mark(KEYMAP['down'] ) def _A ( self ): '''simple docstring''' self.move_direction(Direction.DOWN ) @input.mark(KEYMAP['newline'] ) def _A ( self ): '''simple docstring''' move_cursor(len(self.choices ) - self.position , 'DOWN' ) return self.position @input.mark(KEYMAP['interrupt'] ) def _A ( self ): '''simple docstring''' move_cursor(len(self.choices ) - self.position , 'DOWN' ) raise KeyboardInterrupt @input.mark_multiple(*[KEYMAP[str(_A )] for number in range(10 )] ) def _A ( self ): '''simple docstring''' __SCREAMING_SNAKE_CASE = int(chr(self.current_selection ) ) __SCREAMING_SNAKE_CASE = index - self.position if index == self.position: return if index < len(self.choices ): if self.position > index: self.move_direction(Direction.UP , -movement ) elif self.position < index: self.move_direction(Direction.DOWN , _A ) else: return else: return def _A ( self , _A = 0 ): '''simple docstring''' if self.prompt: linebreak() forceWrite(self.prompt , '\n' ) if in_colab: forceWrite('Please input a choice index (starting from 0), and press enter' , '\n' ) else: forceWrite('Please select a choice using the arrow or number keys, and selecting with enter' , '\n' ) __SCREAMING_SNAKE_CASE = default_choice for i in range(len(self.choices ) ): self.print_choice(_A ) forceWrite('\n' ) move_cursor(len(self.choices ) - self.position , 'UP' ) with cursor.hide(): while True: if in_colab: try: __SCREAMING_SNAKE_CASE = int(builtins.input() ) except ValueError: __SCREAMING_SNAKE_CASE = default_choice else: __SCREAMING_SNAKE_CASE = self.handle_input() if choice is not None: reset_cursor() for _ in range(len(self.choices ) + 1 ): move_cursor(1 , 'UP' ) clear_line() self.write_choice(_A , '\n' ) return choice
257
from collections import defaultdict from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst def lowerCamelCase_ ( ): lowerCamelCase_ , lowerCamelCase_ = 9, 1_4 # noqa: F841 lowerCamelCase_ = [ [0, 1, 4], [0, 7, 8], [1, 2, 8], [7, 8, 7], [7, 6, 1], [2, 8, 2], [8, 6, 6], [2, 3, 7], [2, 5, 4], [6, 5, 2], [3, 5, 1_4], [3, 4, 9], [5, 4, 1_0], [1, 7, 1_1], ] lowerCamelCase_ = defaultdict(lowerCamelCase__ ) for nodea, nodea, cost in edges: adjancency[nodea].append([nodea, cost] ) adjancency[nodea].append([nodea, cost] ) lowerCamelCase_ = mst(lowerCamelCase__ ) lowerCamelCase_ = [ [7, 6, 1], [2, 8, 2], [6, 5, 2], [0, 1, 4], [2, 5, 4], [2, 3, 7], [0, 7, 8], [3, 4, 9], ] for answer in expected: lowerCamelCase_ = tuple(answer[:2] ) lowerCamelCase_ = tuple(edge[::-1] ) assert edge in result or reverse in result
19
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available, is_vision_available, ) _lowercase = {'''configuration_deit''': ['''DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DeiTConfig''', '''DeiTOnnxConfig''']} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase = ['''DeiTFeatureExtractor'''] _lowercase = ['''DeiTImageProcessor'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase = [ '''DEIT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''DeiTForImageClassification''', '''DeiTForImageClassificationWithTeacher''', '''DeiTForMaskedImageModeling''', '''DeiTModel''', '''DeiTPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase = [ '''TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFDeiTForImageClassification''', '''TFDeiTForImageClassificationWithTeacher''', '''TFDeiTForMaskedImageModeling''', '''TFDeiTModel''', '''TFDeiTPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_deit import DeiTFeatureExtractor from .image_processing_deit import DeiTImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_deit import ( DEIT_PRETRAINED_MODEL_ARCHIVE_LIST, DeiTForImageClassification, DeiTForImageClassificationWithTeacher, DeiTForMaskedImageModeling, DeiTModel, DeiTPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_deit import ( TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST, TFDeiTForImageClassification, TFDeiTForImageClassificationWithTeacher, TFDeiTForMaskedImageModeling, TFDeiTModel, TFDeiTPreTrainedModel, ) else: import sys _lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
74
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, # specifically showcasing the experiment tracking capability, # and builds off the `nlp_example.py` script. # # 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 help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## __A =1_6 __A =3_2 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 1_6 ): lowerCamelCase_ = AutoTokenizer.from_pretrained("bert-base-cased" ) lowerCamelCase_ = load_dataset("glue" , "mrpc" ) def tokenize_function(lowerCamelCase__ ): # max_length=None => use the model max length (it's actually the default) lowerCamelCase_ = tokenizer(examples["sentence1"] , examples["sentence2"] , truncation=lowerCamelCase__ , max_length=lowerCamelCase__ ) 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(): lowerCamelCase_ = datasets.map( lowerCamelCase__ , batched=lowerCamelCase__ , 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 lowerCamelCase_ = tokenized_datasets.rename_column("label" , "labels" ) def collate_fn(lowerCamelCase__ ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCamelCase_ = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCamelCase_ = 1_6 elif accelerator.mixed_precision != "no": lowerCamelCase_ = 8 else: lowerCamelCase_ = None return tokenizer.pad( lowerCamelCase__ , padding="longest" , max_length=lowerCamelCase__ , pad_to_multiple_of=lowerCamelCase__ , return_tensors="pt" , ) # Instantiate dataloaders. lowerCamelCase_ = DataLoader( tokenized_datasets["train"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) lowerCamelCase_ = DataLoader( tokenized_datasets["validation"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) 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 __A =mocked_dataloaders # noqa: F811 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): # For testing only if os.environ.get("TESTING_MOCKED_DATALOADERS" , lowerCamelCase__ ) == "1": lowerCamelCase_ = 2 # Initialize Accelerator # New Code # # We pass in "all" to `log_with` to grab all available trackers in the environment # Note: If using a custom `Tracker` class, should be passed in here such as: # >>> log_with = ["all", MyCustomTrackerClassInstance()] if args.with_tracking: lowerCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , log_with="all" , project_dir=args.project_dir ) else: lowerCamelCase_ = Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCamelCase_ = config["lr"] lowerCamelCase_ = int(config["num_epochs"] ) lowerCamelCase_ = int(config["seed"] ) lowerCamelCase_ = int(config["batch_size"] ) set_seed(lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = get_dataloaders(lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = evaluate.load("glue" , "mrpc" ) # If the batch size is too big we use gradient accumulation lowerCamelCase_ = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: lowerCamelCase_ = batch_size // MAX_GPU_BATCH_SIZE lowerCamelCase_ = MAX_GPU_BATCH_SIZE # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCamelCase_ = AutoModelForSequenceClassification.from_pretrained("bert-base-cased" , return_dict=lowerCamelCase__ ) # 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). lowerCamelCase_ = model.to(accelerator.device ) # Instantiate optimizer lowerCamelCase_ = AdamW(params=model.parameters() , lr=lowerCamelCase__ ) # Instantiate scheduler lowerCamelCase_ = get_linear_schedule_with_warmup( optimizer=lowerCamelCase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowerCamelCase__ ) * num_epochs) // gradient_accumulation_steps , ) # 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. lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = accelerator.prepare( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # New Code # # We need to initialize the trackers we use. Overall configurations can also be stored if args.with_tracking: lowerCamelCase_ = os.path.split(lowerCamelCase__ )[-1].split("." )[0] accelerator.init_trackers(lowerCamelCase__ , lowerCamelCase__ ) # Now we train the model for epoch in range(lowerCamelCase__ ): model.train() # New Code # # For our tracking example, we will log the total loss of each epoch if args.with_tracking: lowerCamelCase_ = 0 for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.loss # New Code # if args.with_tracking: total_loss += loss.detach().float() lowerCamelCase_ = loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True` (the default). batch.to(accelerator.device ) with torch.no_grad(): lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.logits.argmax(dim=-1 ) lowerCamelCase_ , lowerCamelCase_ = accelerator.gather_for_metrics((predictions, batch["labels"]) ) metric.add_batch( predictions=lowerCamelCase__ , references=lowerCamelCase__ , ) lowerCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(F'epoch {epoch}:' , lowerCamelCase__ ) # New Code # # To actually log, we call `Accelerator.log` # The values passed can be of `str`, `int`, `float` or `dict` of `str` to `float`/`int` if args.with_tracking: accelerator.log( { "accuracy": eval_metric["accuracy"], "f1": eval_metric["f1"], "train_loss": total_loss.item() / len(lowerCamelCase__ ), "epoch": epoch, } , step=lowerCamelCase__ , ) # New Code # # When a run is finished, you should call `accelerator.end_training()` # to close all of the open trackers if args.with_tracking: accelerator.end_training() def lowerCamelCase_ ( ): lowerCamelCase_ = argparse.ArgumentParser(description="Simple example of training script." ) parser.add_argument( "--mixed_precision" , type=lowerCamelCase__ , default=lowerCamelCase__ , 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." , ) parser.add_argument("--cpu" , action="store_true" , help="If passed, will train on the CPU." ) parser.add_argument( "--with_tracking" , action="store_true" , help="Whether to load in all available experiment trackers from the environment and use them for logging." , ) parser.add_argument( "--project_dir" , type=lowerCamelCase__ , default="logs" , help="Location on where to store experiment tracking logs` and relevent project information" , ) lowerCamelCase_ = parser.parse_args() lowerCamelCase_ = {"lr": 2e-5, "num_epochs": 3, "seed": 4_2, "batch_size": 1_6} training_function(lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": main()
19
0
"""simple docstring""" import io import json import unittest from parameterized import parameterized from transformers import FSMTForConditionalGeneration, FSMTTokenizer from transformers.testing_utils import get_tests_dir, require_torch, slow, torch_device from utils import calculate_bleu _UpperCamelCase: Tuple = get_tests_dir() + '/test_data/fsmt/fsmt_val_data.json' with io.open(filename, 'r', encoding='utf-8') as f: _UpperCamelCase: Dict = json.load(f) @require_torch class a__ ( unittest.TestCase ): def lowercase ( self : Optional[int], lowerCAmelCase : Optional[Any] ) -> str: return FSMTTokenizer.from_pretrained(lowerCAmelCase ) def lowercase ( self : str, lowerCAmelCase : Union[str, Any] ) -> Union[str, Any]: lowercase : Optional[int] = FSMTForConditionalGeneration.from_pretrained(lowerCAmelCase ).to(lowerCAmelCase ) if torch_device == "cuda": model.half() return model @parameterized.expand( [ ['en-ru', 26.0], ['ru-en', 22.0], ['en-de', 22.0], ['de-en', 29.0], ] ) @slow def lowercase ( self : Optional[int], lowerCAmelCase : Any, lowerCAmelCase : str ) -> str: # note: this test is not testing the best performance since it only evals a small batch # but it should be enough to detect a regression in the output quality lowercase : Dict = f'''facebook/wmt19-{pair}''' lowercase : Union[str, Any] = self.get_tokenizer(lowerCAmelCase ) lowercase : Optional[int] = self.get_model(lowerCAmelCase ) lowercase : List[str] = bleu_data[pair]['src'] lowercase : Any = bleu_data[pair]['tgt'] lowercase : Union[str, Any] = tokenizer(lowerCAmelCase, return_tensors='pt', truncation=lowerCAmelCase, padding='longest' ).to(lowerCAmelCase ) lowercase : str = model.generate( input_ids=batch.input_ids, num_beams=8, ) lowercase : List[str] = tokenizer.batch_decode( lowerCAmelCase, skip_special_tokens=lowerCAmelCase, clean_up_tokenization_spaces=lowerCAmelCase ) lowercase : str = calculate_bleu(lowerCAmelCase, lowerCAmelCase ) print(lowerCAmelCase ) self.assertGreaterEqual(scores['bleu'], lowerCAmelCase )
255
import os from shutil import copyfile from typing import List, Optional, Tuple from tokenizers import processors from ...tokenization_utils import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_mbart import MBartTokenizer else: __A =None __A =logging.get_logger(__name__) __A ={'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''} __A ={ '''vocab_file''': { '''facebook/mbart-large-en-ro''': ( '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model''' ), '''facebook/mbart-large-cc25''': ( '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model''' ), }, '''tokenizer_file''': { '''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''', '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''', }, } __A ={ '''facebook/mbart-large-en-ro''': 1_0_2_4, '''facebook/mbart-large-cc25''': 1_0_2_4, } # fmt: off __A =['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN'''] class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = VOCAB_FILES_NAMES lowerCAmelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowerCAmelCase__ = PRETRAINED_VOCAB_FILES_MAP lowerCAmelCase__ = ['input_ids', 'attention_mask'] lowerCAmelCase__ = MBartTokenizer lowerCAmelCase__ = [] lowerCAmelCase__ = [] def __init__( self , lowercase=None , lowercase=None , lowercase="<s>" , lowercase="</s>" , lowercase="</s>" , lowercase="<s>" , lowercase="<unk>" , lowercase="<pad>" , lowercase="<mask>" , lowercase=None , lowercase=None , lowercase=None , **lowercase , ) -> Dict: # Mask token behave like a normal word, i.e. include the space before it lowerCamelCase_ = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else mask_token super().__init__( vocab_file=lowercase , tokenizer_file=lowercase , bos_token=lowercase , eos_token=lowercase , sep_token=lowercase , cls_token=lowercase , unk_token=lowercase , pad_token=lowercase , mask_token=lowercase , src_lang=lowercase , tgt_lang=lowercase , additional_special_tokens=lowercase , **lowercase , ) lowerCamelCase_ = vocab_file lowerCamelCase_ = False if not self.vocab_file else True lowerCamelCase_ = FAIRSEQ_LANGUAGE_CODES.copy() if additional_special_tokens is not None: # Only add those special tokens if they are not already there. _additional_special_tokens.extend( [t for t in additional_special_tokens if t not in _additional_special_tokens] ) self.add_special_tokens({"additional_special_tokens": _additional_special_tokens} ) lowerCamelCase_ = { lang_code: self.convert_tokens_to_ids(lowercase ) for lang_code in FAIRSEQ_LANGUAGE_CODES } lowerCamelCase_ = src_lang if src_lang is not None else "en_XX" lowerCamelCase_ = self.convert_tokens_to_ids(self._src_lang ) lowerCamelCase_ = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def SCREAMING_SNAKE_CASE_( self ) -> str: return self._src_lang @src_lang.setter def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: lowerCamelCase_ = [self.sep_token_id] lowerCamelCase_ = [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 SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , **lowercase ) -> List[Any]: if src_lang is None or tgt_lang is None: raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model" ) lowerCamelCase_ = src_lang lowerCamelCase_ = self(lowercase , add_special_tokens=lowercase , return_tensors=lowercase , **lowercase ) lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = tgt_lang_id return inputs def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = "en_XX" , lowercase = None , lowercase = "ro_RO" , **lowercase , ) -> BatchEncoding: lowerCamelCase_ = src_lang lowerCamelCase_ = tgt_lang return super().prepare_seqaseq_batch(lowercase , lowercase , **lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: return self.set_src_lang_special_tokens(self.src_lang ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> Tuple[str]: if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(lowercase ): logger.error(f'Vocabulary path ({save_directory}) should be a directory.' ) return lowerCamelCase_ = os.path.join( lowercase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowercase ): copyfile(self.vocab_file , lowercase ) return (out_vocab_file,)
19
0
'''simple docstring''' import os import sys import tempfile import unittest import unittest.mock as mock from pathlib import Path from huggingface_hub import HfFolder, delete_repo from huggingface_hub.file_download import http_get from requests.exceptions import HTTPError from transformers import ( AlbertTokenizer, AutoTokenizer, BertTokenizer, BertTokenizerFast, GPTaTokenizerFast, is_tokenizers_available, ) from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers from transformers.tokenization_utils import Trie sys.path.append(str(Path(__file__).parent.parent / 'utils')) from test_module.custom_tokenization import CustomTokenizer # noqa E402 if is_tokenizers_available(): from test_module.custom_tokenization_fast import CustomTokenizerFast class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __magic_name__ ( self : int ) -> Union[str, Any]: # A mock response for an HTTP head request to emulate server down SCREAMING_SNAKE_CASE__ : Optional[int] =mock.Mock() SCREAMING_SNAKE_CASE__ : Any =5_00 SCREAMING_SNAKE_CASE__ : Tuple ={} SCREAMING_SNAKE_CASE__ : Tuple =HTTPError SCREAMING_SNAKE_CASE__ : Tuple ={} # Download this model to make sure it's in the cache. SCREAMING_SNAKE_CASE__ : Optional[int] =BertTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''' ) # Under the mock environment we get a 500 error when trying to reach the tokenizer. with mock.patch('''requests.Session.request''' , return_value=__lowercase ) as mock_head: SCREAMING_SNAKE_CASE__ : int =BertTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''' ) # This check we did call the fake head request mock_head.assert_called() @require_tokenizers def __magic_name__ ( self : List[str] ) -> Tuple: # A mock response for an HTTP head request to emulate server down SCREAMING_SNAKE_CASE__ : Any =mock.Mock() SCREAMING_SNAKE_CASE__ : Dict =5_00 SCREAMING_SNAKE_CASE__ : Dict ={} SCREAMING_SNAKE_CASE__ : int =HTTPError SCREAMING_SNAKE_CASE__ : int ={} # Download this model to make sure it's in the cache. SCREAMING_SNAKE_CASE__ : Union[str, Any] =GPTaTokenizerFast.from_pretrained('''gpt2''' ) # Under the mock environment we get a 500 error when trying to reach the tokenizer. with mock.patch('''requests.Session.request''' , return_value=__lowercase ) as mock_head: SCREAMING_SNAKE_CASE__ : Dict =GPTaTokenizerFast.from_pretrained('''gpt2''' ) # This check we did call the fake head request mock_head.assert_called() def __magic_name__ ( self : Optional[Any] ) -> Any: # This test is for deprecated behavior and can be removed in v5 try: SCREAMING_SNAKE_CASE__ : Any =tempfile.mktemp() with open(__lowercase , '''wb''' ) as f: http_get('''https://huggingface.co/albert-base-v1/resolve/main/spiece.model''' , __lowercase ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =AlbertTokenizer.from_pretrained(__lowercase ) finally: os.remove(__lowercase ) # Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in # the current folder and have the right name. if os.path.isfile('''tokenizer.json''' ): # We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it. return try: with open('''tokenizer.json''' , '''wb''' ) as f: http_get('''https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json''' , __lowercase ) SCREAMING_SNAKE_CASE__ : List[Any] =AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' ) # The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000 self.assertEqual(tokenizer.vocab_size , 10_00 ) # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file. finally: os.remove('''tokenizer.json''' ) def __magic_name__ ( self : Union[str, Any] ) -> int: # This test is for deprecated behavior and can be removed in v5 SCREAMING_SNAKE_CASE__ : Any =AlbertTokenizer.from_pretrained('''https://huggingface.co/albert-base-v1/resolve/main/spiece.model''' ) @is_staging_test class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): snake_case_ = ["""[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """bla""", """blou"""] @classmethod def __magic_name__ ( cls : Any ) -> Tuple: SCREAMING_SNAKE_CASE__ : Optional[Any] =TOKEN HfFolder.save_token(__lowercase ) @classmethod def __magic_name__ ( cls : List[Any] ) -> Dict: try: delete_repo(token=cls._token , repo_id='''test-tokenizer''' ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id='''valid_org/test-tokenizer-org''' ) except HTTPError: pass try: delete_repo(token=cls._token , repo_id='''test-dynamic-tokenizer''' ) except HTTPError: pass def __magic_name__ ( self : List[Any] ) -> List[str]: with tempfile.TemporaryDirectory() as tmp_dir: SCREAMING_SNAKE_CASE__ : Tuple =os.path.join(__lowercase , '''vocab.txt''' ) with open(__lowercase , '''w''' , encoding='''utf-8''' ) as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens] ) ) SCREAMING_SNAKE_CASE__ : Optional[Any] =BertTokenizer(__lowercase ) tokenizer.push_to_hub('''test-tokenizer''' , use_auth_token=self._token ) SCREAMING_SNAKE_CASE__ : int =BertTokenizer.from_pretrained(F"{USER}/test-tokenizer" ) self.assertDictEqual(new_tokenizer.vocab , tokenizer.vocab ) # Reset repo delete_repo(token=self._token , repo_id='''test-tokenizer''' ) # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: tokenizer.save_pretrained(__lowercase , repo_id='''test-tokenizer''' , push_to_hub=__lowercase , use_auth_token=self._token ) SCREAMING_SNAKE_CASE__ : Tuple =BertTokenizer.from_pretrained(F"{USER}/test-tokenizer" ) self.assertDictEqual(new_tokenizer.vocab , tokenizer.vocab ) def __magic_name__ ( self : int ) -> Union[str, Any]: with tempfile.TemporaryDirectory() as tmp_dir: SCREAMING_SNAKE_CASE__ : Optional[int] =os.path.join(__lowercase , '''vocab.txt''' ) with open(__lowercase , '''w''' , encoding='''utf-8''' ) as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens] ) ) SCREAMING_SNAKE_CASE__ : int =BertTokenizer(__lowercase ) tokenizer.push_to_hub('''valid_org/test-tokenizer-org''' , use_auth_token=self._token ) SCREAMING_SNAKE_CASE__ : List[Any] =BertTokenizer.from_pretrained('''valid_org/test-tokenizer-org''' ) self.assertDictEqual(new_tokenizer.vocab , tokenizer.vocab ) # Reset repo delete_repo(token=self._token , repo_id='''valid_org/test-tokenizer-org''' ) # Push to hub via save_pretrained with tempfile.TemporaryDirectory() as tmp_dir: tokenizer.save_pretrained( __lowercase , repo_id='''valid_org/test-tokenizer-org''' , push_to_hub=__lowercase , use_auth_token=self._token ) SCREAMING_SNAKE_CASE__ : int =BertTokenizer.from_pretrained('''valid_org/test-tokenizer-org''' ) self.assertDictEqual(new_tokenizer.vocab , tokenizer.vocab ) @require_tokenizers def __magic_name__ ( self : Tuple ) -> str: CustomTokenizer.register_for_auto_class() with tempfile.TemporaryDirectory() as tmp_dir: SCREAMING_SNAKE_CASE__ : Dict =os.path.join(__lowercase , '''vocab.txt''' ) with open(__lowercase , '''w''' , encoding='''utf-8''' ) as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens] ) ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =CustomTokenizer(__lowercase ) # No fast custom tokenizer tokenizer.push_to_hub('''test-dynamic-tokenizer''' , use_auth_token=self._token ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =AutoTokenizer.from_pretrained(F"{USER}/test-dynamic-tokenizer" , trust_remote_code=__lowercase ) # Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module self.assertEqual(tokenizer.__class__.__name__ , '''CustomTokenizer''' ) # Fast and slow custom tokenizer CustomTokenizerFast.register_for_auto_class() with tempfile.TemporaryDirectory() as tmp_dir: SCREAMING_SNAKE_CASE__ : List[str] =os.path.join(__lowercase , '''vocab.txt''' ) with open(__lowercase , '''w''' , encoding='''utf-8''' ) as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in self.vocab_tokens] ) ) SCREAMING_SNAKE_CASE__ : int =BertTokenizerFast.from_pretrained(__lowercase ) bert_tokenizer.save_pretrained(__lowercase ) SCREAMING_SNAKE_CASE__ : Any =CustomTokenizerFast.from_pretrained(__lowercase ) tokenizer.push_to_hub('''test-dynamic-tokenizer''' , use_auth_token=self._token ) SCREAMING_SNAKE_CASE__ : Any =AutoTokenizer.from_pretrained(F"{USER}/test-dynamic-tokenizer" , trust_remote_code=__lowercase ) # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module self.assertEqual(tokenizer.__class__.__name__ , '''CustomTokenizerFast''' ) SCREAMING_SNAKE_CASE__ : List[str] =AutoTokenizer.from_pretrained( F"{USER}/test-dynamic-tokenizer" , use_fast=__lowercase , trust_remote_code=__lowercase ) # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module self.assertEqual(tokenizer.__class__.__name__ , '''CustomTokenizer''' ) class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __magic_name__ ( self : Tuple ) -> List[Any]: SCREAMING_SNAKE_CASE__ : str =Trie() trie.add('''Hello 友達''' ) self.assertEqual(trie.data , {'''H''': {'''e''': {'''l''': {'''l''': {'''o''': {''' ''': {'''友''': {'''達''': {'''''': 1}}}}}}}}} ) trie.add('''Hello''' ) trie.data self.assertEqual(trie.data , {'''H''': {'''e''': {'''l''': {'''l''': {'''o''': {'''''': 1, ''' ''': {'''友''': {'''達''': {'''''': 1}}}}}}}}} ) def __magic_name__ ( self : int ) -> int: SCREAMING_SNAKE_CASE__ : Dict =Trie() self.assertEqual(trie.split('''[CLS] This is a extra_id_100''' ) , ['''[CLS] This is a extra_id_100'''] ) trie.add('''[CLS]''' ) trie.add('''extra_id_1''' ) trie.add('''extra_id_100''' ) self.assertEqual(trie.split('''[CLS] This is a extra_id_100''' ) , ['''[CLS]''', ''' This is a ''', '''extra_id_100'''] ) def __magic_name__ ( self : int ) -> int: SCREAMING_SNAKE_CASE__ : Any =Trie() trie.add('''A''' ) self.assertEqual(trie.split('''ABC''' ) , ['''A''', '''BC'''] ) self.assertEqual(trie.split('''BCA''' ) , ['''BC''', '''A'''] ) def __magic_name__ ( self : Dict ) -> Any: SCREAMING_SNAKE_CASE__ : Union[str, Any] =Trie() trie.add('''TOKEN]''' ) trie.add('''[SPECIAL_TOKEN]''' ) self.assertEqual(trie.split('''This is something [SPECIAL_TOKEN]''' ) , ['''This is something ''', '''[SPECIAL_TOKEN]'''] ) def __magic_name__ ( self : str ) -> str: SCREAMING_SNAKE_CASE__ : List[Any] =Trie() trie.add('''A''' ) trie.add('''P''' ) trie.add('''[SPECIAL_TOKEN]''' ) self.assertEqual(trie.split('''This is something [SPECIAL_TOKEN]''' ) , ['''This is something ''', '''[SPECIAL_TOKEN]'''] ) def __magic_name__ ( self : Union[str, Any] ) -> List[str]: SCREAMING_SNAKE_CASE__ : Optional[int] =Trie() trie.add('''AB''' ) trie.add('''B''' ) trie.add('''C''' ) self.assertEqual(trie.split('''ABC''' ) , ['''AB''', '''C'''] ) def __magic_name__ ( self : Optional[int] ) -> str: SCREAMING_SNAKE_CASE__ : Union[str, Any] =Trie() trie.add('''ABC''' ) trie.add('''B''' ) trie.add('''CD''' ) self.assertEqual(trie.split('''ABCD''' ) , ['''ABC''', '''D'''] ) def __magic_name__ ( self : Optional[int] ) -> Dict: # Even if the offsets are wrong, we necessarily output correct string # parts. SCREAMING_SNAKE_CASE__ : Union[str, Any] =Trie() SCREAMING_SNAKE_CASE__ : Optional[Any] =trie.cut_text('''ABC''' , [0, 0, 2, 1, 2, 3] ) self.assertEqual(__lowercase , ['''AB''', '''C'''] )
152
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss __A =pytest.mark.integration @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = Dataset.from_dict({"filename": ["my_name-train" + "_" + str(lowercase ) for x in np.arange(30 ).tolist()]} ) return dset def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: import faiss lowerCamelCase_ = self._create_dummy_dataset() lowerCamelCase_ = dset.map( lambda lowercase , lowercase : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=lowercase , keep_in_memory=lowercase ) lowerCamelCase_ = dset.add_faiss_index("vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) dset.drop_index("vecs" ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: dset.save_faiss_index("vecs" , tmp_file.name ) dset.load_faiss_index("vecs2" , tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs2" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" ) dset.drop_index("vecs" ) self.assertRaises(lowercase , partial(dset.get_nearest_examples , "vecs2" , np.ones(5 , dtype=np.floataa ) ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: from elasticsearch import Elasticsearch lowerCamelCase_ = self._create_dummy_dataset() with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = {"acknowledged": True} mocked_bulk.return_value([(True, None)] * 30 ) lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 29}]}} lowerCamelCase_ = Elasticsearch() dset.add_elasticsearch_index("filename" , es_client=lowercase ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("filename" , "my_name-train_29" ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Tuple: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertRaises(lowercase , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries lowerCamelCase_ = np.eye(5 , dtype=np.floataa )[::-1] lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) self.assertRaises(lowercase , index.search_batch , queries[0] ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Any: import faiss lowerCamelCase_ = FaissIndex(string_factory="Flat" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) lowerCamelCase_ = FaissIndex(string_factory="LSH" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(lowercase ): lowerCamelCase_ = FaissIndex(string_factory="Flat" , custom_index=faiss.IndexFlat(5 ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = faiss.IndexFlat(5 ) lowerCamelCase_ = FaissIndex(custom_index=lowercase ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: index.save(tmp_file.name ) lowerCamelCase_ = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def lowerCamelCase_ ( lowerCamelCase__ ): import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) lowerCamelCase_ = "index.faiss" lowerCamelCase_ = F'mock://{index_name}' index.save(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = FaissIndex.load(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowerCamelCase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: from elasticsearch import Elasticsearch with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = Elasticsearch() lowerCamelCase_ = {"acknowledged": True} lowerCamelCase_ = ElasticSearchIndex(es_client=lowercase ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(["foo", "bar", "foobar"] ) # single query lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase ) # batched queries with timeout lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase , request_timeout=30 ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase )
19
0
import argparse import os import torch from transformers import FlavaConfig, FlavaForPreTraining from transformers.models.flava.convert_dalle_to_flava_codebook import convert_dalle_checkpoint def A ( a_ ) -> Union[str, Any]: # encoder.embeddings are double copied in original FLAVA return sum(param.float().sum() if 'encoder.embeddings' not in key else 0 for key, param in state_dict.items() ) def A ( a_ ,a_ ) -> Union[str, Any]: __UpperCamelCase : Any ={} for key, value in state_dict.items(): if "text_encoder.embeddings" in key or "image_encoder.embeddings" in key: continue __UpperCamelCase : List[Any] =key.replace('heads.cmd.mim_head.cls.predictions' ,'mmm_image_head' ) __UpperCamelCase : str =key.replace('heads.cmd.mlm_head.cls.predictions' ,'mmm_text_head' ) __UpperCamelCase : Tuple =key.replace('heads.cmd.itm_head.cls' ,'itm_head' ) __UpperCamelCase : Any =key.replace('heads.cmd.itm_head.pooler' ,'itm_head.pooler' ) __UpperCamelCase : List[Any] =key.replace('heads.cmd.clip_head.logit_scale' ,'flava.logit_scale' ) __UpperCamelCase : str =key.replace('heads.fairseq_mlm.cls.predictions' ,'mlm_head' ) __UpperCamelCase : List[Any] =key.replace('heads.imagenet.mim_head.cls.predictions' ,'mim_head' ) __UpperCamelCase : Any =key.replace('mm_text_projection' ,'flava.text_to_mm_projection' ) __UpperCamelCase : List[Any] =key.replace('mm_image_projection' ,'flava.image_to_mm_projection' ) __UpperCamelCase : List[str] =key.replace('image_encoder.module' ,'flava.image_model' ) __UpperCamelCase : str =key.replace('text_encoder.module' ,'flava.text_model' ) __UpperCamelCase : Optional[Any] =key.replace('mm_encoder.module.encoder.cls_token' ,'flava.multimodal_model.cls_token' ) __UpperCamelCase : int =key.replace('mm_encoder.module' ,'flava.multimodal_model' ) __UpperCamelCase : int =key.replace('text_projection' ,'flava.text_projection' ) __UpperCamelCase : Optional[int] =key.replace('image_projection' ,'flava.image_projection' ) __UpperCamelCase : Dict =value.float() for key, value in codebook_state_dict.items(): __UpperCamelCase : List[str] =value return upgrade @torch.no_grad() def A ( a_ ,a_ ,a_ ,a_=None ) -> Union[str, Any]: if config_path is not None: __UpperCamelCase : List[Any] =FlavaConfig.from_pretrained(lowerCamelCase__ ) else: __UpperCamelCase : int =FlavaConfig() __UpperCamelCase : Tuple =FlavaForPreTraining(lowerCamelCase__ ).eval() __UpperCamelCase : Optional[Any] =convert_dalle_checkpoint(lowerCamelCase__ ,lowerCamelCase__ ,save_checkpoint=lowerCamelCase__ ) if os.path.exists(lowerCamelCase__ ): __UpperCamelCase : str =torch.load(lowerCamelCase__ ,map_location='cpu' ) else: __UpperCamelCase : Union[str, Any] =torch.hub.load_state_dict_from_url(lowerCamelCase__ ,map_location='cpu' ) __UpperCamelCase : Tuple =upgrade_state_dict(lowerCamelCase__ ,lowerCamelCase__ ) hf_model.load_state_dict(lowerCamelCase__ ) __UpperCamelCase : Dict =hf_model.state_dict() __UpperCamelCase : Tuple =count_parameters(lowerCamelCase__ ) __UpperCamelCase : Dict =count_parameters(lowerCamelCase__ ) + count_parameters(lowerCamelCase__ ) assert torch.allclose(lowerCamelCase__ ,lowerCamelCase__ ,atol=1e-3 ) hf_model.save_pretrained(lowerCamelCase__ ) if __name__ == "__main__": A_ :int = 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 flava checkpoint''') parser.add_argument('''--codebook_path''', default=None, type=str, help='''Path to flava codebook checkpoint''') parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''') A_ :Optional[int] = parser.parse_args() convert_flava_checkpoint(args.checkpoint_path, args.codebook_path, args.pytorch_dump_folder_path, args.config_path)
71
import unittest from transformers import is_torch_available 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 from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST, OpenAIGPTConfig, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , lowercase=13 , lowercase=7 , lowercase=True , lowercase=True , lowercase=True , lowercase=99 , lowercase=32 , lowercase=5 , lowercase=4 , lowercase=37 , lowercase="gelu" , lowercase=0.1 , lowercase=0.1 , lowercase=512 , lowercase=16 , lowercase=2 , lowercase=0.0_2 , lowercase=3 , lowercase=4 , lowercase=None , ) -> List[str]: lowerCamelCase_ = parent lowerCamelCase_ = batch_size lowerCamelCase_ = seq_length lowerCamelCase_ = is_training lowerCamelCase_ = use_token_type_ids lowerCamelCase_ = use_labels lowerCamelCase_ = vocab_size lowerCamelCase_ = hidden_size lowerCamelCase_ = num_hidden_layers lowerCamelCase_ = num_attention_heads lowerCamelCase_ = intermediate_size lowerCamelCase_ = hidden_act lowerCamelCase_ = hidden_dropout_prob lowerCamelCase_ = attention_probs_dropout_prob lowerCamelCase_ = max_position_embeddings lowerCamelCase_ = type_vocab_size lowerCamelCase_ = type_sequence_label_size lowerCamelCase_ = initializer_range lowerCamelCase_ = num_labels lowerCamelCase_ = num_choices lowerCamelCase_ = scope lowerCamelCase_ = self.vocab_size - 1 def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_token_type_ids: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = OpenAIGPTConfig( 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 , pad_token_id=self.pad_token_id , ) lowerCamelCase_ = ids_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, head_mask, token_type_ids, sequence_labels, token_labels, choice_labels, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTModel(config=lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , head_mask=lowercase ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = OpenAIGPTLMHeadModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTDoubleHeadsModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = OpenAIGPTForSequenceClassification(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = { "input_ids": input_ids, "token_type_ids": token_type_ids, "head_mask": head_mask, } return config, inputs_dict @require_torch class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification) if is_torch_available() else () ) lowerCAmelCase__ = ( (OpenAIGPTLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly lowerCAmelCase__ = ( { 'feature-extraction': OpenAIGPTModel, 'text-classification': OpenAIGPTForSequenceClassification, 'text-generation': OpenAIGPTLMHeadModel, 'zero-shot': OpenAIGPTForSequenceClassification, } if is_torch_available() else {} ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests": # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers. # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a # tiny config could not be created. return True return False def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=False ) -> Any: lowerCamelCase_ = super()._prepare_for_class(lowercase , lowercase , return_labels=lowercase ) if return_labels: if model_class.__name__ == "OpenAIGPTDoubleHeadsModel": lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowercase ) return inputs_dict def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = OpenAIGPTModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , n_embd=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_double_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Any: for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = OpenAIGPTModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @require_torch class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = OpenAIGPTLMHeadModel.from_pretrained("openai-gpt" ) model.to(lowercase ) lowerCamelCase_ = torch.tensor([[481, 4735, 544]] , dtype=torch.long , device=lowercase ) # the president is lowerCamelCase_ = [ 481, 4735, 544, 246, 963, 870, 762, 239, 244, 40477, 244, 249, 719, 881, 487, 544, 240, 244, 603, 481, ] # the president is a very good man. " \n " i\'m sure he is, " said the lowerCamelCase_ = model.generate(lowercase , do_sample=lowercase ) self.assertListEqual(output_ids[0].tolist() , lowercase )
19
0
'''simple docstring''' import math from typing import Optional import numpy as np from ...configuration_utils import PretrainedConfig from ...utils import logging a_ : str = logging.get_logger(__name__) a_ : Any = { "facebook/encodec_24khz": "https://huggingface.co/facebook/encodec_24khz/resolve/main/config.json", "facebook/encodec_48khz": "https://huggingface.co/facebook/encodec_48khz/resolve/main/config.json", } class a ( snake_case_ ): _lowerCAmelCase = """encodec""" def __init__( self , __magic_name__=[1.5, 3.0, 6.0, 12.0, 24.0] , __magic_name__=2_40_00 , __magic_name__=1 , __magic_name__=False , __magic_name__=None , __magic_name__=None , __magic_name__=1_28 , __magic_name__=32 , __magic_name__=1 , __magic_name__=[8, 5, 4, 2] , __magic_name__="weight_norm" , __magic_name__=7 , __magic_name__=7 , __magic_name__=3 , __magic_name__=2 , __magic_name__=True , __magic_name__="reflect" , __magic_name__=2 , __magic_name__=2 , __magic_name__=1.0 , __magic_name__=10_24 , __magic_name__=None , __magic_name__=True , **__magic_name__ , ) -> Tuple: _a = target_bandwidths _a = sampling_rate _a = audio_channels _a = normalize _a = chunk_length_s _a = overlap _a = hidden_size _a = num_filters _a = num_residual_layers _a = upsampling_ratios _a = norm_type _a = kernel_size _a = last_kernel_size _a = residual_kernel_size _a = dilation_growth_rate _a = use_causal_conv _a = pad_mode _a = compress _a = num_lstm_layers _a = trim_right_ratio _a = codebook_size _a = codebook_dim if codebook_dim is not None else hidden_size _a = use_conv_shortcut if self.norm_type not in ["weight_norm", "time_group_norm"]: raise ValueError( f'self.norm_type must be one of `"weight_norm"`, `"time_group_norm"`), got {self.norm_type}' ) super().__init__(**__magic_name__ ) @property def __UpperCAmelCase ( self ) -> Optional[int]: if self.chunk_length_s is None: return None else: return int(self.chunk_length_s * self.sampling_rate ) @property def __UpperCAmelCase ( self ) -> Optional[int]: if self.chunk_length_s is None or self.overlap is None: return None else: return max(1 , int((1.0 - self.overlap) * self.chunk_length ) ) @property def __UpperCAmelCase ( self ) -> int: _a = np.prod(self.upsampling_ratios ) return math.ceil(self.sampling_rate / hop_length ) @property def __UpperCAmelCase ( self ) -> int: return int(10_00 * self.target_bandwidths[-1] // (self.frame_rate * 10) )
168
__A ={str(digit): digit**5 for digit in range(1_0)} def lowerCamelCase_ ( lowerCamelCase__ ): return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCamelCase__ ) ) def lowerCamelCase_ ( ): return sum( number for number in range(1_0_0_0 , 1_0_0_0_0_0_0 ) if number == digits_fifth_powers_sum(lowerCamelCase__ ) ) if __name__ == "__main__": print(solution())
19
0
import inspect import warnings from typing import Any, Dict, Optional, Union from packaging import version def a ( *A__ : Dict , A__ : Any = None , A__ : str=True , A__ : Union[str, Any]=2 ) -> List[Any]: """simple docstring""" from .. import __version__ _lowercase =take_from _lowercase =() if not isinstance(args[0] , lowerCamelCase__ ): _lowercase =(args,) for attribute, version_name, message in args: if version.parse(version.parse(lowerCamelCase__ ).base_version ) >= version.parse(lowerCamelCase__ ): raise ValueError( F'''The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers\'''' F''' version {__version__} is >= {version_name}''' ) _lowercase =None if isinstance(lowerCamelCase__ , lowerCamelCase__ ) and attribute in deprecated_kwargs: values += (deprecated_kwargs.pop(lowerCamelCase__ ),) _lowercase =F'''The `{attribute}` argument is deprecated and will be removed in version {version_name}.''' elif hasattr(lowerCamelCase__ , lowerCamelCase__ ): values += (getattr(lowerCamelCase__ , lowerCamelCase__ ),) _lowercase =F'''The `{attribute}` attribute is deprecated and will be removed in version {version_name}.''' elif deprecated_kwargs is None: _lowercase =F'''`{attribute}` is deprecated and will be removed in version {version_name}.''' if warning is not None: _lowercase =warning + ' ' if standard_warn else '' warnings.warn(warning + message , lowerCamelCase__ , stacklevel=lowerCamelCase__ ) if isinstance(lowerCamelCase__ , lowerCamelCase__ ) and len(lowerCamelCase__ ) > 0: _lowercase =inspect.getouterframes(inspect.currentframe() )[1] _lowercase =call_frame.filename _lowercase =call_frame.lineno _lowercase =call_frame.function _lowercase , _lowercase =next(iter(deprecated_kwargs.items() ) ) raise TypeError(F'''{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`''' ) if len(lowerCamelCase__ ) == 0: return elif len(lowerCamelCase__ ) == 1: return values[0] return values
205
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 YolosConfig, YolosForObjectDetection, YolosImageProcessor from transformers.utils import logging logging.set_verbosity_info() __A =logging.get_logger(__name__) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = YolosConfig() # size of the architecture if "yolos_ti" in yolos_name: lowerCamelCase_ = 1_9_2 lowerCamelCase_ = 7_6_8 lowerCamelCase_ = 1_2 lowerCamelCase_ = 3 lowerCamelCase_ = [8_0_0, 1_3_3_3] lowerCamelCase_ = False elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = 3_3_0 lowerCamelCase_ = 1_4 lowerCamelCase_ = 6 lowerCamelCase_ = 1_3_2_0 elif "yolos_s" in yolos_name: lowerCamelCase_ = 3_8_4 lowerCamelCase_ = 1_5_3_6 lowerCamelCase_ = 1_2 lowerCamelCase_ = 6 elif "yolos_b" in yolos_name: lowerCamelCase_ = [8_0_0, 1_3_4_4] lowerCamelCase_ = 9_1 lowerCamelCase_ = "huggingface/label-files" lowerCamelCase_ = "coco-detection-id2label.json" lowerCamelCase_ = json.load(open(hf_hub_download(lowerCamelCase__ , lowerCamelCase__ , repo_type="dataset" ) , "r" ) ) lowerCamelCase_ = {int(lowerCamelCase__ ): v for k, v in idalabel.items()} lowerCamelCase_ = idalabel lowerCamelCase_ = {v: k for k, v in idalabel.items()} return config def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.weight' ) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.bias' ) # next, add query, keys and values (in that order) to the state dict lowerCamelCase_ = in_proj_weight[: config.hidden_size, :] lowerCamelCase_ = in_proj_bias[: config.hidden_size] lowerCamelCase_ = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] lowerCamelCase_ = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] lowerCamelCase_ = in_proj_weight[-config.hidden_size :, :] lowerCamelCase_ = in_proj_bias[-config.hidden_size :] def lowerCamelCase_ ( lowerCamelCase__ ): if "backbone" in name: lowerCamelCase_ = name.replace("backbone" , "vit" ) if "cls_token" in name: lowerCamelCase_ = name.replace("cls_token" , "embeddings.cls_token" ) if "det_token" in name: lowerCamelCase_ = name.replace("det_token" , "embeddings.detection_tokens" ) if "mid_pos_embed" in name: lowerCamelCase_ = name.replace("mid_pos_embed" , "encoder.mid_position_embeddings" ) if "pos_embed" in name: lowerCamelCase_ = name.replace("pos_embed" , "embeddings.position_embeddings" ) if "patch_embed.proj" in name: lowerCamelCase_ = name.replace("patch_embed.proj" , "embeddings.patch_embeddings.projection" ) if "blocks" in name: lowerCamelCase_ = name.replace("blocks" , "encoder.layer" ) if "attn.proj" in name: lowerCamelCase_ = name.replace("attn.proj" , "attention.output.dense" ) if "attn" in name: lowerCamelCase_ = name.replace("attn" , "attention.self" ) if "norm1" in name: lowerCamelCase_ = name.replace("norm1" , "layernorm_before" ) if "norm2" in name: lowerCamelCase_ = name.replace("norm2" , "layernorm_after" ) if "mlp.fc1" in name: lowerCamelCase_ = name.replace("mlp.fc1" , "intermediate.dense" ) if "mlp.fc2" in name: lowerCamelCase_ = name.replace("mlp.fc2" , "output.dense" ) if "class_embed" in name: lowerCamelCase_ = name.replace("class_embed" , "class_labels_classifier" ) if "bbox_embed" in name: lowerCamelCase_ = name.replace("bbox_embed" , "bbox_predictor" ) if "vit.norm" in name: lowerCamelCase_ = name.replace("vit.norm" , "vit.layernorm" ) return name def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): for key in orig_state_dict.copy().keys(): lowerCamelCase_ = orig_state_dict.pop(lowerCamelCase__ ) if "qkv" in key: lowerCamelCase_ = key.split("." ) lowerCamelCase_ = int(key_split[2] ) lowerCamelCase_ = model.vit.encoder.layer[layer_num].attention.attention.all_head_size if "weight" in key: lowerCamelCase_ = val[:dim, :] lowerCamelCase_ = val[ dim : dim * 2, : ] lowerCamelCase_ = val[-dim:, :] else: lowerCamelCase_ = val[:dim] lowerCamelCase_ = val[dim : dim * 2] lowerCamelCase_ = val[-dim:] else: lowerCamelCase_ = val return orig_state_dict def lowerCamelCase_ ( ): lowerCamelCase_ = "http://images.cocodataset.org/val2017/000000039769.jpg" lowerCamelCase_ = Image.open(requests.get(lowerCamelCase__ , stream=lowerCamelCase__ ).raw ) return im @torch.no_grad() def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): lowerCamelCase_ = get_yolos_config(lowerCamelCase__ ) # load original state_dict lowerCamelCase_ = torch.load(lowerCamelCase__ , map_location="cpu" )["model"] # load 🤗 model lowerCamelCase_ = YolosForObjectDetection(lowerCamelCase__ ) model.eval() lowerCamelCase_ = convert_state_dict(lowerCamelCase__ , lowerCamelCase__ ) model.load_state_dict(lowerCamelCase__ ) # Check outputs on an image, prepared by YolosImageProcessor lowerCamelCase_ = 8_0_0 if yolos_name != "yolos_ti" else 5_1_2 lowerCamelCase_ = YolosImageProcessor(format="coco_detection" , size=lowerCamelCase__ ) lowerCamelCase_ = image_processor(images=prepare_img() , return_tensors="pt" ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = outputs.logits, outputs.pred_boxes lowerCamelCase_ , lowerCamelCase_ = None, None if yolos_name == "yolos_ti": lowerCamelCase_ = torch.tensor( [[-39.50_22, -11.98_20, -17.68_88], [-29.95_74, -9.97_69, -17.76_91], [-42.32_81, -20.72_00, -30.62_94]] ) lowerCamelCase_ = torch.tensor( [[0.40_21, 0.08_36, 0.79_79], [0.01_84, 0.26_09, 0.03_64], [0.17_81, 0.20_04, 0.20_95]] ) elif yolos_name == "yolos_s_200_pre": lowerCamelCase_ = torch.tensor( [[-24.02_48, -10.30_24, -14.82_90], [-42.03_92, -16.82_00, -27.43_34], [-27.27_43, -11.81_54, -18.71_48]] ) lowerCamelCase_ = torch.tensor( [[0.25_59, 0.54_55, 0.47_06], [0.29_89, 0.72_79, 0.18_75], [0.77_32, 0.40_17, 0.44_62]] ) elif yolos_name == "yolos_s_300_pre": lowerCamelCase_ = torch.tensor( [[-36.22_20, -14.43_85, -23.54_57], [-35.69_70, -14.75_83, -21.39_35], [-31.59_39, -13.60_42, -16.80_49]] ) lowerCamelCase_ = torch.tensor( [[0.76_14, 0.23_16, 0.47_28], [0.71_68, 0.44_95, 0.38_55], [0.49_96, 0.14_66, 0.99_96]] ) elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = torch.tensor( [[-42.86_68, -24.10_49, -41.16_90], [-34.74_56, -14.12_74, -24.91_94], [-33.78_98, -12.19_46, -25.64_95]] ) lowerCamelCase_ = torch.tensor( [[0.55_87, 0.27_73, 0.06_05], [0.50_04, 0.30_14, 0.99_94], [0.49_99, 0.15_48, 0.99_94]] ) elif yolos_name == "yolos_base": lowerCamelCase_ = torch.tensor( [[-40.60_64, -24.30_84, -32.64_47], [-55.19_90, -30.77_19, -35.58_77], [-51.43_11, -33.35_07, -35.64_62]] ) lowerCamelCase_ = torch.tensor( [[0.55_55, 0.27_94, 0.06_55], [0.90_49, 0.26_64, 0.18_94], [0.91_83, 0.19_84, 0.16_35]] ) else: raise ValueError(F'Unknown yolos_name: {yolos_name}' ) assert torch.allclose(logits[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) assert torch.allclose(pred_boxes[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) Path(lowerCamelCase__ ).mkdir(exist_ok=lowerCamelCase__ ) print(F'Saving model {yolos_name} to {pytorch_dump_folder_path}' ) model.save_pretrained(lowerCamelCase__ ) print(F'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(lowerCamelCase__ ) if push_to_hub: lowerCamelCase_ = { "yolos_ti": "yolos-tiny", "yolos_s_200_pre": "yolos-small", "yolos_s_300_pre": "yolos-small-300", "yolos_s_dWr": "yolos-small-dwr", "yolos_base": "yolos-base", } print("Pushing to the hub..." ) lowerCamelCase_ = model_mapping[yolos_name] image_processor.push_to_hub(lowerCamelCase__ , organization="hustvl" ) model.push_to_hub(lowerCamelCase__ , organization="hustvl" ) if __name__ == "__main__": __A =argparse.ArgumentParser() # Required parameters parser.add_argument( '''--yolos_name''', default='''yolos_s_200_pre''', type=str, help=( '''Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\',''' ''' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.''' ), ) parser.add_argument( '''--checkpoint_path''', default=None, type=str, help='''Path to the original state dict (.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.''' ) __A =parser.parse_args() convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
19
0
from __future__ import annotations from math import pi, sqrt def _UpperCAmelCase (UpperCamelCase__ : List[str] , UpperCamelCase__ : Tuple ): if inductance <= 0: raise ValueError("Inductance cannot be 0 or negative" ) elif capacitance <= 0: raise ValueError("Capacitance cannot be 0 or negative" ) else: return ( "Resonant frequency", float(1 / (2 * pi * (sqrt(inductance * capacitance ))) ), ) if __name__ == "__main__": import doctest doctest.testmod()
11
def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [0 for i in range(r + 1 )] # nc0 = 1 lowerCamelCase_ = 1 for i in range(1 , n + 1 ): # to compute current row from previous row. lowerCamelCase_ = min(lowerCamelCase__ , lowerCamelCase__ ) while j > 0: c[j] += c[j - 1] j -= 1 return c[r] print(binomial_coefficient(n=1_0, r=5))
19
0
'''simple docstring''' import unittest from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin __UpperCAmelCase =get_tests_dir("fixtures/test_sentencepiece.model") @require_sentencepiece class a__ ( snake_case_ , unittest.TestCase ): lowerCamelCase : Dict =XLMProphetNetTokenizer lowerCamelCase : str =False lowerCamelCase : List[str] =True def SCREAMING_SNAKE_CASE__ ( self : Any ): """simple docstring""" super().setUp() # We have a SentencePiece fixture for testing __lowerCamelCase = XLMProphetNetTokenizer(a , keep_accents=a ) tokenizer.save_pretrained(self.tmpdirname ) def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ): """simple docstring""" __lowerCamelCase = '''[PAD]''' __lowerCamelCase = 0 self.assertEqual(self.get_tokenizer()._convert_token_to_id(a ) , a ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(a ) , a ) def SCREAMING_SNAKE_CASE__ ( self : Optional[int] ): """simple docstring""" __lowerCamelCase = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''[PAD]''' ) self.assertEqual(vocab_keys[1] , '''[CLS]''' ) self.assertEqual(vocab_keys[-1] , '''j''' ) self.assertEqual(len(a ) , 10_12 ) def SCREAMING_SNAKE_CASE__ ( self : Tuple ): """simple docstring""" self.assertEqual(self.get_tokenizer().vocab_size , 10_12 ) def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ): """simple docstring""" __lowerCamelCase = XLMProphetNetTokenizer(a , keep_accents=a ) __lowerCamelCase = tokenizer.tokenize('''This is a test''' ) self.assertListEqual(a , ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(a ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) __lowerCamelCase = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' ) self.assertListEqual( a , [ 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''', '''é''', '''.''', ] , ) __lowerCamelCase = tokenizer.convert_tokens_to_ids(a ) self.assertListEqual( a , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, -9, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, -9, 4] ] , ) __lowerCamelCase = tokenizer.convert_ids_to_tokens(a ) self.assertListEqual( a , [ 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 SCREAMING_SNAKE_CASE__ ( self : int ): """simple docstring""" return XLMProphetNetTokenizer.from_pretrained('''microsoft/xprophetnet-large-wiki100-cased''' ) @slow def SCREAMING_SNAKE_CASE__ ( self : Any ): """simple docstring""" __lowerCamelCase = '''Hello World!''' __lowerCamelCase = [3_53_89, 66_72, 49, 2] self.assertListEqual(a , self.big_tokenizer.encode(a ) ) @slow def SCREAMING_SNAKE_CASE__ ( self : Optional[int] ): """simple docstring""" __lowerCamelCase = {'''input_ids''': [[1_10_73, 8_27_83, 18, 26, 8_27_83, 5_49, 5_15_40, 2_48, 1_72_09, 13_01, 2_17, 20, 21_51_86, 13_25, 1_47, 1_72_09, 13_01, 2_17, 20, 5_63_70, 53, 12_20_20, 20, 1_64_77, 27, 8_73_55, 45_48, 20, 47_28, 7_83_92, 17, 15_99_69, 18, 26, 2_44_91, 6_29, 15, 5_38, 2_27_04, 54_39, 15, 27_88, 2_44_91, 98_85, 15, 4_35_34, 6_05, 15, 8_14, 1_84_03, 3_32_00, 29, 15, 4_35_34, 2_44_58, 1_24_10, 1_11, 2_49_66, 8_36_69, 96_37, 14_40_68, 26, 8_50, 2_23_46, 27, 1_47, 2_49_66, 8_36_69, 8_34_90, 26, 3_91_13, 7_35, 27, 6_89, 6_56, 28_00, 13_39, 46_00, 53, 12_20_20, 11_57_85, 34, 8_16, 13_39, 4_68_87, 18, 1_47, 5_39_05, 19_51, 4_22_38, 4_11_70, 1_77_32, 8_34, 4_36, 15, 2_75_23, 9_87_33, 2_17, 1_47, 55_42, 49_81, 9_30, 1_73_47, 16, 2], [2_00_91, 6_29, 94, 8_27_86, 58, 4_90, 20, 15_28, 84, 5_39_05, 3_44, 8_05_92, 11_01_28, 1_88_22, 52_67, 13_06, 62, 15_25_37, 3_08, 79_97, 4_01, 12_44_27, 5_49, 3_54_42, 2_25, 1_09, 1_50_55, 2_57_48, 1_47, 71_19, 4_37_12, 34, 7_67, 13_53_66, 18, 16, 2, 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], [5_92, 6_37_84, 11_94_66, 17, 14_78_08, 8_82_14, 18, 6_56, 81, 32, 32_96, 1_02_80, 16, 2, 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, 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, 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, 0, 0, 0, 0, 0], [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, 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=a , model_name='''microsoft/xprophetnet-large-wiki100-cased''' , revision='''1acad1643ddd54a44df6a1b797ada8373685d90e''' , )
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): if 0 not in (x, y): # We use the relation x^y = y*log10(x), where 10 is the base. return y * math.logaa(lowerCamelCase__ ) else: if x == 0: # 0 raised to any number is 0 return 0 elif y == 0: return 1 # any number raised to 0 is 1 raise AssertionError("This should never happen" ) if __name__ == "__main__": # Main function # Read two numbers from input and typecast them to int using map function. # Here x is the base and y is the power. __A ='''Enter the base and the power separated by a comma: ''' __A, __A =map(int, input(prompt).split(''',''')) __A, __A =map(int, input(prompt).split(''',''')) # We find the log of each number, using the function res(), which takes two # arguments. __A =res(xa, ya) __A =res(xa, ya) # We check for the largest number if resa > resa: print('''Largest number is''', xa, '''^''', ya) elif resa > resa: print('''Largest number is''', xa, '''^''', ya) else: print('''Both are equal''')
19
0
SCREAMING_SNAKE_CASE :List[str] = {} def _lowerCAmelCase ( lowerCAmelCase_ :Tuple , lowerCAmelCase_ :List[Any] , lowerCAmelCase_ :List[str] )->str: '''simple docstring''' if late == 3 or absent == 2: return 0 # if we have no days left, and have not failed any other rules, # we have a prize string if days == 0: return 1 # No easy solution, so now we need to do the recursive calculation # First, check if the combination is already in the cache, and # if yes, return the stored value from there since we already # know the number of possible prize strings from this point on snake_case_ = (days, absent, late) if key in cache: return cache[key] # now we calculate the three possible ways that can unfold from # this point on, depending on our attendance today # 1) if we are late (but not absent), the "absent" counter stays as # it is, but the "late" counter increases by one snake_case_ = _calculate(days - 1 , lowerCamelCase__ , late + 1 ) # 2) if we are absent, the "absent" counter increases by 1, and the # "late" counter resets to 0 snake_case_ = _calculate(days - 1 , absent + 1 , 0 ) # 3) if we are on time, this resets the "late" counter and keeps the # absent counter snake_case_ = _calculate(days - 1 , lowerCamelCase__ , 0 ) snake_case_ = state_late + state_absent + state_ontime snake_case_ = prizestrings return prizestrings def _lowerCAmelCase ( lowerCAmelCase_ :int = 30 )->List[str]: '''simple docstring''' return _calculate(lowerCamelCase__ , absent=0 , late=0 ) if __name__ == "__main__": print(solution())
159
import os import time from dataclasses import dataclass, field from enum import Enum from typing import Dict, List, Optional, Union import torch from filelock import FileLock from torch.utils.data import Dataset from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features __A =logging.get_logger(__name__) __A =list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys()) __A =tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) @dataclass class _SCREAMING_SNAKE_CASE : lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Model type selected in the list: ' + ', '.join(snake_case_ )} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'The input data dir. Should contain the .json files for the SQuAD task.'} ) lowerCAmelCase__ = field( default=1_28 , metadata={ 'help': ( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) } , ) lowerCAmelCase__ = field( default=1_28 , metadata={'help': 'When splitting up a long document into chunks, how much stride to take between chunks.'} , ) lowerCAmelCase__ = field( default=64 , metadata={ 'help': ( 'The maximum number of tokens for the question. Questions longer than this will ' 'be truncated to this length.' ) } , ) lowerCAmelCase__ = field( default=30 , metadata={ 'help': ( 'The maximum length of an answer that can be generated. This is needed because the start ' 'and end predictions are not conditioned on one another.' ) } , ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Overwrite the cached training and evaluation sets'} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'If true, the SQuAD examples contain some that do not have an answer.'} ) lowerCAmelCase__ = field( default=0.0 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=20 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=0 , metadata={ 'help': ( 'language id of input for language-specific xlm models (see' ' tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)' ) } , ) lowerCAmelCase__ = field(default=1 , metadata={'help': 'multiple threads for converting example to features'} ) class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 'train' lowerCAmelCase__ = 'dev' class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 def __init__( self , lowercase , lowercase , lowercase = None , lowercase = Split.train , lowercase = False , lowercase = None , lowercase = "pt" , ) -> List[str]: lowerCamelCase_ = args lowerCamelCase_ = is_language_sensitive lowerCamelCase_ = SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor() if isinstance(lowercase , lowercase ): try: lowerCamelCase_ = Split[mode] except KeyError: raise KeyError("mode is not a valid split name" ) lowerCamelCase_ = mode # Load data features from cache or dataset file lowerCamelCase_ = "v2" if args.version_2_with_negative else "v1" lowerCamelCase_ = os.path.join( cache_dir if cache_dir is not None else args.data_dir , f'cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}' , ) # Make sure only the first process in distributed training processes the dataset, # and the others will use the cache. lowerCamelCase_ = cached_features_file + ".lock" with FileLock(lowercase ): if os.path.exists(lowercase ) and not args.overwrite_cache: lowerCamelCase_ = time.time() lowerCamelCase_ = torch.load(lowercase ) # Legacy cache files have only features, while new cache files # will have dataset and examples also. lowerCamelCase_ = self.old_features["features"] lowerCamelCase_ = self.old_features.get("dataset" , lowercase ) lowerCamelCase_ = self.old_features.get("examples" , lowercase ) logger.info( f'Loading features from cached file {cached_features_file} [took %.3f s]' , time.time() - start ) if self.dataset is None or self.examples is None: logger.warning( f'Deleting cached file {cached_features_file} will allow dataset and examples to be cached in' " future run" ) else: if mode == Split.dev: lowerCamelCase_ = self.processor.get_dev_examples(args.data_dir ) else: lowerCamelCase_ = self.processor.get_train_examples(args.data_dir ) lowerCamelCase_ , lowerCamelCase_ = squad_convert_examples_to_features( examples=self.examples , tokenizer=lowercase , max_seq_length=args.max_seq_length , doc_stride=args.doc_stride , max_query_length=args.max_query_length , is_training=mode == Split.train , threads=args.threads , return_dataset=lowercase , ) lowerCamelCase_ = time.time() torch.save( {"features": self.features, "dataset": self.dataset, "examples": self.examples} , lowercase , ) # ^ This seems to take a lot of time so I want to investigate why and how we can improve. logger.info( f'Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]' ) def __len__( self ) -> Tuple: return len(self.features ) def __getitem__( self , lowercase ) -> Dict[str, torch.Tensor]: # Convert to Tensors and build dataset lowerCamelCase_ = self.features[i] lowerCamelCase_ = torch.tensor(feature.input_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.attention_mask , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.token_type_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.cls_index , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.p_mask , dtype=torch.float ) lowerCamelCase_ = torch.tensor(feature.is_impossible , dtype=torch.float ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": attention_mask, "token_type_ids": token_type_ids, } if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]: del inputs["token_type_ids"] if self.args.model_type in ["xlnet", "xlm"]: inputs.update({"cls_index": cls_index, "p_mask": p_mask} ) if self.args.version_2_with_negative: inputs.update({"is_impossible": is_impossible} ) if self.is_language_sensitive: inputs.update({"langs": (torch.ones(input_ids.shape , dtype=torch.intaa ) * self.args.lang_id)} ) if self.mode == Split.train: lowerCamelCase_ = torch.tensor(feature.start_position , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.end_position , dtype=torch.long ) inputs.update({"start_positions": start_positions, "end_positions": end_positions} ) return inputs
19
0
"""simple docstring""" import math def _lowerCamelCase ( _UpperCamelCase , _UpperCamelCase ): '''simple docstring''' if 0 not in (x, y): # We use the relation x^y = y*log10(x), where 10 is the base. return y * math.logaa(lowerCamelCase__ ) else: if x == 0: # 0 raised to any number is 0 return 0 elif y == 0: return 1 # any number raised to 0 is 1 raise AssertionError("This should never happen" ) if __name__ == "__main__": # Main function # Read two numbers from input and typecast them to int using map function. # Here x is the base and y is the power. A : Union[str, Any] = "Enter the base and the power separated by a comma: " A , A : str = map(int, input(prompt).split(",")) A , A : str = map(int, input(prompt).split(",")) # We find the log of each number, using the function res(), which takes two # arguments. A : List[Any] = res(xa, ya) A : Tuple = res(xa, ya) # We check for the largest number if resa > resa: print("Largest number is", xa, "^", ya) elif resa > resa: print("Largest number is", xa, "^", ya) else: print("Both are equal")
57
from abc import ABC, abstractmethod from argparse import ArgumentParser class _SCREAMING_SNAKE_CASE ( snake_case_ ): @staticmethod @abstractmethod def SCREAMING_SNAKE_CASE_( lowercase ) -> int: raise NotImplementedError() @abstractmethod def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: raise NotImplementedError()
19
0
import math def __lowercase ( a__ , a__ = 0 , a__ = 0 ) -> Optional[int]: __SCREAMING_SNAKE_CASE = end or len(lowerCamelCase__ ) for i in range(lowerCamelCase__ , lowerCamelCase__ ): __SCREAMING_SNAKE_CASE = i __SCREAMING_SNAKE_CASE = array[i] while temp_index != start and temp_index_value < array[temp_index - 1]: __SCREAMING_SNAKE_CASE = array[temp_index - 1] temp_index -= 1 __SCREAMING_SNAKE_CASE = temp_index_value return array def __lowercase ( a__ , a__ , a__ ) -> Dict: # Max Heap __SCREAMING_SNAKE_CASE = index __SCREAMING_SNAKE_CASE = 2 * index + 1 # Left Node __SCREAMING_SNAKE_CASE = 2 * index + 2 # Right Node if left_index < heap_size and array[largest] < array[left_index]: __SCREAMING_SNAKE_CASE = left_index if right_index < heap_size and array[largest] < array[right_index]: __SCREAMING_SNAKE_CASE = right_index if largest != index: __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = array[largest], array[index] heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) def __lowercase ( a__ ) -> int: __SCREAMING_SNAKE_CASE = len(lowerCamelCase__ ) for i in range(n // 2 , -1 , -1 ): heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) for i in range(n - 1 , 0 , -1 ): __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = array[0], array[i] heapify(lowerCamelCase__ , 0 , lowerCamelCase__ ) return array def __lowercase ( a__ , a__ , a__ , a__ ) -> Optional[Any]: if (array[first_index] > array[middle_index]) != ( array[first_index] > array[last_index] ): return array[first_index] elif (array[middle_index] > array[first_index]) != ( array[middle_index] > array[last_index] ): return array[middle_index] else: return array[last_index] def __lowercase ( a__ , a__ , a__ , a__ ) -> List[str]: __SCREAMING_SNAKE_CASE = low __SCREAMING_SNAKE_CASE = high while True: while array[i] < pivot: i += 1 j -= 1 while pivot < array[j]: j -= 1 if i >= j: return i __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = array[j], array[i] i += 1 def __lowercase ( a__ ) -> Optional[Any]: if len(lowerCamelCase__ ) == 0: return array __SCREAMING_SNAKE_CASE = 2 * math.ceil(math.loga(len(lowerCamelCase__ ) ) ) __SCREAMING_SNAKE_CASE = 16 return intro_sort(lowerCamelCase__ , 0 , len(lowerCamelCase__ ) , lowerCamelCase__ , lowerCamelCase__ ) def __lowercase ( a__ , a__ , a__ , a__ , a__ ) -> Any: while end - start > size_threshold: if max_depth == 0: return heap_sort(lowerCamelCase__ ) max_depth -= 1 __SCREAMING_SNAKE_CASE = median_of_a(lowerCamelCase__ , lowerCamelCase__ , start + ((end - start) // 2) + 1 , end - 1 ) __SCREAMING_SNAKE_CASE = partition(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) intro_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) __SCREAMING_SNAKE_CASE = p return insertion_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": import doctest doctest.testmod() lowerCAmelCase__ : Any =input('''Enter numbers separated by a comma : ''').strip() lowerCAmelCase__ : Union[str, Any] =[float(item) for item in user_input.split(''',''')] print(sort(unsorted))
257
from typing import Callable, List, Optional, Union import PIL import torch from transformers import ( CLIPImageProcessor, CLIPSegForImageSegmentation, CLIPSegProcessor, CLIPTextModel, CLIPTokenizer, ) from diffusers import DiffusionPipeline from diffusers.configuration_utils import FrozenDict from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler from diffusers.utils import deprecate, is_accelerate_available, logging __A =logging.get_logger(__name__) # pylint: disable=invalid-name class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[Any]: super().__init__() if hasattr(scheduler.config , "steps_offset" ) and scheduler.config.steps_offset != 1: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`' f' should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure ' "to update the config accordingly as leaving `steps_offset` might led to incorrect results" " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub," " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`" " file" ) deprecate("steps_offset!=1" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = 1 lowerCamelCase_ = FrozenDict(lowercase ) if hasattr(scheduler.config , "skip_prk_steps" ) and scheduler.config.skip_prk_steps is False: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} has not set the configuration' " `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make" " sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to" " incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face" " Hub, it would be very nice if you could open a Pull request for the" " `scheduler/scheduler_config.json` file" ) deprecate("skip_prk_steps not set" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = True lowerCamelCase_ = FrozenDict(lowercase ) if safety_checker is None: logger.warning( f'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure' " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered" " results in services or applications open to the public. Both the diffusers team and Hugging Face" " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling" " it only for use-cases that involve analyzing network behavior or auditing its results. For more" " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ." ) self.register_modules( segmentation_model=lowercase , segmentation_processor=lowercase , vae=lowercase , text_encoder=lowercase , tokenizer=lowercase , unet=lowercase , scheduler=lowercase , safety_checker=lowercase , feature_extractor=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase = "auto" ) -> Tuple: if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory lowerCamelCase_ = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: self.enable_attention_slicing(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device("cuda" ) for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: if self.device != torch.device("meta" ) or not hasattr(self.unet , "_hf_hook" ): return self.device for module in self.unet.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() def __call__( self , lowercase , lowercase , lowercase , lowercase = 512 , lowercase = 512 , lowercase = 50 , lowercase = 7.5 , lowercase = None , lowercase = 1 , lowercase = 0.0 , lowercase = None , lowercase = None , lowercase = "pil" , lowercase = True , lowercase = None , lowercase = 1 , **lowercase , ) -> int: lowerCamelCase_ = self.segmentation_processor( text=[text] , images=[image] , padding="max_length" , return_tensors="pt" ).to(self.device ) lowerCamelCase_ = self.segmentation_model(**lowercase ) lowerCamelCase_ = torch.sigmoid(outputs.logits ).cpu().detach().unsqueeze(-1 ).numpy() lowerCamelCase_ = self.numpy_to_pil(lowercase )[0].resize(image.size ) # Run inpainting pipeline with the generated mask lowerCamelCase_ = StableDiffusionInpaintPipeline( vae=self.vae , text_encoder=self.text_encoder , tokenizer=self.tokenizer , unet=self.unet , scheduler=self.scheduler , safety_checker=self.safety_checker , feature_extractor=self.feature_extractor , ) return inpainting_pipeline( prompt=lowercase , image=lowercase , mask_image=lowercase , height=lowercase , width=lowercase , num_inference_steps=lowercase , guidance_scale=lowercase , negative_prompt=lowercase , num_images_per_prompt=lowercase , eta=lowercase , generator=lowercase , latents=lowercase , output_type=lowercase , return_dict=lowercase , callback=lowercase , callback_steps=lowercase , )
19
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) _lowercase = { '''configuration_whisper''': ['''WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WhisperConfig''', '''WhisperOnnxConfig'''], '''feature_extraction_whisper''': ['''WhisperFeatureExtractor'''], '''processing_whisper''': ['''WhisperProcessor'''], '''tokenization_whisper''': ['''WhisperTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase = ['''WhisperTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase = [ '''WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''WhisperForConditionalGeneration''', '''WhisperModel''', '''WhisperPreTrainedModel''', '''WhisperForAudioClassification''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase = [ '''TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFWhisperForConditionalGeneration''', '''TFWhisperModel''', '''TFWhisperPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowercase = [ '''FlaxWhisperForConditionalGeneration''', '''FlaxWhisperModel''', '''FlaxWhisperPreTrainedModel''', '''FlaxWhisperForAudioClassification''', ] if TYPE_CHECKING: from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig from .feature_extraction_whisper import WhisperFeatureExtractor from .processing_whisper import WhisperProcessor from .tokenization_whisper import WhisperTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_whisper_fast import WhisperTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_whisper import ( WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST, WhisperForAudioClassification, WhisperForConditionalGeneration, WhisperModel, WhisperPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_whisper import ( TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST, TFWhisperForConditionalGeneration, TFWhisperModel, TFWhisperPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_whisper import ( FlaxWhisperForAudioClassification, FlaxWhisperForConditionalGeneration, FlaxWhisperModel, FlaxWhisperPreTrainedModel, ) else: import sys _lowercase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
74
from collections import deque def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) lowerCamelCase_ = deque() lowerCamelCase_ = [False for _ in range(lowerCamelCase__ )] lowerCamelCase_ = [-1 for _ in range(lowerCamelCase__ )] lowerCamelCase_ = index_of[:] def strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = index # the number when this node is seen lowerCamelCase_ = index # lowest rank node reachable from here index += 1 stack.append(lowerCamelCase__ ) lowerCamelCase_ = True for w in g[v]: if index_of[w] == -1: lowerCamelCase_ = strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) elif on_stack[w]: lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) if lowlink_of[v] == index_of[v]: lowerCamelCase_ = [] lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) while w != v: lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) components.append(lowerCamelCase__ ) return index lowerCamelCase_ = [] for v in range(lowerCamelCase__ ): if index_of[v] == -1: strong_connect(lowerCamelCase__ , 0 , lowerCamelCase__ ) return components def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [[] for _ in range(lowerCamelCase__ )] for u, v in edges: g[u].append(lowerCamelCase__ ) return g if __name__ == "__main__": # Test __A =7 __A =[0, 0, 1, 2, 3, 3, 4, 4, 6] __A =[1, 3, 2, 0, 1, 4, 5, 6, 5] __A =[(u, v) for u, v in zip(source, target)] __A =create_graph(n_vertices, edges) assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)
19
0
"""simple docstring""" import math def lowercase__ ( _UpperCAmelCase ) -> int: '''simple docstring''' lowercase : Optional[Any] = math.loga(math.sqrt(4 * positive_integer + 1 ) / 2 + 1 / 2 ) return exponent == int(lowerCamelCase__ ) def lowercase__ ( _UpperCAmelCase = 1 / 1_23_45 ) -> Any: '''simple docstring''' lowercase : Any = 0 lowercase : Optional[Any] = 0 lowercase : int = 3 while True: lowercase : Optional[Any] = (integer**2 - 1) / 4 # if candidate is an integer, then there is a partition for k if partition_candidate == int(lowerCamelCase__ ): lowercase : Optional[Any] = int(lowerCamelCase__ ) total_partitions += 1 if check_partition_perfect(lowerCamelCase__ ): perfect_partitions += 1 if perfect_partitions > 0: if perfect_partitions / total_partitions < max_proportion: return int(lowerCamelCase__ ) integer += 1 if __name__ == "__main__": print(f'''{solution() = }''')
255
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) __A ={'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizer'''] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''XGLMForCausalLM''', '''XGLMModel''', '''XGLMPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''FlaxXGLMForCausalLM''', '''FlaxXGLMModel''', '''FlaxXGLMPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFXGLMForCausalLM''', '''TFXGLMModel''', '''TFXGLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm import XGLMTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm_fast import XGLMTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_xglm import ( TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFXGLMForCausalLM, TFXGLMModel, TFXGLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure)
19
0
'''simple docstring''' import argparse import json import os import fairseq import torch from fairseq.data import Dictionary from transformers import ( UniSpeechConfig, UniSpeechForCTC, UniSpeechForPreTraining, WavaVecaFeatureExtractor, WavaVecaPhonemeCTCTokenizer, WavaVecaProcessor, logging, ) logging.set_verbosity_info() a_ = logging.get_logger(__name__) a_ = { 'post_extract_proj': 'feature_projection.projection', 'encoder.pos_conv.0': 'encoder.pos_conv_embed.conv', 'self_attn.k_proj': 'encoder.layers.*.attention.k_proj', 'self_attn.v_proj': 'encoder.layers.*.attention.v_proj', 'self_attn.q_proj': 'encoder.layers.*.attention.q_proj', 'self_attn.out_proj': 'encoder.layers.*.attention.out_proj', 'self_attn_layer_norm': 'encoder.layers.*.layer_norm', 'fc1': 'encoder.layers.*.feed_forward.intermediate_dense', 'fc2': 'encoder.layers.*.feed_forward.output_dense', 'final_layer_norm': 'encoder.layers.*.final_layer_norm', 'encoder.layer_norm': 'encoder.layer_norm', 'w2v_model.layer_norm': 'feature_projection.layer_norm', 'quantizer.weight_proj': 'quantizer.weight_proj', 'quantizer.vars': 'quantizer.codevectors', 'project_q': 'project_q', 'final_proj': 'project_hid', 'w2v_encoder.proj': 'ctc_proj', 'mask_emb': 'masked_spec_embed', } a_ = [ 'ctc_proj', 'quantizer.weight_proj', 'quantizer.codevectors', 'project_q', 'project_hid', ] def _a( UpperCamelCase__ : str, UpperCamelCase__ : List[str], UpperCamelCase__ : List[Any], UpperCamelCase__ : Any, UpperCamelCase__ : str, UpperCamelCase__ : Any ): '''simple docstring''' for attribute in key.split('''.''' ): if is_finetuned: if attribute in ["quantizer", "project_q", "project_hid"]: # those layers are only relevant for pretraining and should be dropped return if attribute == "ctc_proj": # we should rename `ctc_proj` to `lm_head` for fine-tuned phoneme models SCREAMING_SNAKE_CASE__ : List[str] ='''lm_head''' SCREAMING_SNAKE_CASE__ : Any =getattr(lowerCamelCase__, lowerCamelCase__ ) if weight_type is not None: SCREAMING_SNAKE_CASE__ : Any =getattr(lowerCamelCase__, lowerCamelCase__ ).shape else: SCREAMING_SNAKE_CASE__ : Optional[int] =hf_pointer.shape assert hf_shape == value.shape, ( f"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be" f" {value.shape} for {full_name}" ) if weight_type == "weight": SCREAMING_SNAKE_CASE__ : int =value elif weight_type == "weight_g": SCREAMING_SNAKE_CASE__ : Optional[Any] =value elif weight_type == "weight_v": SCREAMING_SNAKE_CASE__ : Dict =value elif weight_type == "bias": SCREAMING_SNAKE_CASE__ : Tuple =value else: SCREAMING_SNAKE_CASE__ : List[Any] =value logger.info(f"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}." ) def _a( UpperCamelCase__ : int, UpperCamelCase__ : Optional[int], UpperCamelCase__ : List[str] ): '''simple docstring''' SCREAMING_SNAKE_CASE__ : List[str] =[] SCREAMING_SNAKE_CASE__ : Optional[int] =fairseq_model.state_dict() SCREAMING_SNAKE_CASE__ : int =hf_model.unispeech.feature_extractor for name, value in fairseq_dict.items(): SCREAMING_SNAKE_CASE__ : Optional[int] =False if "conv_layers" in name: load_conv_layer( lowerCamelCase__, lowerCamelCase__, lowerCamelCase__, lowerCamelCase__, hf_model.config.feat_extract_norm == '''group''', ) SCREAMING_SNAKE_CASE__ : Any =True else: for key, mapped_key in MAPPING.items(): SCREAMING_SNAKE_CASE__ : Optional[int] ='''unispeech.''' + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key if key in name or key.split('''w2v_model.''' )[-1] == name.split('''.''' )[0]: SCREAMING_SNAKE_CASE__ : Any =True if "*" in mapped_key: SCREAMING_SNAKE_CASE__ : Tuple =name.split(lowerCamelCase__ )[0].split('''.''' )[-2] SCREAMING_SNAKE_CASE__ : str =mapped_key.replace('''*''', lowerCamelCase__ ) if "weight_g" in name: SCREAMING_SNAKE_CASE__ : Dict ='''weight_g''' elif "weight_v" in name: SCREAMING_SNAKE_CASE__ : Tuple ='''weight_v''' elif "bias" in name: SCREAMING_SNAKE_CASE__ : List[str] ='''bias''' elif "weight" in name: # TODO: don't match quantizer.weight_proj SCREAMING_SNAKE_CASE__ : Union[str, Any] ='''weight''' else: SCREAMING_SNAKE_CASE__ : str =None set_recursively(lowerCamelCase__, lowerCamelCase__, lowerCamelCase__, lowerCamelCase__, lowerCamelCase__, lowerCamelCase__ ) continue if not is_used: unused_weights.append(lowerCamelCase__ ) logger.warning(f"Unused weights: {unused_weights}" ) def _a( UpperCamelCase__ : Optional[Any], UpperCamelCase__ : Optional[Any], UpperCamelCase__ : Union[str, Any], UpperCamelCase__ : Union[str, Any], UpperCamelCase__ : List[str] ): '''simple docstring''' SCREAMING_SNAKE_CASE__ : List[str] =full_name.split('''conv_layers.''' )[-1] SCREAMING_SNAKE_CASE__ : Union[str, Any] =name.split('''.''' ) SCREAMING_SNAKE_CASE__ : str =int(items[0] ) SCREAMING_SNAKE_CASE__ : int =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." ) SCREAMING_SNAKE_CASE__ : Dict =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." ) SCREAMING_SNAKE_CASE__ : List[Any] =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." ) SCREAMING_SNAKE_CASE__ : List[Any] =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." ) SCREAMING_SNAKE_CASE__ : Optional[int] =value logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}." ) else: unused_weights.append(lowerCamelCase__ ) @torch.no_grad() def _a( UpperCamelCase__ : List[str], UpperCamelCase__ : Any, UpperCamelCase__ : Any=None, UpperCamelCase__ : Dict=None, UpperCamelCase__ : Tuple=True ): '''simple docstring''' if config_path is not None: SCREAMING_SNAKE_CASE__ : List[Any] =UniSpeechConfig.from_pretrained(lowerCamelCase__ ) else: SCREAMING_SNAKE_CASE__ : int =UniSpeechConfig() if is_finetuned: if dict_path: SCREAMING_SNAKE_CASE__ : List[str] =Dictionary.load_from_json(lowerCamelCase__ ) # important change bos & pad token id since CTC symbol is <pad> and # not <s> as in fairseq SCREAMING_SNAKE_CASE__ : str =target_dict.pad_index SCREAMING_SNAKE_CASE__ : Any =target_dict.bos_index SCREAMING_SNAKE_CASE__ : List[str] =target_dict.eos_index SCREAMING_SNAKE_CASE__ : List[str] =len(target_dict.symbols ) SCREAMING_SNAKE_CASE__ : List[Any] =os.path.join(lowerCamelCase__, '''vocab.json''' ) if not os.path.isdir(lowerCamelCase__ ): logger.error('''--pytorch_dump_folder_path ({}) should be a directory'''.format(lowerCamelCase__ ) ) return os.makedirs(lowerCamelCase__, exist_ok=lowerCamelCase__ ) SCREAMING_SNAKE_CASE__ : Optional[Any] =target_dict.indices # fairseq has the <pad> and <s> switched SCREAMING_SNAKE_CASE__ : Union[str, Any] =4_2 SCREAMING_SNAKE_CASE__ : str =4_3 with open(lowerCamelCase__, '''w''', encoding='''utf-8''' ) as vocab_handle: json.dump(lowerCamelCase__, lowerCamelCase__ ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =WavaVecaPhonemeCTCTokenizer( lowerCamelCase__, 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=lowerCamelCase__, ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =True if config.feat_extract_norm == '''layer''' else False SCREAMING_SNAKE_CASE__ : Dict =WavaVecaFeatureExtractor( feature_size=1, sampling_rate=1_6_0_0_0, padding_value=0, do_normalize=lowerCamelCase__, return_attention_mask=lowerCamelCase__, ) SCREAMING_SNAKE_CASE__ : List[str] =WavaVecaProcessor(feature_extractor=lowerCamelCase__, tokenizer=lowerCamelCase__ ) processor.save_pretrained(lowerCamelCase__ ) SCREAMING_SNAKE_CASE__ : List[Any] =UniSpeechForCTC(lowerCamelCase__ ) else: SCREAMING_SNAKE_CASE__ : Tuple =UniSpeechForPreTraining(lowerCamelCase__ ) if is_finetuned: SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : Optional[Any] =fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path], arg_overrides={'''data''': '''/'''.join(dict_path.split('''/''' )[:-1] ), '''w2v_path''': checkpoint_path} ) else: SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : List[Any] =fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] ) SCREAMING_SNAKE_CASE__ : Tuple =model[0].eval() recursively_load_weights(lowerCamelCase__, lowerCamelCase__, lowerCamelCase__ ) hf_unispeech.save_pretrained(lowerCamelCase__ ) if __name__ == "__main__": a_ = 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' ) a_ = parser.parse_args() convert_unispeech_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
152
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __A ={'''configuration_wavlm''': ['''WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WavLMConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''WavLMForAudioFrameClassification''', '''WavLMForCTC''', '''WavLMForSequenceClassification''', '''WavLMForXVector''', '''WavLMModel''', '''WavLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_wavlm import ( WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST, WavLMForAudioFrameClassification, WavLMForCTC, WavLMForSequenceClassification, WavLMForXVector, WavLMModel, WavLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
import qiskit def A ( a_ ,a_ ) -> Optional[Any]: __UpperCamelCase : Any =qiskit.Aer.get_backend('aer_simulator' ) # Create a Quantum Circuit acting on the q register __UpperCamelCase : str =qiskit.QuantumCircuit(lowerCamelCase__ ,lowerCamelCase__ ) # Map the quantum measurement to the classical bits circuit.measure([0] ,[0] ) # Execute the circuit on the simulator __UpperCamelCase : int =qiskit.execute(lowerCamelCase__ ,lowerCamelCase__ ,shots=1_000 ) # Return the histogram data of the results of the experiment. return job.result().get_counts(lowerCamelCase__ ) if __name__ == "__main__": print(f"Total count for various states are: {single_qubit_measure(1, 1)}")
71
# Lint as: python3 # pylint: enable=line-too-long # pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position __A ='''2.13.1''' import platform import pyarrow from packaging import version if version.parse(platform.python_version()) < version.parse('''3.7'''): raise ImportWarning( '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.''' ) if version.parse(pyarrow.__version__).major < 8: raise ImportWarning( '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n''' '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.''' ) del platform del pyarrow del version from .arrow_dataset import Dataset from .arrow_reader import ReadInstruction from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder from .combine import concatenate_datasets, interleave_datasets from .dataset_dict import DatasetDict, IterableDatasetDict from .download import * from .features import * from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled from .info import DatasetInfo, MetricInfo from .inspect import ( get_dataset_config_info, get_dataset_config_names, get_dataset_infos, get_dataset_split_names, inspect_dataset, inspect_metric, list_datasets, list_metrics, ) from .iterable_dataset import IterableDataset from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric from .metric import Metric from .splits import ( NamedSplit, NamedSplitAll, Split, SplitBase, SplitDict, SplitGenerator, SplitInfo, SubSplitInfo, percent, ) from .tasks import * from .utils import * from .utils import logging # deprecated modules from datasets import arrow_dataset as _arrow_dataset # isort:skip from datasets import utils as _utils # isort:skip from datasets.utils import download_manager as _deprecated_download_manager # isort:skip __A =concatenate_datasets __A =DownloadConfig __A =DownloadManager __A =DownloadMode __A =DownloadConfig __A =DownloadMode __A =DownloadManager del _arrow_dataset, _utils, _deprecated_download_manager
19
0
'''simple docstring''' import argparse import os from pathlib import Path import fairseq import torch from packaging import version from torch import nn from transformers import ( BartConfig, BartForConditionalGeneration, BartForSequenceClassification, BartModel, BartTokenizer, ) from transformers.utils import logging a_ : Dict = ["bart.large", "bart.large.mnli", "bart.large.cnn", "bart_xsum/model.pt"] a_ : Any = {"bart.large": BartModel, "bart.large.mnli": BartForSequenceClassification} if version.parse(fairseq.__version__) < version.parse("0.9.0"): raise Exception("requires fairseq >= 0.9.0") logging.set_verbosity_info() a_ : List[str] = logging.get_logger(__name__) a_ : Any = " Hello world! cécé herlolip" a_ : Optional[Any] = [ ("model.classification_heads.mnli.dense.weight", "classification_head.dense.weight"), ("model.classification_heads.mnli.dense.bias", "classification_head.dense.bias"), ("model.classification_heads.mnli.out_proj.weight", "classification_head.out_proj.weight"), ("model.classification_heads.mnli.out_proj.bias", "classification_head.out_proj.bias"), ] def _A (lowerCAmelCase__ :int ) -> Tuple: '''simple docstring''' _a = [ 'encoder.version', 'decoder.version', 'model.encoder.version', 'model.decoder.version', '_float_tensor', ] for k in ignore_keys: state_dict.pop(lowerCamelCase__ , lowerCamelCase__ ) def _A (lowerCAmelCase__ :List[str] , lowerCAmelCase__ :Optional[Any] , lowerCAmelCase__ :int ) -> Tuple: '''simple docstring''' _a = dct.pop(lowerCamelCase__ ) _a = val def _A (lowerCAmelCase__ :Optional[Any] ) -> Any: '''simple docstring''' _a = torch.load(lowerCamelCase__ , map_location='cpu' ) _a = torch.hub.load('pytorch/fairseq' , 'bart.large.cnn' ).eval() hub_interface.model.load_state_dict(sd['model'] ) return hub_interface def _A (lowerCAmelCase__ :Any ) -> Optional[int]: '''simple docstring''' _a , _a = emb.weight.shape _a = nn.Linear(lowerCamelCase__ , lowerCamelCase__ , bias=lowerCamelCase__ ) _a = emb.weight.data return lin_layer @torch.no_grad() def _A (lowerCAmelCase__ :Union[str, Any] , lowerCAmelCase__ :Dict , lowerCAmelCase__ :List[str]=None ) -> List[str]: '''simple docstring''' if not os.path.exists(lowerCamelCase__ ): _a = torch.hub.load('pytorch/fairseq' , lowerCamelCase__ ).eval() else: _a = load_xsum_checkpoint(lowerCamelCase__ ) bart.model.upgrade_state_dict(bart.model.state_dict() ) if hf_checkpoint_name is None: _a = checkpoint_path.replace('.' , '-' ) _a = BartConfig.from_pretrained(lowerCamelCase__ ) _a = bart.encode(lowerCamelCase__ ).unsqueeze(0 ) _a = BartTokenizer.from_pretrained(lowerCamelCase__ ).encode(lowerCamelCase__ , return_tensors='pt' ).unsqueeze(0 ) if not torch.eq(lowerCamelCase__ , lowerCamelCase__ ).all(): raise ValueError( f'converted tokenizer and pretrained tokenizer returned different output: {tokens} != {tokensa}' ) if checkpoint_path == "bart.large.mnli": _a = bart.state_dict() remove_ignore_keys_(lowerCamelCase__ ) _a = state_dict['model.decoder.embed_tokens.weight'] for src, dest in mnli_rename_keys: rename_key(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) _a = BartForSequenceClassification(lowerCamelCase__ ).eval() model.load_state_dict(lowerCamelCase__ ) _a = bart.predict('mnli' , lowerCamelCase__ , return_logits=lowerCamelCase__ ) _a = model(lowerCamelCase__ )[0] # logits else: # no classification heads to worry about _a = bart.model.state_dict() remove_ignore_keys_(lowerCamelCase__ ) _a = state_dict['decoder.embed_tokens.weight'] _a = bart.extract_features(lowerCamelCase__ ) if hf_checkpoint_name == "facebook/bart-large": _a = BartModel(lowerCamelCase__ ).eval() model.load_state_dict(lowerCamelCase__ ) _a = model(lowerCamelCase__ ).model[0] else: _a = BartForConditionalGeneration(lowerCamelCase__ ).eval() # an existing summarization ckpt model.model.load_state_dict(lowerCamelCase__ ) if hasattr(lowerCamelCase__ , 'lm_head' ): _a = make_linear_from_emb(model.model.shared ) _a = model.model(lowerCamelCase__ )[0] # Check results if fairseq_output.shape != new_model_outputs.shape: raise ValueError( f'`fairseq_output` shape and `new_model_output` shape are different: {fairseq_output.shape=}, {new_model_outputs.shape}' ) if (fairseq_output != new_model_outputs).any().item(): raise ValueError('Some values in `fairseq_output` are different from `new_model_outputs`' ) Path(lowerCamelCase__ ).mkdir(exist_ok=lowerCamelCase__ ) model.save_pretrained(lowerCamelCase__ ) if __name__ == "__main__": a_ : Any = argparse.ArgumentParser() # Required parameters parser.add_argument( "fairseq_path", type=str, help="bart.large, bart.large.cnn or a path to a model.pt on local filesystem." ) parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument( "--hf_config", default=None, type=str, help="Which huggingface architecture to use: bart-large-xsum" ) a_ : Union[str, Any] = parser.parse_args() convert_bart_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, hf_checkpoint_name=args.hf_config)
168
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __A ={ '''configuration_bloom''': ['''BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BloomConfig''', '''BloomOnnxConfig'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''BloomTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''BloomForCausalLM''', '''BloomModel''', '''BloomPreTrainedModel''', '''BloomForSequenceClassification''', '''BloomForTokenClassification''', '''BloomForQuestionAnswering''', ] if TYPE_CHECKING: from .configuration_bloom import BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP, BloomConfig, BloomOnnxConfig try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_bloom_fast import BloomTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_bloom import ( BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST, BloomForCausalLM, BloomForQuestionAnswering, BloomForSequenceClassification, BloomForTokenClassification, BloomModel, BloomPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
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, )
205
from __future__ import annotations import unittest from transformers import EsmConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers.models.esm.modeling_tf_esm import ( TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, TFEsmModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , ) -> Optional[int]: lowerCamelCase_ = parent lowerCamelCase_ = 13 lowerCamelCase_ = 7 lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = 99 lowerCamelCase_ = 32 lowerCamelCase_ = 2 lowerCamelCase_ = 4 lowerCamelCase_ = 37 lowerCamelCase_ = "gelu" lowerCamelCase_ = 0.1 lowerCamelCase_ = 0.1 lowerCamelCase_ = 512 lowerCamelCase_ = 16 lowerCamelCase_ = 2 lowerCamelCase_ = 0.0_2 lowerCamelCase_ = 3 lowerCamelCase_ = 4 lowerCamelCase_ = None def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_input_mask: lowerCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = EsmConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , pad_token_id=1 , 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 , initializer_range=self.initializer_range , ) return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def SCREAMING_SNAKE_CASE_( self ) -> List[str]: ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = self.prepare_config_and_inputs() lowerCamelCase_ = True lowerCamelCase_ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Any: lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> Tuple: lowerCamelCase_ = True lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": input_mask, "encoder_hidden_states": encoder_hidden_states, "encoder_attention_mask": encoder_attention_mask, } lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase , encoder_hidden_states=lowercase ) # Also check the case where encoder outputs are not passed lowerCamelCase_ = model(lowercase , attention_mask=lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Optional[int]: lowerCamelCase_ = TFEsmForMaskedLM(config=lowercase ) lowerCamelCase_ = model([input_ids, input_mask] ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = TFEsmForTokenClassification(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_tf class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( ( TFEsmModel, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, ) if is_tf_available() else () ) lowerCAmelCase__ = ( { 'feature-extraction': TFEsmModel, 'fill-mask': TFEsmForMaskedLM, 'text-classification': TFEsmForSequenceClassification, 'token-classification': TFEsmForTokenClassification, 'zero-shot': TFEsmForSequenceClassification, } if is_tf_available() else {} ) lowerCAmelCase__ = False lowerCAmelCase__ = False def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = TFEsmModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , hidden_size=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Dict: for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = TFEsmModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: pass @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> Any: pass def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ , lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCamelCase_ = model_class(lowercase ) assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer ) if model_class is TFEsmForMaskedLM: # Output embedding test differs from the main test because they're a matrix, not a layer lowerCamelCase_ = model.get_bias() assert isinstance(lowercase , lowercase ) for k, v in name.items(): assert isinstance(lowercase , tf.Variable ) else: lowerCamelCase_ = model.get_output_embeddings() assert x is None lowerCamelCase_ = model.get_bias() assert name is None @require_tf class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 1, 2, 3, 4, 5]] ) lowerCamelCase_ = model(lowercase )[0] lowerCamelCase_ = [1, 6, 33] self.assertEqual(list(output.numpy().shape ) , lowercase ) # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7], [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5], [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-2 ) ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] ) lowerCamelCase_ = model(lowercase )[0] # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9], [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2], [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
19
0
def _UpperCAmelCase (UpperCamelCase__ : List[str] , UpperCamelCase__ : List[Any] , UpperCamelCase__ : int ): if principal <= 0: raise Exception("Principal borrowed must be > 0" ) if rate_per_annum < 0: raise Exception("Rate of interest must be >= 0" ) if years_to_repay <= 0 or not isinstance(lowerCamelCase__ , lowerCamelCase__ ): raise Exception("Years to repay must be an integer > 0" ) # Yearly rate is divided by 12 to get monthly rate _A : Optional[Any] = rate_per_annum / 12 # Years to repay is multiplied by 12 to get number of payments as payment is monthly _A : Tuple = years_to_repay * 12 return ( principal * rate_per_month * (1 + rate_per_month) ** number_of_payments / ((1 + rate_per_month) ** number_of_payments - 1) ) if __name__ == "__main__": import doctest doctest.testmod()
11
import importlib.util import json import os import warnings from dataclasses import dataclass, field import torch from ..training_args import TrainingArguments from ..utils import cached_property, is_sagemaker_dp_enabled, logging __A =logging.get_logger(__name__) def lowerCamelCase_ ( ): # Get the sagemaker specific mp parameters from smp_options variable. lowerCamelCase_ = os.getenv("SM_HP_MP_PARAMETERS" , "{}" ) try: # Parse it and check the field "partitions" is included, it is required for model parallel. lowerCamelCase_ = json.loads(lowerCamelCase__ ) if "partitions" not in smp_options: return False except json.JSONDecodeError: return False # Get the sagemaker specific framework parameters from mpi_options variable. lowerCamelCase_ = os.getenv("SM_FRAMEWORK_PARAMS" , "{}" ) try: # Parse it and check the field "sagemaker_distributed_dataparallel_enabled". lowerCamelCase_ = json.loads(lowerCamelCase__ ) if not mpi_options.get("sagemaker_mpi_enabled" , lowerCamelCase__ ): return False except json.JSONDecodeError: return False # Lastly, check if the `smdistributed` module is present. return importlib.util.find_spec("smdistributed" ) is not None if is_sagemaker_model_parallel_available(): import smdistributed.modelparallel.torch as smp smp.init() @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = field( default='' , metadata={'help': 'Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'} , ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: super().__post_init__() warnings.warn( "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use " "`TrainingArguments` instead." , lowercase , ) @cached_property def SCREAMING_SNAKE_CASE_( self ) -> "torch.device": logger.info("PyTorch: setting up devices" ) if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1: logger.warning( "torch.distributed process group is initialized, but local_rank == -1. " "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch" ) if self.no_cuda: lowerCamelCase_ = torch.device("cpu" ) lowerCamelCase_ = 0 elif is_sagemaker_model_parallel_available(): lowerCamelCase_ = smp.local_rank() lowerCamelCase_ = torch.device("cuda" , lowercase ) lowerCamelCase_ = 1 elif is_sagemaker_dp_enabled(): import smdistributed.dataparallel.torch.torch_smddp # noqa: F401 torch.distributed.init_process_group(backend="smddp" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = int(os.getenv("SMDATAPARALLEL_LOCAL_RANK" ) ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 elif self.local_rank == -1: # if n_gpu is > 1 we'll use nn.DataParallel. # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0` # Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will # trigger an error that a device index is missing. Index 0 takes into account the # GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0` # will use the first GPU in that env, i.e. GPU#1 lowerCamelCase_ = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" ) # Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at # the default value. lowerCamelCase_ = torch.cuda.device_count() else: # Here, we'll use torch.distributed. # Initializes the distributed backend which will take care of synchronizing nodes/GPUs if not torch.distributed.is_initialized(): torch.distributed.init_process_group(backend="nccl" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 if device.type == "cuda": torch.cuda.set_device(lowercase ) return device @property def SCREAMING_SNAKE_CASE_( self ) -> Tuple: if is_sagemaker_model_parallel_available(): return smp.dp_size() return super().world_size @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: return not is_sagemaker_model_parallel_available() @property def SCREAMING_SNAKE_CASE_( self ) -> Dict: return False
19
0
'''simple docstring''' import gc import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, EulerAncestralDiscreteScheduler, LMSDiscreteScheduler, PNDMScheduler, StableDiffusionPanoramaPipeline, UNetaDConditionModel, ) from diffusers.utils import slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps 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() @skip_mps class a__ ( snake_case_ , snake_case_ , unittest.TestCase ): lowerCamelCase : List[str] =StableDiffusionPanoramaPipeline lowerCamelCase : Optional[int] =TEXT_TO_IMAGE_PARAMS lowerCamelCase : Optional[int] =TEXT_TO_IMAGE_BATCH_PARAMS lowerCamelCase : Optional[Any] =TEXT_TO_IMAGE_IMAGE_PARAMS lowerCamelCase : int =TEXT_TO_IMAGE_IMAGE_PARAMS def SCREAMING_SNAKE_CASE__ ( self : Dict ): """simple docstring""" torch.manual_seed(0 ) __lowerCamelCase = UNetaDConditionModel( block_out_channels=(32, 64) , layers_per_block=1 , sample_size=32 , in_channels=4 , out_channels=4 , down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''') , up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''') , cross_attention_dim=32 , ) __lowerCamelCase = DDIMScheduler() torch.manual_seed(0 ) __lowerCamelCase = 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 ) __lowerCamelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-0_5 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) __lowerCamelCase = CLIPTextModel(a ) __lowerCamelCase = CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) __lowerCamelCase = { '''unet''': unet, '''scheduler''': scheduler, '''vae''': vae, '''text_encoder''': text_encoder, '''tokenizer''': tokenizer, '''safety_checker''': None, '''feature_extractor''': None, } return components def SCREAMING_SNAKE_CASE__ ( self : int , a : Any , a : Dict=0 ): """simple docstring""" __lowerCamelCase = torch.manual_seed(a ) __lowerCamelCase = { '''prompt''': '''a photo of the dolomites''', '''generator''': generator, # Setting height and width to None to prevent OOMs on CPU. '''height''': None, '''width''': None, '''num_inference_steps''': 1, '''guidance_scale''': 6.0, '''output_type''': '''numpy''', } return inputs def SCREAMING_SNAKE_CASE__ ( self : List[Any] ): """simple docstring""" __lowerCamelCase = '''cpu''' # ensure determinism for the device-dependent torch.Generator __lowerCamelCase = self.get_dummy_components() __lowerCamelCase = StableDiffusionPanoramaPipeline(**a ) __lowerCamelCase = sd_pipe.to(a ) sd_pipe.set_progress_bar_config(disable=a ) __lowerCamelCase = self.get_dummy_inputs(a ) __lowerCamelCase = sd_pipe(**a ).images __lowerCamelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __lowerCamelCase = np.array([0.61_86, 0.53_74, 0.49_15, 0.41_35, 0.41_14, 0.45_63, 0.51_28, 0.49_77, 0.47_57] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def SCREAMING_SNAKE_CASE__ ( self : Optional[int] ): """simple docstring""" super().test_inference_batch_consistent(batch_sizes=[1, 2] ) def SCREAMING_SNAKE_CASE__ ( self : Dict ): """simple docstring""" super().test_inference_batch_single_identical(batch_size=2 , expected_max_diff=3.2_5e-3 ) def SCREAMING_SNAKE_CASE__ ( self : Tuple ): """simple docstring""" __lowerCamelCase = '''cpu''' # ensure determinism for the device-dependent torch.Generator __lowerCamelCase = self.get_dummy_components() __lowerCamelCase = StableDiffusionPanoramaPipeline(**a ) __lowerCamelCase = sd_pipe.to(a ) sd_pipe.set_progress_bar_config(disable=a ) __lowerCamelCase = self.get_dummy_inputs(a ) __lowerCamelCase = '''french fries''' __lowerCamelCase = sd_pipe(**a , negative_prompt=a ) __lowerCamelCase = output.images __lowerCamelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __lowerCamelCase = np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def SCREAMING_SNAKE_CASE__ ( self : Optional[int] ): """simple docstring""" __lowerCamelCase = '''cpu''' # ensure determinism for the device-dependent torch.Generator __lowerCamelCase = self.get_dummy_components() __lowerCamelCase = StableDiffusionPanoramaPipeline(**a ) __lowerCamelCase = sd_pipe.to(a ) sd_pipe.set_progress_bar_config(disable=a ) __lowerCamelCase = self.get_dummy_inputs(a ) __lowerCamelCase = sd_pipe(**a , view_batch_size=2 ) __lowerCamelCase = output.images __lowerCamelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __lowerCamelCase = np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def SCREAMING_SNAKE_CASE__ ( self : List[Any] ): """simple docstring""" __lowerCamelCase = '''cpu''' # ensure determinism for the device-dependent torch.Generator __lowerCamelCase = self.get_dummy_components() __lowerCamelCase = EulerAncestralDiscreteScheduler( beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' ) __lowerCamelCase = StableDiffusionPanoramaPipeline(**a ) __lowerCamelCase = sd_pipe.to(a ) sd_pipe.set_progress_bar_config(disable=a ) __lowerCamelCase = self.get_dummy_inputs(a ) __lowerCamelCase = sd_pipe(**a ).images __lowerCamelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __lowerCamelCase = np.array([0.40_24, 0.65_10, 0.49_01, 0.53_78, 0.58_13, 0.56_22, 0.47_95, 0.44_67, 0.49_52] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ): """simple docstring""" __lowerCamelCase = '''cpu''' # ensure determinism for the device-dependent torch.Generator __lowerCamelCase = self.get_dummy_components() __lowerCamelCase = PNDMScheduler( beta_start=0.0_00_85 , beta_end=0.0_12 , beta_schedule='''scaled_linear''' , skip_prk_steps=a ) __lowerCamelCase = StableDiffusionPanoramaPipeline(**a ) __lowerCamelCase = sd_pipe.to(a ) sd_pipe.set_progress_bar_config(disable=a ) __lowerCamelCase = self.get_dummy_inputs(a ) __lowerCamelCase = sd_pipe(**a ).images __lowerCamelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) __lowerCamelCase = np.array([0.63_91, 0.62_91, 0.48_61, 0.51_34, 0.55_52, 0.45_78, 0.50_32, 0.50_23, 0.45_39] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 @slow @require_torch_gpu class a__ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def SCREAMING_SNAKE_CASE__ ( self : Optional[Any] , a : Optional[int]=0 ): """simple docstring""" __lowerCamelCase = torch.manual_seed(a ) __lowerCamelCase = { '''prompt''': '''a photo of the dolomites''', '''generator''': generator, '''num_inference_steps''': 3, '''guidance_scale''': 7.5, '''output_type''': '''numpy''', } return inputs def SCREAMING_SNAKE_CASE__ ( self : int ): """simple docstring""" __lowerCamelCase = '''stabilityai/stable-diffusion-2-base''' __lowerCamelCase = DDIMScheduler.from_pretrained(a , subfolder='''scheduler''' ) __lowerCamelCase = StableDiffusionPanoramaPipeline.from_pretrained(a , scheduler=a , safety_checker=a ) pipe.to(a ) pipe.set_progress_bar_config(disable=a ) pipe.enable_attention_slicing() __lowerCamelCase = self.get_inputs() __lowerCamelCase = pipe(**a ).images __lowerCamelCase = image[0, -3:, -3:, -1].flatten() assert image.shape == (1, 5_12, 20_48, 3) __lowerCamelCase = np.array( [ 0.36_96_83_92, 0.27_02_53_72, 0.32_44_67_66, 0.28_37_93_87, 0.36_36_32_74, 0.30_73_33_47, 0.27_10_00_27, 0.27_05_41_25, 0.25_53_60_96, ] ) assert np.abs(expected_slice - image_slice ).max() < 1e-2 def SCREAMING_SNAKE_CASE__ ( self : Dict ): """simple docstring""" __lowerCamelCase = StableDiffusionPanoramaPipeline.from_pretrained( '''stabilityai/stable-diffusion-2-base''' , safety_checker=a ) __lowerCamelCase = LMSDiscreteScheduler.from_config(pipe.scheduler.config ) pipe.to(a ) pipe.set_progress_bar_config(disable=a ) pipe.enable_attention_slicing() __lowerCamelCase = self.get_inputs() __lowerCamelCase = pipe(**a ).images __lowerCamelCase = image[0, -3:, -3:, -1].flatten() assert image.shape == (1, 5_12, 20_48, 3) __lowerCamelCase = np.array( [ [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ] ] ) assert np.abs(expected_slice - image_slice ).max() < 1e-3 def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ): """simple docstring""" __lowerCamelCase = 0 def callback_fn(a : List[str] , a : Union[str, Any] , a : int ) -> None: __lowerCamelCase = True nonlocal number_of_steps number_of_steps += 1 if step == 1: __lowerCamelCase = latents.detach().cpu().numpy() assert latents.shape == (1, 4, 64, 2_56) __lowerCamelCase = latents[0, -3:, -3:, -1] __lowerCamelCase = np.array( [ 0.18_68_18_69, 0.33_90_78_16, 0.5_36_12_76, 0.14_43_28_65, -0.02_85_66_11, -0.73_94_11_23, 0.23_39_79_87, 0.47_32_26_82, -0.37_82_31_64, ] ) assert np.abs(latents_slice.flatten() - expected_slice ).max() < 5e-2 elif step == 2: __lowerCamelCase = latents.detach().cpu().numpy() assert latents.shape == (1, 4, 64, 2_56) __lowerCamelCase = latents[0, -3:, -3:, -1] __lowerCamelCase = np.array( [ 0.18_53_96_45, 0.33_98_72_48, 0.5_37_85_59, 0.14_43_71_42, -0.02_45_52_61, -0.7_33_83_17, 0.23_99_07_55, 0.47_35_62_72, -0.3_78_65_05, ] ) assert np.abs(latents_slice.flatten() - expected_slice ).max() < 5e-2 __lowerCamelCase = False __lowerCamelCase = '''stabilityai/stable-diffusion-2-base''' __lowerCamelCase = DDIMScheduler.from_pretrained(a , subfolder='''scheduler''' ) __lowerCamelCase = StableDiffusionPanoramaPipeline.from_pretrained(a , scheduler=a , safety_checker=a ) __lowerCamelCase = pipe.to(a ) pipe.set_progress_bar_config(disable=a ) pipe.enable_attention_slicing() __lowerCamelCase = self.get_inputs() pipe(**a , callback=a , callback_steps=1 ) assert callback_fn.has_been_called assert number_of_steps == 3 def SCREAMING_SNAKE_CASE__ ( self : List[Any] ): """simple docstring""" torch.cuda.empty_cache() torch.cuda.reset_max_memory_allocated() torch.cuda.reset_peak_memory_stats() __lowerCamelCase = '''stabilityai/stable-diffusion-2-base''' __lowerCamelCase = DDIMScheduler.from_pretrained(a , subfolder='''scheduler''' ) __lowerCamelCase = StableDiffusionPanoramaPipeline.from_pretrained(a , scheduler=a , safety_checker=a ) __lowerCamelCase = pipe.to(a ) pipe.set_progress_bar_config(disable=a ) pipe.enable_attention_slicing(1 ) pipe.enable_sequential_cpu_offload() __lowerCamelCase = self.get_inputs() __lowerCamelCase = pipe(**a ) __lowerCamelCase = torch.cuda.max_memory_allocated() # make sure that less than 5.2 GB is allocated assert mem_bytes < 5.5 * 10**9
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 0 , lowerCamelCase__ = 0 ): lowerCamelCase_ = end or len(lowerCamelCase__ ) for i in range(lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = i lowerCamelCase_ = array[i] while temp_index != start and temp_index_value < array[temp_index - 1]: lowerCamelCase_ = array[temp_index - 1] temp_index -= 1 lowerCamelCase_ = temp_index_value return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): # Max Heap lowerCamelCase_ = index lowerCamelCase_ = 2 * index + 1 # Left Node lowerCamelCase_ = 2 * index + 2 # Right Node if left_index < heap_size and array[largest] < array[left_index]: lowerCamelCase_ = left_index if right_index < heap_size and array[largest] < array[right_index]: lowerCamelCase_ = right_index if largest != index: lowerCamelCase_ , lowerCamelCase_ = array[largest], array[index] heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) for i in range(n // 2 , -1 , -1 ): heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) for i in range(n - 1 , 0 , -1 ): lowerCamelCase_ , lowerCamelCase_ = array[0], array[i] heapify(lowerCamelCase__ , 0 , lowerCamelCase__ ) return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): if (array[first_index] > array[middle_index]) != ( array[first_index] > array[last_index] ): return array[first_index] elif (array[middle_index] > array[first_index]) != ( array[middle_index] > array[last_index] ): return array[middle_index] else: return array[last_index] def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = low lowerCamelCase_ = high while True: while array[i] < pivot: i += 1 j -= 1 while pivot < array[j]: j -= 1 if i >= j: return i lowerCamelCase_ , lowerCamelCase_ = array[j], array[i] i += 1 def lowerCamelCase_ ( lowerCamelCase__ ): if len(lowerCamelCase__ ) == 0: return array lowerCamelCase_ = 2 * math.ceil(math.loga(len(lowerCamelCase__ ) ) ) lowerCamelCase_ = 1_6 return intro_sort(lowerCamelCase__ , 0 , len(lowerCamelCase__ ) , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): while end - start > size_threshold: if max_depth == 0: return heap_sort(lowerCamelCase__ ) max_depth -= 1 lowerCamelCase_ = median_of_a(lowerCamelCase__ , lowerCamelCase__ , start + ((end - start) // 2) + 1 , end - 1 ) lowerCamelCase_ = partition(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) intro_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = p return insertion_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": import doctest doctest.testmod() __A =input('''Enter numbers separated by a comma : ''').strip() __A =[float(item) for item in user_input.split(''',''')] print(sort(unsorted))
19
0
# 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. import argparse import os from accelerate.utils import ComputeEnvironment from .cluster import get_cluster_input from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file # noqa: F401 from .config_utils import _ask_field, _ask_options, _convert_compute_environment # noqa: F401 from .sagemaker import get_sagemaker_input SCREAMING_SNAKE_CASE :str = '''Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine''' def _lowerCAmelCase ( )->Optional[int]: '''simple docstring''' snake_case_ = _ask_options( "In which compute environment are you running?" , ["This machine", "AWS (Amazon SageMaker)"] , _convert_compute_environment , ) if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER: snake_case_ = get_sagemaker_input() else: snake_case_ = get_cluster_input() return config def _lowerCAmelCase ( lowerCAmelCase_ :Dict=None )->Optional[int]: '''simple docstring''' if subparsers is not None: snake_case_ = subparsers.add_parser("config" , description=lowerCamelCase__ ) else: snake_case_ = argparse.ArgumentParser("Accelerate config command" , description=lowerCamelCase__ ) parser.add_argument( "--config_file" , default=lowerCamelCase__ , 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'." ) , ) if subparsers is not None: parser.set_defaults(func=lowerCamelCase__ ) return parser def _lowerCAmelCase ( lowerCAmelCase_ :List[str] )->int: '''simple docstring''' snake_case_ = get_user_input() if args.config_file is not None: snake_case_ = args.config_file else: if not os.path.isdir(lowerCamelCase__ ): os.makedirs(lowerCamelCase__ ) snake_case_ = default_yaml_config_file if config_file.endswith(".json" ): config.to_json_file(lowerCamelCase__ ) else: config.to_yaml_file(lowerCamelCase__ ) print(F'''accelerate configuration saved at {config_file}''' ) def _lowerCAmelCase ( )->Tuple: '''simple docstring''' snake_case_ = config_command_parser() snake_case_ = parser.parse_args() config_command(lowerCamelCase__ ) if __name__ == "__main__": main()
159
import math import time from typing import Dict, List, Optional from torch.utils.data import Dataset from transformers import SeqaSeqTrainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , *lowercase , lowercase=None , lowercase=None , **lowercase ) -> List[str]: super().__init__(*lowercase , **lowercase ) lowerCamelCase_ = eval_examples lowerCamelCase_ = post_process_function def SCREAMING_SNAKE_CASE_( self , lowercase = None , lowercase=None , lowercase = None , lowercase = "eval" , **lowercase , ) -> Dict[str, float]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = ( gen_kwargs["max_length"] if gen_kwargs.get("max_length" ) is not None else self.args.generation_max_length ) lowerCamelCase_ = ( gen_kwargs["num_beams"] if gen_kwargs.get("num_beams" ) is not None else self.args.generation_num_beams ) lowerCamelCase_ = gen_kwargs lowerCamelCase_ = self.eval_dataset if eval_dataset is None else eval_dataset lowerCamelCase_ = self.get_eval_dataloader(lowercase ) lowerCamelCase_ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Evaluation" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) else: lowerCamelCase_ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(lowercase ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) lowerCamelCase_ = self.callback_handler.on_evaluate(self.args , self.state , self.control , lowercase ) return metrics def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=None , lowercase = "test" , **lowercase ) -> Union[str, Any]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = self.get_test_dataloader(lowercase ) # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Prediction" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase , "predict" ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=lowercase )
19
0
"""simple docstring""" import json from typing import List, Optional, Tuple from tokenizers import normalizers from ....tokenization_utils_fast import PreTrainedTokenizerFast from ....utils import logging from .tokenization_retribert import RetriBertTokenizer A : str = logging.get_logger(__name__) A : Optional[int] = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"} A : Dict = { "vocab_file": { "yjernite/retribert-base-uncased": ( "https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/vocab.txt" ), }, "tokenizer_file": { "yjernite/retribert-base-uncased": ( "https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/tokenizer.json" ), }, } A : Optional[Any] = { "yjernite/retribert-base-uncased": 5_1_2, } A : str = { "yjernite/retribert-base-uncased": {"do_lower_case": True}, } class _UpperCamelCase ( snake_case_ ): '''simple docstring''' __UpperCAmelCase : List[str] =VOCAB_FILES_NAMES __UpperCAmelCase : List[Any] =PRETRAINED_VOCAB_FILES_MAP __UpperCAmelCase : Tuple =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCAmelCase : Tuple =PRETRAINED_INIT_CONFIGURATION __UpperCAmelCase : Tuple =RetriBertTokenizer __UpperCAmelCase : Any =["""input_ids""", """attention_mask"""] def __init__( self , __a=None , __a=None , __a=True , __a="[UNK]" , __a="[SEP]" , __a="[PAD]" , __a="[CLS]" , __a="[MASK]" , __a=True , __a=None , **__a , ): super().__init__( __a , tokenizer_file=__a , do_lower_case=__a , unk_token=__a , sep_token=__a , pad_token=__a , cls_token=__a , mask_token=__a , tokenize_chinese_chars=__a , strip_accents=__a , **__a , ) __lowerCAmelCase = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get("lowercase" , __a ) != do_lower_case or normalizer_state.get("strip_accents" , __a ) != strip_accents or normalizer_state.get("handle_chinese_chars" , __a ) != tokenize_chinese_chars ): __lowerCAmelCase = getattr(__a , normalizer_state.pop("type" ) ) __lowerCAmelCase = do_lower_case __lowerCAmelCase = strip_accents __lowerCAmelCase = tokenize_chinese_chars __lowerCAmelCase = normalizer_class(**__a ) __lowerCAmelCase = do_lower_case def snake_case ( self , __a , __a=None ): __lowerCAmelCase = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def snake_case ( self , __a , __a = None ): __lowerCAmelCase = [self.sep_token_id] __lowerCAmelCase = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def snake_case ( self , __a , __a = None ): __lowerCAmelCase = self._tokenizer.model.save(__a , name=__a ) return tuple(__a )
57
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __A =logging.get_logger(__name__) # pylint: disable=invalid-name __A =''' Examples: ```py >>> from PIL import Image >>> import torch >>> from diffusers import DiffusionPipeline >>> from diffusers.utils import export_to_gif, load_image >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu") >>> repo = "openai/shap-e-img2img" >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16) >>> pipe = pipe.to(device) >>> guidance_scale = 3.0 >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png" >>> image = load_image(image_url).convert("RGB") >>> images = pipe( ... image, ... guidance_scale=guidance_scale, ... num_inference_steps=64, ... frame_size=256, ... ).images >>> gif_path = export_to_gif(images[0], "corgi_3d.gif") ``` ''' @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: super().__init__() self.register_modules( prior=lowercase , image_encoder=lowercase , image_processor=lowercase , scheduler=lowercase , renderer=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if latents is None: lowerCamelCase_ = randn_tensor(lowercase , generator=lowercase , device=lowercase , dtype=lowercase ) else: if latents.shape != shape: raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {shape}' ) lowerCamelCase_ = latents.to(lowercase ) lowerCamelCase_ = latents * scheduler.init_noise_sigma return latents def SCREAMING_SNAKE_CASE_( self , lowercase=0 ) -> int: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device(f'cuda:{gpu_id}' ) lowerCamelCase_ = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: if self.device != torch.device("meta" ) or not hasattr(self.image_encoder , "_hf_hook" ): return self.device for module in self.image_encoder.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: if isinstance(lowercase , lowercase ) and isinstance(image[0] , torch.Tensor ): lowerCamelCase_ = torch.cat(lowercase , axis=0 ) if image[0].ndim == 4 else torch.stack(lowercase , axis=0 ) if not isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = self.image_processor(lowercase , return_tensors="pt" ).pixel_values[0].unsqueeze(0 ) lowerCamelCase_ = image.to(dtype=self.image_encoder.dtype , device=lowercase ) lowerCamelCase_ = self.image_encoder(lowercase )["last_hidden_state"] lowerCamelCase_ = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 lowerCamelCase_ = image_embeds.repeat_interleave(lowercase , dim=0 ) if do_classifier_free_guidance: lowerCamelCase_ = torch.zeros_like(lowercase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes lowerCamelCase_ = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(lowercase ) def __call__( self , lowercase , lowercase = 1 , lowercase = 25 , lowercase = None , lowercase = None , lowercase = 4.0 , lowercase = 64 , lowercase = "pil" , lowercase = True , ) -> Union[str, Any]: if isinstance(lowercase , PIL.Image.Image ): lowerCamelCase_ = 1 elif isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = image.shape[0] elif isinstance(lowercase , lowercase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): lowerCamelCase_ = len(lowercase ) else: raise ValueError( f'`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(lowercase )}' ) lowerCamelCase_ = self._execution_device lowerCamelCase_ = batch_size * num_images_per_prompt lowerCamelCase_ = guidance_scale > 1.0 lowerCamelCase_ = self._encode_image(lowercase , lowercase , lowercase , lowercase ) # prior self.scheduler.set_timesteps(lowercase , device=lowercase ) lowerCamelCase_ = self.scheduler.timesteps lowerCamelCase_ = self.prior.config.num_embeddings lowerCamelCase_ = self.prior.config.embedding_dim lowerCamelCase_ = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , lowercase , lowercase , lowercase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim lowerCamelCase_ = latents.reshape(latents.shape[0] , lowercase , lowercase ) for i, t in enumerate(self.progress_bar(lowercase ) ): # expand the latents if we are doing classifier free guidance lowerCamelCase_ = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents lowerCamelCase_ = self.scheduler.scale_model_input(lowercase , lowercase ) lowerCamelCase_ = self.prior( lowercase , timestep=lowercase , proj_embedding=lowercase , ).predicted_image_embedding # remove the variance lowerCamelCase_ , lowerCamelCase_ = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: lowerCamelCase_ , lowerCamelCase_ = noise_pred.chunk(2 ) lowerCamelCase_ = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) lowerCamelCase_ = self.scheduler.step( lowercase , timestep=lowercase , sample=lowercase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=lowercase ) lowerCamelCase_ = [] for i, latent in enumerate(lowercase ): print() lowerCamelCase_ = self.renderer.decode( latent[None, :] , lowercase , size=lowercase , ray_batch_size=4096 , n_coarse_samples=64 , n_fine_samples=128 , ) images.append(lowercase ) lowerCamelCase_ = torch.stack(lowercase ) if output_type not in ["np", "pil"]: raise ValueError(f'Only the output types `pil` and `np` are supported not output_type={output_type}' ) lowerCamelCase_ = images.cpu().numpy() if output_type == "pil": lowerCamelCase_ = [self.numpy_to_pil(lowercase ) for image in images] # Offload last model to CPU if hasattr(self , "final_offload_hook" ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=lowercase )
19
0
from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available lowerCAmelCase__ : Tuple ={'''configuration_focalnet''': ['''FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FocalNetConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ : Union[str, Any] =[ '''FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST''', '''FocalNetForImageClassification''', '''FocalNetForMaskedImageModeling''', '''FocalNetBackbone''', '''FocalNetModel''', '''FocalNetPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_focalnet import FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FocalNetConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_focalnet import ( FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST, FocalNetBackbone, FocalNetForImageClassification, FocalNetForMaskedImageModeling, FocalNetModel, FocalNetPreTrainedModel, ) else: import sys lowerCAmelCase__ : List[str] =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
257
from collections import defaultdict from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst def lowerCamelCase_ ( ): lowerCamelCase_ , lowerCamelCase_ = 9, 1_4 # noqa: F841 lowerCamelCase_ = [ [0, 1, 4], [0, 7, 8], [1, 2, 8], [7, 8, 7], [7, 6, 1], [2, 8, 2], [8, 6, 6], [2, 3, 7], [2, 5, 4], [6, 5, 2], [3, 5, 1_4], [3, 4, 9], [5, 4, 1_0], [1, 7, 1_1], ] lowerCamelCase_ = defaultdict(lowerCamelCase__ ) for nodea, nodea, cost in edges: adjancency[nodea].append([nodea, cost] ) adjancency[nodea].append([nodea, cost] ) lowerCamelCase_ = mst(lowerCamelCase__ ) lowerCamelCase_ = [ [7, 6, 1], [2, 8, 2], [6, 5, 2], [0, 1, 4], [2, 5, 4], [2, 3, 7], [0, 7, 8], [3, 4, 9], ] for answer in expected: lowerCamelCase_ = tuple(answer[:2] ) lowerCamelCase_ = tuple(edge[::-1] ) assert edge in result or reverse in result
19
0
"""simple docstring""" import datasets from .evaluate import evaluate _lowercase = '''\ @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} } ''' _lowercase = ''' 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. ''' _lowercase = ''' 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 lowerCAmelCase_ ( datasets.Metric ): '''simple docstring''' def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Union[str, Any]: 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 _SCREAMING_SNAKE_CASE ( self : Optional[int] ,A_ : Any ,A_ : Tuple ) -> Any: A = {prediction['id']: prediction['prediction_text'] for prediction in predictions} A = [ { 'paragraphs': [ { 'qas': [ { 'answers': [{'text': answer_text} for answer_text in ref['answers']['text']], 'id': ref['id'], } for ref in references ] } ] } ] A = evaluate(dataset=A_ ,predictions=A_ ) return score
74
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, # specifically showcasing the experiment tracking capability, # and builds off the `nlp_example.py` script. # # 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 help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## __A =1_6 __A =3_2 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 1_6 ): lowerCamelCase_ = AutoTokenizer.from_pretrained("bert-base-cased" ) lowerCamelCase_ = load_dataset("glue" , "mrpc" ) def tokenize_function(lowerCamelCase__ ): # max_length=None => use the model max length (it's actually the default) lowerCamelCase_ = tokenizer(examples["sentence1"] , examples["sentence2"] , truncation=lowerCamelCase__ , max_length=lowerCamelCase__ ) 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(): lowerCamelCase_ = datasets.map( lowerCamelCase__ , batched=lowerCamelCase__ , 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 lowerCamelCase_ = tokenized_datasets.rename_column("label" , "labels" ) def collate_fn(lowerCamelCase__ ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCamelCase_ = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCamelCase_ = 1_6 elif accelerator.mixed_precision != "no": lowerCamelCase_ = 8 else: lowerCamelCase_ = None return tokenizer.pad( lowerCamelCase__ , padding="longest" , max_length=lowerCamelCase__ , pad_to_multiple_of=lowerCamelCase__ , return_tensors="pt" , ) # Instantiate dataloaders. lowerCamelCase_ = DataLoader( tokenized_datasets["train"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) lowerCamelCase_ = DataLoader( tokenized_datasets["validation"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) 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 __A =mocked_dataloaders # noqa: F811 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): # For testing only if os.environ.get("TESTING_MOCKED_DATALOADERS" , lowerCamelCase__ ) == "1": lowerCamelCase_ = 2 # Initialize Accelerator # New Code # # We pass in "all" to `log_with` to grab all available trackers in the environment # Note: If using a custom `Tracker` class, should be passed in here such as: # >>> log_with = ["all", MyCustomTrackerClassInstance()] if args.with_tracking: lowerCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , log_with="all" , project_dir=args.project_dir ) else: lowerCamelCase_ = Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCamelCase_ = config["lr"] lowerCamelCase_ = int(config["num_epochs"] ) lowerCamelCase_ = int(config["seed"] ) lowerCamelCase_ = int(config["batch_size"] ) set_seed(lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = get_dataloaders(lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = evaluate.load("glue" , "mrpc" ) # If the batch size is too big we use gradient accumulation lowerCamelCase_ = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: lowerCamelCase_ = batch_size // MAX_GPU_BATCH_SIZE lowerCamelCase_ = MAX_GPU_BATCH_SIZE # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCamelCase_ = AutoModelForSequenceClassification.from_pretrained("bert-base-cased" , return_dict=lowerCamelCase__ ) # 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). lowerCamelCase_ = model.to(accelerator.device ) # Instantiate optimizer lowerCamelCase_ = AdamW(params=model.parameters() , lr=lowerCamelCase__ ) # Instantiate scheduler lowerCamelCase_ = get_linear_schedule_with_warmup( optimizer=lowerCamelCase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowerCamelCase__ ) * num_epochs) // gradient_accumulation_steps , ) # 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. lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = accelerator.prepare( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # New Code # # We need to initialize the trackers we use. Overall configurations can also be stored if args.with_tracking: lowerCamelCase_ = os.path.split(lowerCamelCase__ )[-1].split("." )[0] accelerator.init_trackers(lowerCamelCase__ , lowerCamelCase__ ) # Now we train the model for epoch in range(lowerCamelCase__ ): model.train() # New Code # # For our tracking example, we will log the total loss of each epoch if args.with_tracking: lowerCamelCase_ = 0 for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.loss # New Code # if args.with_tracking: total_loss += loss.detach().float() lowerCamelCase_ = loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True` (the default). batch.to(accelerator.device ) with torch.no_grad(): lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.logits.argmax(dim=-1 ) lowerCamelCase_ , lowerCamelCase_ = accelerator.gather_for_metrics((predictions, batch["labels"]) ) metric.add_batch( predictions=lowerCamelCase__ , references=lowerCamelCase__ , ) lowerCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(F'epoch {epoch}:' , lowerCamelCase__ ) # New Code # # To actually log, we call `Accelerator.log` # The values passed can be of `str`, `int`, `float` or `dict` of `str` to `float`/`int` if args.with_tracking: accelerator.log( { "accuracy": eval_metric["accuracy"], "f1": eval_metric["f1"], "train_loss": total_loss.item() / len(lowerCamelCase__ ), "epoch": epoch, } , step=lowerCamelCase__ , ) # New Code # # When a run is finished, you should call `accelerator.end_training()` # to close all of the open trackers if args.with_tracking: accelerator.end_training() def lowerCamelCase_ ( ): lowerCamelCase_ = argparse.ArgumentParser(description="Simple example of training script." ) parser.add_argument( "--mixed_precision" , type=lowerCamelCase__ , default=lowerCamelCase__ , 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." , ) parser.add_argument("--cpu" , action="store_true" , help="If passed, will train on the CPU." ) parser.add_argument( "--with_tracking" , action="store_true" , help="Whether to load in all available experiment trackers from the environment and use them for logging." , ) parser.add_argument( "--project_dir" , type=lowerCamelCase__ , default="logs" , help="Location on where to store experiment tracking logs` and relevent project information" , ) lowerCamelCase_ = parser.parse_args() lowerCamelCase_ = {"lr": 2e-5, "num_epochs": 3, "seed": 4_2, "batch_size": 1_6} training_function(lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": main()
19
0
"""simple docstring""" import os import pytest import yaml from datasets.features.features import Features, Value from datasets.info import DatasetInfo, DatasetInfosDict @pytest.mark.parametrize( 'files' , [ ['full:README.md', 'dataset_infos.json'], ['empty:README.md', 'dataset_infos.json'], ['dataset_infos.json'], ['full:README.md'], ] , ) def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: '''simple docstring''' lowercase : Union[str, Any] = tmp_path_factory.mktemp('dset_infos_dir' ) if "full:README.md" in files: with open(dataset_infos_dir / 'README.md' , 'w' ) as f: f.write('---\ndataset_info:\n dataset_size: 42\n---' ) if "empty:README.md" in files: with open(dataset_infos_dir / 'README.md' , 'w' ) as f: f.write('' ) # we want to support dataset_infos.json for backward compatibility if "dataset_infos.json" in files: with open(dataset_infos_dir / 'dataset_infos.json' , 'w' ) as f: f.write('{\"default\": {\"dataset_size\": 42}}' ) lowercase : Tuple = DatasetInfosDict.from_directory(lowerCamelCase__ ) assert dataset_infos assert dataset_infos["default"].dataset_size == 42 @pytest.mark.parametrize( 'dataset_info' , [ DatasetInfo(), DatasetInfo( description='foo' , features=Features({'a': Value('int32' )} ) , builder_name='builder' , config_name='config' , version='1.0.0' , splits=[{'name': 'train'}] , download_size=42 , ), ] , ) def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase ) -> Any: '''simple docstring''' lowercase : Optional[int] = str(lowerCamelCase__ ) dataset_info.write_to_directory(lowerCamelCase__ ) lowercase : Dict = DatasetInfo.from_directory(lowerCamelCase__ ) assert dataset_info == reloaded assert os.path.exists(os.path.join(lowerCamelCase__ , 'dataset_info.json' ) ) def lowercase__ ( ) -> List[Any]: '''simple docstring''' lowercase : List[str] = DatasetInfo( description='foo' , citation='bar' , homepage='https://foo.bar' , license='CC0' , features=Features({'a': Value('int32' )} ) , post_processed={} , supervised_keys=() , task_templates=[] , builder_name='builder' , config_name='config' , version='1.0.0' , splits=[{'name': 'train', 'num_examples': 42}] , download_checksums={} , download_size=13_37 , post_processing_size=4_42 , dataset_size=12_34 , size_in_bytes=13_37 + 4_42 + 12_34 , ) lowercase : Dict = dataset_info._to_yaml_dict() assert sorted(lowerCamelCase__ ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML ) for key in DatasetInfo._INCLUDED_INFO_IN_YAML: assert key in dataset_info_yaml_dict assert isinstance(dataset_info_yaml_dict[key] , (list, dict, int, str) ) lowercase : Optional[int] = yaml.safe_dump(lowerCamelCase__ ) lowercase : List[str] = yaml.safe_load(lowerCamelCase__ ) assert dataset_info_yaml_dict == reloaded def lowercase__ ( ) -> int: '''simple docstring''' lowercase : Optional[Any] = DatasetInfo() lowercase : Tuple = dataset_info._to_yaml_dict() assert dataset_info_yaml_dict == {} @pytest.mark.parametrize( 'dataset_infos_dict' , [ DatasetInfosDict(), DatasetInfosDict({'default': DatasetInfo()} ), DatasetInfosDict({'my_config_name': DatasetInfo()} ), DatasetInfosDict( { 'default': DatasetInfo( description='foo' , features=Features({'a': Value('int32' )} ) , builder_name='builder' , config_name='config' , version='1.0.0' , splits=[{'name': 'train'}] , download_size=42 , ) } ), DatasetInfosDict( { 'v1': DatasetInfo(dataset_size=42 ), 'v2': DatasetInfo(dataset_size=13_37 ), } ), ] , ) def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase ) -> Tuple: '''simple docstring''' lowercase : Union[str, Any] = str(lowerCamelCase__ ) dataset_infos_dict.write_to_directory(lowerCamelCase__ ) lowercase : Optional[Any] = DatasetInfosDict.from_directory(lowerCamelCase__ ) # the config_name of the dataset_infos_dict take over the attribute for config_name, dataset_info in dataset_infos_dict.items(): lowercase : int = config_name # the yaml representation doesn't include fields like description or citation # so we just test that we can recover what we can from the yaml lowercase : List[Any] = DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict() ) assert dataset_infos_dict == reloaded if dataset_infos_dict: assert os.path.exists(os.path.join(lowerCamelCase__ , 'README.md' ) )
255
import os from shutil import copyfile from typing import List, Optional, Tuple from tokenizers import processors from ...tokenization_utils import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_mbart import MBartTokenizer else: __A =None __A =logging.get_logger(__name__) __A ={'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''} __A ={ '''vocab_file''': { '''facebook/mbart-large-en-ro''': ( '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model''' ), '''facebook/mbart-large-cc25''': ( '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model''' ), }, '''tokenizer_file''': { '''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''', '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''', }, } __A ={ '''facebook/mbart-large-en-ro''': 1_0_2_4, '''facebook/mbart-large-cc25''': 1_0_2_4, } # fmt: off __A =['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN'''] class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = VOCAB_FILES_NAMES lowerCAmelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowerCAmelCase__ = PRETRAINED_VOCAB_FILES_MAP lowerCAmelCase__ = ['input_ids', 'attention_mask'] lowerCAmelCase__ = MBartTokenizer lowerCAmelCase__ = [] lowerCAmelCase__ = [] def __init__( self , lowercase=None , lowercase=None , lowercase="<s>" , lowercase="</s>" , lowercase="</s>" , lowercase="<s>" , lowercase="<unk>" , lowercase="<pad>" , lowercase="<mask>" , lowercase=None , lowercase=None , lowercase=None , **lowercase , ) -> Dict: # Mask token behave like a normal word, i.e. include the space before it lowerCamelCase_ = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else mask_token super().__init__( vocab_file=lowercase , tokenizer_file=lowercase , bos_token=lowercase , eos_token=lowercase , sep_token=lowercase , cls_token=lowercase , unk_token=lowercase , pad_token=lowercase , mask_token=lowercase , src_lang=lowercase , tgt_lang=lowercase , additional_special_tokens=lowercase , **lowercase , ) lowerCamelCase_ = vocab_file lowerCamelCase_ = False if not self.vocab_file else True lowerCamelCase_ = FAIRSEQ_LANGUAGE_CODES.copy() if additional_special_tokens is not None: # Only add those special tokens if they are not already there. _additional_special_tokens.extend( [t for t in additional_special_tokens if t not in _additional_special_tokens] ) self.add_special_tokens({"additional_special_tokens": _additional_special_tokens} ) lowerCamelCase_ = { lang_code: self.convert_tokens_to_ids(lowercase ) for lang_code in FAIRSEQ_LANGUAGE_CODES } lowerCamelCase_ = src_lang if src_lang is not None else "en_XX" lowerCamelCase_ = self.convert_tokens_to_ids(self._src_lang ) lowerCamelCase_ = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def SCREAMING_SNAKE_CASE_( self ) -> str: return self._src_lang @src_lang.setter def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: lowerCamelCase_ = [self.sep_token_id] lowerCamelCase_ = [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 SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , **lowercase ) -> List[Any]: if src_lang is None or tgt_lang is None: raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model" ) lowerCamelCase_ = src_lang lowerCamelCase_ = self(lowercase , add_special_tokens=lowercase , return_tensors=lowercase , **lowercase ) lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = tgt_lang_id return inputs def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = "en_XX" , lowercase = None , lowercase = "ro_RO" , **lowercase , ) -> BatchEncoding: lowerCamelCase_ = src_lang lowerCamelCase_ = tgt_lang return super().prepare_seqaseq_batch(lowercase , lowercase , **lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: return self.set_src_lang_special_tokens(self.src_lang ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> Tuple[str]: if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(lowercase ): logger.error(f'Vocabulary path ({save_directory}) should be a directory.' ) return lowerCamelCase_ = os.path.join( lowercase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowercase ): copyfile(self.vocab_file , lowercase ) return (out_vocab_file,)
19
0
'''simple docstring''' import unittest from transformers import is_torch_available 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 from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST, OpenAIGPTConfig, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel, ) class __SCREAMING_SNAKE_CASE : def __init__( self : List[str] , __lowercase : int , __lowercase : Optional[Any]=13 , __lowercase : str=7 , __lowercase : List[Any]=True , __lowercase : Union[str, Any]=True , __lowercase : Tuple=True , __lowercase : Any=99 , __lowercase : Optional[Any]=32 , __lowercase : int=5 , __lowercase : Dict=4 , __lowercase : Optional[int]=37 , __lowercase : Dict="gelu" , __lowercase : Union[str, Any]=0.1 , __lowercase : Optional[Any]=0.1 , __lowercase : str=5_12 , __lowercase : Optional[Any]=16 , __lowercase : Union[str, Any]=2 , __lowercase : List[Any]=0.02 , __lowercase : Tuple=3 , __lowercase : str=4 , __lowercase : Optional[Any]=None , ) -> List[str]: SCREAMING_SNAKE_CASE__ : Optional[int] =parent SCREAMING_SNAKE_CASE__ : str =batch_size SCREAMING_SNAKE_CASE__ : int =seq_length SCREAMING_SNAKE_CASE__ : Optional[int] =is_training SCREAMING_SNAKE_CASE__ : Optional[Any] =use_token_type_ids SCREAMING_SNAKE_CASE__ : List[str] =use_labels SCREAMING_SNAKE_CASE__ : Tuple =vocab_size SCREAMING_SNAKE_CASE__ : Optional[Any] =hidden_size SCREAMING_SNAKE_CASE__ : Dict =num_hidden_layers SCREAMING_SNAKE_CASE__ : str =num_attention_heads SCREAMING_SNAKE_CASE__ : Tuple =intermediate_size SCREAMING_SNAKE_CASE__ : Tuple =hidden_act SCREAMING_SNAKE_CASE__ : Tuple =hidden_dropout_prob SCREAMING_SNAKE_CASE__ : Optional[Any] =attention_probs_dropout_prob SCREAMING_SNAKE_CASE__ : int =max_position_embeddings SCREAMING_SNAKE_CASE__ : Any =type_vocab_size SCREAMING_SNAKE_CASE__ : Dict =type_sequence_label_size SCREAMING_SNAKE_CASE__ : Tuple =initializer_range SCREAMING_SNAKE_CASE__ : Tuple =num_labels SCREAMING_SNAKE_CASE__ : Tuple =num_choices SCREAMING_SNAKE_CASE__ : Any =scope SCREAMING_SNAKE_CASE__ : int =self.vocab_size - 1 def __magic_name__ ( self : Optional[int] ) -> Any: SCREAMING_SNAKE_CASE__ : Any =ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE__ : List[Any] =None if self.use_token_type_ids: SCREAMING_SNAKE_CASE__ : Optional[int] =ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =None SCREAMING_SNAKE_CASE__ : Any =None SCREAMING_SNAKE_CASE__ : List[str] =None if self.use_labels: SCREAMING_SNAKE_CASE__ : Dict =ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE__ : Dict =ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) SCREAMING_SNAKE_CASE__ : List[Any] =ids_tensor([self.batch_size] , self.num_choices ) SCREAMING_SNAKE_CASE__ : Optional[int] =OpenAIGPTConfig( 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 , pad_token_id=self.pad_token_id , ) SCREAMING_SNAKE_CASE__ : str =ids_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, head_mask, token_type_ids, sequence_labels, token_labels, choice_labels, ) def __magic_name__ ( self : List[Any] , __lowercase : List[str] , __lowercase : int , __lowercase : List[Any] , __lowercase : List[str] , *__lowercase : Any ) -> Dict: SCREAMING_SNAKE_CASE__ : Optional[Any] =OpenAIGPTModel(config=__lowercase ) model.to(__lowercase ) model.eval() SCREAMING_SNAKE_CASE__ : str =model(__lowercase , token_type_ids=__lowercase , head_mask=__lowercase ) SCREAMING_SNAKE_CASE__ : List[Any] =model(__lowercase , token_type_ids=__lowercase ) SCREAMING_SNAKE_CASE__ : List[Any] =model(__lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__ ( self : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : int , __lowercase : Any , *__lowercase : str ) -> int: SCREAMING_SNAKE_CASE__ : List[str] =OpenAIGPTLMHeadModel(__lowercase ) model.to(__lowercase ) model.eval() SCREAMING_SNAKE_CASE__ : Any =model(__lowercase , token_type_ids=__lowercase , labels=__lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __magic_name__ ( self : List[str] , __lowercase : Optional[int] , __lowercase : List[Any] , __lowercase : Union[str, Any] , __lowercase : Optional[Any] , *__lowercase : Optional[int] ) -> Dict: SCREAMING_SNAKE_CASE__ : Any =OpenAIGPTDoubleHeadsModel(__lowercase ) model.to(__lowercase ) model.eval() SCREAMING_SNAKE_CASE__ : List[Any] =model(__lowercase , token_type_ids=__lowercase , labels=__lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __magic_name__ ( self : Union[str, Any] , __lowercase : Union[str, Any] , __lowercase : Union[str, Any] , __lowercase : Optional[int] , __lowercase : List[str] , *__lowercase : Optional[Any] ) -> int: SCREAMING_SNAKE_CASE__ : Optional[int] =self.num_labels SCREAMING_SNAKE_CASE__ : Dict =OpenAIGPTForSequenceClassification(__lowercase ) model.to(__lowercase ) model.eval() SCREAMING_SNAKE_CASE__ : Dict =ids_tensor([self.batch_size] , self.type_sequence_label_size ) SCREAMING_SNAKE_CASE__ : Any =model(__lowercase , token_type_ids=__lowercase , labels=__lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def __magic_name__ ( self : Optional[int] ) -> Union[str, Any]: SCREAMING_SNAKE_CASE__ : List[Any] =self.prepare_config_and_inputs() ( ( SCREAMING_SNAKE_CASE__ ) , ( SCREAMING_SNAKE_CASE__ ) , ( SCREAMING_SNAKE_CASE__ ) , ( SCREAMING_SNAKE_CASE__ ) , ( SCREAMING_SNAKE_CASE__ ) , ( SCREAMING_SNAKE_CASE__ ) , ( SCREAMING_SNAKE_CASE__ ) , ) : List[str] =config_and_inputs SCREAMING_SNAKE_CASE__ : Any ={ '''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''head_mask''': head_mask, } return config, inputs_dict @require_torch class __SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , snake_case_ , unittest.TestCase ): snake_case_ = ( (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification) if is_torch_available() else () ) snake_case_ = ( (OpenAIGPTLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly snake_case_ = ( { """feature-extraction""": OpenAIGPTModel, """text-classification""": OpenAIGPTForSequenceClassification, """text-generation""": OpenAIGPTLMHeadModel, """zero-shot""": OpenAIGPTForSequenceClassification, } if is_torch_available() else {} ) def __magic_name__ ( self : Tuple , __lowercase : int , __lowercase : Tuple , __lowercase : Any , __lowercase : List[str] , __lowercase : List[str] ) -> int: if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests": # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers. # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a # tiny config could not be created. return True return False def __magic_name__ ( self : Optional[int] , __lowercase : int , __lowercase : List[Any] , __lowercase : Tuple=False ) -> Any: SCREAMING_SNAKE_CASE__ : Optional[Any] =super()._prepare_for_class(__lowercase , __lowercase , return_labels=__lowercase ) if return_labels: if model_class.__name__ == "OpenAIGPTDoubleHeadsModel": SCREAMING_SNAKE_CASE__ : List[Any] =torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length) , dtype=torch.long , device=__lowercase , ) SCREAMING_SNAKE_CASE__ : List[str] =inputs_dict['''labels'''] SCREAMING_SNAKE_CASE__ : Optional[Any] =inputs_dict['''labels'''] SCREAMING_SNAKE_CASE__ : Optional[int] =torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices) , dtype=torch.long , device=__lowercase , ) SCREAMING_SNAKE_CASE__ : Optional[Any] =torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=__lowercase ) return inputs_dict def __magic_name__ ( self : Tuple ) -> Dict: SCREAMING_SNAKE_CASE__ : Union[str, Any] =OpenAIGPTModelTester(self ) SCREAMING_SNAKE_CASE__ : Optional[int] =ConfigTester(self , config_class=__lowercase , n_embd=37 ) def __magic_name__ ( self : Union[str, Any] ) -> Any: self.config_tester.run_common_tests() def __magic_name__ ( self : Dict ) -> Union[str, Any]: SCREAMING_SNAKE_CASE__ : List[Any] =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_model(*__lowercase ) def __magic_name__ ( self : Tuple ) -> str: SCREAMING_SNAKE_CASE__ : Tuple =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*__lowercase ) def __magic_name__ ( self : Union[str, Any] ) -> Tuple: SCREAMING_SNAKE_CASE__ : Any =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_double_lm_head_model(*__lowercase ) def __magic_name__ ( self : List[str] ) -> Optional[Any]: SCREAMING_SNAKE_CASE__ : Any =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*__lowercase ) @slow def __magic_name__ ( self : List[str] ) -> Any: for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: SCREAMING_SNAKE_CASE__ : List[Any] =OpenAIGPTModel.from_pretrained(__lowercase ) self.assertIsNotNone(__lowercase ) @require_torch class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def __magic_name__ ( self : Union[str, Any] ) -> str: SCREAMING_SNAKE_CASE__ : Dict =OpenAIGPTLMHeadModel.from_pretrained('''openai-gpt''' ) model.to(__lowercase ) SCREAMING_SNAKE_CASE__ : Any =torch.tensor([[4_81, 47_35, 5_44]] , dtype=torch.long , device=__lowercase ) # the president is SCREAMING_SNAKE_CASE__ : int =[ 4_81, 47_35, 5_44, 2_46, 9_63, 8_70, 7_62, 2_39, 2_44, 4_04_77, 2_44, 2_49, 7_19, 8_81, 4_87, 5_44, 2_40, 2_44, 6_03, 4_81, ] # the president is a very good man. " \n " i\'m sure he is, " said the SCREAMING_SNAKE_CASE__ : List[Any] =model.generate(__lowercase , do_sample=__lowercase ) self.assertListEqual(output_ids[0].tolist() , __lowercase )
152
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss __A =pytest.mark.integration @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = Dataset.from_dict({"filename": ["my_name-train" + "_" + str(lowercase ) for x in np.arange(30 ).tolist()]} ) return dset def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: import faiss lowerCamelCase_ = self._create_dummy_dataset() lowerCamelCase_ = dset.map( lambda lowercase , lowercase : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=lowercase , keep_in_memory=lowercase ) lowerCamelCase_ = dset.add_faiss_index("vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) dset.drop_index("vecs" ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: dset.save_faiss_index("vecs" , tmp_file.name ) dset.load_faiss_index("vecs2" , tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs2" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" ) dset.drop_index("vecs" ) self.assertRaises(lowercase , partial(dset.get_nearest_examples , "vecs2" , np.ones(5 , dtype=np.floataa ) ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: from elasticsearch import Elasticsearch lowerCamelCase_ = self._create_dummy_dataset() with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = {"acknowledged": True} mocked_bulk.return_value([(True, None)] * 30 ) lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 29}]}} lowerCamelCase_ = Elasticsearch() dset.add_elasticsearch_index("filename" , es_client=lowercase ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("filename" , "my_name-train_29" ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Tuple: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertRaises(lowercase , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries lowerCamelCase_ = np.eye(5 , dtype=np.floataa )[::-1] lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) self.assertRaises(lowercase , index.search_batch , queries[0] ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Any: import faiss lowerCamelCase_ = FaissIndex(string_factory="Flat" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) lowerCamelCase_ = FaissIndex(string_factory="LSH" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(lowercase ): lowerCamelCase_ = FaissIndex(string_factory="Flat" , custom_index=faiss.IndexFlat(5 ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = faiss.IndexFlat(5 ) lowerCamelCase_ = FaissIndex(custom_index=lowercase ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: index.save(tmp_file.name ) lowerCamelCase_ = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def lowerCamelCase_ ( lowerCamelCase__ ): import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) lowerCamelCase_ = "index.faiss" lowerCamelCase_ = F'mock://{index_name}' index.save(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = FaissIndex.load(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowerCamelCase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: from elasticsearch import Elasticsearch with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = Elasticsearch() lowerCamelCase_ = {"acknowledged": True} lowerCamelCase_ = ElasticSearchIndex(es_client=lowercase ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(["foo", "bar", "foobar"] ) # single query lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase ) # batched queries with timeout lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase , request_timeout=30 ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase )
19
0
import inspect import unittest from huggingface_hub import hf_hub_download from transformers import ConvNextConfig, UperNetConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import UperNetForSemanticSegmentation from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class __A : """simple docstring""" def __init__( self , lowerCamelCase__ , lowerCamelCase__=13 , lowerCamelCase__=32 , lowerCamelCase__=3 , lowerCamelCase__=4 , lowerCamelCase__=[10, 20, 30, 40] , lowerCamelCase__=[2, 2, 3, 2] , lowerCamelCase__=True , lowerCamelCase__=True , lowerCamelCase__=37 , lowerCamelCase__="gelu" , lowerCamelCase__=10 , lowerCamelCase__=0.02 , lowerCamelCase__=["stage2", "stage3", "stage4"] , lowerCamelCase__=3 , lowerCamelCase__=None , ): """simple docstring""" __UpperCamelCase : Optional[Any] =parent __UpperCamelCase : List[str] =batch_size __UpperCamelCase : int =image_size __UpperCamelCase : Tuple =num_channels __UpperCamelCase : List[str] =num_stages __UpperCamelCase : str =hidden_sizes __UpperCamelCase : Optional[int] =depths __UpperCamelCase : Union[str, Any] =is_training __UpperCamelCase : Optional[Any] =use_labels __UpperCamelCase : List[Any] =intermediate_size __UpperCamelCase : Optional[Any] =hidden_act __UpperCamelCase : str =type_sequence_label_size __UpperCamelCase : List[str] =initializer_range __UpperCamelCase : Tuple =out_features __UpperCamelCase : List[Any] =num_labels __UpperCamelCase : List[Any] =scope __UpperCamelCase : Optional[int] =num_stages def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[str] =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) __UpperCamelCase : str =None if self.use_labels: __UpperCamelCase : Dict =ids_tensor([self.batch_size] , self.type_sequence_label_size ) __UpperCamelCase : str =self.get_config() return config, pixel_values, labels def __lowercase ( self ): """simple docstring""" return ConvNextConfig( num_channels=self.num_channels , num_stages=self.num_stages , hidden_sizes=self.hidden_sizes , depths=self.depths , is_training=self.is_training , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , out_features=self.out_features , ) def __lowercase ( self ): """simple docstring""" return UperNetConfig( backbone_config=self.get_backbone_config() , hidden_size=512 , pool_scales=[1, 2, 3, 6] , use_auxiliary_head=lowerCamelCase__ , auxiliary_loss_weight=0.4 , auxiliary_in_channels=40 , auxiliary_channels=256 , auxiliary_num_convs=1 , auxiliary_concat_input=lowerCamelCase__ , loss_ignore_index=255 , num_labels=self.num_labels , ) def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : str =UperNetForSemanticSegmentation(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __UpperCamelCase : Tuple =model(lowerCamelCase__ ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size, self.image_size) ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Tuple =self.prepare_config_and_inputs() ( ( __UpperCamelCase ) , ( __UpperCamelCase ) , ( __UpperCamelCase ) , ) : List[Any] =config_and_inputs __UpperCamelCase : Dict ={'pixel_values': pixel_values} return config, inputs_dict @require_torch class __A ( snake_case_ , snake_case_ , unittest.TestCase ): """simple docstring""" UpperCamelCase__ : str =(UperNetForSemanticSegmentation,) if is_torch_available() else () UpperCamelCase__ : Dict ={"""image-segmentation""": UperNetForSemanticSegmentation} if is_torch_available() else {} UpperCamelCase__ : int =False UpperCamelCase__ : List[str] =False UpperCamelCase__ : Union[str, Any] =False UpperCamelCase__ : str =False UpperCamelCase__ : List[Any] =False UpperCamelCase__ : Optional[Any] =False def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[Any] =UperNetModelTester(self ) __UpperCamelCase : Tuple =ConfigTester(self , config_class=lowerCamelCase__ , has_text_modality=lowerCamelCase__ , hidden_size=37 ) def __lowercase ( self ): """simple docstring""" self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def __lowercase ( self ): """simple docstring""" return def __lowercase ( self ): """simple docstring""" __UpperCamelCase , __UpperCamelCase : Union[str, Any] =self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __UpperCamelCase : List[Any] =model_class(lowerCamelCase__ ) __UpperCamelCase : List[str] =inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic __UpperCamelCase : Dict =[*signature.parameters.keys()] __UpperCamelCase : int =['pixel_values'] self.assertListEqual(arg_names[:1] , lowerCamelCase__ ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Dict =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase__ ) @unittest.skip(reason='UperNet does not use inputs_embeds' ) def __lowercase ( self ): """simple docstring""" pass @unittest.skip(reason='UperNet does not support input and output embeddings' ) def __lowercase ( self ): """simple docstring""" pass @unittest.skip(reason='UperNet does not have a base model' ) def __lowercase ( self ): """simple docstring""" pass @unittest.skip(reason='UperNet does not have a base model' ) def __lowercase ( self ): """simple docstring""" pass @require_torch_multi_gpu @unittest.skip(reason='UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' ) def __lowercase ( self ): """simple docstring""" pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def __lowercase ( self ): """simple docstring""" pass def __lowercase ( self ): """simple docstring""" def check_hidden_states_output(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): __UpperCamelCase : Optional[int] =model_class(lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() with torch.no_grad(): __UpperCamelCase : str =model(**self._prepare_for_class(lowerCamelCase__ , lowerCamelCase__ ) ) __UpperCamelCase : Optional[int] =outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states __UpperCamelCase : Any =self.model_tester.num_stages self.assertEqual(len(lowerCamelCase__ ) , expected_num_stages + 1 ) # ConvNext's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) __UpperCamelCase , __UpperCamelCase : Union[str, Any] =self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __UpperCamelCase : Dict =True check_hidden_states_output(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] __UpperCamelCase : List[str] =True check_hidden_states_output(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase , __UpperCamelCase : Tuple =self.model_tester.prepare_config_and_inputs_for_common() __UpperCamelCase : Union[str, Any] =_config_zero_init(lowerCamelCase__ ) __UpperCamelCase : Optional[int] =_config_zero_init(configs_no_init.backbone_config ) for model_class in self.all_model_classes: __UpperCamelCase : str =model_class(config=lowerCamelCase__ ) for name, param in model.named_parameters(): if param.requires_grad: self.assertIn( ((param.data.mean() * 1E9).round() / 1E9).item() , [0.0, 1.0] , msg=f'Parameter {name} of model {model_class} seems not properly initialized' , ) @unittest.skip(reason='UperNet does not have tied weights' ) def __lowercase ( self ): """simple docstring""" pass @slow def __lowercase ( self ): """simple docstring""" for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __UpperCamelCase : Optional[int] =UperNetForSemanticSegmentation.from_pretrained(lowerCamelCase__ ) self.assertIsNotNone(lowerCamelCase__ ) def A ( ) -> Dict: __UpperCamelCase : Optional[int] =hf_hub_download( repo_id='hf-internal-testing/fixtures_ade20k' ,repo_type='dataset' ,filename='ADE_val_00000001.jpg' ) __UpperCamelCase : Optional[int] =Image.open(lowerCamelCase__ ).convert('RGB' ) return image @require_torch @require_vision @slow class __A ( unittest.TestCase ): """simple docstring""" def __lowercase ( self ): """simple docstring""" __UpperCamelCase : str =AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny' ) __UpperCamelCase : Union[str, Any] =UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny' ).to(lowerCamelCase__ ) __UpperCamelCase : Union[str, Any] =prepare_img() __UpperCamelCase : Tuple =processor(images=lowerCamelCase__ , return_tensors='pt' ).to(lowerCamelCase__ ) with torch.no_grad(): __UpperCamelCase : List[Any] =model(**lowerCamelCase__ ) __UpperCamelCase : List[Any] =torch.Size((1, model.config.num_labels, 512, 512) ) self.assertEqual(outputs.logits.shape , lowerCamelCase__ ) __UpperCamelCase : List[Any] =torch.tensor( [[-7.5_958, -7.5_958, -7.4_302], [-7.5_958, -7.5_958, -7.4_302], [-7.4_797, -7.4_797, -7.3_068]] ).to(lowerCamelCase__ ) self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] , lowerCamelCase__ , atol=1E-4 ) ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : int =AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny' ) __UpperCamelCase : int =UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny' ).to(lowerCamelCase__ ) __UpperCamelCase : Dict =prepare_img() __UpperCamelCase : Union[str, Any] =processor(images=lowerCamelCase__ , return_tensors='pt' ).to(lowerCamelCase__ ) with torch.no_grad(): __UpperCamelCase : Any =model(**lowerCamelCase__ ) __UpperCamelCase : Optional[Any] =torch.Size((1, model.config.num_labels, 512, 512) ) self.assertEqual(outputs.logits.shape , lowerCamelCase__ ) __UpperCamelCase : List[str] =torch.tensor( [[-8.8_110, -8.8_110, -8.6_521], [-8.8_110, -8.8_110, -8.6_521], [-8.7_746, -8.7_746, -8.6_130]] ).to(lowerCamelCase__ ) self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] , lowerCamelCase__ , atol=1E-4 ) )
71
import unittest from transformers import is_torch_available 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 from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST, OpenAIGPTConfig, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , lowercase=13 , lowercase=7 , lowercase=True , lowercase=True , lowercase=True , lowercase=99 , lowercase=32 , lowercase=5 , lowercase=4 , lowercase=37 , lowercase="gelu" , lowercase=0.1 , lowercase=0.1 , lowercase=512 , lowercase=16 , lowercase=2 , lowercase=0.0_2 , lowercase=3 , lowercase=4 , lowercase=None , ) -> List[str]: lowerCamelCase_ = parent lowerCamelCase_ = batch_size lowerCamelCase_ = seq_length lowerCamelCase_ = is_training lowerCamelCase_ = use_token_type_ids lowerCamelCase_ = use_labels lowerCamelCase_ = vocab_size lowerCamelCase_ = hidden_size lowerCamelCase_ = num_hidden_layers lowerCamelCase_ = num_attention_heads lowerCamelCase_ = intermediate_size lowerCamelCase_ = hidden_act lowerCamelCase_ = hidden_dropout_prob lowerCamelCase_ = attention_probs_dropout_prob lowerCamelCase_ = max_position_embeddings lowerCamelCase_ = type_vocab_size lowerCamelCase_ = type_sequence_label_size lowerCamelCase_ = initializer_range lowerCamelCase_ = num_labels lowerCamelCase_ = num_choices lowerCamelCase_ = scope lowerCamelCase_ = self.vocab_size - 1 def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_token_type_ids: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = OpenAIGPTConfig( 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 , pad_token_id=self.pad_token_id , ) lowerCamelCase_ = ids_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, head_mask, token_type_ids, sequence_labels, token_labels, choice_labels, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTModel(config=lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , head_mask=lowercase ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = OpenAIGPTLMHeadModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTDoubleHeadsModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = OpenAIGPTForSequenceClassification(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = { "input_ids": input_ids, "token_type_ids": token_type_ids, "head_mask": head_mask, } return config, inputs_dict @require_torch class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification) if is_torch_available() else () ) lowerCAmelCase__ = ( (OpenAIGPTLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly lowerCAmelCase__ = ( { 'feature-extraction': OpenAIGPTModel, 'text-classification': OpenAIGPTForSequenceClassification, 'text-generation': OpenAIGPTLMHeadModel, 'zero-shot': OpenAIGPTForSequenceClassification, } if is_torch_available() else {} ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests": # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers. # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a # tiny config could not be created. return True return False def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=False ) -> Any: lowerCamelCase_ = super()._prepare_for_class(lowercase , lowercase , return_labels=lowercase ) if return_labels: if model_class.__name__ == "OpenAIGPTDoubleHeadsModel": lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowercase ) return inputs_dict def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = OpenAIGPTModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , n_embd=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_double_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Any: for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = OpenAIGPTModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @require_torch class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = OpenAIGPTLMHeadModel.from_pretrained("openai-gpt" ) model.to(lowercase ) lowerCamelCase_ = torch.tensor([[481, 4735, 544]] , dtype=torch.long , device=lowercase ) # the president is lowerCamelCase_ = [ 481, 4735, 544, 246, 963, 870, 762, 239, 244, 40477, 244, 249, 719, 881, 487, 544, 240, 244, 603, 481, ] # the president is a very good man. " \n " i\'m sure he is, " said the lowerCamelCase_ = model.generate(lowercase , do_sample=lowercase ) self.assertListEqual(output_ids[0].tolist() , lowercase )
19
0
'''simple docstring''' from functools import lru_cache @lru_cache def _A (lowerCAmelCase__ :List[str] ) -> Dict: '''simple docstring''' if num < 0: raise ValueError('Number should not be negative.' ) return 1 if num in (0, 1) else num * factorial(num - 1 ) if __name__ == "__main__": import doctest doctest.testmod()
168
__A ={str(digit): digit**5 for digit in range(1_0)} def lowerCamelCase_ ( lowerCamelCase__ ): return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCamelCase__ ) ) def lowerCamelCase_ ( ): return sum( number for number in range(1_0_0_0 , 1_0_0_0_0_0_0 ) if number == digits_fifth_powers_sum(lowerCamelCase__ ) ) if __name__ == "__main__": print(solution())
19
0
import os import unittest from huggingface_hub.utils import are_progress_bars_disabled import transformers.models.bart.tokenization_bart from transformers import logging from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context from transformers.utils.logging import disable_progress_bar, enable_progress_bar class __lowerCAmelCase ( unittest.TestCase ): def A__ ( self ) -> Optional[int]: '''simple docstring''' _lowercase =logging.get_logger() # the current default level is logging.WARNING _lowercase =logging.get_verbosity() logging.set_verbosity_error() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) logging.set_verbosity_warning() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) logging.set_verbosity_info() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) logging.set_verbosity_debug() self.assertEqual(logger.getEffectiveLevel() , logging.get_verbosity() ) # restore to the original level logging.set_verbosity(lowerCAmelCase ) def A__ ( self ) -> List[Any]: '''simple docstring''' _lowercase =logging.get_verbosity() _lowercase =logging.get_logger('transformers.models.bart.tokenization_bart' ) _lowercase ='Testing 1, 2, 3' # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`) if level_origin <= logging.WARNING: with CaptureLogger(lowerCAmelCase ) as cl: logger.warning(lowerCAmelCase ) self.assertEqual(cl.out , msg + '\n' ) # this is setting the level for all of `transformers.*` loggers logging.set_verbosity_error() # should not be able to log warnings with CaptureLogger(lowerCAmelCase ) as cl: logger.warning(lowerCAmelCase ) self.assertEqual(cl.out , '' ) # should be able to log warnings again logging.set_verbosity_warning() with CaptureLogger(lowerCAmelCase ) as cl: logger.warning(lowerCAmelCase ) self.assertEqual(cl.out , msg + '\n' ) # restore to the original level logging.set_verbosity(lowerCAmelCase ) @mockenv(TRANSFORMERS_VERBOSITY='error' ) def A__ ( self ) -> str: '''simple docstring''' transformers.utils.logging._reset_library_root_logger() # this action activates the env var _lowercase =logging.get_logger('transformers.models.bart.tokenization_bart' ) _lowercase =os.getenv('TRANSFORMERS_VERBOSITY' , lowerCAmelCase ) _lowercase =logging.log_levels[env_level_str] _lowercase =logging.get_verbosity() self.assertEqual( lowerCAmelCase , lowerCAmelCase , F'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}''' , ) # restore to the original level _lowercase ='' transformers.utils.logging._reset_library_root_logger() @mockenv(TRANSFORMERS_VERBOSITY='super-error' ) def A__ ( self ) -> int: '''simple docstring''' transformers.utils.logging._reset_library_root_logger() _lowercase =logging.logging.getLogger() with CaptureLogger(lowerCAmelCase ) as cl: # this action activates the env var logging.get_logger('transformers.models.bart.tokenization_bart' ) self.assertIn('Unknown option TRANSFORMERS_VERBOSITY=super-error' , cl.out ) # no need to restore as nothing was changed def A__ ( self ) -> Any: '''simple docstring''' transformers.utils.logging._reset_library_root_logger() _lowercase =logging.get_logger('transformers.models.bart.tokenization_bart' ) _lowercase ='Testing 1, 2, 3' with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='1' ): # nothing should be logged as env var disables this method with CaptureLogger(lowerCAmelCase ) as cl: logger.warning_advice(lowerCAmelCase ) self.assertEqual(cl.out , '' ) with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='' ): # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset with CaptureLogger(lowerCAmelCase ) as cl: logger.warning_advice(lowerCAmelCase ) self.assertEqual(cl.out , msg + '\n' ) def a ( ) -> Optional[int]: """simple docstring""" disable_progress_bar() assert are_progress_bars_disabled() enable_progress_bar() assert not are_progress_bars_disabled()
205
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 YolosConfig, YolosForObjectDetection, YolosImageProcessor from transformers.utils import logging logging.set_verbosity_info() __A =logging.get_logger(__name__) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = YolosConfig() # size of the architecture if "yolos_ti" in yolos_name: lowerCamelCase_ = 1_9_2 lowerCamelCase_ = 7_6_8 lowerCamelCase_ = 1_2 lowerCamelCase_ = 3 lowerCamelCase_ = [8_0_0, 1_3_3_3] lowerCamelCase_ = False elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = 3_3_0 lowerCamelCase_ = 1_4 lowerCamelCase_ = 6 lowerCamelCase_ = 1_3_2_0 elif "yolos_s" in yolos_name: lowerCamelCase_ = 3_8_4 lowerCamelCase_ = 1_5_3_6 lowerCamelCase_ = 1_2 lowerCamelCase_ = 6 elif "yolos_b" in yolos_name: lowerCamelCase_ = [8_0_0, 1_3_4_4] lowerCamelCase_ = 9_1 lowerCamelCase_ = "huggingface/label-files" lowerCamelCase_ = "coco-detection-id2label.json" lowerCamelCase_ = json.load(open(hf_hub_download(lowerCamelCase__ , lowerCamelCase__ , repo_type="dataset" ) , "r" ) ) lowerCamelCase_ = {int(lowerCamelCase__ ): v for k, v in idalabel.items()} lowerCamelCase_ = idalabel lowerCamelCase_ = {v: k for k, v in idalabel.items()} return config def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.weight' ) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.bias' ) # next, add query, keys and values (in that order) to the state dict lowerCamelCase_ = in_proj_weight[: config.hidden_size, :] lowerCamelCase_ = in_proj_bias[: config.hidden_size] lowerCamelCase_ = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] lowerCamelCase_ = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] lowerCamelCase_ = in_proj_weight[-config.hidden_size :, :] lowerCamelCase_ = in_proj_bias[-config.hidden_size :] def lowerCamelCase_ ( lowerCamelCase__ ): if "backbone" in name: lowerCamelCase_ = name.replace("backbone" , "vit" ) if "cls_token" in name: lowerCamelCase_ = name.replace("cls_token" , "embeddings.cls_token" ) if "det_token" in name: lowerCamelCase_ = name.replace("det_token" , "embeddings.detection_tokens" ) if "mid_pos_embed" in name: lowerCamelCase_ = name.replace("mid_pos_embed" , "encoder.mid_position_embeddings" ) if "pos_embed" in name: lowerCamelCase_ = name.replace("pos_embed" , "embeddings.position_embeddings" ) if "patch_embed.proj" in name: lowerCamelCase_ = name.replace("patch_embed.proj" , "embeddings.patch_embeddings.projection" ) if "blocks" in name: lowerCamelCase_ = name.replace("blocks" , "encoder.layer" ) if "attn.proj" in name: lowerCamelCase_ = name.replace("attn.proj" , "attention.output.dense" ) if "attn" in name: lowerCamelCase_ = name.replace("attn" , "attention.self" ) if "norm1" in name: lowerCamelCase_ = name.replace("norm1" , "layernorm_before" ) if "norm2" in name: lowerCamelCase_ = name.replace("norm2" , "layernorm_after" ) if "mlp.fc1" in name: lowerCamelCase_ = name.replace("mlp.fc1" , "intermediate.dense" ) if "mlp.fc2" in name: lowerCamelCase_ = name.replace("mlp.fc2" , "output.dense" ) if "class_embed" in name: lowerCamelCase_ = name.replace("class_embed" , "class_labels_classifier" ) if "bbox_embed" in name: lowerCamelCase_ = name.replace("bbox_embed" , "bbox_predictor" ) if "vit.norm" in name: lowerCamelCase_ = name.replace("vit.norm" , "vit.layernorm" ) return name def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): for key in orig_state_dict.copy().keys(): lowerCamelCase_ = orig_state_dict.pop(lowerCamelCase__ ) if "qkv" in key: lowerCamelCase_ = key.split("." ) lowerCamelCase_ = int(key_split[2] ) lowerCamelCase_ = model.vit.encoder.layer[layer_num].attention.attention.all_head_size if "weight" in key: lowerCamelCase_ = val[:dim, :] lowerCamelCase_ = val[ dim : dim * 2, : ] lowerCamelCase_ = val[-dim:, :] else: lowerCamelCase_ = val[:dim] lowerCamelCase_ = val[dim : dim * 2] lowerCamelCase_ = val[-dim:] else: lowerCamelCase_ = val return orig_state_dict def lowerCamelCase_ ( ): lowerCamelCase_ = "http://images.cocodataset.org/val2017/000000039769.jpg" lowerCamelCase_ = Image.open(requests.get(lowerCamelCase__ , stream=lowerCamelCase__ ).raw ) return im @torch.no_grad() def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): lowerCamelCase_ = get_yolos_config(lowerCamelCase__ ) # load original state_dict lowerCamelCase_ = torch.load(lowerCamelCase__ , map_location="cpu" )["model"] # load 🤗 model lowerCamelCase_ = YolosForObjectDetection(lowerCamelCase__ ) model.eval() lowerCamelCase_ = convert_state_dict(lowerCamelCase__ , lowerCamelCase__ ) model.load_state_dict(lowerCamelCase__ ) # Check outputs on an image, prepared by YolosImageProcessor lowerCamelCase_ = 8_0_0 if yolos_name != "yolos_ti" else 5_1_2 lowerCamelCase_ = YolosImageProcessor(format="coco_detection" , size=lowerCamelCase__ ) lowerCamelCase_ = image_processor(images=prepare_img() , return_tensors="pt" ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = outputs.logits, outputs.pred_boxes lowerCamelCase_ , lowerCamelCase_ = None, None if yolos_name == "yolos_ti": lowerCamelCase_ = torch.tensor( [[-39.50_22, -11.98_20, -17.68_88], [-29.95_74, -9.97_69, -17.76_91], [-42.32_81, -20.72_00, -30.62_94]] ) lowerCamelCase_ = torch.tensor( [[0.40_21, 0.08_36, 0.79_79], [0.01_84, 0.26_09, 0.03_64], [0.17_81, 0.20_04, 0.20_95]] ) elif yolos_name == "yolos_s_200_pre": lowerCamelCase_ = torch.tensor( [[-24.02_48, -10.30_24, -14.82_90], [-42.03_92, -16.82_00, -27.43_34], [-27.27_43, -11.81_54, -18.71_48]] ) lowerCamelCase_ = torch.tensor( [[0.25_59, 0.54_55, 0.47_06], [0.29_89, 0.72_79, 0.18_75], [0.77_32, 0.40_17, 0.44_62]] ) elif yolos_name == "yolos_s_300_pre": lowerCamelCase_ = torch.tensor( [[-36.22_20, -14.43_85, -23.54_57], [-35.69_70, -14.75_83, -21.39_35], [-31.59_39, -13.60_42, -16.80_49]] ) lowerCamelCase_ = torch.tensor( [[0.76_14, 0.23_16, 0.47_28], [0.71_68, 0.44_95, 0.38_55], [0.49_96, 0.14_66, 0.99_96]] ) elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = torch.tensor( [[-42.86_68, -24.10_49, -41.16_90], [-34.74_56, -14.12_74, -24.91_94], [-33.78_98, -12.19_46, -25.64_95]] ) lowerCamelCase_ = torch.tensor( [[0.55_87, 0.27_73, 0.06_05], [0.50_04, 0.30_14, 0.99_94], [0.49_99, 0.15_48, 0.99_94]] ) elif yolos_name == "yolos_base": lowerCamelCase_ = torch.tensor( [[-40.60_64, -24.30_84, -32.64_47], [-55.19_90, -30.77_19, -35.58_77], [-51.43_11, -33.35_07, -35.64_62]] ) lowerCamelCase_ = torch.tensor( [[0.55_55, 0.27_94, 0.06_55], [0.90_49, 0.26_64, 0.18_94], [0.91_83, 0.19_84, 0.16_35]] ) else: raise ValueError(F'Unknown yolos_name: {yolos_name}' ) assert torch.allclose(logits[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) assert torch.allclose(pred_boxes[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) Path(lowerCamelCase__ ).mkdir(exist_ok=lowerCamelCase__ ) print(F'Saving model {yolos_name} to {pytorch_dump_folder_path}' ) model.save_pretrained(lowerCamelCase__ ) print(F'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(lowerCamelCase__ ) if push_to_hub: lowerCamelCase_ = { "yolos_ti": "yolos-tiny", "yolos_s_200_pre": "yolos-small", "yolos_s_300_pre": "yolos-small-300", "yolos_s_dWr": "yolos-small-dwr", "yolos_base": "yolos-base", } print("Pushing to the hub..." ) lowerCamelCase_ = model_mapping[yolos_name] image_processor.push_to_hub(lowerCamelCase__ , organization="hustvl" ) model.push_to_hub(lowerCamelCase__ , organization="hustvl" ) if __name__ == "__main__": __A =argparse.ArgumentParser() # Required parameters parser.add_argument( '''--yolos_name''', default='''yolos_s_200_pre''', type=str, help=( '''Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\',''' ''' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.''' ), ) parser.add_argument( '''--checkpoint_path''', default=None, type=str, help='''Path to the original state dict (.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.''' ) __A =parser.parse_args() convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
19
0
from collections import defaultdict from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst def _UpperCAmelCase (): _A , _A : Tuple = 9, 14 # noqa: F841 _A : Optional[int] = [ [0, 1, 4], [0, 7, 8], [1, 2, 8], [7, 8, 7], [7, 6, 1], [2, 8, 2], [8, 6, 6], [2, 3, 7], [2, 5, 4], [6, 5, 2], [3, 5, 14], [3, 4, 9], [5, 4, 10], [1, 7, 11], ] _A : Optional[Any] = defaultdict(lowerCamelCase__ ) for nodea, nodea, cost in edges: adjancency[nodea].append([nodea, cost] ) adjancency[nodea].append([nodea, cost] ) _A : Union[str, Any] = mst(lowerCamelCase__ ) _A : List[str] = [ [7, 6, 1], [2, 8, 2], [6, 5, 2], [0, 1, 4], [2, 5, 4], [2, 3, 7], [0, 7, 8], [3, 4, 9], ] for answer in expected: _A : str = tuple(answer[:2] ) _A : str = tuple(edge[::-1] ) assert edge in result or reverse in result
11
def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [0 for i in range(r + 1 )] # nc0 = 1 lowerCamelCase_ = 1 for i in range(1 , n + 1 ): # to compute current row from previous row. lowerCamelCase_ = min(lowerCamelCase__ , lowerCamelCase__ ) while j > 0: c[j] += c[j - 1] j -= 1 return c[r] print(binomial_coefficient(n=1_0, r=5))
19
0
'''simple docstring''' import copy from ...configuration_utils import PretrainedConfig from ...utils import add_start_docstrings __UpperCAmelCase =R"\n [`RagConfig`] stores the configuration of a *RagModel*. Configuration objects inherit from [`PretrainedConfig`] and\n can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information.\n\n Args:\n title_sep (`str`, *optional*, defaults to `\" / \"`):\n Separator inserted between the title and the text of the retrieved document when calling [`RagRetriever`].\n doc_sep (`str`, *optional*, defaults to `\" // \"`):\n Separator inserted between the text of the retrieved document and the original input when calling\n [`RagRetriever`].\n n_docs (`int`, *optional*, defaults to 5):\n Number of documents to retrieve.\n max_combined_length (`int`, *optional*, defaults to 300):\n Max length of contextualized input returned by [`~RagRetriever.__call__`].\n retrieval_vector_size (`int`, *optional*, defaults to 768):\n Dimensionality of the document embeddings indexed by [`RagRetriever`].\n retrieval_batch_size (`int`, *optional*, defaults to 8):\n Retrieval batch size, defined as the number of queries issues concurrently to the faiss index encapsulated\n [`RagRetriever`].\n dataset (`str`, *optional*, defaults to `\"wiki_dpr\"`):\n A dataset identifier of the indexed dataset in HuggingFace Datasets (list all available datasets and ids\n using `datasets.list_datasets()`).\n dataset_split (`str`, *optional*, defaults to `\"train\"`)\n Which split of the `dataset` to load.\n index_name (`str`, *optional*, defaults to `\"compressed\"`)\n The index name of the index associated with the `dataset`. One can choose between `\"legacy\"`, `\"exact\"` and\n `\"compressed\"`.\n index_path (`str`, *optional*)\n The path to the serialized faiss index on disk.\n passages_path (`str`, *optional*):\n A path to text passages compatible with the faiss index. Required if using\n [`~models.rag.retrieval_rag.LegacyIndex`]\n use_dummy_dataset (`bool`, *optional*, defaults to `False`)\n Whether to load a \"dummy\" variant of the dataset specified by `dataset`.\n label_smoothing (`float`, *optional*, defaults to 0.0):\n Only relevant if `return_loss` is set to `True`. Controls the `epsilon` parameter value for label smoothing\n in the loss calculation. If set to 0, no label smoothing is performed.\n do_marginalize (`bool`, *optional*, defaults to `False`):\n If `True`, the logits are marginalized over all documents by making use of\n `torch.nn.functional.log_softmax`.\n reduce_loss (`bool`, *optional*, defaults to `False`):\n Whether or not to reduce the NLL loss using the `torch.Tensor.sum` operation.\n do_deduplication (`bool`, *optional*, defaults to `True`):\n Whether or not to deduplicate the generations from different context documents for a given input. Has to be\n set to `False` if used while training with distributed backend.\n exclude_bos_score (`bool`, *optional*, defaults to `False`):\n Whether or not to disregard the BOS token when computing the loss.\n output_retrieved(`bool`, *optional*, defaults to `False`):\n If set to `True`, `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` and\n `context_attention_mask` are returned. See returned tensors for more detail.\n use_cache (`bool`, *optional*, defaults to `True`):\n Whether or not the model should return the last key/values attentions (not used by all models).\n forced_eos_token_id (`int`, *optional*):\n The id of the token to force as the last generated token when `max_length` is reached. Usually set to\n `eos_token_id`.\n" @add_start_docstrings(snake_case_ ) class a__ ( snake_case_ ): lowerCamelCase : Optional[int] ="rag" lowerCamelCase : Optional[Any] =True def __init__( self : Dict , a : Tuple=None , a : str=True , a : List[str]=None , a : Union[str, Any]=None , a : Tuple=None , a : Optional[Any]=None , a : int=None , a : Union[str, Any]=" / " , a : Optional[Any]=" // " , a : int=5 , a : Optional[int]=3_00 , a : Dict=7_68 , a : Optional[int]=8 , a : List[Any]="wiki_dpr" , a : Optional[Any]="train" , a : Dict="compressed" , a : Any=None , a : Optional[int]=None , a : Tuple=False , a : Tuple=False , a : Dict=0.0 , a : Optional[Any]=True , a : List[str]=False , a : Any=False , a : List[str]=False , a : Dict=True , a : int=None , **a : Optional[Any] , ): """simple docstring""" super().__init__( bos_token_id=a , pad_token_id=a , eos_token_id=a , decoder_start_token_id=a , forced_eos_token_id=a , is_encoder_decoder=a , prefix=a , vocab_size=a , **a , ) assert ( "question_encoder" in kwargs and "generator" in kwargs ), "Config has to be initialized with question_encoder and generator config" __lowerCamelCase = kwargs.pop('''question_encoder''' ) __lowerCamelCase = question_encoder_config.pop('''model_type''' ) __lowerCamelCase = kwargs.pop('''generator''' ) __lowerCamelCase = decoder_config.pop('''model_type''' ) from ..auto.configuration_auto import AutoConfig __lowerCamelCase = AutoConfig.for_model(a , **a ) __lowerCamelCase = AutoConfig.for_model(a , **a ) __lowerCamelCase = reduce_loss __lowerCamelCase = label_smoothing __lowerCamelCase = exclude_bos_score __lowerCamelCase = do_marginalize __lowerCamelCase = title_sep __lowerCamelCase = doc_sep __lowerCamelCase = n_docs __lowerCamelCase = max_combined_length __lowerCamelCase = dataset __lowerCamelCase = dataset_split __lowerCamelCase = index_name __lowerCamelCase = retrieval_vector_size __lowerCamelCase = retrieval_batch_size __lowerCamelCase = passages_path __lowerCamelCase = index_path __lowerCamelCase = use_dummy_dataset __lowerCamelCase = output_retrieved __lowerCamelCase = do_deduplication __lowerCamelCase = use_cache if self.forced_eos_token_id is None: __lowerCamelCase = getattr(self.generator , '''forced_eos_token_id''' , a ) @classmethod def SCREAMING_SNAKE_CASE__ ( cls : Tuple , a : Optional[Any] , a : Optional[int] , **a : List[Any] ): """simple docstring""" return cls(question_encoder=question_encoder_config.to_dict() , generator=generator_config.to_dict() , **a ) def SCREAMING_SNAKE_CASE__ ( self : str ): """simple docstring""" __lowerCamelCase = copy.deepcopy(self.__dict__ ) __lowerCamelCase = self.question_encoder.to_dict() __lowerCamelCase = self.generator.to_dict() __lowerCamelCase = self.__class__.model_type return output
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): if 0 not in (x, y): # We use the relation x^y = y*log10(x), where 10 is the base. return y * math.logaa(lowerCamelCase__ ) else: if x == 0: # 0 raised to any number is 0 return 0 elif y == 0: return 1 # any number raised to 0 is 1 raise AssertionError("This should never happen" ) if __name__ == "__main__": # Main function # Read two numbers from input and typecast them to int using map function. # Here x is the base and y is the power. __A ='''Enter the base and the power separated by a comma: ''' __A, __A =map(int, input(prompt).split(''',''')) __A, __A =map(int, input(prompt).split(''',''')) # We find the log of each number, using the function res(), which takes two # arguments. __A =res(xa, ya) __A =res(xa, ya) # We check for the largest number if resa > resa: print('''Largest number is''', xa, '''^''', ya) elif resa > resa: print('''Largest number is''', xa, '''^''', ya) else: print('''Both are equal''')
19
0
import os import unicodedata from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import SPIECE_UNDERLINE, logging SCREAMING_SNAKE_CASE :Dict = logging.get_logger(__name__) SCREAMING_SNAKE_CASE :int = {'''vocab_file''': '''spiece.model'''} SCREAMING_SNAKE_CASE :List[str] = { '''vocab_file''': { '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model''', '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model''', } } SCREAMING_SNAKE_CASE :int = { '''xlnet-base-cased''': None, '''xlnet-large-cased''': None, } # Segments (not really needed) SCREAMING_SNAKE_CASE :str = 0 SCREAMING_SNAKE_CASE :Dict = 1 SCREAMING_SNAKE_CASE :Tuple = 2 SCREAMING_SNAKE_CASE :int = 3 SCREAMING_SNAKE_CASE :Optional[int] = 4 class __lowerCAmelCase ( snake_case_ ): """simple docstring""" _SCREAMING_SNAKE_CASE = VOCAB_FILES_NAMES _SCREAMING_SNAKE_CASE = PRETRAINED_VOCAB_FILES_MAP _SCREAMING_SNAKE_CASE = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _SCREAMING_SNAKE_CASE = 'left' def __init__( self : Tuple , _lowerCAmelCase : Dict , _lowerCAmelCase : Dict=False , _lowerCAmelCase : str=True , _lowerCAmelCase : List[Any]=False , _lowerCAmelCase : Optional[int]="<s>" , _lowerCAmelCase : List[Any]="</s>" , _lowerCAmelCase : List[str]="<unk>" , _lowerCAmelCase : Any="<sep>" , _lowerCAmelCase : str="<pad>" , _lowerCAmelCase : Any="<cls>" , _lowerCAmelCase : Any="<mask>" , _lowerCAmelCase : Tuple=["<eop>", "<eod>"] , _lowerCAmelCase : List[str] = None , **_lowerCAmelCase : str , ) -> None: """simple docstring""" # Mask token behave like a normal word, i.e. include the space before it snake_case_ = AddedToken(_lowerCAmelCase , lstrip=_lowerCAmelCase , rstrip=_lowerCAmelCase ) if isinstance(_lowerCAmelCase , _lowerCAmelCase ) else mask_token snake_case_ = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=_lowerCAmelCase , remove_space=_lowerCAmelCase , keep_accents=_lowerCAmelCase , bos_token=_lowerCAmelCase , eos_token=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , additional_special_tokens=_lowerCAmelCase , sp_model_kwargs=self.sp_model_kwargs , **_lowerCAmelCase , ) snake_case_ = 3 snake_case_ = do_lower_case snake_case_ = remove_space snake_case_ = keep_accents snake_case_ = vocab_file snake_case_ = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(_lowerCAmelCase ) @property def lowerCAmelCase__ ( self : Union[str, Any] ) -> int: """simple docstring""" return len(self.sp_model ) def lowerCAmelCase__ ( self : List[Any] ) -> Optional[int]: """simple docstring""" snake_case_ = {self.convert_ids_to_tokens(_lowerCAmelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : Union[str, Any] ) -> str: """simple docstring""" snake_case_ = self.__dict__.copy() snake_case_ = None return state def __setstate__( self : Union[str, Any] , _lowerCAmelCase : Optional[int] ) -> Optional[Any]: """simple docstring""" snake_case_ = d # for backward compatibility if not hasattr(self , "sp_model_kwargs" ): snake_case_ = {} snake_case_ = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def lowerCAmelCase__ ( self : str , _lowerCAmelCase : Optional[int] ) -> Any: """simple docstring""" if self.remove_space: snake_case_ = " ".join(inputs.strip().split() ) else: snake_case_ = inputs snake_case_ = outputs.replace("``" , "\"" ).replace("''" , "\"" ) if not self.keep_accents: snake_case_ = unicodedata.normalize("NFKD" , _lowerCAmelCase ) snake_case_ = "".join([c for c in outputs if not unicodedata.combining(_lowerCAmelCase )] ) if self.do_lower_case: snake_case_ = outputs.lower() return outputs def lowerCAmelCase__ ( self : Optional[Any] , _lowerCAmelCase : Any ) -> List[str]: """simple docstring""" snake_case_ = self.preprocess_text(_lowerCAmelCase ) snake_case_ = self.sp_model.encode(_lowerCAmelCase , out_type=_lowerCAmelCase ) snake_case_ = [] for piece in pieces: if len(_lowerCAmelCase ) > 1 and piece[-1] == str("," ) and piece[-2].isdigit(): snake_case_ = self.sp_model.EncodeAsPieces(piece[:-1].replace(_lowerCAmelCase , "" ) ) if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE: if len(cur_pieces[0] ) == 1: snake_case_ = cur_pieces[1:] else: snake_case_ = cur_pieces[0][1:] cur_pieces.append(piece[-1] ) new_pieces.extend(_lowerCAmelCase ) else: new_pieces.append(_lowerCAmelCase ) return new_pieces def lowerCAmelCase__ ( self : Union[str, Any] , _lowerCAmelCase : Union[str, Any] ) -> Union[str, Any]: """simple docstring""" return self.sp_model.PieceToId(_lowerCAmelCase ) def lowerCAmelCase__ ( self : Tuple , _lowerCAmelCase : Union[str, Any] ) -> List[Any]: """simple docstring""" return self.sp_model.IdToPiece(_lowerCAmelCase ) def lowerCAmelCase__ ( self : Union[str, Any] , _lowerCAmelCase : int ) -> Tuple: """simple docstring""" snake_case_ = "".join(_lowerCAmelCase ).replace(_lowerCAmelCase , " " ).strip() return out_string def lowerCAmelCase__ ( self : Optional[int] , _lowerCAmelCase : Any , _lowerCAmelCase : Dict = False , _lowerCAmelCase : Any = None , _lowerCAmelCase : Any = True , **_lowerCAmelCase : List[Any] , ) -> str: """simple docstring""" snake_case_ = kwargs.pop("use_source_tokenizer" , _lowerCAmelCase ) snake_case_ = self.convert_ids_to_tokens(_lowerCAmelCase , skip_special_tokens=_lowerCAmelCase ) # To avoid mixing byte-level and unicode for byte-level BPT # we need to build string separately for added tokens and byte-level tokens # cf. https://github.com/huggingface/transformers/issues/1133 snake_case_ = [] snake_case_ = [] for token in filtered_tokens: if skip_special_tokens and token in self.all_special_ids: continue if token in self.added_tokens_encoder: if current_sub_text: sub_texts.append(self.convert_tokens_to_string(_lowerCAmelCase ) ) snake_case_ = [] sub_texts.append(_lowerCAmelCase ) else: current_sub_text.append(_lowerCAmelCase ) if current_sub_text: sub_texts.append(self.convert_tokens_to_string(_lowerCAmelCase ) ) # Mimic the behavior of the Rust tokenizer: # By default, there are no spaces between special tokens snake_case_ = "".join(_lowerCAmelCase ) snake_case_ = ( clean_up_tokenization_spaces if clean_up_tokenization_spaces is not None else self.clean_up_tokenization_spaces ) if clean_up_tokenization_spaces: snake_case_ = self.clean_up_tokenization(_lowerCAmelCase ) return clean_text else: return text def lowerCAmelCase__ ( self : Optional[Any] , _lowerCAmelCase : Tuple , _lowerCAmelCase : List[str] = None ) -> List[int]: """simple docstring""" snake_case_ = [self.sep_token_id] snake_case_ = [self.cls_token_id] if token_ids_a is None: return token_ids_a + sep + cls return token_ids_a + sep + token_ids_a + sep + cls def lowerCAmelCase__ ( self : Union[str, Any] , _lowerCAmelCase : Dict , _lowerCAmelCase : str = None , _lowerCAmelCase : int = False ) -> List[int]: """simple docstring""" if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=_lowerCAmelCase , token_ids_a=_lowerCAmelCase , already_has_special_tokens=_lowerCAmelCase ) if token_ids_a is not None: return ([0] * len(_lowerCAmelCase )) + [1] + ([0] * len(_lowerCAmelCase )) + [1, 1] return ([0] * len(_lowerCAmelCase )) + [1, 1] def lowerCAmelCase__ ( self : Optional[int] , _lowerCAmelCase : str , _lowerCAmelCase : Tuple = None ) -> List[int]: """simple docstring""" snake_case_ = [self.sep_token_id] snake_case_ = [2] if token_ids_a is None: return len(token_ids_a + sep ) * [0] + cls_segment_id return len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] + cls_segment_id def lowerCAmelCase__ ( self : List[str] , _lowerCAmelCase : str , _lowerCAmelCase : Dict = None ) -> Tuple[str]: """simple docstring""" if not os.path.isdir(_lowerCAmelCase ): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' ) return snake_case_ = os.path.join( _lowerCAmelCase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_lowerCAmelCase ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , _lowerCAmelCase ) elif not os.path.isfile(self.vocab_file ): with open(_lowerCAmelCase , "wb" ) as fi: snake_case_ = self.sp_model.serialized_model_proto() fi.write(_lowerCAmelCase ) return (out_vocab_file,)
159
import os import time from dataclasses import dataclass, field from enum import Enum from typing import Dict, List, Optional, Union import torch from filelock import FileLock from torch.utils.data import Dataset from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features __A =logging.get_logger(__name__) __A =list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys()) __A =tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) @dataclass class _SCREAMING_SNAKE_CASE : lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Model type selected in the list: ' + ', '.join(snake_case_ )} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'The input data dir. Should contain the .json files for the SQuAD task.'} ) lowerCAmelCase__ = field( default=1_28 , metadata={ 'help': ( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) } , ) lowerCAmelCase__ = field( default=1_28 , metadata={'help': 'When splitting up a long document into chunks, how much stride to take between chunks.'} , ) lowerCAmelCase__ = field( default=64 , metadata={ 'help': ( 'The maximum number of tokens for the question. Questions longer than this will ' 'be truncated to this length.' ) } , ) lowerCAmelCase__ = field( default=30 , metadata={ 'help': ( 'The maximum length of an answer that can be generated. This is needed because the start ' 'and end predictions are not conditioned on one another.' ) } , ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Overwrite the cached training and evaluation sets'} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'If true, the SQuAD examples contain some that do not have an answer.'} ) lowerCAmelCase__ = field( default=0.0 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=20 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=0 , metadata={ 'help': ( 'language id of input for language-specific xlm models (see' ' tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)' ) } , ) lowerCAmelCase__ = field(default=1 , metadata={'help': 'multiple threads for converting example to features'} ) class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 'train' lowerCAmelCase__ = 'dev' class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 def __init__( self , lowercase , lowercase , lowercase = None , lowercase = Split.train , lowercase = False , lowercase = None , lowercase = "pt" , ) -> List[str]: lowerCamelCase_ = args lowerCamelCase_ = is_language_sensitive lowerCamelCase_ = SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor() if isinstance(lowercase , lowercase ): try: lowerCamelCase_ = Split[mode] except KeyError: raise KeyError("mode is not a valid split name" ) lowerCamelCase_ = mode # Load data features from cache or dataset file lowerCamelCase_ = "v2" if args.version_2_with_negative else "v1" lowerCamelCase_ = os.path.join( cache_dir if cache_dir is not None else args.data_dir , f'cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}' , ) # Make sure only the first process in distributed training processes the dataset, # and the others will use the cache. lowerCamelCase_ = cached_features_file + ".lock" with FileLock(lowercase ): if os.path.exists(lowercase ) and not args.overwrite_cache: lowerCamelCase_ = time.time() lowerCamelCase_ = torch.load(lowercase ) # Legacy cache files have only features, while new cache files # will have dataset and examples also. lowerCamelCase_ = self.old_features["features"] lowerCamelCase_ = self.old_features.get("dataset" , lowercase ) lowerCamelCase_ = self.old_features.get("examples" , lowercase ) logger.info( f'Loading features from cached file {cached_features_file} [took %.3f s]' , time.time() - start ) if self.dataset is None or self.examples is None: logger.warning( f'Deleting cached file {cached_features_file} will allow dataset and examples to be cached in' " future run" ) else: if mode == Split.dev: lowerCamelCase_ = self.processor.get_dev_examples(args.data_dir ) else: lowerCamelCase_ = self.processor.get_train_examples(args.data_dir ) lowerCamelCase_ , lowerCamelCase_ = squad_convert_examples_to_features( examples=self.examples , tokenizer=lowercase , max_seq_length=args.max_seq_length , doc_stride=args.doc_stride , max_query_length=args.max_query_length , is_training=mode == Split.train , threads=args.threads , return_dataset=lowercase , ) lowerCamelCase_ = time.time() torch.save( {"features": self.features, "dataset": self.dataset, "examples": self.examples} , lowercase , ) # ^ This seems to take a lot of time so I want to investigate why and how we can improve. logger.info( f'Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]' ) def __len__( self ) -> Tuple: return len(self.features ) def __getitem__( self , lowercase ) -> Dict[str, torch.Tensor]: # Convert to Tensors and build dataset lowerCamelCase_ = self.features[i] lowerCamelCase_ = torch.tensor(feature.input_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.attention_mask , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.token_type_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.cls_index , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.p_mask , dtype=torch.float ) lowerCamelCase_ = torch.tensor(feature.is_impossible , dtype=torch.float ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": attention_mask, "token_type_ids": token_type_ids, } if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]: del inputs["token_type_ids"] if self.args.model_type in ["xlnet", "xlm"]: inputs.update({"cls_index": cls_index, "p_mask": p_mask} ) if self.args.version_2_with_negative: inputs.update({"is_impossible": is_impossible} ) if self.is_language_sensitive: inputs.update({"langs": (torch.ones(input_ids.shape , dtype=torch.intaa ) * self.args.lang_id)} ) if self.mode == Split.train: lowerCamelCase_ = torch.tensor(feature.start_position , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.end_position , dtype=torch.long ) inputs.update({"start_positions": start_positions, "end_positions": end_positions} ) return inputs
19
0
"""simple docstring""" import random def _lowerCamelCase ( _UpperCamelCase ): '''simple docstring''' __lowerCAmelCase = num - 1 __lowerCAmelCase = 0 while s % 2 == 0: __lowerCAmelCase = s // 2 t += 1 for _ in range(5 ): __lowerCAmelCase = random.randrange(2 , num - 1 ) __lowerCAmelCase = pow(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if v != 1: __lowerCAmelCase = 0 while v != (num - 1): if i == t - 1: return False else: __lowerCAmelCase = i + 1 __lowerCAmelCase = (v**2) % num return True def _lowerCamelCase ( _UpperCamelCase ): '''simple docstring''' if num < 2: return False __lowerCAmelCase = [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, ] if num in low_primes: return True for prime in low_primes: if (num % prime) == 0: return False return rabin_miller(lowerCamelCase__ ) def _lowerCamelCase ( _UpperCamelCase = 1024 ): '''simple docstring''' while True: __lowerCAmelCase = random.randrange(2 ** (keysize - 1) , 2 ** (keysize) ) if is_prime_low_num(lowerCamelCase__ ): return num if __name__ == "__main__": A : Optional[int] = generate_large_prime() print(("Prime number:", num)) print(("is_prime_low_num:", is_prime_low_num(num)))
57
from abc import ABC, abstractmethod from argparse import ArgumentParser class _SCREAMING_SNAKE_CASE ( snake_case_ ): @staticmethod @abstractmethod def SCREAMING_SNAKE_CASE_( lowercase ) -> int: raise NotImplementedError() @abstractmethod def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: raise NotImplementedError()
19
0
import inspect from typing import Optional, Union import numpy as np import PIL import torch from torch.nn import functional as F from torchvision import transforms from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, DPMSolverMultistepScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.utils import ( PIL_INTERPOLATION, randn_tensor, ) def __lowercase ( a__ , a__ , a__ ) -> str: if isinstance(lowerCamelCase__ , torch.Tensor ): return image elif isinstance(lowerCamelCase__ , PIL.Image.Image ): __SCREAMING_SNAKE_CASE = [image] if isinstance(image[0] , PIL.Image.Image ): __SCREAMING_SNAKE_CASE = [np.array(i.resize((w, h) , resample=PIL_INTERPOLATION['lanczos'] ) )[None, :] for i in image] __SCREAMING_SNAKE_CASE = np.concatenate(lowerCamelCase__ , axis=0 ) __SCREAMING_SNAKE_CASE = np.array(lowerCamelCase__ ).astype(np.floataa ) / 2_55.0 __SCREAMING_SNAKE_CASE = image.transpose(0 , 3 , 1 , 2 ) __SCREAMING_SNAKE_CASE = 2.0 * image - 1.0 __SCREAMING_SNAKE_CASE = torch.from_numpy(lowerCamelCase__ ) elif isinstance(image[0] , torch.Tensor ): __SCREAMING_SNAKE_CASE = torch.cat(lowerCamelCase__ , dim=0 ) return image def __lowercase ( a__ , a__ , a__ , a__=0.9995 ) -> Tuple: if not isinstance(lowerCamelCase__ , np.ndarray ): __SCREAMING_SNAKE_CASE = True __SCREAMING_SNAKE_CASE = va.device __SCREAMING_SNAKE_CASE = va.cpu().numpy() __SCREAMING_SNAKE_CASE = va.cpu().numpy() __SCREAMING_SNAKE_CASE = np.sum(va * va / (np.linalg.norm(lowerCamelCase__ ) * np.linalg.norm(lowerCamelCase__ )) ) if np.abs(lowerCamelCase__ ) > DOT_THRESHOLD: __SCREAMING_SNAKE_CASE = (1 - t) * va + t * va else: __SCREAMING_SNAKE_CASE = np.arccos(lowerCamelCase__ ) __SCREAMING_SNAKE_CASE = np.sin(lowerCamelCase__ ) __SCREAMING_SNAKE_CASE = theta_a * t __SCREAMING_SNAKE_CASE = np.sin(lowerCamelCase__ ) __SCREAMING_SNAKE_CASE = np.sin(theta_a - theta_t ) / sin_theta_a __SCREAMING_SNAKE_CASE = sin_theta_t / sin_theta_a __SCREAMING_SNAKE_CASE = sa * va + sa * va if inputs_are_torch: __SCREAMING_SNAKE_CASE = torch.from_numpy(lowerCamelCase__ ).to(lowerCamelCase__ ) return va def __lowercase ( a__ , a__ ) -> Dict: __SCREAMING_SNAKE_CASE = F.normalize(lowerCamelCase__ , dim=-1 ) __SCREAMING_SNAKE_CASE = F.normalize(lowerCamelCase__ , dim=-1 ) return (x - y).norm(dim=-1 ).div(2 ).arcsin().pow(2 ).mul(2 ) def __lowercase ( a__ , a__ ) -> Dict: for param in model.parameters(): __SCREAMING_SNAKE_CASE = value class UpperCAmelCase_ ( snake_case_ ): '''simple docstring''' def __init__( self , _A , _A , _A , _A , _A , _A , _A , _A=None , _A=None , _A=None , ): '''simple docstring''' super().__init__() self.register_modules( vae=_A , text_encoder=_A , clip_model=_A , tokenizer=_A , unet=_A , scheduler=_A , feature_extractor=_A , coca_model=_A , coca_tokenizer=_A , coca_transform=_A , ) __SCREAMING_SNAKE_CASE = ( feature_extractor.size if isinstance(feature_extractor.size , _A ) else feature_extractor.size['shortest_edge'] ) __SCREAMING_SNAKE_CASE = transforms.Normalize(mean=feature_extractor.image_mean , std=feature_extractor.image_std ) set_requires_grad(self.text_encoder , _A ) set_requires_grad(self.clip_model , _A ) def _A ( self , _A = "auto" ): '''simple docstring''' if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory __SCREAMING_SNAKE_CASE = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(_A ) def _A ( self ): '''simple docstring''' self.enable_attention_slicing(_A ) def _A ( self ): '''simple docstring''' set_requires_grad(self.vae , _A ) def _A ( self ): '''simple docstring''' set_requires_grad(self.vae , _A ) def _A ( self ): '''simple docstring''' set_requires_grad(self.unet , _A ) def _A ( self ): '''simple docstring''' set_requires_grad(self.unet , _A ) def _A ( self , _A , _A , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = min(int(num_inference_steps * strength ) , _A ) __SCREAMING_SNAKE_CASE = max(num_inference_steps - init_timestep , 0 ) __SCREAMING_SNAKE_CASE = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def _A ( self , _A , _A , _A , _A , _A , _A=None ): '''simple docstring''' if not isinstance(_A , torch.Tensor ): raise ValueError(f"""`image` has to be of type `torch.Tensor` but is {type(_A )}""" ) __SCREAMING_SNAKE_CASE = image.to(device=_A , dtype=_A ) if isinstance(_A , _A ): __SCREAMING_SNAKE_CASE = [ self.vae.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(_A ) ] __SCREAMING_SNAKE_CASE = torch.cat(_A , dim=0 ) else: __SCREAMING_SNAKE_CASE = self.vae.encode(_A ).latent_dist.sample(_A ) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor __SCREAMING_SNAKE_CASE = 0.1_8_2_1_5 * init_latents __SCREAMING_SNAKE_CASE = init_latents.repeat_interleave(_A , dim=0 ) __SCREAMING_SNAKE_CASE = randn_tensor(init_latents.shape , generator=_A , device=_A , dtype=_A ) # get latents __SCREAMING_SNAKE_CASE = self.scheduler.add_noise(_A , _A , _A ) __SCREAMING_SNAKE_CASE = init_latents return latents def _A ( self , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = self.coca_transform(_A ).unsqueeze(0 ) with torch.no_grad(), torch.cuda.amp.autocast(): __SCREAMING_SNAKE_CASE = self.coca_model.generate(transformed_image.to(device=self.device , dtype=self.coca_model.dtype ) ) __SCREAMING_SNAKE_CASE = self.coca_tokenizer.decode(generated[0].cpu().numpy() ) return generated.split('<end_of_text>' )[0].replace('<start_of_text>' , '' ).rstrip(' .,' ) def _A ( self , _A , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = self.feature_extractor.preprocess(_A ) __SCREAMING_SNAKE_CASE = torch.from_numpy(clip_image_input['pixel_values'][0] ).unsqueeze(0 ).to(self.device ).half() __SCREAMING_SNAKE_CASE = self.clip_model.get_image_features(_A ) __SCREAMING_SNAKE_CASE = image_embeddings_clip / image_embeddings_clip.norm(p=2 , dim=-1 , keepdim=_A ) __SCREAMING_SNAKE_CASE = image_embeddings_clip.repeat_interleave(_A , dim=0 ) return image_embeddings_clip @torch.enable_grad() def _A ( self , _A , _A , _A , _A , _A , _A , _A , ): '''simple docstring''' __SCREAMING_SNAKE_CASE = latents.detach().requires_grad_() __SCREAMING_SNAKE_CASE = self.scheduler.scale_model_input(_A , _A ) # predict the noise residual __SCREAMING_SNAKE_CASE = self.unet(_A , _A , encoder_hidden_states=_A ).sample if isinstance(self.scheduler , (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler) ): __SCREAMING_SNAKE_CASE = self.scheduler.alphas_cumprod[timestep] __SCREAMING_SNAKE_CASE = 1 - alpha_prod_t # compute predicted original sample from predicted noise also called # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf __SCREAMING_SNAKE_CASE = (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5 __SCREAMING_SNAKE_CASE = torch.sqrt(_A ) __SCREAMING_SNAKE_CASE = pred_original_sample * (fac) + latents * (1 - fac) elif isinstance(self.scheduler , _A ): __SCREAMING_SNAKE_CASE = self.scheduler.sigmas[index] __SCREAMING_SNAKE_CASE = latents - sigma * noise_pred else: raise ValueError(f"""scheduler type {type(self.scheduler )} not supported""" ) # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor __SCREAMING_SNAKE_CASE = 1 / 0.1_8_2_1_5 * sample __SCREAMING_SNAKE_CASE = self.vae.decode(_A ).sample __SCREAMING_SNAKE_CASE = (image / 2 + 0.5).clamp(0 , 1 ) __SCREAMING_SNAKE_CASE = transforms.Resize(self.feature_extractor_size )(_A ) __SCREAMING_SNAKE_CASE = self.normalize(_A ).to(latents.dtype ) __SCREAMING_SNAKE_CASE = self.clip_model.get_image_features(_A ) __SCREAMING_SNAKE_CASE = image_embeddings_clip / image_embeddings_clip.norm(p=2 , dim=-1 , keepdim=_A ) __SCREAMING_SNAKE_CASE = spherical_dist_loss(_A , _A ).mean() * clip_guidance_scale __SCREAMING_SNAKE_CASE = -torch.autograd.grad(_A , _A )[0] if isinstance(self.scheduler , _A ): __SCREAMING_SNAKE_CASE = latents.detach() + grads * (sigma**2) __SCREAMING_SNAKE_CASE = noise_pred_original else: __SCREAMING_SNAKE_CASE = noise_pred_original - torch.sqrt(_A ) * grads return noise_pred, latents @torch.no_grad() def __call__( self , _A , _A , _A = None , _A = None , _A = 512 , _A = 512 , _A = 0.6 , _A = 50 , _A = 7.5 , _A = 1 , _A = 0.0 , _A = 100 , _A = None , _A = "pil" , _A = True , _A = 0.8 , _A = 0.1 , _A = 0.1 , ): '''simple docstring''' if isinstance(_A , _A ) and len(_A ) != batch_size: raise ValueError(f"""You have passed {batch_size} batch_size, but only {len(_A )} generators.""" ) if height % 8 != 0 or width % 8 != 0: raise ValueError(f"""`height` and `width` have to be divisible by 8 but are {height} and {width}.""" ) if isinstance(_A , torch.Generator ) and batch_size > 1: __SCREAMING_SNAKE_CASE = [generator] + [None] * (batch_size - 1) __SCREAMING_SNAKE_CASE = [ ('model', self.coca_model is None), ('tokenizer', self.coca_tokenizer is None), ('transform', self.coca_transform is None), ] __SCREAMING_SNAKE_CASE = [x[0] for x in coca_is_none if x[1]] __SCREAMING_SNAKE_CASE = ', '.join(_A ) # generate prompts with coca model if prompt is None if content_prompt is None: if len(_A ): raise ValueError( f"""Content prompt is None and CoCa [{coca_is_none_str}] is None.""" f"""Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.""" ) __SCREAMING_SNAKE_CASE = self.get_image_description(_A ) if style_prompt is None: if len(_A ): raise ValueError( f"""Style prompt is None and CoCa [{coca_is_none_str}] is None.""" f""" Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.""" ) __SCREAMING_SNAKE_CASE = self.get_image_description(_A ) # get prompt text embeddings for content and style __SCREAMING_SNAKE_CASE = self.tokenizer( _A , padding='max_length' , max_length=self.tokenizer.model_max_length , truncation=_A , return_tensors='pt' , ) __SCREAMING_SNAKE_CASE = self.text_encoder(content_text_input.input_ids.to(self.device ) )[0] __SCREAMING_SNAKE_CASE = self.tokenizer( _A , padding='max_length' , max_length=self.tokenizer.model_max_length , truncation=_A , return_tensors='pt' , ) __SCREAMING_SNAKE_CASE = self.text_encoder(style_text_input.input_ids.to(self.device ) )[0] __SCREAMING_SNAKE_CASE = slerp(_A , _A , _A ) # duplicate text embeddings for each generation per prompt __SCREAMING_SNAKE_CASE = text_embeddings.repeat_interleave(_A , dim=0 ) # set timesteps __SCREAMING_SNAKE_CASE = 'offset' in set(inspect.signature(self.scheduler.set_timesteps ).parameters.keys() ) __SCREAMING_SNAKE_CASE = {} if accepts_offset: __SCREAMING_SNAKE_CASE = 1 self.scheduler.set_timesteps(_A , **_A ) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand self.scheduler.timesteps.to(self.device ) __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = self.get_timesteps(_A , _A , self.device ) __SCREAMING_SNAKE_CASE = timesteps[:1].repeat(_A ) # Preprocess image __SCREAMING_SNAKE_CASE = preprocess(_A , _A , _A ) __SCREAMING_SNAKE_CASE = self.prepare_latents( _A , _A , _A , text_embeddings.dtype , self.device , _A ) __SCREAMING_SNAKE_CASE = preprocess(_A , _A , _A ) __SCREAMING_SNAKE_CASE = self.prepare_latents( _A , _A , _A , text_embeddings.dtype , self.device , _A ) __SCREAMING_SNAKE_CASE = slerp(_A , _A , _A ) if clip_guidance_scale > 0: __SCREAMING_SNAKE_CASE = self.get_clip_image_embeddings(_A , _A ) __SCREAMING_SNAKE_CASE = self.get_clip_image_embeddings(_A , _A ) __SCREAMING_SNAKE_CASE = slerp( _A , _A , _A ) # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` # corresponds to doing no classifier free guidance. __SCREAMING_SNAKE_CASE = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: __SCREAMING_SNAKE_CASE = content_text_input.input_ids.shape[-1] __SCREAMING_SNAKE_CASE = self.tokenizer([''] , padding='max_length' , max_length=_A , return_tensors='pt' ) __SCREAMING_SNAKE_CASE = self.text_encoder(uncond_input.input_ids.to(self.device ) )[0] # duplicate unconditional embeddings for each generation per prompt __SCREAMING_SNAKE_CASE = uncond_embeddings.repeat_interleave(_A , dim=0 ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes __SCREAMING_SNAKE_CASE = torch.cat([uncond_embeddings, text_embeddings] ) # get the initial random noise unless the user supplied it # Unlike in other pipelines, latents need to be generated in the target device # for 1-to-1 results reproducibility with the CompVis implementation. # However this currently doesn't work in `mps`. __SCREAMING_SNAKE_CASE = (batch_size, self.unet.config.in_channels, height // 8, width // 8) __SCREAMING_SNAKE_CASE = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not work reproducibly on mps __SCREAMING_SNAKE_CASE = torch.randn(_A , generator=_A , device='cpu' , dtype=_A ).to( self.device ) else: __SCREAMING_SNAKE_CASE = torch.randn(_A , generator=_A , device=self.device , dtype=_A ) else: if latents.shape != latents_shape: raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}""" ) __SCREAMING_SNAKE_CASE = latents.to(self.device ) # scale the initial noise by the standard deviation required by the scheduler __SCREAMING_SNAKE_CASE = latents * self.scheduler.init_noise_sigma # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers. # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502 # and should be between [0, 1] __SCREAMING_SNAKE_CASE = 'eta' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) __SCREAMING_SNAKE_CASE = {} if accepts_eta: __SCREAMING_SNAKE_CASE = eta # check if the scheduler accepts generator __SCREAMING_SNAKE_CASE = 'generator' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) if accepts_generator: __SCREAMING_SNAKE_CASE = generator with self.progress_bar(total=_A ): for i, t in enumerate(_A ): # expand the latents if we are doing classifier free guidance __SCREAMING_SNAKE_CASE = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents __SCREAMING_SNAKE_CASE = self.scheduler.scale_model_input(_A , _A ) # predict the noise residual __SCREAMING_SNAKE_CASE = self.unet(_A , _A , encoder_hidden_states=_A ).sample # perform classifier free guidance if do_classifier_free_guidance: __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = noise_pred.chunk(2 ) __SCREAMING_SNAKE_CASE = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # perform clip guidance if clip_guidance_scale > 0: __SCREAMING_SNAKE_CASE = ( text_embeddings.chunk(2 )[1] if do_classifier_free_guidance else text_embeddings ) __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = self.cond_fn( _A , _A , _A , _A , _A , _A , _A , ) # compute the previous noisy sample x_t -> x_t-1 __SCREAMING_SNAKE_CASE = self.scheduler.step(_A , _A , _A , **_A ).prev_sample # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor __SCREAMING_SNAKE_CASE = 1 / 0.1_8_2_1_5 * latents __SCREAMING_SNAKE_CASE = self.vae.decode(_A ).sample __SCREAMING_SNAKE_CASE = (image / 2 + 0.5).clamp(0 , 1 ) __SCREAMING_SNAKE_CASE = image.cpu().permute(0 , 2 , 3 , 1 ).numpy() if output_type == "pil": __SCREAMING_SNAKE_CASE = self.numpy_to_pil(_A ) if not return_dict: return (image, None) return StableDiffusionPipelineOutput(images=_A , nsfw_content_detected=_A )
257
from typing import Callable, List, Optional, Union import PIL import torch from transformers import ( CLIPImageProcessor, CLIPSegForImageSegmentation, CLIPSegProcessor, CLIPTextModel, CLIPTokenizer, ) from diffusers import DiffusionPipeline from diffusers.configuration_utils import FrozenDict from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler from diffusers.utils import deprecate, is_accelerate_available, logging __A =logging.get_logger(__name__) # pylint: disable=invalid-name class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[Any]: super().__init__() if hasattr(scheduler.config , "steps_offset" ) and scheduler.config.steps_offset != 1: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`' f' should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure ' "to update the config accordingly as leaving `steps_offset` might led to incorrect results" " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub," " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`" " file" ) deprecate("steps_offset!=1" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = 1 lowerCamelCase_ = FrozenDict(lowercase ) if hasattr(scheduler.config , "skip_prk_steps" ) and scheduler.config.skip_prk_steps is False: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} has not set the configuration' " `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make" " sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to" " incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face" " Hub, it would be very nice if you could open a Pull request for the" " `scheduler/scheduler_config.json` file" ) deprecate("skip_prk_steps not set" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = True lowerCamelCase_ = FrozenDict(lowercase ) if safety_checker is None: logger.warning( f'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure' " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered" " results in services or applications open to the public. Both the diffusers team and Hugging Face" " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling" " it only for use-cases that involve analyzing network behavior or auditing its results. For more" " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ." ) self.register_modules( segmentation_model=lowercase , segmentation_processor=lowercase , vae=lowercase , text_encoder=lowercase , tokenizer=lowercase , unet=lowercase , scheduler=lowercase , safety_checker=lowercase , feature_extractor=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase = "auto" ) -> Tuple: if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory lowerCamelCase_ = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: self.enable_attention_slicing(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device("cuda" ) for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: if self.device != torch.device("meta" ) or not hasattr(self.unet , "_hf_hook" ): return self.device for module in self.unet.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() def __call__( self , lowercase , lowercase , lowercase , lowercase = 512 , lowercase = 512 , lowercase = 50 , lowercase = 7.5 , lowercase = None , lowercase = 1 , lowercase = 0.0 , lowercase = None , lowercase = None , lowercase = "pil" , lowercase = True , lowercase = None , lowercase = 1 , **lowercase , ) -> int: lowerCamelCase_ = self.segmentation_processor( text=[text] , images=[image] , padding="max_length" , return_tensors="pt" ).to(self.device ) lowerCamelCase_ = self.segmentation_model(**lowercase ) lowerCamelCase_ = torch.sigmoid(outputs.logits ).cpu().detach().unsqueeze(-1 ).numpy() lowerCamelCase_ = self.numpy_to_pil(lowercase )[0].resize(image.size ) # Run inpainting pipeline with the generated mask lowerCamelCase_ = StableDiffusionInpaintPipeline( vae=self.vae , text_encoder=self.text_encoder , tokenizer=self.tokenizer , unet=self.unet , scheduler=self.scheduler , safety_checker=self.safety_checker , feature_extractor=self.feature_extractor , ) return inpainting_pipeline( prompt=lowercase , image=lowercase , mask_image=lowercase , height=lowercase , width=lowercase , num_inference_steps=lowercase , guidance_scale=lowercase , negative_prompt=lowercase , num_images_per_prompt=lowercase , eta=lowercase , generator=lowercase , latents=lowercase , output_type=lowercase , return_dict=lowercase , callback=lowercase , callback_steps=lowercase , )
19
0
"""simple docstring""" import unittest from transformers import BertGenerationTokenizer from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow from transformers.utils import cached_property from ...test_tokenization_common import TokenizerTesterMixin _lowercase = '''▁''' _lowercase = get_tests_dir('''fixtures/test_sentencepiece.model''') @require_sentencepiece class lowerCAmelCase_ ( snake_case_ , unittest.TestCase ): '''simple docstring''' _lowerCamelCase: Any = BertGenerationTokenizer _lowerCamelCase: Dict = False _lowerCamelCase: Any = True def _SCREAMING_SNAKE_CASE ( self : str ) -> Union[str, Any]: super().setUp() A = BertGenerationTokenizer(A_ ,keep_accents=A_ ) tokenizer.save_pretrained(self.tmpdirname ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Optional[Any]: A = '<s>' A = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(A_ ) ,A_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(A_ ) ,A_ ) def _SCREAMING_SNAKE_CASE ( self : List[str] ) -> Union[str, Any]: A = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] ,'<unk>' ) self.assertEqual(vocab_keys[1] ,'<s>' ) self.assertEqual(vocab_keys[-1] ,'<pad>' ) self.assertEqual(len(A_ ) ,1002 ) def _SCREAMING_SNAKE_CASE ( self : List[Any] ) -> Any: self.assertEqual(self.get_tokenizer().vocab_size ,1000 ) def _SCREAMING_SNAKE_CASE ( self : Any ) -> Dict: A = BertGenerationTokenizer(A_ ,keep_accents=A_ ) A = tokenizer.tokenize('This is a test' ) self.assertListEqual(A_ ,['▁This', '▁is', '▁a', '▁t', 'est'] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(A_ ) ,[285, 46, 10, 170, 382] ,) A = tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( A_ ,[ 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', 'é', '.', ] ,) A = tokenizer.convert_tokens_to_ids(A_ ) self.assertListEqual( A_ ,[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4] ,) A = tokenizer.convert_ids_to_tokens(A_ ) self.assertListEqual( A_ ,[ 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 _SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> List[str]: return BertGenerationTokenizer.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder' ) @slow def _SCREAMING_SNAKE_CASE ( self : List[Any] ) -> Union[str, Any]: A = 'Hello World!' A = [1_8536, 2260, 101] self.assertListEqual(A_ ,self.big_tokenizer.encode(A_ ) ) @slow def _SCREAMING_SNAKE_CASE ( self : int ) -> Any: A = ( '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' ) A = [ 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, 3_4324, 497, 391, 408, 1_1342, 1244, 385, 100, 938, 985, 456, 574, 362, 1_2597, 3200, 3129, 1172, ] self.assertListEqual(A_ ,self.big_tokenizer.encode(A_ ) ) @require_torch @slow def _SCREAMING_SNAKE_CASE ( self : Dict ) -> Union[str, Any]: import torch from transformers import BertGenerationConfig, BertGenerationEncoder # Build sequence A = list(self.big_tokenizer.get_vocab().keys() )[:10] A = ' '.join(A_ ) A = self.big_tokenizer.encode_plus(A_ ,return_tensors='pt' ,return_token_type_ids=A_ ) A = self.big_tokenizer.batch_encode_plus( [sequence + ' ' + sequence] ,return_tensors='pt' ,return_token_type_ids=A_ ) A = BertGenerationConfig() A = BertGenerationEncoder(A_ ) assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size with torch.no_grad(): model(**A_ ) model(**A_ ) @slow def _SCREAMING_SNAKE_CASE ( self : Dict ) -> Optional[Any]: # fmt: off A = {'input_ids': [[3_9286, 458, 3_6335, 2001, 456, 1_3073, 1_3266, 455, 113, 7746, 1741, 1_1157, 391, 1_3073, 1_3266, 455, 113, 3967, 3_5412, 113, 4936, 109, 3870, 2377, 113, 3_0084, 4_5720, 458, 134, 1_7496, 112, 503, 1_1672, 113, 118, 112, 5665, 1_3347, 3_8687, 112, 1496, 3_1389, 112, 3268, 4_7264, 134, 962, 112, 1_6377, 8035, 2_3130, 430, 1_2169, 1_5518, 2_8592, 458, 146, 4_1697, 109, 391, 1_2169, 1_5518, 1_6689, 458, 146, 4_1358, 109, 452, 726, 4034, 111, 763, 3_5412, 5082, 388, 1903, 111, 9051, 391, 2870, 4_8918, 1900, 1123, 550, 998, 112, 9586, 1_5985, 455, 391, 410, 2_2955, 3_7636, 114], [448, 1_7496, 419, 3663, 385, 763, 113, 2_7533, 2870, 3283, 1_3043, 1639, 2_4713, 523, 656, 2_4013, 1_8550, 2521, 517, 2_7014, 2_1244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 1_1786, 114, 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], [484, 2169, 7687, 2_1932, 1_8146, 726, 363, 1_7032, 3391, 114, 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, 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, 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=A_ ,model_name='google/bert_for_seq_generation_L-24_bbc_encoder' ,revision='c817d1fd1be2ffa69431227a1fe320544943d4db' ,)
74
from collections import deque def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) lowerCamelCase_ = deque() lowerCamelCase_ = [False for _ in range(lowerCamelCase__ )] lowerCamelCase_ = [-1 for _ in range(lowerCamelCase__ )] lowerCamelCase_ = index_of[:] def strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = index # the number when this node is seen lowerCamelCase_ = index # lowest rank node reachable from here index += 1 stack.append(lowerCamelCase__ ) lowerCamelCase_ = True for w in g[v]: if index_of[w] == -1: lowerCamelCase_ = strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) elif on_stack[w]: lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) if lowlink_of[v] == index_of[v]: lowerCamelCase_ = [] lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) while w != v: lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) components.append(lowerCamelCase__ ) return index lowerCamelCase_ = [] for v in range(lowerCamelCase__ ): if index_of[v] == -1: strong_connect(lowerCamelCase__ , 0 , lowerCamelCase__ ) return components def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [[] for _ in range(lowerCamelCase__ )] for u, v in edges: g[u].append(lowerCamelCase__ ) return g if __name__ == "__main__": # Test __A =7 __A =[0, 0, 1, 2, 3, 3, 4, 4, 6] __A =[1, 3, 2, 0, 1, 4, 5, 6, 5] __A =[(u, v) for u, v in zip(source, target)] __A =create_graph(n_vertices, edges) assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)
19
0
"""simple docstring""" 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, # specifically showcasing the experiment tracking capability, # and builds off the `nlp_example.py` script. # # 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 help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## _UpperCamelCase: Tuple = 1_6 _UpperCamelCase: List[Any] = 3_2 def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase = 16 ) -> int: '''simple docstring''' lowercase : Any = AutoTokenizer.from_pretrained('bert-base-cased' ) lowercase : Optional[Any] = load_dataset('glue' , 'mrpc' ) def tokenize_function(_UpperCAmelCase ): # max_length=None => use the model max length (it's actually the default) lowercase : Any = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=lowerCamelCase__ , max_length=lowerCamelCase__ ) 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(): lowercase : Optional[Any] = datasets.map( lowerCamelCase__ , batched=lowerCamelCase__ , 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 lowercase : Any = tokenized_datasets.rename_column('label' , 'labels' ) def collate_fn(_UpperCAmelCase ): # On TPU it's best to pad everything to the same length or training will be very slow. lowercase : Optional[Any] = 1_28 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowercase : Tuple = 16 elif accelerator.mixed_precision != "no": lowercase : Any = 8 else: lowercase : int = None return tokenizer.pad( lowerCamelCase__ , padding='longest' , max_length=lowerCamelCase__ , pad_to_multiple_of=lowerCamelCase__ , return_tensors='pt' , ) # Instantiate dataloaders. lowercase : Any = DataLoader( tokenized_datasets['train'] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) lowercase : List[str] = DataLoader( tokenized_datasets['validation'] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) 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 _UpperCamelCase: Optional[int] = mocked_dataloaders # noqa: F811 def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase ) -> List[str]: '''simple docstring''' if os.environ.get('TESTING_MOCKED_DATALOADERS' , lowerCamelCase__ ) == "1": lowercase : List[str] = 2 # Initialize Accelerator # New Code # # We pass in "all" to `log_with` to grab all available trackers in the environment # Note: If using a custom `Tracker` class, should be passed in here such as: # >>> log_with = ["all", MyCustomTrackerClassInstance()] if args.with_tracking: lowercase : Tuple = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , log_with='all' , project_dir=args.project_dir ) else: lowercase : List[str] = Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowercase : Dict = config['lr'] lowercase : Dict = int(config['num_epochs'] ) lowercase : Any = int(config['seed'] ) lowercase : Dict = int(config['batch_size'] ) set_seed(lowerCamelCase__ ) lowercase , lowercase : List[str] = get_dataloaders(lowerCamelCase__ , lowerCamelCase__ ) lowercase : str = evaluate.load('glue' , 'mrpc' ) # If the batch size is too big we use gradient accumulation lowercase : str = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: lowercase : Any = batch_size // MAX_GPU_BATCH_SIZE lowercase : str = MAX_GPU_BATCH_SIZE # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowercase : str = AutoModelForSequenceClassification.from_pretrained('bert-base-cased' , return_dict=lowerCamelCase__ ) # 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). lowercase : Tuple = model.to(accelerator.device ) # Instantiate optimizer lowercase : Union[str, Any] = AdamW(params=model.parameters() , lr=lowerCamelCase__ ) # Instantiate scheduler lowercase : Union[str, Any] = get_linear_schedule_with_warmup( optimizer=lowerCamelCase__ , num_warmup_steps=1_00 , num_training_steps=(len(lowerCamelCase__ ) * num_epochs) // gradient_accumulation_steps , ) # 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. lowercase , lowercase , lowercase , lowercase , lowercase : str = accelerator.prepare( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # New Code # # We need to initialize the trackers we use. Overall configurations can also be stored if args.with_tracking: lowercase : Optional[int] = os.path.split(lowerCamelCase__ )[-1].split('.' )[0] accelerator.init_trackers(lowerCamelCase__ , lowerCamelCase__ ) # Now we train the model for epoch in range(lowerCamelCase__ ): model.train() # New Code # # For our tracking example, we will log the total loss of each epoch if args.with_tracking: lowercase : Dict = 0 for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) lowercase : str = model(**lowerCamelCase__ ) lowercase : Tuple = outputs.loss # New Code # if args.with_tracking: total_loss += loss.detach().float() lowercase : Union[str, Any] = loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True` (the default). batch.to(accelerator.device ) with torch.no_grad(): lowercase : Tuple = model(**lowerCamelCase__ ) lowercase : List[Any] = outputs.logits.argmax(dim=-1 ) lowercase , lowercase : Tuple = accelerator.gather_for_metrics((predictions, batch['labels']) ) metric.add_batch( predictions=lowerCamelCase__ , references=lowerCamelCase__ , ) lowercase : Optional[int] = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(f'''epoch {epoch}:''' , lowerCamelCase__ ) # New Code # # To actually log, we call `Accelerator.log` # The values passed can be of `str`, `int`, `float` or `dict` of `str` to `float`/`int` if args.with_tracking: accelerator.log( { 'accuracy': eval_metric['accuracy'], 'f1': eval_metric['f1'], 'train_loss': total_loss.item() / len(lowerCamelCase__ ), 'epoch': epoch, } , step=lowerCamelCase__ , ) # New Code # # When a run is finished, you should call `accelerator.end_training()` # to close all of the open trackers if args.with_tracking: accelerator.end_training() def lowercase__ ( ) -> List[Any]: '''simple docstring''' lowercase : str = argparse.ArgumentParser(description='Simple example of training script.' ) parser.add_argument( '--mixed_precision' , type=lowerCamelCase__ , default=lowerCamelCase__ , 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.' , ) parser.add_argument('--cpu' , action='store_true' , help='If passed, will train on the CPU.' ) parser.add_argument( '--with_tracking' , action='store_true' , help='Whether to load in all available experiment trackers from the environment and use them for logging.' , ) parser.add_argument( '--project_dir' , type=lowerCamelCase__ , default='logs' , help='Location on where to store experiment tracking logs` and relevent project information' , ) lowercase : Union[str, Any] = parser.parse_args() lowercase : Union[str, Any] = {'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16} training_function(lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": main()
255
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) __A ={'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizer'''] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''XGLMForCausalLM''', '''XGLMModel''', '''XGLMPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''FlaxXGLMForCausalLM''', '''FlaxXGLMModel''', '''FlaxXGLMPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFXGLMForCausalLM''', '''TFXGLMModel''', '''TFXGLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm import XGLMTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm_fast import XGLMTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_xglm import ( TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFXGLMForCausalLM, TFXGLMModel, TFXGLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure)
19
0
'''simple docstring''' import copy import tempfile import unittest from transformers import MaMaaaConfig, is_torch_available from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from transformers.utils import cached_property from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import MaMaaaForConditionalGeneration, MaMaaaModel, MaMaaaTokenizer from transformers.models.mam_aaa.modeling_mam_aaa import MaMaaaDecoder, MaMaaaEncoder def _a( UpperCamelCase__ : str, UpperCamelCase__ : Union[str, Any], UpperCamelCase__ : Dict, UpperCamelCase__ : int=None, UpperCamelCase__ : List[Any]=None, UpperCamelCase__ : Optional[int]=None, UpperCamelCase__ : Union[str, Any]=None, UpperCamelCase__ : Any=None, ): '''simple docstring''' if attention_mask is None: SCREAMING_SNAKE_CASE__ : Dict =input_ids.ne(config.pad_token_id ) if decoder_attention_mask is None: SCREAMING_SNAKE_CASE__ : str =decoder_input_ids.ne(config.pad_token_id ) if head_mask is None: SCREAMING_SNAKE_CASE__ : Union[str, Any] =torch.ones(config.encoder_layers, config.encoder_attention_heads, device=lowerCamelCase__ ) if decoder_head_mask is None: SCREAMING_SNAKE_CASE__ : Union[str, Any] =torch.ones(config.decoder_layers, config.decoder_attention_heads, device=lowerCamelCase__ ) if cross_attn_head_mask is None: SCREAMING_SNAKE_CASE__ : Optional[int] =torch.ones(config.decoder_layers, config.decoder_attention_heads, device=lowerCamelCase__ ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } class __SCREAMING_SNAKE_CASE : def __init__( self : Tuple , __lowercase : str , __lowercase : List[Any]=13 , __lowercase : Union[str, Any]=7 , __lowercase : Any=True , __lowercase : str=False , __lowercase : Optional[Any]=99 , __lowercase : Optional[int]=16 , __lowercase : Union[str, Any]=2 , __lowercase : Tuple=4 , __lowercase : int=4 , __lowercase : Dict="relu" , __lowercase : Optional[int]=0.1 , __lowercase : List[Any]=0.1 , __lowercase : str=0.0 , __lowercase : Dict=0.0 , __lowercase : Any=20 , __lowercase : List[str]=2 , __lowercase : str=1 , __lowercase : Dict=0 , ) -> int: SCREAMING_SNAKE_CASE__ : Optional[Any] =parent SCREAMING_SNAKE_CASE__ : int =batch_size SCREAMING_SNAKE_CASE__ : Optional[Any] =seq_length SCREAMING_SNAKE_CASE__ : List[str] =is_training SCREAMING_SNAKE_CASE__ : str =use_labels SCREAMING_SNAKE_CASE__ : int =vocab_size SCREAMING_SNAKE_CASE__ : Optional[int] =hidden_size SCREAMING_SNAKE_CASE__ : str =num_hidden_layers SCREAMING_SNAKE_CASE__ : Tuple =num_attention_heads SCREAMING_SNAKE_CASE__ : Dict =intermediate_size SCREAMING_SNAKE_CASE__ : str =hidden_act SCREAMING_SNAKE_CASE__ : Optional[Any] =hidden_dropout_prob SCREAMING_SNAKE_CASE__ : Any =attention_probs_dropout_prob SCREAMING_SNAKE_CASE__ : int =encoder_layerdrop SCREAMING_SNAKE_CASE__ : List[Any] =decoder_layerdrop SCREAMING_SNAKE_CASE__ : int =max_position_embeddings SCREAMING_SNAKE_CASE__ : Tuple =eos_token_id SCREAMING_SNAKE_CASE__ : Tuple =pad_token_id SCREAMING_SNAKE_CASE__ : List[Any] =bos_token_id def __magic_name__ ( self : Union[str, Any] ) -> Optional[int]: SCREAMING_SNAKE_CASE__ : Any =ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) SCREAMING_SNAKE_CASE__ : str =self.eos_token_id # Eos Token SCREAMING_SNAKE_CASE__ : Optional[int] =ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) # we need to clamp the input ids here to avoid having pad token in between # this is because for M2M100 the position_ids are prepared such that # all pad tokens have pos id = 2 and rest are between 2..seq_length # and the seq_length here is seq_length - num_pad_tokens # but when using past, there is no way of knowing if the past input ids had # pad tokens in them, which results in incorrect seq_lenth and which in turn results in # position_ids being off by num_pad_tokens in past input SCREAMING_SNAKE_CASE__ : List[str] =input_ids.clamp(self.pad_token_id + 1 ) SCREAMING_SNAKE_CASE__ : Any =decoder_input_ids.clamp(self.pad_token_id + 1 ) SCREAMING_SNAKE_CASE__ : Optional[Any] =self.get_config() SCREAMING_SNAKE_CASE__ : Dict =prepare_mam_aaa_inputs_dict(__lowercase , __lowercase , __lowercase ) return config, inputs_dict def __magic_name__ ( self : Tuple ) -> Any: return MaMaaaConfig( 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 , encoder_layerdrop=self.encoder_layerdrop , decoder_layerdrop=self.decoder_layerdrop , 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 , ) def __magic_name__ ( self : Dict ) -> Tuple: SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : Optional[int] =self.prepare_config_and_inputs() return config, inputs_dict def __magic_name__ ( self : Tuple , __lowercase : int , __lowercase : List[str] ) -> Any: SCREAMING_SNAKE_CASE__ : Tuple =MaMaaaModel(config=__lowercase ).get_decoder().to(__lowercase ).eval() SCREAMING_SNAKE_CASE__ : str =inputs_dict['''input_ids'''] SCREAMING_SNAKE_CASE__ : List[str] =inputs_dict['''attention_mask'''] SCREAMING_SNAKE_CASE__ : str =inputs_dict['''head_mask'''] # first forward pass SCREAMING_SNAKE_CASE__ : str =model(__lowercase , attention_mask=__lowercase , head_mask=__lowercase , use_cache=__lowercase ) SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : Optional[Any] =outputs.to_tuple() # create hypothetical multiple next token and extent to next_input_ids SCREAMING_SNAKE_CASE__ : int =ids_tensor((self.batch_size, 3) , config.vocab_size ) SCREAMING_SNAKE_CASE__ : Tuple =ids_tensor((self.batch_size, 3) , 2 ) # append to next input_ids and SCREAMING_SNAKE_CASE__ : Optional[int] =torch.cat([input_ids, next_tokens] , dim=-1 ) SCREAMING_SNAKE_CASE__ : Tuple =torch.cat([attention_mask, next_attn_mask] , dim=-1 ) SCREAMING_SNAKE_CASE__ : Optional[int] =model(__lowercase , attention_mask=__lowercase )['''last_hidden_state'''] SCREAMING_SNAKE_CASE__ : Tuple =model(__lowercase , attention_mask=__lowercase , past_key_values=__lowercase )[ '''last_hidden_state''' ] # select random slice SCREAMING_SNAKE_CASE__ : int =ids_tensor((1,) , output_from_past.shape[-1] ).item() SCREAMING_SNAKE_CASE__ : Dict =output_from_no_past[:, -3:, random_slice_idx].detach() SCREAMING_SNAKE_CASE__ : List[str] =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(__lowercase , __lowercase , atol=1e-2 ) ) def __magic_name__ ( self : List[Any] , __lowercase : Optional[int] , __lowercase : List[str] ) -> Union[str, Any]: SCREAMING_SNAKE_CASE__ : List[str] =MaMaaaModel(config=__lowercase ).to(__lowercase ).eval() SCREAMING_SNAKE_CASE__ : List[str] =model(**__lowercase ) SCREAMING_SNAKE_CASE__ : Optional[int] =outputs.encoder_last_hidden_state SCREAMING_SNAKE_CASE__ : Optional[int] =outputs.last_hidden_state with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE__ : Optional[int] =model.get_encoder() encoder.save_pretrained(__lowercase ) SCREAMING_SNAKE_CASE__ : int =MaMaaaEncoder.from_pretrained(__lowercase ).to(__lowercase ) SCREAMING_SNAKE_CASE__ : List[str] =encoder(inputs_dict['''input_ids'''] , attention_mask=inputs_dict['''attention_mask'''] )[ 0 ] self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3 ) with tempfile.TemporaryDirectory() as tmpdirname: SCREAMING_SNAKE_CASE__ : int =model.get_decoder() decoder.save_pretrained(__lowercase ) SCREAMING_SNAKE_CASE__ : Any =MaMaaaDecoder.from_pretrained(__lowercase ).to(__lowercase ) SCREAMING_SNAKE_CASE__ : Dict =decoder( input_ids=inputs_dict['''decoder_input_ids'''] , attention_mask=inputs_dict['''decoder_attention_mask'''] , encoder_hidden_states=__lowercase , encoder_attention_mask=inputs_dict['''attention_mask'''] , )[0] self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3 ) @require_torch class __SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , snake_case_ , unittest.TestCase ): snake_case_ = ( ( MaMaaaModel, MaMaaaForConditionalGeneration, ) if is_torch_available() else () ) snake_case_ = (MaMaaaForConditionalGeneration,) if is_torch_available() else () snake_case_ = ( { """conversational""": MaMaaaForConditionalGeneration, """feature-extraction""": MaMaaaModel, """summarization""": MaMaaaForConditionalGeneration, """text2text-generation""": MaMaaaForConditionalGeneration, """translation""": MaMaaaForConditionalGeneration, } if is_torch_available() else {} ) snake_case_ = True snake_case_ = True snake_case_ = False snake_case_ = False def __magic_name__ ( self : Any , __lowercase : int , __lowercase : Union[str, Any] , __lowercase : Any , __lowercase : int , __lowercase : Optional[Any] ) -> int: if pipeline_test_casse_name == "TranslationPipelineTests": # Get `ValueError: Translation requires a `src_lang` and a `tgt_lang` for this model`. # `M2M100Config` was never used in pipeline tests: cannot create a simple tokenizer. return True return False def __magic_name__ ( self : Dict ) -> Optional[Any]: SCREAMING_SNAKE_CASE__ : Optional[Any] =MaMaaaModelTester(self ) SCREAMING_SNAKE_CASE__ : List[Any] =ConfigTester(self , config_class=__lowercase ) def __magic_name__ ( self : int ) -> str: self.config_tester.run_common_tests() def __magic_name__ ( self : Optional[Any] ) -> Optional[int]: SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : Optional[int] =self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: SCREAMING_SNAKE_CASE__ : int =model_class(__lowercase ) with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(__lowercase ) SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : int =model_class.from_pretrained(__lowercase , output_loading_info=__lowercase ) self.assertEqual(info['''missing_keys'''] , [] ) def __magic_name__ ( self : int ) -> int: SCREAMING_SNAKE_CASE__ : Any =self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_decoder_model_past_large_inputs(*__lowercase ) def __magic_name__ ( self : str ) -> Any: SCREAMING_SNAKE_CASE__ : List[Any] =self.model_tester.prepare_config_and_inputs_for_common() self.model_tester.check_encoder_decoder_model_standalone(*__lowercase ) def __magic_name__ ( self : List[Any] ) -> Optional[Any]: SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : Tuple =self.model_tester.prepare_config_and_inputs_for_common() for model_class in (MaMaaaModel, MaMaaaForConditionalGeneration): SCREAMING_SNAKE_CASE__ : str =model_class(__lowercase ) model.to(__lowercase ) model.eval() SCREAMING_SNAKE_CASE__ : Optional[int] =copy.deepcopy(self._prepare_for_class(__lowercase , __lowercase ) ) if not self.is_encoder_decoder: SCREAMING_SNAKE_CASE__ : Tuple =inputs['''input_ids'''] del inputs["input_ids"] else: SCREAMING_SNAKE_CASE__ : Tuple =inputs['''input_ids'''] SCREAMING_SNAKE_CASE__ : Optional[Any] =inputs.get('''decoder_input_ids''' , __lowercase ) del inputs["input_ids"] inputs.pop('''decoder_input_ids''' , __lowercase ) SCREAMING_SNAKE_CASE__ : Tuple =model.get_input_embeddings() if not self.is_encoder_decoder: SCREAMING_SNAKE_CASE__ : Dict =wte(__lowercase ) else: SCREAMING_SNAKE_CASE__ : List[Any] =wte(__lowercase ) SCREAMING_SNAKE_CASE__ : str =wte(__lowercase ) with torch.no_grad(): model(**__lowercase )[0] def __magic_name__ ( self : List[str] ) -> int: SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ : str =self.model_tester.prepare_config_and_inputs() SCREAMING_SNAKE_CASE__ : Optional[Any] =input_dict['''input_ids'''] SCREAMING_SNAKE_CASE__ : Tuple =input_ids.ne(1 ).to(__lowercase ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =MaMaaaForConditionalGeneration(__lowercase ).eval().to(__lowercase ) if torch_device == "cuda": model.half() model.generate(__lowercase , attention_mask=__lowercase ) model.generate(num_beams=4 , do_sample=__lowercase , early_stopping=__lowercase , num_return_sequences=3 ) def _a( UpperCamelCase__ : Dict ): '''simple docstring''' return torch.tensor(lowerCamelCase__, dtype=torch.long, device=lowerCamelCase__ ) a_ = 1E-4 @require_torch @require_sentencepiece @require_tokenizers @slow class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): @cached_property def __magic_name__ ( self : Dict ) -> Optional[int]: return MaMaaaTokenizer.from_pretrained('''facebook/m2m100_418M''' ) def __magic_name__ ( self : int ) -> List[Any]: SCREAMING_SNAKE_CASE__ : int =MaMaaaModel.from_pretrained('''facebook/m2m100_418M''' ).to(__lowercase ) SCREAMING_SNAKE_CASE__ : Any =_long_tensor([[12_80_28, 98, 12, 3_05_27, 27_32, 1_59, 77_55, 6_19_04, 3_91_44, 38, 2]] ) SCREAMING_SNAKE_CASE__ : List[Any] =_long_tensor([[2, 12_80_28, 98, 12, 3_05_27, 27_32, 1_59, 77_55, 6_19_04, 3_91_44, 38]] ) SCREAMING_SNAKE_CASE__ : Optional[Any] =prepare_mam_aaa_inputs_dict(model.config , __lowercase , __lowercase ) with torch.no_grad(): SCREAMING_SNAKE_CASE__ : Any =model(**__lowercase )[0] SCREAMING_SNAKE_CASE__ : Any =torch.Size((1, 11, 10_24) ) self.assertEqual(output.shape , __lowercase ) # change to expected output here SCREAMING_SNAKE_CASE__ : List[str] =torch.tensor( [[-0.7780, -0.1676, 0.1038], [-6.7556, -1.3992, 0.0567], [-7.5383, -0.5920, -0.2779]] , device=__lowercase ) self.assertTrue(torch.allclose(output[:, :3, :3] , __lowercase , atol=__lowercase ) ) def __magic_name__ ( self : int ) -> Optional[int]: SCREAMING_SNAKE_CASE__ : str =MaMaaaForConditionalGeneration.from_pretrained('''facebook/m2m100_418M''' ).to(__lowercase ) # change to intended input SCREAMING_SNAKE_CASE__ : Tuple =_long_tensor([[12_80_28, 98, 12, 3_05_27, 27_32, 1_59, 77_55, 6_19_04, 3_91_44, 38, 2]] ) SCREAMING_SNAKE_CASE__ : Any =_long_tensor([[2, 12_80_28, 98, 12, 3_05_27, 27_32, 1_59, 77_55, 6_19_04, 3_91_44, 38]] ) SCREAMING_SNAKE_CASE__ : int =prepare_mam_aaa_inputs_dict(model.config , __lowercase , __lowercase ) with torch.no_grad(): SCREAMING_SNAKE_CASE__ : Any =model(**__lowercase )[0] SCREAMING_SNAKE_CASE__ : Optional[Any] =torch.Size((1, 11, model.config.vocab_size) ) self.assertEqual(output.shape , __lowercase ) # change to expected output here SCREAMING_SNAKE_CASE__ : Union[str, Any] =torch.tensor( [[-1.0448, -1.0411, 3.7992], [-3.2191, -3.2386, -1.3451], [-3.6210, -3.5993, 0.4925]] , device=__lowercase ) self.assertTrue(torch.allclose(output[:, :3, :3] , __lowercase , atol=__lowercase ) ) def __magic_name__ ( self : int ) -> Union[str, Any]: SCREAMING_SNAKE_CASE__ : Dict =MaMaaaForConditionalGeneration.from_pretrained('''facebook/m2m100_418M''' ).to(__lowercase ) SCREAMING_SNAKE_CASE__ : Optional[Any] =MaMaaaTokenizer.from_pretrained('''facebook/m2m100_418M''' , src_lang='''fr''' , tgt_lang='''en''' ) SCREAMING_SNAKE_CASE__ : Optional[int] =[ '''L\'affaire NSA souligne l\'absence totale de débat sur le renseignement''', '''Selon moi, il y a deux niveaux de réponse de la part du gouvernement français.''', '''Lorsque François Hollande téléphone à Barack Obama ou quand le ministre des affaires étrangères Laurent''' ''' Fabius convoque l\'ambassadeur des Etats-Unis, ils réagissent à une vraie découverte, qui est celle de''' ''' l\'ampleur de la surveillance américaine sur l\'ensemble des communications en France.''', ] # The below article tests that we don't add any hypotheses outside of the top n_beams SCREAMING_SNAKE_CASE__ : List[str] =tokenizer(__lowercase , padding=__lowercase , return_tensors='''pt''' ) SCREAMING_SNAKE_CASE__ : List[str] =model.generate( input_ids=dct['''input_ids'''].to(__lowercase ) , attention_mask=dct['''attention_mask'''].to(__lowercase ) , num_beams=5 , forced_bos_token_id=tokenizer.get_lang_id('''en''' ) , ) SCREAMING_SNAKE_CASE__ : Optional[Any] =[ '''The NSA case highlights the total absence of intelligence debate''', '''I think there are two levels of response from the French government.''', '''When François Hollande calls Barack Obama or when Foreign Minister Laurent Fabius calls the U.S.''' ''' Ambassador, they respond to a real discovery, which is that of the scale of U.S. surveillance on all''' ''' communications in France.''', ] SCREAMING_SNAKE_CASE__ : str =tokenizer.batch_decode( hypotheses_batch.tolist() , clean_up_tokenization_spaces=__lowercase , skip_special_tokens=__lowercase ) assert generated == expected_en
152
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __A ={'''configuration_wavlm''': ['''WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WavLMConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''WavLMForAudioFrameClassification''', '''WavLMForCTC''', '''WavLMForSequenceClassification''', '''WavLMForXVector''', '''WavLMModel''', '''WavLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_wavlm import ( WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST, WavLMForAudioFrameClassification, WavLMForCTC, WavLMForSequenceClassification, WavLMForXVector, WavLMModel, WavLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
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 A_ :Optional[int] = '''▁''' A_ :Dict = {'''vocab_file''': '''spiece.model'''} A_ :str = { '''vocab_file''': {'''google/pegasus-xsum''': '''https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model'''} } A_ :List[Any] = { '''google/pegasus-xsum''': 512, } A_ :Tuple = logging.get_logger(__name__) class __A ( snake_case_ ): """simple docstring""" UpperCamelCase__ : List[Any] =VOCAB_FILES_NAMES UpperCamelCase__ : Tuple =VOCAB_FILES_NAMES UpperCamelCase__ : Any =PRETRAINED_VOCAB_FILES_MAP UpperCamelCase__ : str =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase__ : Dict =["""input_ids""", """attention_mask"""] def __init__( self , lowerCamelCase__ , lowerCamelCase__="<pad>" , lowerCamelCase__="</s>" , lowerCamelCase__="<unk>" , lowerCamelCase__="<mask_2>" , lowerCamelCase__="<mask_1>" , lowerCamelCase__=None , lowerCamelCase__=103 , lowerCamelCase__ = None , **lowerCamelCase__ , ): """simple docstring""" __UpperCamelCase : Any =offset if additional_special_tokens is not None: if not isinstance(lowerCamelCase__ , lowerCamelCase__ ): raise TypeError( f'additional_special_tokens should be of type {type(lowerCamelCase__ )}, but is' f' {type(lowerCamelCase__ )}' ) __UpperCamelCase : Union[str, Any] =( ([mask_token_sent] + additional_special_tokens) if mask_token_sent not in additional_special_tokens and mask_token_sent is not None else additional_special_tokens ) # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken additional_special_tokens_extended += [ f'<unk_{i}>' for i in range(len(lowerCamelCase__ ) , self.offset - 1 ) ] if len(set(lowerCamelCase__ ) ) != len(lowerCamelCase__ ): raise ValueError( 'Please make sure that the provided additional_special_tokens do not contain an incorrectly' f' shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.' ) __UpperCamelCase : int =additional_special_tokens_extended else: __UpperCamelCase : str =[mask_token_sent] if mask_token_sent is not None else [] additional_special_tokens += [f'<unk_{i}>' for i in range(2 , self.offset )] __UpperCamelCase : List[Any] ={} if sp_model_kwargs is None else sp_model_kwargs super().__init__( eos_token=lowerCamelCase__ , unk_token=lowerCamelCase__ , mask_token=lowerCamelCase__ , pad_token=lowerCamelCase__ , mask_token_sent=lowerCamelCase__ , offset=lowerCamelCase__ , additional_special_tokens=lowerCamelCase__ , sp_model_kwargs=self.sp_model_kwargs , **lowerCamelCase__ , ) __UpperCamelCase : str =mask_token_sent __UpperCamelCase : Tuple =vocab_file __UpperCamelCase : Optional[Any] =spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(lowerCamelCase__ ) # add special tokens to encoder dict __UpperCamelCase : Tuple ={ 0: self.pad_token, 1: self.eos_token, } if self.mask_token_sent is not None: self.encoder.update( { 2: self.mask_token_sent, 3: self.mask_token, } ) if self.offset > 0: # entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102 # mask_token_sent is already added to list -> so start at 1 self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1 , self.offset - 1 )} ) __UpperCamelCase : Union[str, Any] ={v: k for k, v in self.encoder.items()} @property def __lowercase ( self ): """simple docstring""" return len(self.sp_model ) + self.offset def __lowercase ( self ): """simple docstring""" __UpperCamelCase : int ={self.convert_ids_to_tokens(lowerCamelCase__ ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self ): """simple docstring""" __UpperCamelCase : List[str] =self.__dict__.copy() __UpperCamelCase : Tuple =None return state def __setstate__( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : Any =d # for backward compatibility if not hasattr(self , 'sp_model_kwargs' ): __UpperCamelCase : Optional[int] ={} __UpperCamelCase : Optional[int] =spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" return self.sp_model.encode(lowerCamelCase__ , out_type=lowerCamelCase__ ) def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" if token in self.decoder: return self.decoder[token] elif token in self.added_tokens_decoder: return self.added_tokens_decoder[token] __UpperCamelCase : List[Any] =self.sp_model.piece_to_id(lowerCamelCase__ ) return sp_id + self.offset def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" if index in self.encoder: return self.encoder[index] elif index in self.added_tokens_encoder: return self.added_tokens_encoder[index] else: __UpperCamelCase : int =self.sp_model.IdToPiece(index - self.offset ) return token def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : List[Any] =[] __UpperCamelCase : List[str] ='' 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(lowerCamelCase__ ) + token __UpperCamelCase : Dict =[] else: current_sub_tokens.append(lowerCamelCase__ ) out_string += self.sp_model.decode(lowerCamelCase__ ) return out_string.strip() def __lowercase ( self , lowerCamelCase__=False ): """simple docstring""" return 1 def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : Any =set(self.all_special_ids ) # call it once instead of inside list comp all_special_ids.remove(self.unk_token_id ) # <unk> is only sometimes special return [1 if x in all_special_ids else 0 for x in seq] def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ = None , lowerCamelCase__ = False ): """simple docstring""" if already_has_special_tokens: return self._special_token_mask(lowerCamelCase__ ) elif token_ids_a is None: return self._special_token_mask(lowerCamelCase__ ) + [1] else: return self._special_token_mask(token_ids_a + token_ids_a ) + [1] def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__=None ): """simple docstring""" if token_ids_a is None: return token_ids_a + [self.eos_token_id] # We don't expect to process pairs, but leave the pair logic for API consistency return token_ids_a + token_ids_a + [self.eos_token_id] def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ = None ): """simple docstring""" if not os.path.isdir(lowerCamelCase__ ): logger.error(f'Vocabulary path ({save_directory}) should be a directory' ) return __UpperCamelCase : List[str] =os.path.join( lowerCamelCase__ , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowerCamelCase__ ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , lowerCamelCase__ ) elif not os.path.isfile(self.vocab_file ): with open(lowerCamelCase__ , 'wb' ) as fi: __UpperCamelCase : List[Any] =self.sp_model.serialized_model_proto() fi.write(lowerCamelCase__ ) return (out_vocab_file,)
71
# Lint as: python3 # pylint: enable=line-too-long # pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position __A ='''2.13.1''' import platform import pyarrow from packaging import version if version.parse(platform.python_version()) < version.parse('''3.7'''): raise ImportWarning( '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.''' ) if version.parse(pyarrow.__version__).major < 8: raise ImportWarning( '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n''' '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.''' ) del platform del pyarrow del version from .arrow_dataset import Dataset from .arrow_reader import ReadInstruction from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder from .combine import concatenate_datasets, interleave_datasets from .dataset_dict import DatasetDict, IterableDatasetDict from .download import * from .features import * from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled from .info import DatasetInfo, MetricInfo from .inspect import ( get_dataset_config_info, get_dataset_config_names, get_dataset_infos, get_dataset_split_names, inspect_dataset, inspect_metric, list_datasets, list_metrics, ) from .iterable_dataset import IterableDataset from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric from .metric import Metric from .splits import ( NamedSplit, NamedSplitAll, Split, SplitBase, SplitDict, SplitGenerator, SplitInfo, SubSplitInfo, percent, ) from .tasks import * from .utils import * from .utils import logging # deprecated modules from datasets import arrow_dataset as _arrow_dataset # isort:skip from datasets import utils as _utils # isort:skip from datasets.utils import download_manager as _deprecated_download_manager # isort:skip __A =concatenate_datasets __A =DownloadConfig __A =DownloadManager __A =DownloadMode __A =DownloadConfig __A =DownloadMode __A =DownloadManager del _arrow_dataset, _utils, _deprecated_download_manager
19
0
'''simple docstring''' import shutil import tempfile import unittest from transformers import ( SPIECE_UNDERLINE, AddedToken, BatchEncoding, NllbTokenizer, NllbTokenizerFast, is_torch_available, ) from transformers.testing_utils import ( get_tests_dir, nested_simplify, require_sentencepiece, require_tokenizers, require_torch, ) from ...test_tokenization_common import TokenizerTesterMixin a_ : Optional[int] = get_tests_dir("fixtures/test_sentencepiece.model") if is_torch_available(): from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right a_ : List[str] = 2_5_6_0_4_7 a_ : Any = 2_5_6_1_4_5 @require_sentencepiece @require_tokenizers class a ( snake_case_ , unittest.TestCase ): _lowerCAmelCase = NllbTokenizer _lowerCAmelCase = NllbTokenizerFast _lowerCAmelCase = True _lowerCAmelCase = True _lowerCAmelCase = {} def __UpperCAmelCase ( self ) -> Dict: super().setUp() # We have a SentencePiece fixture for testing _a = NllbTokenizer(__magic_name__ , keep_accents=__magic_name__ ) tokenizer.save_pretrained(self.tmpdirname ) def __UpperCAmelCase ( self ) -> Optional[int]: _a = NllbTokenizer(__magic_name__ , keep_accents=__magic_name__ ) _a = tokenizer.tokenize('This is a test' ) self.assertListEqual(__magic_name__ , ['▁This', '▁is', '▁a', '▁t', 'est'] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(__magic_name__ ) , [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]] , ) _a = tokenizer.tokenize('I was born in 92000, and this is falsé.' ) self.assertListEqual( __magic_name__ , [ 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', 'é', '.', ] , ) _a = tokenizer.convert_tokens_to_ids(__magic_name__ ) self.assertListEqual( __magic_name__ , [ value + tokenizer.fairseq_offset for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4] ] , ) _a = tokenizer.convert_ids_to_tokens(__magic_name__ ) self.assertListEqual( __magic_name__ , [ SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.', ] , ) def __UpperCAmelCase ( self ) -> List[str]: _a = (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {}) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})' ): _a = self.rust_tokenizer_class.from_pretrained(__magic_name__ , **__magic_name__ ) _a = self.tokenizer_class.from_pretrained(__magic_name__ , **__magic_name__ ) _a = tempfile.mkdtemp() _a = tokenizer_r.save_pretrained(__magic_name__ ) _a = tokenizer_p.save_pretrained(__magic_name__ ) # Checks it save with the same files + the tokenizer.json file for the fast one self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files ) ) _a = tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f ) self.assertSequenceEqual(__magic_name__ , __magic_name__ ) # Checks everything loads correctly in the same way _a = tokenizer_r.from_pretrained(__magic_name__ ) _a = tokenizer_p.from_pretrained(__magic_name__ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(__magic_name__ , __magic_name__ ) ) shutil.rmtree(__magic_name__ ) # Save tokenizer rust, legacy_format=True _a = tempfile.mkdtemp() _a = tokenizer_r.save_pretrained(__magic_name__ , legacy_format=__magic_name__ ) _a = tokenizer_p.save_pretrained(__magic_name__ ) # Checks it save with the same files self.assertSequenceEqual(__magic_name__ , __magic_name__ ) # Checks everything loads correctly in the same way _a = tokenizer_r.from_pretrained(__magic_name__ ) _a = tokenizer_p.from_pretrained(__magic_name__ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(__magic_name__ , __magic_name__ ) ) shutil.rmtree(__magic_name__ ) # Save tokenizer rust, legacy_format=False _a = tempfile.mkdtemp() _a = tokenizer_r.save_pretrained(__magic_name__ , legacy_format=__magic_name__ ) _a = tokenizer_p.save_pretrained(__magic_name__ ) # Checks it saved the tokenizer.json file self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files ) ) # Checks everything loads correctly in the same way _a = tokenizer_r.from_pretrained(__magic_name__ ) _a = tokenizer_p.from_pretrained(__magic_name__ ) # Check special tokens are set accordingly on Rust and Python for key in tokenizer_pp.special_tokens_map: self.assertTrue(hasattr(__magic_name__ , __magic_name__ ) ) shutil.rmtree(__magic_name__ ) @require_torch def __UpperCAmelCase ( self ) -> str: if not self.test_seqaseq: return _a = self.get_tokenizers() for tokenizer in tokenizers: with self.subTest(f'{tokenizer.__class__.__name__}' ): # Longer text that will definitely require truncation. _a = [ ' UN Chief Says There Is No Military Solution in Syria', ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for' ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons' ' will only worsen the violence and misery for millions of people.', ] _a = [ 'Şeful ONU declară că nu există o soluţie militară în Siria', 'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al' ' Rusiei pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi' ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.', ] try: _a = tokenizer.prepare_seqaseq_batch( src_texts=__magic_name__ , tgt_texts=__magic_name__ , max_length=3 , max_target_length=10 , return_tensors='pt' , src_lang='eng_Latn' , tgt_lang='ron_Latn' , ) except NotImplementedError: return self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.labels.shape[1] , 10 ) # max_target_length will default to max_length if not specified _a = tokenizer.prepare_seqaseq_batch( __magic_name__ , tgt_texts=__magic_name__ , max_length=3 , return_tensors='pt' ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.labels.shape[1] , 3 ) _a = tokenizer.prepare_seqaseq_batch( src_texts=__magic_name__ , max_length=3 , max_target_length=10 , return_tensors='pt' ) self.assertEqual(batch_encoder_only.input_ids.shape[1] , 3 ) self.assertEqual(batch_encoder_only.attention_mask.shape[1] , 3 ) self.assertNotIn('decoder_input_ids' , __magic_name__ ) @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.' ) def __UpperCAmelCase ( self ) -> Any: pass def __UpperCAmelCase ( self ) -> List[Any]: for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})' ): _a = [AddedToken('<special>' , lstrip=__magic_name__ )] _a = self.rust_tokenizer_class.from_pretrained( __magic_name__ , additional_special_tokens=__magic_name__ , **__magic_name__ ) _a = tokenizer_r.encode('Hey this is a <special> token' ) _a = tokenizer_r.encode('<special>' , add_special_tokens=__magic_name__ )[0] self.assertTrue(special_token_id in r_output ) if self.test_slow_tokenizer: _a = self.rust_tokenizer_class.from_pretrained( __magic_name__ , additional_special_tokens=__magic_name__ , **__magic_name__ , ) _a = self.tokenizer_class.from_pretrained( __magic_name__ , additional_special_tokens=__magic_name__ , **__magic_name__ ) _a = tokenizer_p.encode('Hey this is a <special> token' ) _a = tokenizer_cr.encode('Hey this is a <special> token' ) self.assertEqual(__magic_name__ , __magic_name__ ) self.assertEqual(__magic_name__ , __magic_name__ ) self.assertTrue(special_token_id in p_output ) self.assertTrue(special_token_id in cr_output ) @require_torch @require_sentencepiece @require_tokenizers class a ( unittest.TestCase ): _lowerCAmelCase = """facebook/nllb-200-distilled-600M""" _lowerCAmelCase = [ """ UN Chief Says There Is No Military Solution in Syria""", """ Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""", ] _lowerCAmelCase = [ """Şeful ONU declară că nu există o soluţie militară în Siria""", """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei""" """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor""" """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""", ] _lowerCAmelCase = [ 2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 8_1_6_5, 2_4_8_0_6_6, 1_4_7_3_4, 9_5_0, 1_1_3_5, 1_0_5_7_2_1, 3_5_7_3, 8_3, 2_7_3_5_2, 1_0_8, 4_9_4_8_6, 2, ] @classmethod def __UpperCAmelCase ( cls ) -> int: _a = NllbTokenizer.from_pretrained( cls.checkpoint_name , src_lang='eng_Latn' , tgt_lang='ron_Latn' ) _a = 1 return cls def __UpperCAmelCase ( self ) -> Optional[int]: self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab'] , 25_60_01 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn'] , 25_60_02 ) self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn'] , 25_60_57 ) def __UpperCAmelCase ( self ) -> Any: _a = self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0] self.assertListEqual(self.expected_src_tokens , __magic_name__ ) def __UpperCAmelCase ( self ) -> Optional[Any]: self.assertIn(__magic_name__ , self.tokenizer.all_special_ids ) # fmt: off _a = [RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47] # fmt: on _a = self.tokenizer.decode(__magic_name__ , skip_special_tokens=__magic_name__ ) _a = self.tokenizer.decode(generated_ids[1:] , skip_special_tokens=__magic_name__ ) self.assertEqual(__magic_name__ , __magic_name__ ) self.assertNotIn(self.tokenizer.eos_token , __magic_name__ ) def __UpperCAmelCase ( self ) -> Any: _a = ['this is gunna be a long sentence ' * 20] assert isinstance(src_text[0] , __magic_name__ ) _a = 10 _a = self.tokenizer(__magic_name__ , max_length=__magic_name__ , truncation=__magic_name__ ).input_ids[0] self.assertEqual(ids[-1] , 2 ) self.assertEqual(ids[0] , __magic_name__ ) self.assertEqual(len(__magic_name__ ) , __magic_name__ ) def __UpperCAmelCase ( self ) -> Any: self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR'] ) , [25_62_03, 3] ) def __UpperCAmelCase ( self ) -> Optional[int]: _a = tempfile.mkdtemp() _a = self.tokenizer.fairseq_tokens_to_ids self.tokenizer.save_pretrained(__magic_name__ ) _a = NllbTokenizer.from_pretrained(__magic_name__ ) self.assertDictEqual(new_tok.fairseq_tokens_to_ids , __magic_name__ ) @require_torch def __UpperCAmelCase ( self ) -> int: _a = self.tokenizer( self.src_text , text_target=self.tgt_text , padding=__magic_name__ , truncation=__magic_name__ , max_length=len(self.expected_src_tokens ) , return_tensors='pt' , ) _a = shift_tokens_right( batch['labels'] , self.tokenizer.pad_token_id , self.tokenizer.lang_code_to_id['ron_Latn'] ) self.assertIsInstance(__magic_name__ , __magic_name__ ) self.assertEqual((2, 15) , batch.input_ids.shape ) self.assertEqual((2, 15) , batch.attention_mask.shape ) _a = batch.input_ids.tolist()[0] self.assertListEqual(self.expected_src_tokens , __magic_name__ ) self.assertEqual(__magic_name__ , batch.decoder_input_ids[0, 0] ) # EOS # Test that special tokens are reset self.assertEqual(self.tokenizer.prefix_tokens , [EN_CODE] ) self.assertEqual(self.tokenizer.suffix_tokens , [self.tokenizer.eos_token_id] ) def __UpperCAmelCase ( self ) -> int: _a = self.tokenizer(self.src_text , padding=__magic_name__ , truncation=__magic_name__ , max_length=3 , return_tensors='pt' ) _a = self.tokenizer( text_target=self.tgt_text , padding=__magic_name__ , truncation=__magic_name__ , max_length=10 , return_tensors='pt' ) _a = targets['input_ids'] _a = shift_tokens_right( __magic_name__ , self.tokenizer.pad_token_id , decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang] , ) self.assertEqual(batch.input_ids.shape[1] , 3 ) self.assertEqual(batch.decoder_input_ids.shape[1] , 10 ) @require_torch def __UpperCAmelCase ( self ) -> List[Any]: _a = self.tokenizer._build_translation_inputs( 'A test' , return_tensors='pt' , src_lang='eng_Latn' , tgt_lang='fra_Latn' ) self.assertEqual( nested_simplify(__magic_name__ ) , { # A, test, EOS, en_XX 'input_ids': [[25_60_47, 70, 73_56, 2]], 'attention_mask': [[1, 1, 1, 1]], # ar_AR 'forced_bos_token_id': 25_60_57, } , ) @require_torch def __UpperCAmelCase ( self ) -> Tuple: _a = True _a = self.tokenizer( 'UN Chief says there is no military solution in Syria' , src_lang='eng_Latn' , tgt_lang='fra_Latn' ) self.assertEqual( inputs.input_ids , [1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47] ) _a = False _a = self.tokenizer( 'UN Chief says there is no military solution in Syria' , src_lang='eng_Latn' , tgt_lang='fra_Latn' ) self.assertEqual( inputs.input_ids , [25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2] )
168
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __A ={ '''configuration_bloom''': ['''BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BloomConfig''', '''BloomOnnxConfig'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''BloomTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''BloomForCausalLM''', '''BloomModel''', '''BloomPreTrainedModel''', '''BloomForSequenceClassification''', '''BloomForTokenClassification''', '''BloomForQuestionAnswering''', ] if TYPE_CHECKING: from .configuration_bloom import BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP, BloomConfig, BloomOnnxConfig try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_bloom_fast import BloomTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_bloom import ( BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST, BloomForCausalLM, BloomForQuestionAnswering, BloomForSequenceClassification, BloomForTokenClassification, BloomModel, BloomPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
import logging import random import ray from transformers import RagConfig, RagRetriever, RagTokenizer from transformers.models.rag.retrieval_rag import CustomHFIndex lowercase_ = logging.getLogger(__name__) class __lowerCAmelCase : def __init__( self ) -> Optional[int]: '''simple docstring''' _lowercase =False def A__ ( self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ) -> Optional[int]: '''simple docstring''' if not self.initialized: _lowercase =RagRetriever( lowerCAmelCase , question_encoder_tokenizer=lowerCAmelCase , generator_tokenizer=lowerCAmelCase , index=lowerCAmelCase , init_retrieval=lowerCAmelCase , ) _lowercase =True def A__ ( self ) -> List[Any]: '''simple docstring''' self.retriever.index.init_index() def A__ ( self , lowerCAmelCase , lowerCAmelCase ) -> Any: '''simple docstring''' _lowercase , _lowercase =self.retriever._main_retrieve(lowerCAmelCase , lowerCAmelCase ) return doc_ids, retrieved_doc_embeds class __lowerCAmelCase ( snake_case_ ): def __init__( self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=None ) -> Dict: '''simple docstring''' if index is not None and index.is_initialized() and len(lowerCAmelCase ) > 0: raise ValueError( 'When using Ray for distributed fine-tuning, ' 'you\'ll need to provide the paths instead, ' 'as the dataset and the index are loaded ' 'separately. More info in examples/rag/use_own_knowledge_dataset.py ' ) super().__init__( lowerCAmelCase , question_encoder_tokenizer=lowerCAmelCase , generator_tokenizer=lowerCAmelCase , index=lowerCAmelCase , init_retrieval=lowerCAmelCase , ) _lowercase =retrieval_workers if len(self.retrieval_workers ) > 0: ray.get( [ worker.create_rag_retriever.remote(lowerCAmelCase , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase ) for worker in self.retrieval_workers ] ) def A__ ( self ) -> Optional[int]: '''simple docstring''' logger.info('initializing retrieval' ) if len(self.retrieval_workers ) > 0: ray.get([worker.init_retrieval.remote() for worker in self.retrieval_workers] ) else: # Non-distributed training. Load index into this same process. self.index.init_index() def A__ ( self , lowerCAmelCase , lowerCAmelCase ) -> Dict: '''simple docstring''' if len(self.retrieval_workers ) > 0: # Select a random retrieval actor. _lowercase =self.retrieval_workers[random.randint(0 , len(self.retrieval_workers ) - 1 )] _lowercase , _lowercase =ray.get(random_worker.retrieve.remote(lowerCAmelCase , lowerCAmelCase ) ) else: _lowercase , _lowercase =self._main_retrieve(lowerCAmelCase , lowerCAmelCase ) return retrieved_doc_embeds, doc_ids, self.index.get_doc_dicts(lowerCAmelCase ) @classmethod def A__ ( cls , lowerCAmelCase , lowerCAmelCase=None , **lowerCAmelCase ) -> Optional[int]: '''simple docstring''' return super(lowerCAmelCase , cls ).get_tokenizers(lowerCAmelCase , lowerCAmelCase , **lowerCAmelCase ) @classmethod def A__ ( cls , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=None , **lowerCAmelCase ) -> Optional[Any]: '''simple docstring''' _lowercase =kwargs.pop('config' , lowerCAmelCase ) or RagConfig.from_pretrained(lowerCAmelCase , **lowerCAmelCase ) _lowercase =RagTokenizer.from_pretrained(lowerCAmelCase , config=lowerCAmelCase ) _lowercase =rag_tokenizer.question_encoder _lowercase =rag_tokenizer.generator if indexed_dataset is not None: _lowercase ='custom' _lowercase =CustomHFIndex(config.retrieval_vector_size , lowerCAmelCase ) else: _lowercase =cls._build_index(lowerCAmelCase ) return cls( lowerCAmelCase , question_encoder_tokenizer=lowerCAmelCase , generator_tokenizer=lowerCAmelCase , retrieval_workers=lowerCAmelCase , index=lowerCAmelCase , )
205
from __future__ import annotations import unittest from transformers import EsmConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers.models.esm.modeling_tf_esm import ( TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, TFEsmModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , ) -> Optional[int]: lowerCamelCase_ = parent lowerCamelCase_ = 13 lowerCamelCase_ = 7 lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = 99 lowerCamelCase_ = 32 lowerCamelCase_ = 2 lowerCamelCase_ = 4 lowerCamelCase_ = 37 lowerCamelCase_ = "gelu" lowerCamelCase_ = 0.1 lowerCamelCase_ = 0.1 lowerCamelCase_ = 512 lowerCamelCase_ = 16 lowerCamelCase_ = 2 lowerCamelCase_ = 0.0_2 lowerCamelCase_ = 3 lowerCamelCase_ = 4 lowerCamelCase_ = None def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_input_mask: lowerCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = EsmConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , pad_token_id=1 , 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 , initializer_range=self.initializer_range , ) return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def SCREAMING_SNAKE_CASE_( self ) -> List[str]: ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = self.prepare_config_and_inputs() lowerCamelCase_ = True lowerCamelCase_ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Any: lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> Tuple: lowerCamelCase_ = True lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": input_mask, "encoder_hidden_states": encoder_hidden_states, "encoder_attention_mask": encoder_attention_mask, } lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase , encoder_hidden_states=lowercase ) # Also check the case where encoder outputs are not passed lowerCamelCase_ = model(lowercase , attention_mask=lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Optional[int]: lowerCamelCase_ = TFEsmForMaskedLM(config=lowercase ) lowerCamelCase_ = model([input_ids, input_mask] ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = TFEsmForTokenClassification(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_tf class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( ( TFEsmModel, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, ) if is_tf_available() else () ) lowerCAmelCase__ = ( { 'feature-extraction': TFEsmModel, 'fill-mask': TFEsmForMaskedLM, 'text-classification': TFEsmForSequenceClassification, 'token-classification': TFEsmForTokenClassification, 'zero-shot': TFEsmForSequenceClassification, } if is_tf_available() else {} ) lowerCAmelCase__ = False lowerCAmelCase__ = False def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = TFEsmModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , hidden_size=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Dict: for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = TFEsmModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: pass @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> Any: pass def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ , lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCamelCase_ = model_class(lowercase ) assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer ) if model_class is TFEsmForMaskedLM: # Output embedding test differs from the main test because they're a matrix, not a layer lowerCamelCase_ = model.get_bias() assert isinstance(lowercase , lowercase ) for k, v in name.items(): assert isinstance(lowercase , tf.Variable ) else: lowerCamelCase_ = model.get_output_embeddings() assert x is None lowerCamelCase_ = model.get_bias() assert name is None @require_tf class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 1, 2, 3, 4, 5]] ) lowerCamelCase_ = model(lowercase )[0] lowerCamelCase_ = [1, 6, 33] self.assertEqual(list(output.numpy().shape ) , lowercase ) # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7], [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5], [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-2 ) ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] ) lowerCamelCase_ = model(lowercase )[0] # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9], [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2], [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
19
0
import itertools import random import unittest import numpy as np from transformers import ASTFeatureExtractor from transformers.testing_utils import require_torch, require_torchaudio from transformers.utils.import_utils import is_torch_available from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin lowerCAmelCase__ = random.Random() if is_torch_available(): import torch def _UpperCAmelCase (UpperCamelCase__ : List[Any] , UpperCamelCase__ : Tuple=1.0 , UpperCamelCase__ : Dict=None , UpperCamelCase__ : str=None ): if rng is None: _A : Optional[Any] = global_rng _A : Dict = [] for batch_idx in range(shape[0] ): values.append([] ) for _ in range(shape[1] ): values[-1].append(rng.random() * scale ) return values class lowerCAmelCase__ ( unittest.TestCase): '''simple docstring''' def __init__( self , __lowerCamelCase , __lowerCamelCase=7 , __lowerCamelCase=4_0_0 , __lowerCamelCase=2_0_0_0 , __lowerCamelCase=1 , __lowerCamelCase=0.0 , __lowerCamelCase=1_6_0_0_0 , __lowerCamelCase=True , __lowerCamelCase=True , ) -> Optional[Any]: _A : Tuple = parent _A : Dict = batch_size _A : Dict = min_seq_length _A : Optional[int] = max_seq_length _A : Optional[int] = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1) _A : List[Any] = feature_size _A : str = padding_value _A : Any = sampling_rate _A : int = return_attention_mask _A : Tuple = do_normalize def _lowerCamelCase ( self) -> Union[str, Any]: return { "feature_size": self.feature_size, "padding_value": self.padding_value, "sampling_rate": self.sampling_rate, "return_attention_mask": self.return_attention_mask, "do_normalize": self.do_normalize, } def _lowerCamelCase ( self , __lowerCamelCase=False , __lowerCamelCase=False) -> Optional[Any]: def _flatten(__lowerCamelCase): return list(itertools.chain(*__lowerCamelCase)) if equal_length: _A : Dict = floats_list((self.batch_size, self.max_seq_length)) else: # make sure that inputs increase in size _A : List[str] = [ _flatten(floats_list((x, self.feature_size))) for x in range(self.min_seq_length , self.max_seq_length , self.seq_length_diff) ] if numpify: _A : List[Any] = [np.asarray(__lowerCamelCase) for x in speech_inputs] return speech_inputs @require_torch @require_torchaudio class lowerCAmelCase__ ( snake_case_ , unittest.TestCase): '''simple docstring''' __SCREAMING_SNAKE_CASE = ASTFeatureExtractor def _lowerCamelCase ( self) -> str: _A : Optional[int] = ASTFeatureExtractionTester(self) def _lowerCamelCase ( self) -> Any: # Tests that all call wrap to encode_plus and batch_encode_plus _A : List[Any] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()) # create three inputs of length 800, 1000, and 1200 _A : List[Any] = [floats_list((1, x))[0] for x in range(8_0_0 , 1_4_0_0 , 2_0_0)] _A : Tuple = [np.asarray(__lowerCamelCase) for speech_input in speech_inputs] # Test not batched input _A : Tuple = feat_extract(speech_inputs[0] , return_tensors="np").input_values _A : int = feat_extract(np_speech_inputs[0] , return_tensors="np").input_values self.assertTrue(np.allclose(__lowerCamelCase , __lowerCamelCase , atol=1e-3)) # Test batched _A : int = feat_extract(__lowerCamelCase , padding=__lowerCamelCase , return_tensors="np").input_values _A : Optional[Any] = feat_extract(__lowerCamelCase , padding=__lowerCamelCase , return_tensors="np").input_values for enc_seq_a, enc_seq_a in zip(__lowerCamelCase , __lowerCamelCase): self.assertTrue(np.allclose(__lowerCamelCase , __lowerCamelCase , atol=1e-3)) # Test 2-D numpy arrays are batched. _A : List[Any] = [floats_list((1, x))[0] for x in (8_0_0, 8_0_0, 8_0_0)] _A : List[str] = np.asarray(__lowerCamelCase) _A : Optional[Any] = feat_extract(__lowerCamelCase , return_tensors="np").input_values _A : Union[str, Any] = feat_extract(__lowerCamelCase , return_tensors="np").input_values for enc_seq_a, enc_seq_a in zip(__lowerCamelCase , __lowerCamelCase): self.assertTrue(np.allclose(__lowerCamelCase , __lowerCamelCase , atol=1e-3)) @require_torch def _lowerCamelCase ( self) -> int: import torch _A : List[str] = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()) _A : int = np.random.rand(1_0_0).astype(np.floataa) _A : Dict = np_speech_inputs.tolist() for inputs in [py_speech_inputs, np_speech_inputs]: _A : str = feature_extractor.pad([{"input_values": inputs}] , return_tensors="np") self.assertTrue(np_processed.input_values.dtype == np.floataa) _A : Tuple = feature_extractor.pad([{"input_values": inputs}] , return_tensors="pt") self.assertTrue(pt_processed.input_values.dtype == torch.floataa) def _lowerCamelCase ( self , __lowerCamelCase) -> int: from datasets import load_dataset _A : Dict = load_dataset("hf-internal-testing/librispeech_asr_dummy" , "clean" , split="validation") # automatic decoding with librispeech _A : Dict = ds.sort("id").select(range(__lowerCamelCase))[:num_samples]["audio"] return [x["array"] for x in speech_samples] @require_torch def _lowerCamelCase ( self) -> int: # fmt: off _A : Union[str, Any] = torch.tensor( [-0.9_8_9_4, -1.2_7_7_6, -0.9_0_6_6, -1.2_7_7_6, -0.9_3_4_9, -1.2_6_0_9, -1.0_3_8_6, -1.2_7_7_6, -1.1_5_6_1, -1.2_7_7_6, -1.2_0_5_2, -1.2_7_2_3, -1.2_1_9_0, -1.2_1_3_2, -1.2_7_7_6, -1.1_1_3_3, -1.1_9_5_3, -1.1_3_4_3, -1.1_5_8_4, -1.2_2_0_3, -1.1_7_7_0, -1.2_4_7_4, -1.2_3_8_1, -1.1_9_3_6, -0.9_2_7_0, -0.8_3_1_7, -0.8_0_4_9, -0.7_7_0_6, -0.7_5_6_5, -0.7_8_6_9]) # fmt: on _A : str = self._load_datasamples(1) _A : List[Any] = ASTFeatureExtractor() _A : List[str] = feature_extractor(__lowerCamelCase , return_tensors="pt").input_values self.assertEquals(input_values.shape , (1, 1_0_2_4, 1_2_8)) self.assertTrue(torch.allclose(input_values[0, 0, :3_0] , __lowerCamelCase , atol=1e-4))
11
import importlib.util import json import os import warnings from dataclasses import dataclass, field import torch from ..training_args import TrainingArguments from ..utils import cached_property, is_sagemaker_dp_enabled, logging __A =logging.get_logger(__name__) def lowerCamelCase_ ( ): # Get the sagemaker specific mp parameters from smp_options variable. lowerCamelCase_ = os.getenv("SM_HP_MP_PARAMETERS" , "{}" ) try: # Parse it and check the field "partitions" is included, it is required for model parallel. lowerCamelCase_ = json.loads(lowerCamelCase__ ) if "partitions" not in smp_options: return False except json.JSONDecodeError: return False # Get the sagemaker specific framework parameters from mpi_options variable. lowerCamelCase_ = os.getenv("SM_FRAMEWORK_PARAMS" , "{}" ) try: # Parse it and check the field "sagemaker_distributed_dataparallel_enabled". lowerCamelCase_ = json.loads(lowerCamelCase__ ) if not mpi_options.get("sagemaker_mpi_enabled" , lowerCamelCase__ ): return False except json.JSONDecodeError: return False # Lastly, check if the `smdistributed` module is present. return importlib.util.find_spec("smdistributed" ) is not None if is_sagemaker_model_parallel_available(): import smdistributed.modelparallel.torch as smp smp.init() @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = field( default='' , metadata={'help': 'Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'} , ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: super().__post_init__() warnings.warn( "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use " "`TrainingArguments` instead." , lowercase , ) @cached_property def SCREAMING_SNAKE_CASE_( self ) -> "torch.device": logger.info("PyTorch: setting up devices" ) if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1: logger.warning( "torch.distributed process group is initialized, but local_rank == -1. " "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch" ) if self.no_cuda: lowerCamelCase_ = torch.device("cpu" ) lowerCamelCase_ = 0 elif is_sagemaker_model_parallel_available(): lowerCamelCase_ = smp.local_rank() lowerCamelCase_ = torch.device("cuda" , lowercase ) lowerCamelCase_ = 1 elif is_sagemaker_dp_enabled(): import smdistributed.dataparallel.torch.torch_smddp # noqa: F401 torch.distributed.init_process_group(backend="smddp" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = int(os.getenv("SMDATAPARALLEL_LOCAL_RANK" ) ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 elif self.local_rank == -1: # if n_gpu is > 1 we'll use nn.DataParallel. # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0` # Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will # trigger an error that a device index is missing. Index 0 takes into account the # GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0` # will use the first GPU in that env, i.e. GPU#1 lowerCamelCase_ = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" ) # Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at # the default value. lowerCamelCase_ = torch.cuda.device_count() else: # Here, we'll use torch.distributed. # Initializes the distributed backend which will take care of synchronizing nodes/GPUs if not torch.distributed.is_initialized(): torch.distributed.init_process_group(backend="nccl" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 if device.type == "cuda": torch.cuda.set_device(lowercase ) return device @property def SCREAMING_SNAKE_CASE_( self ) -> Tuple: if is_sagemaker_model_parallel_available(): return smp.dp_size() return super().world_size @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: return not is_sagemaker_model_parallel_available() @property def SCREAMING_SNAKE_CASE_( self ) -> Dict: return False
19
0
'''simple docstring''' import copy import random from transformers import CLIPTokenizer class a__ ( snake_case_ ): def __init__( self : str , *a : int , **a : Any ): """simple docstring""" super().__init__(*a , **a ) __lowerCamelCase = {} def SCREAMING_SNAKE_CASE__ ( self : List[Any] , a : Optional[Any] , *a : Union[str, Any] , **a : Tuple ): """simple docstring""" __lowerCamelCase = super().add_tokens(a , *a , **a ) if num_added_tokens == 0: raise ValueError( f"""The tokenizer already contains the token {placeholder_token}. Please pass a different""" ''' `placeholder_token` that is not already in the tokenizer.''' ) def SCREAMING_SNAKE_CASE__ ( self : Any , a : List[str] , *a : List[Any] , a : List[str]=1 , **a : Tuple ): """simple docstring""" __lowerCamelCase = [] if num_vec_per_token == 1: self.try_adding_tokens(a , *a , **a ) output.append(a ) else: __lowerCamelCase = [] for i in range(a ): __lowerCamelCase = placeholder_token + f"""_{i}""" self.try_adding_tokens(a , *a , **a ) output.append(a ) # handle cases where there is a new placeholder token that contains the current placeholder token but is larger for token in self.token_map: if token in placeholder_token: raise ValueError( f"""The tokenizer already has placeholder token {token} that can get confused with""" f""" {placeholder_token}keep placeholder tokens independent""" ) __lowerCamelCase = output def SCREAMING_SNAKE_CASE__ ( self : Any , a : Optional[int] , a : Optional[int]=False , a : List[Any]=1.0 ): """simple docstring""" if isinstance(a , a ): __lowerCamelCase = [] for i in range(len(a ) ): output.append(self.replace_placeholder_tokens_in_text(text[i] , vector_shuffle=a ) ) return output for placeholder_token in self.token_map: if placeholder_token in text: __lowerCamelCase = self.token_map[placeholder_token] __lowerCamelCase = tokens[: 1 + int(len(a ) * prop_tokens_to_load )] if vector_shuffle: __lowerCamelCase = copy.copy(a ) random.shuffle(a ) __lowerCamelCase = text.replace(a , ''' '''.join(a ) ) return text def __call__( self : str , a : List[Any] , *a : Union[str, Any] , a : Tuple=False , a : Optional[Any]=1.0 , **a : str ): """simple docstring""" return super().__call__( self.replace_placeholder_tokens_in_text( a , vector_shuffle=a , prop_tokens_to_load=a ) , *a , **a , ) def SCREAMING_SNAKE_CASE__ ( self : Optional[int] , a : List[Any] , *a : List[str] , a : Optional[int]=False , a : List[str]=1.0 , **a : Tuple ): """simple docstring""" return super().encode( self.replace_placeholder_tokens_in_text( a , vector_shuffle=a , prop_tokens_to_load=a ) , *a , **a , )
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 0 , lowerCamelCase__ = 0 ): lowerCamelCase_ = end or len(lowerCamelCase__ ) for i in range(lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = i lowerCamelCase_ = array[i] while temp_index != start and temp_index_value < array[temp_index - 1]: lowerCamelCase_ = array[temp_index - 1] temp_index -= 1 lowerCamelCase_ = temp_index_value return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): # Max Heap lowerCamelCase_ = index lowerCamelCase_ = 2 * index + 1 # Left Node lowerCamelCase_ = 2 * index + 2 # Right Node if left_index < heap_size and array[largest] < array[left_index]: lowerCamelCase_ = left_index if right_index < heap_size and array[largest] < array[right_index]: lowerCamelCase_ = right_index if largest != index: lowerCamelCase_ , lowerCamelCase_ = array[largest], array[index] heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) for i in range(n // 2 , -1 , -1 ): heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) for i in range(n - 1 , 0 , -1 ): lowerCamelCase_ , lowerCamelCase_ = array[0], array[i] heapify(lowerCamelCase__ , 0 , lowerCamelCase__ ) return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): if (array[first_index] > array[middle_index]) != ( array[first_index] > array[last_index] ): return array[first_index] elif (array[middle_index] > array[first_index]) != ( array[middle_index] > array[last_index] ): return array[middle_index] else: return array[last_index] def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = low lowerCamelCase_ = high while True: while array[i] < pivot: i += 1 j -= 1 while pivot < array[j]: j -= 1 if i >= j: return i lowerCamelCase_ , lowerCamelCase_ = array[j], array[i] i += 1 def lowerCamelCase_ ( lowerCamelCase__ ): if len(lowerCamelCase__ ) == 0: return array lowerCamelCase_ = 2 * math.ceil(math.loga(len(lowerCamelCase__ ) ) ) lowerCamelCase_ = 1_6 return intro_sort(lowerCamelCase__ , 0 , len(lowerCamelCase__ ) , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): while end - start > size_threshold: if max_depth == 0: return heap_sort(lowerCamelCase__ ) max_depth -= 1 lowerCamelCase_ = median_of_a(lowerCamelCase__ , lowerCamelCase__ , start + ((end - start) // 2) + 1 , end - 1 ) lowerCamelCase_ = partition(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) intro_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = p return insertion_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": import doctest doctest.testmod() __A =input('''Enter numbers separated by a comma : ''').strip() __A =[float(item) for item in user_input.split(''',''')] print(sort(unsorted))
19
0
import torch from torch import nn from transformers import CLIPPreTrainedModel, CLIPVisionModel from ...models.attention import BasicTransformerBlock from ...utils import logging SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) # pylint: disable=invalid-name class __lowerCAmelCase ( snake_case_ ): """simple docstring""" def __init__( self : Tuple , _lowerCAmelCase : Any , _lowerCAmelCase : Optional[Any]=7_6_8 ) -> Optional[int]: """simple docstring""" super().__init__(_lowerCAmelCase ) snake_case_ = proj_size snake_case_ = CLIPVisionModel(_lowerCAmelCase ) snake_case_ = PaintByExampleMapper(_lowerCAmelCase ) snake_case_ = nn.LayerNorm(config.hidden_size ) snake_case_ = nn.Linear(config.hidden_size , self.proj_size ) # uncondition for scaling snake_case_ = nn.Parameter(torch.randn((1, 1, self.proj_size) ) ) def lowerCAmelCase__ ( self : Optional[int] , _lowerCAmelCase : Any , _lowerCAmelCase : Optional[Any]=False ) -> List[Any]: """simple docstring""" snake_case_ = self.model(pixel_values=_lowerCAmelCase ) snake_case_ = clip_output.pooler_output snake_case_ = self.mapper(latent_states[:, None] ) snake_case_ = self.final_layer_norm(_lowerCAmelCase ) snake_case_ = self.proj_out(_lowerCAmelCase ) if return_uncond_vector: return latent_states, self.uncond_vector return latent_states class __lowerCAmelCase ( nn.Module ): """simple docstring""" def __init__( self : Any , _lowerCAmelCase : Union[str, Any] ) -> Any: """simple docstring""" super().__init__() snake_case_ = (config.num_hidden_layers + 1) // 5 snake_case_ = config.hidden_size snake_case_ = 1 snake_case_ = nn.ModuleList( [ BasicTransformerBlock(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , activation_fn="gelu" , attention_bias=_lowerCAmelCase ) for _ in range(_lowerCAmelCase ) ] ) def lowerCAmelCase__ ( self : Union[str, Any] , _lowerCAmelCase : Any ) -> Tuple: """simple docstring""" for block in self.blocks: snake_case_ = block(_lowerCAmelCase ) return hidden_states
159
import math import time from typing import Dict, List, Optional from torch.utils.data import Dataset from transformers import SeqaSeqTrainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , *lowercase , lowercase=None , lowercase=None , **lowercase ) -> List[str]: super().__init__(*lowercase , **lowercase ) lowerCamelCase_ = eval_examples lowerCamelCase_ = post_process_function def SCREAMING_SNAKE_CASE_( self , lowercase = None , lowercase=None , lowercase = None , lowercase = "eval" , **lowercase , ) -> Dict[str, float]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = ( gen_kwargs["max_length"] if gen_kwargs.get("max_length" ) is not None else self.args.generation_max_length ) lowerCamelCase_ = ( gen_kwargs["num_beams"] if gen_kwargs.get("num_beams" ) is not None else self.args.generation_num_beams ) lowerCamelCase_ = gen_kwargs lowerCamelCase_ = self.eval_dataset if eval_dataset is None else eval_dataset lowerCamelCase_ = self.get_eval_dataloader(lowercase ) lowerCamelCase_ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Evaluation" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) else: lowerCamelCase_ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(lowercase ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) lowerCamelCase_ = self.callback_handler.on_evaluate(self.args , self.state , self.control , lowercase ) return metrics def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=None , lowercase = "test" , **lowercase ) -> Union[str, Any]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = self.get_test_dataloader(lowercase ) # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Prediction" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase , "predict" ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=lowercase )
19
0
"""simple docstring""" from collections import deque class _UpperCamelCase : '''simple docstring''' def __init__( self , __a , __a , __a ): __lowerCAmelCase = process_name # process name __lowerCAmelCase = arrival_time # arrival time of the process # completion time of finished process or last interrupted time __lowerCAmelCase = arrival_time __lowerCAmelCase = burst_time # remaining burst time __lowerCAmelCase = 0 # total time of the process wait in ready queue __lowerCAmelCase = 0 # time from arrival time to completion time class _UpperCamelCase : '''simple docstring''' def __init__( self , __a , __a , __a , __a , ): # total number of mlfq's queues __lowerCAmelCase = number_of_queues # time slice of queues that round robin algorithm applied __lowerCAmelCase = time_slices # unfinished process is in this ready_queue __lowerCAmelCase = queue # current time __lowerCAmelCase = current_time # finished process is in this sequence queue __lowerCAmelCase = deque() def snake_case ( self ): __lowerCAmelCase = [] for i in range(len(self.finish_queue ) ): sequence.append(self.finish_queue[i].process_name ) return sequence def snake_case ( self , __a ): __lowerCAmelCase = [] for i in range(len(__a ) ): waiting_times.append(queue[i].waiting_time ) return waiting_times def snake_case ( self , __a ): __lowerCAmelCase = [] for i in range(len(__a ) ): turnaround_times.append(queue[i].turnaround_time ) return turnaround_times def snake_case ( self , __a ): __lowerCAmelCase = [] for i in range(len(__a ) ): completion_times.append(queue[i].stop_time ) return completion_times def snake_case ( self , __a ): return [q.burst_time for q in queue] def snake_case ( self , __a ): process.waiting_time += self.current_time - process.stop_time return process.waiting_time def snake_case ( self , __a ): __lowerCAmelCase = deque() # sequence deque of finished process while len(__a ) != 0: __lowerCAmelCase = ready_queue.popleft() # current process # if process's arrival time is later than current time, update current time if self.current_time < cp.arrival_time: self.current_time += cp.arrival_time # update waiting time of current process self.update_waiting_time(__a ) # update current time self.current_time += cp.burst_time # finish the process and set the process's burst-time 0 __lowerCAmelCase = 0 # set the process's turnaround time because it is finished __lowerCAmelCase = self.current_time - cp.arrival_time # set the completion time __lowerCAmelCase = self.current_time # add the process to queue that has finished queue finished.append(__a ) self.finish_queue.extend(__a ) # add finished process to finish queue # FCFS will finish all remaining processes return finished def snake_case ( self , __a , __a ): __lowerCAmelCase = deque() # sequence deque of terminated process # just for 1 cycle and unfinished processes will go back to queue for _ in range(len(__a ) ): __lowerCAmelCase = ready_queue.popleft() # current process # if process's arrival time is later than current time, update current time if self.current_time < cp.arrival_time: self.current_time += cp.arrival_time # update waiting time of unfinished processes self.update_waiting_time(__a ) # if the burst time of process is bigger than time-slice if cp.burst_time > time_slice: # use CPU for only time-slice self.current_time += time_slice # update remaining burst time cp.burst_time -= time_slice # update end point time __lowerCAmelCase = self.current_time # locate the process behind the queue because it is not finished ready_queue.append(__a ) else: # use CPU for remaining burst time self.current_time += cp.burst_time # set burst time 0 because the process is finished __lowerCAmelCase = 0 # set the finish time __lowerCAmelCase = self.current_time # update the process' turnaround time because it is finished __lowerCAmelCase = self.current_time - cp.arrival_time # add the process to queue that has finished queue finished.append(__a ) self.finish_queue.extend(__a ) # add finished process to finish queue # return finished processes queue and remaining processes queue return finished, ready_queue def snake_case ( self ): # all queues except last one have round_robin algorithm for i in range(self.number_of_queues - 1 ): __lowerCAmelCase , __lowerCAmelCase = self.round_robin( self.ready_queue , self.time_slices[i] ) # the last queue has first_come_first_served algorithm self.first_come_first_served(self.ready_queue ) return self.finish_queue if __name__ == "__main__": import doctest A : Tuple = Process("P1", 0, 5_3) A : Optional[int] = Process("P2", 0, 1_7) A : Union[str, Any] = Process("P3", 0, 6_8) A : Dict = Process("P4", 0, 2_4) A : Any = 3 A : Optional[Any] = [1_7, 2_5] A : Any = deque([Pa, Pa, Pa, Pa]) if len(time_slices) != number_of_queues - 1: raise SystemExit(0) doctest.testmod(extraglobs={"queue": deque([Pa, Pa, Pa, Pa])}) A : List[str] = Process("P1", 0, 5_3) A : int = Process("P2", 0, 1_7) A : Tuple = Process("P3", 0, 6_8) A : List[Any] = Process("P4", 0, 2_4) A : int = 3 A : str = [1_7, 2_5] A : str = deque([Pa, Pa, Pa, Pa]) A : List[Any] = MLFQ(number_of_queues, time_slices, queue, 0) A : Optional[Any] = mlfq.multi_level_feedback_queue() # print total waiting times of processes(P1, P2, P3, P4) print( f'''waiting time:\ \t\t\t{MLFQ.calculate_waiting_time(mlfq, [Pa, Pa, Pa, Pa])}''' ) # print completion times of processes(P1, P2, P3, P4) print( f'''completion time:\ \t\t{MLFQ.calculate_completion_time(mlfq, [Pa, Pa, Pa, Pa])}''' ) # print total turnaround times of processes(P1, P2, P3, P4) print( f'''turnaround time:\ \t\t{MLFQ.calculate_turnaround_time(mlfq, [Pa, Pa, Pa, Pa])}''' ) # print sequence of finished processes print( f'''sequence of finished processes:\ {mlfq.calculate_sequence_of_finish_queue()}''' )
57
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __A =logging.get_logger(__name__) # pylint: disable=invalid-name __A =''' Examples: ```py >>> from PIL import Image >>> import torch >>> from diffusers import DiffusionPipeline >>> from diffusers.utils import export_to_gif, load_image >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu") >>> repo = "openai/shap-e-img2img" >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16) >>> pipe = pipe.to(device) >>> guidance_scale = 3.0 >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png" >>> image = load_image(image_url).convert("RGB") >>> images = pipe( ... image, ... guidance_scale=guidance_scale, ... num_inference_steps=64, ... frame_size=256, ... ).images >>> gif_path = export_to_gif(images[0], "corgi_3d.gif") ``` ''' @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: super().__init__() self.register_modules( prior=lowercase , image_encoder=lowercase , image_processor=lowercase , scheduler=lowercase , renderer=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if latents is None: lowerCamelCase_ = randn_tensor(lowercase , generator=lowercase , device=lowercase , dtype=lowercase ) else: if latents.shape != shape: raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {shape}' ) lowerCamelCase_ = latents.to(lowercase ) lowerCamelCase_ = latents * scheduler.init_noise_sigma return latents def SCREAMING_SNAKE_CASE_( self , lowercase=0 ) -> int: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device(f'cuda:{gpu_id}' ) lowerCamelCase_ = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: if self.device != torch.device("meta" ) or not hasattr(self.image_encoder , "_hf_hook" ): return self.device for module in self.image_encoder.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: if isinstance(lowercase , lowercase ) and isinstance(image[0] , torch.Tensor ): lowerCamelCase_ = torch.cat(lowercase , axis=0 ) if image[0].ndim == 4 else torch.stack(lowercase , axis=0 ) if not isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = self.image_processor(lowercase , return_tensors="pt" ).pixel_values[0].unsqueeze(0 ) lowerCamelCase_ = image.to(dtype=self.image_encoder.dtype , device=lowercase ) lowerCamelCase_ = self.image_encoder(lowercase )["last_hidden_state"] lowerCamelCase_ = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 lowerCamelCase_ = image_embeds.repeat_interleave(lowercase , dim=0 ) if do_classifier_free_guidance: lowerCamelCase_ = torch.zeros_like(lowercase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes lowerCamelCase_ = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(lowercase ) def __call__( self , lowercase , lowercase = 1 , lowercase = 25 , lowercase = None , lowercase = None , lowercase = 4.0 , lowercase = 64 , lowercase = "pil" , lowercase = True , ) -> Union[str, Any]: if isinstance(lowercase , PIL.Image.Image ): lowerCamelCase_ = 1 elif isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = image.shape[0] elif isinstance(lowercase , lowercase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): lowerCamelCase_ = len(lowercase ) else: raise ValueError( f'`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(lowercase )}' ) lowerCamelCase_ = self._execution_device lowerCamelCase_ = batch_size * num_images_per_prompt lowerCamelCase_ = guidance_scale > 1.0 lowerCamelCase_ = self._encode_image(lowercase , lowercase , lowercase , lowercase ) # prior self.scheduler.set_timesteps(lowercase , device=lowercase ) lowerCamelCase_ = self.scheduler.timesteps lowerCamelCase_ = self.prior.config.num_embeddings lowerCamelCase_ = self.prior.config.embedding_dim lowerCamelCase_ = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , lowercase , lowercase , lowercase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim lowerCamelCase_ = latents.reshape(latents.shape[0] , lowercase , lowercase ) for i, t in enumerate(self.progress_bar(lowercase ) ): # expand the latents if we are doing classifier free guidance lowerCamelCase_ = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents lowerCamelCase_ = self.scheduler.scale_model_input(lowercase , lowercase ) lowerCamelCase_ = self.prior( lowercase , timestep=lowercase , proj_embedding=lowercase , ).predicted_image_embedding # remove the variance lowerCamelCase_ , lowerCamelCase_ = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: lowerCamelCase_ , lowerCamelCase_ = noise_pred.chunk(2 ) lowerCamelCase_ = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) lowerCamelCase_ = self.scheduler.step( lowercase , timestep=lowercase , sample=lowercase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=lowercase ) lowerCamelCase_ = [] for i, latent in enumerate(lowercase ): print() lowerCamelCase_ = self.renderer.decode( latent[None, :] , lowercase , size=lowercase , ray_batch_size=4096 , n_coarse_samples=64 , n_fine_samples=128 , ) images.append(lowercase ) lowerCamelCase_ = torch.stack(lowercase ) if output_type not in ["np", "pil"]: raise ValueError(f'Only the output types `pil` and `np` are supported not output_type={output_type}' ) lowerCamelCase_ = images.cpu().numpy() if output_type == "pil": lowerCamelCase_ = [self.numpy_to_pil(lowercase ) for image in images] # Offload last model to CPU if hasattr(self , "final_offload_hook" ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=lowercase )
19
0
import argparse import glob import logging import os from argparse import Namespace from importlib import import_module import numpy as np import torch from lightning_base import BaseTransformer, add_generic_args, generic_train from seqeval.metrics import accuracy_score, fa_score, precision_score, recall_score from torch.nn import CrossEntropyLoss from torch.utils.data import DataLoader, TensorDataset from utils_ner import TokenClassificationTask lowerCAmelCase__ : Any =logging.getLogger(__name__) class UpperCAmelCase_ ( snake_case_ ): '''simple docstring''' UpperCamelCase__ : Union[str, Any] = '''token-classification''' def __init__( self , _A ): '''simple docstring''' if type(_A ) == dict: __SCREAMING_SNAKE_CASE = Namespace(**_A ) __SCREAMING_SNAKE_CASE = import_module('tasks' ) try: __SCREAMING_SNAKE_CASE = getattr(_A , hparams.task_type ) __SCREAMING_SNAKE_CASE = token_classification_task_clazz() except AttributeError: raise ValueError( f"""Task {hparams.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. """ f"""Available tasks classes are: {TokenClassificationTask.__subclasses__()}""" ) __SCREAMING_SNAKE_CASE = self.token_classification_task.get_labels(hparams.labels ) __SCREAMING_SNAKE_CASE = CrossEntropyLoss().ignore_index super().__init__(_A , len(self.labels ) , self.mode ) def _A ( self , **_A ): '''simple docstring''' return self.model(**_A ) def _A ( self , _A , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = {'input_ids': batch[0], 'attention_mask': batch[1], 'labels': batch[3]} if self.config.model_type != "distilbert": __SCREAMING_SNAKE_CASE = ( batch[2] if self.config.model_type in ['bert', 'xlnet'] else None ) # XLM and RoBERTa don"t use token_type_ids __SCREAMING_SNAKE_CASE = self(**_A ) __SCREAMING_SNAKE_CASE = outputs[0] # tensorboard_logs = {"loss": loss, "rate": self.lr_scheduler.get_last_lr()[-1]} return {"loss": loss} def _A ( self ): '''simple docstring''' __SCREAMING_SNAKE_CASE = self.hparams for mode in ["train", "dev", "test"]: __SCREAMING_SNAKE_CASE = self._feature_file(_A ) if os.path.exists(_A ) and not args.overwrite_cache: logger.info('Loading features from cached file %s' , _A ) __SCREAMING_SNAKE_CASE = torch.load(_A ) else: logger.info('Creating features from dataset file at %s' , args.data_dir ) __SCREAMING_SNAKE_CASE = self.token_classification_task.read_examples_from_file(args.data_dir , _A ) __SCREAMING_SNAKE_CASE = self.token_classification_task.convert_examples_to_features( _A , self.labels , args.max_seq_length , self.tokenizer , cls_token_at_end=bool(self.config.model_type in ['xlnet'] ) , cls_token=self.tokenizer.cls_token , cls_token_segment_id=2 if self.config.model_type in ['xlnet'] else 0 , sep_token=self.tokenizer.sep_token , sep_token_extra=_A , pad_on_left=bool(self.config.model_type in ['xlnet'] ) , pad_token=self.tokenizer.pad_token_id , pad_token_segment_id=self.tokenizer.pad_token_type_id , pad_token_label_id=self.pad_token_label_id , ) logger.info('Saving features into cached file %s' , _A ) torch.save(_A , _A ) def _A ( self , _A , _A , _A = False ): '''simple docstring''' __SCREAMING_SNAKE_CASE = self._feature_file(_A ) logger.info('Loading features from cached file %s' , _A ) __SCREAMING_SNAKE_CASE = torch.load(_A ) __SCREAMING_SNAKE_CASE = torch.tensor([f.input_ids for f in features] , dtype=torch.long ) __SCREAMING_SNAKE_CASE = torch.tensor([f.attention_mask for f in features] , dtype=torch.long ) if features[0].token_type_ids is not None: __SCREAMING_SNAKE_CASE = torch.tensor([f.token_type_ids for f in features] , dtype=torch.long ) else: __SCREAMING_SNAKE_CASE = torch.tensor([0 for f in features] , dtype=torch.long ) # HACK(we will not use this anymore soon) __SCREAMING_SNAKE_CASE = torch.tensor([f.label_ids for f in features] , dtype=torch.long ) return DataLoader( TensorDataset(_A , _A , _A , _A ) , batch_size=_A ) def _A ( self , _A , _A ): '''simple docstring''' """Compute validation""" "" __SCREAMING_SNAKE_CASE = {'input_ids': batch[0], 'attention_mask': batch[1], 'labels': batch[3]} if self.config.model_type != "distilbert": __SCREAMING_SNAKE_CASE = ( batch[2] if self.config.model_type in ['bert', 'xlnet'] else None ) # XLM and RoBERTa don"t use token_type_ids __SCREAMING_SNAKE_CASE = self(**_A ) __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = outputs[:2] __SCREAMING_SNAKE_CASE = logits.detach().cpu().numpy() __SCREAMING_SNAKE_CASE = inputs['labels'].detach().cpu().numpy() return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids} def _A ( self , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE = torch.stack([x['val_loss'] for x in outputs] ).mean() __SCREAMING_SNAKE_CASE = np.concatenate([x['pred'] for x in outputs] , axis=0 ) __SCREAMING_SNAKE_CASE = np.argmax(_A , axis=2 ) __SCREAMING_SNAKE_CASE = np.concatenate([x['target'] for x in outputs] , axis=0 ) __SCREAMING_SNAKE_CASE = dict(enumerate(self.labels ) ) __SCREAMING_SNAKE_CASE = [[] for _ in range(out_label_ids.shape[0] )] __SCREAMING_SNAKE_CASE = [[] for _ in range(out_label_ids.shape[0] )] for i in range(out_label_ids.shape[0] ): for j in range(out_label_ids.shape[1] ): if out_label_ids[i, j] != self.pad_token_label_id: out_label_list[i].append(label_map[out_label_ids[i][j]] ) preds_list[i].append(label_map[preds[i][j]] ) __SCREAMING_SNAKE_CASE = { 'val_loss': val_loss_mean, 'accuracy_score': accuracy_score(_A , _A ), 'precision': precision_score(_A , _A ), 'recall': recall_score(_A , _A ), 'f1': fa_score(_A , _A ), } __SCREAMING_SNAKE_CASE = dict(results.items() ) __SCREAMING_SNAKE_CASE = results return ret, preds_list, out_label_list def _A ( self , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = self._eval_end(_A ) __SCREAMING_SNAKE_CASE = ret['log'] return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs} def _A ( self , _A ): '''simple docstring''' __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = self._eval_end(_A ) # Converting to the dict required by pl # https://github.com/PyTorchLightning/pytorch-lightning/blob/master/\ # pytorch_lightning/trainer/logging.py#L139 __SCREAMING_SNAKE_CASE = ret['log'] # `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss` return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs} @staticmethod def _A ( _A , _A ): '''simple docstring''' BaseTransformer.add_model_specific_args(_A , _A ) parser.add_argument( '--task_type' , default='NER' , type=_A , help='Task type to fine tune in training (e.g. NER, POS, etc)' ) parser.add_argument( '--max_seq_length' , default=128 , type=_A , help=( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) , ) parser.add_argument( '--labels' , default='' , type=_A , help='Path to a file containing all labels. If not specified, CoNLL-2003 labels are used.' , ) parser.add_argument( '--gpus' , default=0 , type=_A , help='The number of GPUs allocated for this, it is by default 0 meaning none' , ) parser.add_argument( '--overwrite_cache' , action='store_true' , help='Overwrite the cached training and evaluation sets' ) return parser if __name__ == "__main__": lowerCAmelCase__ : int =argparse.ArgumentParser() add_generic_args(parser, os.getcwd()) lowerCAmelCase__ : Dict =NERTransformer.add_model_specific_args(parser, os.getcwd()) lowerCAmelCase__ : Dict =parser.parse_args() lowerCAmelCase__ : Tuple =NERTransformer(args) lowerCAmelCase__ : Tuple =generic_train(model, args) if args.do_predict: # See https://github.com/huggingface/transformers/issues/3159 # pl use this default format to create a checkpoint: # https://github.com/PyTorchLightning/pytorch-lightning/blob/master\ # /pytorch_lightning/callbacks/model_checkpoint.py#L322 lowerCAmelCase__ : Tuple =sorted(glob.glob(os.path.join(args.output_dir, '''checkpoint-epoch=*.ckpt'''), recursive=True)) lowerCAmelCase__ : List[Any] =model.load_from_checkpoint(checkpoints[-1]) trainer.test(model)
257
from collections import defaultdict from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst def lowerCamelCase_ ( ): lowerCamelCase_ , lowerCamelCase_ = 9, 1_4 # noqa: F841 lowerCamelCase_ = [ [0, 1, 4], [0, 7, 8], [1, 2, 8], [7, 8, 7], [7, 6, 1], [2, 8, 2], [8, 6, 6], [2, 3, 7], [2, 5, 4], [6, 5, 2], [3, 5, 1_4], [3, 4, 9], [5, 4, 1_0], [1, 7, 1_1], ] lowerCamelCase_ = defaultdict(lowerCamelCase__ ) for nodea, nodea, cost in edges: adjancency[nodea].append([nodea, cost] ) adjancency[nodea].append([nodea, cost] ) lowerCamelCase_ = mst(lowerCamelCase__ ) lowerCamelCase_ = [ [7, 6, 1], [2, 8, 2], [6, 5, 2], [0, 1, 4], [2, 5, 4], [2, 3, 7], [0, 7, 8], [3, 4, 9], ] for answer in expected: lowerCamelCase_ = tuple(answer[:2] ) lowerCamelCase_ = tuple(edge[::-1] ) assert edge in result or reverse in result
19
0
"""simple docstring""" import inspect import unittest from transformers import DecisionTransformerConfig, is_torch_available 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, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import DecisionTransformerModel from transformers.models.decision_transformer.modeling_decision_transformer import ( DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ) class lowerCAmelCase_ : '''simple docstring''' def __init__( self : int ,A_ : List[Any] ,A_ : str=13 ,A_ : List[Any]=7 ,A_ : List[str]=6 ,A_ : Any=17 ,A_ : int=23 ,A_ : Optional[int]=11 ,A_ : Union[str, Any]=True ,) -> int: A = parent A = batch_size A = seq_length A = act_dim A = state_dim A = hidden_size A = max_length A = is_training def _SCREAMING_SNAKE_CASE ( self : int ) -> Union[str, Any]: A = floats_tensor((self.batch_size, self.seq_length, self.state_dim) ) A = floats_tensor((self.batch_size, self.seq_length, self.act_dim) ) A = floats_tensor((self.batch_size, self.seq_length, 1) ) A = floats_tensor((self.batch_size, self.seq_length, 1) ) A = ids_tensor((self.batch_size, self.seq_length) ,vocab_size=1000 ) A = random_attention_mask((self.batch_size, self.seq_length) ) A = self.get_config() return ( config, states, actions, rewards, returns_to_go, timesteps, attention_mask, ) def _SCREAMING_SNAKE_CASE ( self : int ) -> Any: return DecisionTransformerConfig( batch_size=self.batch_size ,seq_length=self.seq_length ,act_dim=self.act_dim ,state_dim=self.state_dim ,hidden_size=self.hidden_size ,max_length=self.max_length ,) def _SCREAMING_SNAKE_CASE ( self : List[Any] ,A_ : str ,A_ : int ,A_ : Union[str, Any] ,A_ : int ,A_ : str ,A_ : int ,A_ : Tuple ,) -> List[str]: A = DecisionTransformerModel(config=A_ ) model.to(A_ ) model.eval() A = model(A_ ,A_ ,A_ ,A_ ,A_ ,A_ ) self.parent.assertEqual(result.state_preds.shape ,states.shape ) self.parent.assertEqual(result.action_preds.shape ,actions.shape ) self.parent.assertEqual(result.return_preds.shape ,returns_to_go.shape ) self.parent.assertEqual( result.last_hidden_state.shape ,(self.batch_size, self.seq_length * 3, self.hidden_size) ) # seq length *3 as there are 3 modelities: states, returns and actions def _SCREAMING_SNAKE_CASE ( self : Dict ) -> Optional[Any]: A = self.prepare_config_and_inputs() ( ( A ) , ( A ) , ( A ) , ( A ) , ( A ) , ( A ) , ( A ) , ) = config_and_inputs A = { 'states': states, 'actions': actions, 'rewards': rewards, 'returns_to_go': returns_to_go, 'timesteps': timesteps, 'attention_mask': attention_mask, } return config, inputs_dict @require_torch class lowerCAmelCase_ ( snake_case_ , snake_case_ , snake_case_ , unittest.TestCase ): '''simple docstring''' _lowerCamelCase: Tuple = (DecisionTransformerModel,) if is_torch_available() else () _lowerCamelCase: str = () _lowerCamelCase: int = {'''feature-extraction''': DecisionTransformerModel} if is_torch_available() else {} # Ignoring of a failing test from GenerationTesterMixin, as the model does not use inputs_ids _lowerCamelCase: str = False # Ignoring of a failing tests from ModelTesterMixin, as the model does not implement these features _lowerCamelCase: Any = False _lowerCamelCase: List[Any] = False _lowerCamelCase: List[Any] = False _lowerCamelCase: Any = False _lowerCamelCase: List[str] = False _lowerCamelCase: List[str] = False _lowerCamelCase: Dict = False _lowerCamelCase: List[Any] = False _lowerCamelCase: Optional[Any] = False def _SCREAMING_SNAKE_CASE ( self : Tuple ) -> Optional[int]: A = DecisionTransformerModelTester(self ) A = ConfigTester(self ,config_class=A_ ,hidden_size=37 ) def _SCREAMING_SNAKE_CASE ( self : Dict ) -> Any: self.config_tester.run_common_tests() def _SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> Optional[int]: A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A_ ) @slow def _SCREAMING_SNAKE_CASE ( self : Dict ) -> Optional[Any]: for model_name in DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: A = DecisionTransformerModel.from_pretrained(A_ ) self.assertIsNotNone(A_ ) def _SCREAMING_SNAKE_CASE ( self : List[str] ) -> Any: A , A = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: A = model_class(A_ ) A = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic A = [*signature.parameters.keys()] A = [ 'states', 'actions', 'rewards', 'returns_to_go', 'timesteps', 'attention_mask', ] self.assertListEqual(arg_names[: len(A_ )] ,A_ ) @require_torch class lowerCAmelCase_ ( unittest.TestCase ): '''simple docstring''' @slow def _SCREAMING_SNAKE_CASE ( self : List[Any] ) -> List[Any]: A = 2 # number of steps of autoregressive prediction we will perform A = 10 # defined by the RL environment, may be normalized A = DecisionTransformerModel.from_pretrained('edbeeching/decision-transformer-gym-hopper-expert' ) A = model.to(A_ ) A = model.config torch.manual_seed(0 ) A = torch.randn(1 ,1 ,config.state_dim ).to(device=A_ ,dtype=torch.floataa ) # env.reset() A = torch.tensor( [[0.24_27_93, -0.28_69_30_74, 0.8_74_26_13], [0.67_81_52_74, -0.08_10_10_85, -0.12_95_21_47]] ,device=A_ ) A = torch.tensor(A_ ,device=A_ ,dtype=torch.floataa ).reshape(1 ,1 ,1 ) A = state A = torch.zeros(1 ,0 ,config.act_dim ,device=A_ ,dtype=torch.floataa ) A = torch.zeros(1 ,0 ,device=A_ ,dtype=torch.floataa ) A = torch.tensor(0 ,device=A_ ,dtype=torch.long ).reshape(1 ,1 ) for step in range(A_ ): A = torch.cat([actions, torch.zeros(1 ,1 ,config.act_dim ,device=A_ )] ,dim=1 ) A = torch.cat([rewards, torch.zeros(1 ,1 ,device=A_ )] ,dim=1 ) A = torch.ones(1 ,states.shape[1] ).to(dtype=torch.long ,device=states.device ) with torch.no_grad(): A , A , A = model( states=A_ ,actions=A_ ,rewards=A_ ,returns_to_go=A_ ,timesteps=A_ ,attention_mask=A_ ,return_dict=A_ ,) self.assertEqual(action_pred.shape ,actions.shape ) self.assertTrue(torch.allclose(action_pred[0, -1] ,expected_outputs[step] ,atol=1e-4 ) ) A , A , A , A = ( # env.step(action) torch.randn(1 ,1 ,config.state_dim ).to(device=A_ ,dtype=torch.floataa ), 1.0, False, {}, ) A = action_pred[0, -1] A = torch.cat([states, state] ,dim=1 ) A = returns_to_go[0, -1] - reward A = torch.cat([returns_to_go, pred_return.reshape(1 ,1 ,1 )] ,dim=1 ) A = torch.cat( [timesteps, torch.ones((1, 1) ,device=A_ ,dtype=torch.long ) * (step + 1)] ,dim=1 )
74
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, # specifically showcasing the experiment tracking capability, # and builds off the `nlp_example.py` script. # # 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 help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## __A =1_6 __A =3_2 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 1_6 ): lowerCamelCase_ = AutoTokenizer.from_pretrained("bert-base-cased" ) lowerCamelCase_ = load_dataset("glue" , "mrpc" ) def tokenize_function(lowerCamelCase__ ): # max_length=None => use the model max length (it's actually the default) lowerCamelCase_ = tokenizer(examples["sentence1"] , examples["sentence2"] , truncation=lowerCamelCase__ , max_length=lowerCamelCase__ ) 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(): lowerCamelCase_ = datasets.map( lowerCamelCase__ , batched=lowerCamelCase__ , 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 lowerCamelCase_ = tokenized_datasets.rename_column("label" , "labels" ) def collate_fn(lowerCamelCase__ ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCamelCase_ = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCamelCase_ = 1_6 elif accelerator.mixed_precision != "no": lowerCamelCase_ = 8 else: lowerCamelCase_ = None return tokenizer.pad( lowerCamelCase__ , padding="longest" , max_length=lowerCamelCase__ , pad_to_multiple_of=lowerCamelCase__ , return_tensors="pt" , ) # Instantiate dataloaders. lowerCamelCase_ = DataLoader( tokenized_datasets["train"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) lowerCamelCase_ = DataLoader( tokenized_datasets["validation"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) 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 __A =mocked_dataloaders # noqa: F811 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): # For testing only if os.environ.get("TESTING_MOCKED_DATALOADERS" , lowerCamelCase__ ) == "1": lowerCamelCase_ = 2 # Initialize Accelerator # New Code # # We pass in "all" to `log_with` to grab all available trackers in the environment # Note: If using a custom `Tracker` class, should be passed in here such as: # >>> log_with = ["all", MyCustomTrackerClassInstance()] if args.with_tracking: lowerCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , log_with="all" , project_dir=args.project_dir ) else: lowerCamelCase_ = Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCamelCase_ = config["lr"] lowerCamelCase_ = int(config["num_epochs"] ) lowerCamelCase_ = int(config["seed"] ) lowerCamelCase_ = int(config["batch_size"] ) set_seed(lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = get_dataloaders(lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = evaluate.load("glue" , "mrpc" ) # If the batch size is too big we use gradient accumulation lowerCamelCase_ = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: lowerCamelCase_ = batch_size // MAX_GPU_BATCH_SIZE lowerCamelCase_ = MAX_GPU_BATCH_SIZE # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCamelCase_ = AutoModelForSequenceClassification.from_pretrained("bert-base-cased" , return_dict=lowerCamelCase__ ) # 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). lowerCamelCase_ = model.to(accelerator.device ) # Instantiate optimizer lowerCamelCase_ = AdamW(params=model.parameters() , lr=lowerCamelCase__ ) # Instantiate scheduler lowerCamelCase_ = get_linear_schedule_with_warmup( optimizer=lowerCamelCase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowerCamelCase__ ) * num_epochs) // gradient_accumulation_steps , ) # 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. lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = accelerator.prepare( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # New Code # # We need to initialize the trackers we use. Overall configurations can also be stored if args.with_tracking: lowerCamelCase_ = os.path.split(lowerCamelCase__ )[-1].split("." )[0] accelerator.init_trackers(lowerCamelCase__ , lowerCamelCase__ ) # Now we train the model for epoch in range(lowerCamelCase__ ): model.train() # New Code # # For our tracking example, we will log the total loss of each epoch if args.with_tracking: lowerCamelCase_ = 0 for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.loss # New Code # if args.with_tracking: total_loss += loss.detach().float() lowerCamelCase_ = loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True` (the default). batch.to(accelerator.device ) with torch.no_grad(): lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.logits.argmax(dim=-1 ) lowerCamelCase_ , lowerCamelCase_ = accelerator.gather_for_metrics((predictions, batch["labels"]) ) metric.add_batch( predictions=lowerCamelCase__ , references=lowerCamelCase__ , ) lowerCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(F'epoch {epoch}:' , lowerCamelCase__ ) # New Code # # To actually log, we call `Accelerator.log` # The values passed can be of `str`, `int`, `float` or `dict` of `str` to `float`/`int` if args.with_tracking: accelerator.log( { "accuracy": eval_metric["accuracy"], "f1": eval_metric["f1"], "train_loss": total_loss.item() / len(lowerCamelCase__ ), "epoch": epoch, } , step=lowerCamelCase__ , ) # New Code # # When a run is finished, you should call `accelerator.end_training()` # to close all of the open trackers if args.with_tracking: accelerator.end_training() def lowerCamelCase_ ( ): lowerCamelCase_ = argparse.ArgumentParser(description="Simple example of training script." ) parser.add_argument( "--mixed_precision" , type=lowerCamelCase__ , default=lowerCamelCase__ , 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." , ) parser.add_argument("--cpu" , action="store_true" , help="If passed, will train on the CPU." ) parser.add_argument( "--with_tracking" , action="store_true" , help="Whether to load in all available experiment trackers from the environment and use them for logging." , ) parser.add_argument( "--project_dir" , type=lowerCamelCase__ , default="logs" , help="Location on where to store experiment tracking logs` and relevent project information" , ) lowerCamelCase_ = parser.parse_args() lowerCamelCase_ = {"lr": 2e-5, "num_epochs": 3, "seed": 4_2, "batch_size": 1_6} training_function(lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": main()
19
0
"""simple docstring""" _UpperCamelCase: int = [ 'Audio', 'Array2D', 'Array3D', 'Array4D', 'Array5D', 'ClassLabel', 'Features', 'Sequence', 'Value', 'Image', 'Translation', 'TranslationVariableLanguages', ] from .audio import Audio from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value from .image import Image from .translation import Translation, TranslationVariableLanguages
255
import os from shutil import copyfile from typing import List, Optional, Tuple from tokenizers import processors from ...tokenization_utils import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_mbart import MBartTokenizer else: __A =None __A =logging.get_logger(__name__) __A ={'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''} __A ={ '''vocab_file''': { '''facebook/mbart-large-en-ro''': ( '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model''' ), '''facebook/mbart-large-cc25''': ( '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model''' ), }, '''tokenizer_file''': { '''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''', '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''', }, } __A ={ '''facebook/mbart-large-en-ro''': 1_0_2_4, '''facebook/mbart-large-cc25''': 1_0_2_4, } # fmt: off __A =['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN'''] class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = VOCAB_FILES_NAMES lowerCAmelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowerCAmelCase__ = PRETRAINED_VOCAB_FILES_MAP lowerCAmelCase__ = ['input_ids', 'attention_mask'] lowerCAmelCase__ = MBartTokenizer lowerCAmelCase__ = [] lowerCAmelCase__ = [] def __init__( self , lowercase=None , lowercase=None , lowercase="<s>" , lowercase="</s>" , lowercase="</s>" , lowercase="<s>" , lowercase="<unk>" , lowercase="<pad>" , lowercase="<mask>" , lowercase=None , lowercase=None , lowercase=None , **lowercase , ) -> Dict: # Mask token behave like a normal word, i.e. include the space before it lowerCamelCase_ = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else mask_token super().__init__( vocab_file=lowercase , tokenizer_file=lowercase , bos_token=lowercase , eos_token=lowercase , sep_token=lowercase , cls_token=lowercase , unk_token=lowercase , pad_token=lowercase , mask_token=lowercase , src_lang=lowercase , tgt_lang=lowercase , additional_special_tokens=lowercase , **lowercase , ) lowerCamelCase_ = vocab_file lowerCamelCase_ = False if not self.vocab_file else True lowerCamelCase_ = FAIRSEQ_LANGUAGE_CODES.copy() if additional_special_tokens is not None: # Only add those special tokens if they are not already there. _additional_special_tokens.extend( [t for t in additional_special_tokens if t not in _additional_special_tokens] ) self.add_special_tokens({"additional_special_tokens": _additional_special_tokens} ) lowerCamelCase_ = { lang_code: self.convert_tokens_to_ids(lowercase ) for lang_code in FAIRSEQ_LANGUAGE_CODES } lowerCamelCase_ = src_lang if src_lang is not None else "en_XX" lowerCamelCase_ = self.convert_tokens_to_ids(self._src_lang ) lowerCamelCase_ = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def SCREAMING_SNAKE_CASE_( self ) -> str: return self._src_lang @src_lang.setter def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: lowerCamelCase_ = [self.sep_token_id] lowerCamelCase_ = [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 SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , **lowercase ) -> List[Any]: if src_lang is None or tgt_lang is None: raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model" ) lowerCamelCase_ = src_lang lowerCamelCase_ = self(lowercase , add_special_tokens=lowercase , return_tensors=lowercase , **lowercase ) lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = tgt_lang_id return inputs def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = "en_XX" , lowercase = None , lowercase = "ro_RO" , **lowercase , ) -> BatchEncoding: lowerCamelCase_ = src_lang lowerCamelCase_ = tgt_lang return super().prepare_seqaseq_batch(lowercase , lowercase , **lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: return self.set_src_lang_special_tokens(self.src_lang ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> Tuple[str]: if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(lowercase ): logger.error(f'Vocabulary path ({save_directory}) should be a directory.' ) return lowerCamelCase_ = os.path.join( lowercase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowercase ): copyfile(self.vocab_file , lowercase ) return (out_vocab_file,)
19
0
'''simple docstring''' import copy from ...configuration_utils import PretrainedConfig from ...utils import logging from ..auto import CONFIG_MAPPING a_ = logging.get_logger(__name__) a_ = { 'SenseTime/deformable-detr': 'https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json', # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr } class __SCREAMING_SNAKE_CASE ( snake_case_ ): snake_case_ = """deformable_detr""" snake_case_ = { """hidden_size""": """d_model""", """num_attention_heads""": """encoder_attention_heads""", } def __init__( self : int , __lowercase : Any=True , __lowercase : str=None , __lowercase : int=3 , __lowercase : str=3_00 , __lowercase : Tuple=10_24 , __lowercase : str=6 , __lowercase : Optional[int]=10_24 , __lowercase : Tuple=8 , __lowercase : List[Any]=6 , __lowercase : int=10_24 , __lowercase : str=8 , __lowercase : Optional[Any]=0.0 , __lowercase : List[str]=True , __lowercase : str="relu" , __lowercase : Dict=2_56 , __lowercase : Tuple=0.1 , __lowercase : int=0.0 , __lowercase : Union[str, Any]=0.0 , __lowercase : Optional[Any]=0.02 , __lowercase : Optional[Any]=1.0 , __lowercase : Dict=True , __lowercase : Optional[int]=False , __lowercase : str="sine" , __lowercase : List[Any]="resnet50" , __lowercase : str=True , __lowercase : List[str]=False , __lowercase : str=4 , __lowercase : int=4 , __lowercase : List[Any]=4 , __lowercase : int=False , __lowercase : Dict=3_00 , __lowercase : str=False , __lowercase : Optional[Any]=1 , __lowercase : int=5 , __lowercase : List[str]=2 , __lowercase : Optional[int]=1 , __lowercase : Union[str, Any]=1 , __lowercase : Any=5 , __lowercase : str=2 , __lowercase : Optional[int]=0.1 , __lowercase : Union[str, Any]=0.25 , __lowercase : List[Any]=False , **__lowercase : Tuple , ) -> List[str]: if backbone_config is not None and use_timm_backbone: raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.''' ) if not use_timm_backbone: if backbone_config is None: logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.''' ) SCREAMING_SNAKE_CASE__ : Dict =CONFIG_MAPPING['''resnet'''](out_features=['''stage4'''] ) elif isinstance(__lowercase , __lowercase ): SCREAMING_SNAKE_CASE__ : Optional[int] =backbone_config.get('''model_type''' ) SCREAMING_SNAKE_CASE__ : Optional[Any] =CONFIG_MAPPING[backbone_model_type] SCREAMING_SNAKE_CASE__ : List[Any] =config_class.from_dict(__lowercase ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =use_timm_backbone SCREAMING_SNAKE_CASE__ : Any =backbone_config SCREAMING_SNAKE_CASE__ : str =num_channels SCREAMING_SNAKE_CASE__ : Optional[Any] =num_queries SCREAMING_SNAKE_CASE__ : List[str] =max_position_embeddings SCREAMING_SNAKE_CASE__ : Any =d_model SCREAMING_SNAKE_CASE__ : Any =encoder_ffn_dim SCREAMING_SNAKE_CASE__ : Any =encoder_layers SCREAMING_SNAKE_CASE__ : int =encoder_attention_heads SCREAMING_SNAKE_CASE__ : Optional[int] =decoder_ffn_dim SCREAMING_SNAKE_CASE__ : int =decoder_layers SCREAMING_SNAKE_CASE__ : int =decoder_attention_heads SCREAMING_SNAKE_CASE__ : Union[str, Any] =dropout SCREAMING_SNAKE_CASE__ : Tuple =attention_dropout SCREAMING_SNAKE_CASE__ : Union[str, Any] =activation_dropout SCREAMING_SNAKE_CASE__ : List[Any] =activation_function SCREAMING_SNAKE_CASE__ : Optional[int] =init_std SCREAMING_SNAKE_CASE__ : Any =init_xavier_std SCREAMING_SNAKE_CASE__ : Any =encoder_layerdrop SCREAMING_SNAKE_CASE__ : Any =auxiliary_loss SCREAMING_SNAKE_CASE__ : Tuple =position_embedding_type SCREAMING_SNAKE_CASE__ : int =backbone SCREAMING_SNAKE_CASE__ : int =use_pretrained_backbone SCREAMING_SNAKE_CASE__ : Union[str, Any] =dilation # deformable attributes SCREAMING_SNAKE_CASE__ : Optional[int] =num_feature_levels SCREAMING_SNAKE_CASE__ : List[str] =encoder_n_points SCREAMING_SNAKE_CASE__ : Dict =decoder_n_points SCREAMING_SNAKE_CASE__ : Tuple =two_stage SCREAMING_SNAKE_CASE__ : Tuple =two_stage_num_proposals SCREAMING_SNAKE_CASE__ : Optional[Any] =with_box_refine if two_stage is True and with_box_refine is False: raise ValueError('''If two_stage is True, with_box_refine must be True.''' ) # Hungarian matcher SCREAMING_SNAKE_CASE__ : str =class_cost SCREAMING_SNAKE_CASE__ : Union[str, Any] =bbox_cost SCREAMING_SNAKE_CASE__ : Optional[int] =giou_cost # Loss coefficients SCREAMING_SNAKE_CASE__ : Any =mask_loss_coefficient SCREAMING_SNAKE_CASE__ : int =dice_loss_coefficient SCREAMING_SNAKE_CASE__ : Tuple =bbox_loss_coefficient SCREAMING_SNAKE_CASE__ : Union[str, Any] =giou_loss_coefficient SCREAMING_SNAKE_CASE__ : List[Any] =eos_coefficient SCREAMING_SNAKE_CASE__ : Any =focal_alpha SCREAMING_SNAKE_CASE__ : Any =disable_custom_kernels super().__init__(is_encoder_decoder=__lowercase , **__lowercase ) @property def __magic_name__ ( self : List[str] ) -> int: return self.encoder_attention_heads @property def __magic_name__ ( self : Dict ) -> int: return self.d_model def __magic_name__ ( self : Optional[Any] ) -> Union[str, Any]: SCREAMING_SNAKE_CASE__ : Any =copy.deepcopy(self.__dict__ ) if self.backbone_config is not None: SCREAMING_SNAKE_CASE__ : int =self.backbone_config.to_dict() SCREAMING_SNAKE_CASE__ : Optional[Any] =self.__class__.model_type return output
152
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss __A =pytest.mark.integration @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = Dataset.from_dict({"filename": ["my_name-train" + "_" + str(lowercase ) for x in np.arange(30 ).tolist()]} ) return dset def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: import faiss lowerCamelCase_ = self._create_dummy_dataset() lowerCamelCase_ = dset.map( lambda lowercase , lowercase : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=lowercase , keep_in_memory=lowercase ) lowerCamelCase_ = dset.add_faiss_index("vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) dset.drop_index("vecs" ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: dset.save_faiss_index("vecs" , tmp_file.name ) dset.load_faiss_index("vecs2" , tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs2" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" ) dset.drop_index("vecs" ) self.assertRaises(lowercase , partial(dset.get_nearest_examples , "vecs2" , np.ones(5 , dtype=np.floataa ) ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: from elasticsearch import Elasticsearch lowerCamelCase_ = self._create_dummy_dataset() with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = {"acknowledged": True} mocked_bulk.return_value([(True, None)] * 30 ) lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 29}]}} lowerCamelCase_ = Elasticsearch() dset.add_elasticsearch_index("filename" , es_client=lowercase ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("filename" , "my_name-train_29" ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Tuple: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertRaises(lowercase , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries lowerCamelCase_ = np.eye(5 , dtype=np.floataa )[::-1] lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) self.assertRaises(lowercase , index.search_batch , queries[0] ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Any: import faiss lowerCamelCase_ = FaissIndex(string_factory="Flat" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) lowerCamelCase_ = FaissIndex(string_factory="LSH" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(lowercase ): lowerCamelCase_ = FaissIndex(string_factory="Flat" , custom_index=faiss.IndexFlat(5 ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = faiss.IndexFlat(5 ) lowerCamelCase_ = FaissIndex(custom_index=lowercase ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: index.save(tmp_file.name ) lowerCamelCase_ = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def lowerCamelCase_ ( lowerCamelCase__ ): import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) lowerCamelCase_ = "index.faiss" lowerCamelCase_ = F'mock://{index_name}' index.save(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = FaissIndex.load(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowerCamelCase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: from elasticsearch import Elasticsearch with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = Elasticsearch() lowerCamelCase_ = {"acknowledged": True} lowerCamelCase_ = ElasticSearchIndex(es_client=lowercase ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(["foo", "bar", "foobar"] ) # single query lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase ) # batched queries with timeout lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase , request_timeout=30 ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase )
19
0
import os import pickle import unittest from transformers import AutoTokenizer from transformers.models.bert.tokenization_bert import BertTokenizer from transformers.models.bert_japanese.tokenization_bert_japanese import ( VOCAB_FILES_NAMES, BertJapaneseTokenizer, CharacterTokenizer, JumanppTokenizer, MecabTokenizer, SudachiTokenizer, WordpieceTokenizer, ) from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi from ...test_tokenization_common import TokenizerTesterMixin @custom_tokenizers class __A ( snake_case_ , unittest.TestCase ): """simple docstring""" UpperCamelCase__ : Any =BertJapaneseTokenizer UpperCamelCase__ : Any =False UpperCamelCase__ : Union[str, Any] =True def __lowercase ( self ): """simple docstring""" super().setUp() __UpperCamelCase : Any =[ '[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは', '世界', '##世界', '、', '##、', '。', '##。', ] __UpperCamelCase : str =os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : Union[str, Any] ='こんにちは、世界。 \nこんばんは、世界。' __UpperCamelCase : Dict ='こんにちは 、 世界 。 こんばんは 、 世界 。' return input_text, output_text def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase , __UpperCamelCase : Union[str, Any] =self.get_input_output_texts(lowerCamelCase__ ) __UpperCamelCase : str =tokenizer.encode(lowerCamelCase__ , add_special_tokens=lowerCamelCase__ ) __UpperCamelCase : Union[str, Any] =tokenizer.decode(lowerCamelCase__ , clean_up_tokenization_spaces=lowerCamelCase__ ) return text, ids def __lowercase ( self ): """simple docstring""" pass # TODO add if relevant def __lowercase ( self ): """simple docstring""" pass # TODO add if relevant def __lowercase ( self ): """simple docstring""" pass # TODO add if relevant def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Union[str, Any] =self.tokenizer_class(self.vocab_file ) __UpperCamelCase : int =tokenizer.tokenize('こんにちは、世界。\nこんばんは、世界。' ) self.assertListEqual(lowerCamelCase__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) , [3, 12, 10, 14, 4, 9, 12, 10, 14] ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[Any] =self.tokenizer_class(self.vocab_file , word_tokenizer_type='mecab' ) self.assertIsNotNone(lowerCamelCase__ ) __UpperCamelCase : Optional[Any] ='こんにちは、世界。\nこんばんは、世界。' __UpperCamelCase : Union[str, Any] =tokenizer.tokenize(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) , [3, 12, 10, 14, 4, 9, 12, 10, 14] ) __UpperCamelCase : str =os.path.join(self.tmpdirname , 'tokenizer.bin' ) with open(lowerCamelCase__ , 'wb' ) as handle: pickle.dump(lowerCamelCase__ , lowerCamelCase__ ) with open(lowerCamelCase__ , 'rb' ) as handle: __UpperCamelCase : int =pickle.load(lowerCamelCase__ ) __UpperCamelCase : List[Any] =tokenizer_new.tokenize(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__ ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Dict =MecabTokenizer(mecab_dic='ipadic' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def __lowercase ( self ): """simple docstring""" try: __UpperCamelCase : str =MecabTokenizer(mecab_dic='unidic_lite' ) except ModuleNotFoundError: return self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def __lowercase ( self ): """simple docstring""" try: __UpperCamelCase : List[str] =MecabTokenizer(mecab_dic='unidic' ) except ModuleNotFoundError: return self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Union[str, Any] =MecabTokenizer(do_lower_case=lowerCamelCase__ , mecab_dic='ipadic' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iphone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) def __lowercase ( self ): """simple docstring""" try: __UpperCamelCase : Optional[Any] =MecabTokenizer( do_lower_case=lowerCamelCase__ , normalize_text=lowerCamelCase__ , mecab_option='-d /usr/local/lib/mecab/dic/jumandic' ) except RuntimeError: # if dict doesn't exist in the system, previous code raises this error. return self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れた', '\u3000', '。'] , ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Optional[Any] =MecabTokenizer(normalize_text=lowerCamelCase__ , mecab_dic='ipadic' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', ' ', '。'] , ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Tuple =self.tokenizer_class(self.vocab_file , word_tokenizer_type='sudachi' ) self.assertIsNotNone(lowerCamelCase__ ) __UpperCamelCase : List[Any] ='こんにちは、世界。\nこんばんは、世界。' __UpperCamelCase : Optional[int] =tokenizer.tokenize(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) , [3, 12, 10, 14, 4, 9, 12, 10, 14] ) __UpperCamelCase : Optional[Any] =os.path.join(self.tmpdirname , 'tokenizer.bin' ) with open(lowerCamelCase__ , 'wb' ) as handle: pickle.dump(lowerCamelCase__ , lowerCamelCase__ ) with open(lowerCamelCase__ , 'rb' ) as handle: __UpperCamelCase : Optional[int] =pickle.load(lowerCamelCase__ ) __UpperCamelCase : List[str] =tokenizer_new.tokenize(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__ ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Dict =SudachiTokenizer(sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , [' ', '\t', 'アップル', 'ストア', 'で', 'iPhone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' '] , ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[Any] =SudachiTokenizer(sudachi_dict_type='core' , sudachi_split_mode='A' ) self.assertListEqual(tokenizer.tokenize('外国人参政権' ) , ['外国', '人', '参政', '権'] ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Union[str, Any] =SudachiTokenizer(sudachi_dict_type='core' , sudachi_split_mode='B' ) self.assertListEqual(tokenizer.tokenize('外国人参政権' ) , ['外国人', '参政権'] ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Optional[Any] =SudachiTokenizer(sudachi_dict_type='core' , sudachi_split_mode='C' ) self.assertListEqual(tokenizer.tokenize('外国人参政権' ) , ['外国人参政権'] ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[str] =SudachiTokenizer(do_lower_case=lowerCamelCase__ , sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , [' ', '\t', 'アップル', 'ストア', 'で', 'iphone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' '] , ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Dict =SudachiTokenizer(normalize_text=lowerCamelCase__ , sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , [' ', '\t', 'アップル', 'ストア', 'で', 'iPhone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', '\u3000', '。', ' ', ' '] , ) @require_sudachi def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Optional[int] =SudachiTokenizer(trim_whitespace=lowerCamelCase__ , sudachi_dict_type='core' ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。'] , ) @require_jumanpp def __lowercase ( self ): """simple docstring""" __UpperCamelCase : int =self.tokenizer_class(self.vocab_file , word_tokenizer_type='jumanpp' ) self.assertIsNotNone(lowerCamelCase__ ) __UpperCamelCase : int ='こんにちは、世界。\nこんばんは、世界。' __UpperCamelCase : List[Any] =tokenizer.tokenize(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。'] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) , [3, 12, 10, 14, 4, 9, 12, 10, 14] ) __UpperCamelCase : Dict =os.path.join(self.tmpdirname , 'tokenizer.bin' ) with open(lowerCamelCase__ , 'wb' ) as handle: pickle.dump(lowerCamelCase__ , lowerCamelCase__ ) with open(lowerCamelCase__ , 'rb' ) as handle: __UpperCamelCase : Tuple =pickle.load(lowerCamelCase__ ) __UpperCamelCase : Any =tokenizer_new.tokenize(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__ ) @require_jumanpp def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Optional[int] =JumanppTokenizer() self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。'] , ) @require_jumanpp def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[Any] =JumanppTokenizer(do_lower_case=lowerCamelCase__ ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iphone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。'] , ) @require_jumanpp def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Optional[Any] =JumanppTokenizer(normalize_text=lowerCamelCase__ ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['ア', 'ッ', 'フ', '゚', 'ル', 'ストア', 'で', 'iPhone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。'] , ) @require_jumanpp def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Union[str, Any] =JumanppTokenizer(trim_whitespace=lowerCamelCase__ ) self.assertListEqual( tokenizer.tokenize(' \tアップルストアでiPhone8 が \n 発売された 。 ' ) , ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れた', '。'] , ) @require_jumanpp def __lowercase ( self ): """simple docstring""" __UpperCamelCase : int =JumanppTokenizer() self.assertListEqual( tokenizer.tokenize('ありがとうございますm(_ _)m見つけるのが大変です。' ) , ['ありがとう', 'ございます', 'm(_ _)m', '見つける', 'の', 'が', '大変です', '。'] , ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[Any] =['[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは'] __UpperCamelCase : Any ={} for i, token in enumerate(lowerCamelCase__ ): __UpperCamelCase : int =i __UpperCamelCase : int =WordpieceTokenizer(vocab=lowerCamelCase__ , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('こんにちは' ) , ['こんにちは'] ) self.assertListEqual(tokenizer.tokenize('こんばんは' ) , ['こん', '##ばんは'] ) self.assertListEqual(tokenizer.tokenize('こんばんは こんばんにちは こんにちは' ) , ['こん', '##ばんは', '[UNK]', 'こんにちは'] ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Union[str, Any] =BertJapaneseTokenizer.from_pretrained('nlp-waseda/roberta-base-japanese-with-auto-jumanpp' ) __UpperCamelCase : Any =tokenizer.subword_tokenizer __UpperCamelCase : Union[str, Any] =subword_tokenizer.tokenize('国境 の 長い トンネル を 抜ける と 雪国 であった 。' ) self.assertListEqual(lowerCamelCase__ , ['▁国境', '▁の', '▁長い', '▁トンネル', '▁を', '▁抜ける', '▁と', '▁雪', '国', '▁であった', '▁。'] ) __UpperCamelCase : str =subword_tokenizer.tokenize('こんばんは こんばん にち は こんにちは' ) self.assertListEqual(lowerCamelCase__ , ['▁こん', 'ばん', 'は', '▁こん', 'ばん', '▁に', 'ち', '▁は', '▁こんにちは'] ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[Any] =self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese' ) __UpperCamelCase : Union[str, Any] =tokenizer.encode('ありがとう。' , add_special_tokens=lowerCamelCase__ ) __UpperCamelCase : int =tokenizer.encode('どういたしまして。' , add_special_tokens=lowerCamelCase__ ) __UpperCamelCase : str =tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ ) __UpperCamelCase : int =tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ , lowerCamelCase__ ) # 2 is for "[CLS]", 3 is for "[SEP]" assert encoded_sentence == [2] + text + [3] assert encoded_pair == [2] + text + [3] + text_a + [3] @custom_tokenizers class __A ( snake_case_ , unittest.TestCase ): """simple docstring""" UpperCamelCase__ : Any =BertJapaneseTokenizer UpperCamelCase__ : Optional[int] =False def __lowercase ( self ): """simple docstring""" super().setUp() __UpperCamelCase : Union[str, Any] =['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。'] __UpperCamelCase : List[Any] =os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as vocab_writer: vocab_writer.write(''.join([x + '\n' for x in vocab_tokens] ) ) def __lowercase ( self , **lowerCamelCase__ ): """simple docstring""" return BertJapaneseTokenizer.from_pretrained(self.tmpdirname , subword_tokenizer_type='character' , **lowerCamelCase__ ) def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : Optional[int] ='こんにちは、世界。 \nこんばんは、世界。' __UpperCamelCase : str ='こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。' return input_text, output_text def __lowercase ( self ): """simple docstring""" pass # TODO add if relevant def __lowercase ( self ): """simple docstring""" pass # TODO add if relevant def __lowercase ( self ): """simple docstring""" pass # TODO add if relevant def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Dict =self.tokenizer_class(self.vocab_file , subword_tokenizer_type='character' ) __UpperCamelCase : Union[str, Any] =tokenizer.tokenize('こんにちは、世界。 \nこんばんは、世界。' ) self.assertListEqual( lowerCamelCase__ , ['こ', 'ん', 'に', 'ち', 'は', '、', '世', '界', '。', 'こ', 'ん', 'ば', 'ん', 'は', '、', '世', '界', '。'] ) self.assertListEqual( tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) , [3, 4, 5, 6, 7, 11, 9, 10, 12, 3, 4, 8, 4, 7, 11, 9, 10, 12] ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Any =['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。'] __UpperCamelCase : List[str] ={} for i, token in enumerate(lowerCamelCase__ ): __UpperCamelCase : List[Any] =i __UpperCamelCase : Dict =CharacterTokenizer(vocab=lowerCamelCase__ , unk_token='[UNK]' ) self.assertListEqual(tokenizer.tokenize('' ) , [] ) self.assertListEqual(tokenizer.tokenize('こんにちは' ) , ['こ', 'ん', 'に', 'ち', 'は'] ) self.assertListEqual(tokenizer.tokenize('こんにちほ' ) , ['こ', 'ん', 'に', 'ち', '[UNK]'] ) def __lowercase ( self ): """simple docstring""" __UpperCamelCase : str =self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese-char' ) __UpperCamelCase : List[Any] =tokenizer.encode('ありがとう。' , add_special_tokens=lowerCamelCase__ ) __UpperCamelCase : Union[str, Any] =tokenizer.encode('どういたしまして。' , add_special_tokens=lowerCamelCase__ ) __UpperCamelCase : Optional[int] =tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ ) __UpperCamelCase : List[Any] =tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ , lowerCamelCase__ ) # 2 is for "[CLS]", 3 is for "[SEP]" assert encoded_sentence == [2] + text + [3] assert encoded_pair == [2] + text + [3] + text_a + [3] @custom_tokenizers class __A ( unittest.TestCase ): """simple docstring""" def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Any ='cl-tohoku/bert-base-japanese' __UpperCamelCase : Union[str, Any] =AutoTokenizer.from_pretrained(lowerCamelCase__ ) self.assertIsInstance(lowerCamelCase__ , lowerCamelCase__ ) class __A ( unittest.TestCase ): """simple docstring""" def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[Any] ='cl-tohoku/bert-base-japanese' with self.assertLogs('transformers' , level='WARNING' ) as cm: BertTokenizer.from_pretrained(lowerCamelCase__ ) self.assertTrue( cm.records[0].message.startswith( 'The tokenizer class you load from this checkpoint is not the same type as the class this function' ' is called from.' ) ) __UpperCamelCase : Union[str, Any] ='bert-base-cased' with self.assertLogs('transformers' , level='WARNING' ) as cm: BertJapaneseTokenizer.from_pretrained(lowerCamelCase__ ) self.assertTrue( cm.records[0].message.startswith( 'The tokenizer class you load from this checkpoint is not the same type as the class this function' ' is called from.' ) )
71
import unittest from transformers import is_torch_available 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 from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST, OpenAIGPTConfig, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , lowercase=13 , lowercase=7 , lowercase=True , lowercase=True , lowercase=True , lowercase=99 , lowercase=32 , lowercase=5 , lowercase=4 , lowercase=37 , lowercase="gelu" , lowercase=0.1 , lowercase=0.1 , lowercase=512 , lowercase=16 , lowercase=2 , lowercase=0.0_2 , lowercase=3 , lowercase=4 , lowercase=None , ) -> List[str]: lowerCamelCase_ = parent lowerCamelCase_ = batch_size lowerCamelCase_ = seq_length lowerCamelCase_ = is_training lowerCamelCase_ = use_token_type_ids lowerCamelCase_ = use_labels lowerCamelCase_ = vocab_size lowerCamelCase_ = hidden_size lowerCamelCase_ = num_hidden_layers lowerCamelCase_ = num_attention_heads lowerCamelCase_ = intermediate_size lowerCamelCase_ = hidden_act lowerCamelCase_ = hidden_dropout_prob lowerCamelCase_ = attention_probs_dropout_prob lowerCamelCase_ = max_position_embeddings lowerCamelCase_ = type_vocab_size lowerCamelCase_ = type_sequence_label_size lowerCamelCase_ = initializer_range lowerCamelCase_ = num_labels lowerCamelCase_ = num_choices lowerCamelCase_ = scope lowerCamelCase_ = self.vocab_size - 1 def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_token_type_ids: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = OpenAIGPTConfig( 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 , pad_token_id=self.pad_token_id , ) lowerCamelCase_ = ids_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, head_mask, token_type_ids, sequence_labels, token_labels, choice_labels, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTModel(config=lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , head_mask=lowercase ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = OpenAIGPTLMHeadModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTDoubleHeadsModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = OpenAIGPTForSequenceClassification(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = { "input_ids": input_ids, "token_type_ids": token_type_ids, "head_mask": head_mask, } return config, inputs_dict @require_torch class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification) if is_torch_available() else () ) lowerCAmelCase__ = ( (OpenAIGPTLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly lowerCAmelCase__ = ( { 'feature-extraction': OpenAIGPTModel, 'text-classification': OpenAIGPTForSequenceClassification, 'text-generation': OpenAIGPTLMHeadModel, 'zero-shot': OpenAIGPTForSequenceClassification, } if is_torch_available() else {} ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests": # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers. # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a # tiny config could not be created. return True return False def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=False ) -> Any: lowerCamelCase_ = super()._prepare_for_class(lowercase , lowercase , return_labels=lowercase ) if return_labels: if model_class.__name__ == "OpenAIGPTDoubleHeadsModel": lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowercase ) return inputs_dict def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = OpenAIGPTModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , n_embd=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_double_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Any: for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = OpenAIGPTModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @require_torch class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = OpenAIGPTLMHeadModel.from_pretrained("openai-gpt" ) model.to(lowercase ) lowerCamelCase_ = torch.tensor([[481, 4735, 544]] , dtype=torch.long , device=lowercase ) # the president is lowerCamelCase_ = [ 481, 4735, 544, 246, 963, 870, 762, 239, 244, 40477, 244, 249, 719, 881, 487, 544, 240, 244, 603, 481, ] # the president is a very good man. " \n " i\'m sure he is, " said the lowerCamelCase_ = model.generate(lowercase , do_sample=lowercase ) self.assertListEqual(output_ids[0].tolist() , lowercase )
19
0
'''simple docstring''' from typing import List, Union from ..utils import ( add_end_docstrings, is_tf_available, is_torch_available, is_vision_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING from ..tf_utils import stable_softmax if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING a_ : Union[str, Any] = logging.get_logger(__name__) @add_end_docstrings(snake_case_ ) class a ( snake_case_ ): def __init__( self , *__magic_name__ , **__magic_name__ ) -> str: super().__init__(*__magic_name__ , **__magic_name__ ) requires_backends(self , 'vision' ) self.check_model_type( TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING if self.framework == 'tf' else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING ) def __UpperCAmelCase ( self , __magic_name__=None ) -> Tuple: _a = {} if top_k is not None: _a = top_k return {}, {}, postprocess_params def __call__( self , __magic_name__ , **__magic_name__ ) -> Any: return super().__call__(__magic_name__ , **__magic_name__ ) def __UpperCAmelCase ( self , __magic_name__ ) -> int: _a = load_image(__magic_name__ ) _a = self.image_processor(images=__magic_name__ , return_tensors=self.framework ) return model_inputs def __UpperCAmelCase ( self , __magic_name__ ) -> Tuple: _a = self.model(**__magic_name__ ) return model_outputs def __UpperCAmelCase ( self , __magic_name__ , __magic_name__=5 ) -> List[Any]: if top_k > self.model.config.num_labels: _a = self.model.config.num_labels if self.framework == "pt": _a = model_outputs.logits.softmax(-1 )[0] _a , _a = probs.topk(__magic_name__ ) elif self.framework == "tf": _a = stable_softmax(model_outputs.logits , axis=-1 )[0] _a = tf.math.top_k(__magic_name__ , k=__magic_name__ ) _a , _a = topk.values.numpy(), topk.indices.numpy() else: raise ValueError(f'Unsupported framework: {self.framework}' ) _a = scores.tolist() _a = ids.tolist() return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(__magic_name__ , __magic_name__ )]
168
__A ={str(digit): digit**5 for digit in range(1_0)} def lowerCamelCase_ ( lowerCamelCase__ ): return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCamelCase__ ) ) def lowerCamelCase_ ( ): return sum( number for number in range(1_0_0_0 , 1_0_0_0_0_0_0 ) if number == digits_fifth_powers_sum(lowerCamelCase__ ) ) if __name__ == "__main__": print(solution())
19
0
from __future__ import annotations def a ( A__ : Dict ) -> str: """simple docstring""" _lowercase =[True] * limit _lowercase =False _lowercase =False _lowercase =True for i in range(3 , int(limit**0.5 + 1 ) , 2 ): _lowercase =i * 2 while index < limit: _lowercase =False _lowercase =index + i _lowercase =[2] for i in range(3 , lowerCamelCase__ , 2 ): if is_prime[i]: primes.append(lowerCamelCase__ ) return primes def a ( A__ : List[str] = 1000000 ) -> Optional[Any]: """simple docstring""" _lowercase =prime_sieve(lowerCamelCase__ ) _lowercase =0 _lowercase =0 for i in range(len(lowerCamelCase__ ) ): for j in range(i + length , len(lowerCamelCase__ ) ): _lowercase =sum(primes[i:j] ) if sol >= ceiling: break if sol in primes: _lowercase =j - i _lowercase =sol return largest if __name__ == "__main__": print(f"{solution() = }")
205
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 YolosConfig, YolosForObjectDetection, YolosImageProcessor from transformers.utils import logging logging.set_verbosity_info() __A =logging.get_logger(__name__) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = YolosConfig() # size of the architecture if "yolos_ti" in yolos_name: lowerCamelCase_ = 1_9_2 lowerCamelCase_ = 7_6_8 lowerCamelCase_ = 1_2 lowerCamelCase_ = 3 lowerCamelCase_ = [8_0_0, 1_3_3_3] lowerCamelCase_ = False elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = 3_3_0 lowerCamelCase_ = 1_4 lowerCamelCase_ = 6 lowerCamelCase_ = 1_3_2_0 elif "yolos_s" in yolos_name: lowerCamelCase_ = 3_8_4 lowerCamelCase_ = 1_5_3_6 lowerCamelCase_ = 1_2 lowerCamelCase_ = 6 elif "yolos_b" in yolos_name: lowerCamelCase_ = [8_0_0, 1_3_4_4] lowerCamelCase_ = 9_1 lowerCamelCase_ = "huggingface/label-files" lowerCamelCase_ = "coco-detection-id2label.json" lowerCamelCase_ = json.load(open(hf_hub_download(lowerCamelCase__ , lowerCamelCase__ , repo_type="dataset" ) , "r" ) ) lowerCamelCase_ = {int(lowerCamelCase__ ): v for k, v in idalabel.items()} lowerCamelCase_ = idalabel lowerCamelCase_ = {v: k for k, v in idalabel.items()} return config def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.weight' ) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.bias' ) # next, add query, keys and values (in that order) to the state dict lowerCamelCase_ = in_proj_weight[: config.hidden_size, :] lowerCamelCase_ = in_proj_bias[: config.hidden_size] lowerCamelCase_ = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] lowerCamelCase_ = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] lowerCamelCase_ = in_proj_weight[-config.hidden_size :, :] lowerCamelCase_ = in_proj_bias[-config.hidden_size :] def lowerCamelCase_ ( lowerCamelCase__ ): if "backbone" in name: lowerCamelCase_ = name.replace("backbone" , "vit" ) if "cls_token" in name: lowerCamelCase_ = name.replace("cls_token" , "embeddings.cls_token" ) if "det_token" in name: lowerCamelCase_ = name.replace("det_token" , "embeddings.detection_tokens" ) if "mid_pos_embed" in name: lowerCamelCase_ = name.replace("mid_pos_embed" , "encoder.mid_position_embeddings" ) if "pos_embed" in name: lowerCamelCase_ = name.replace("pos_embed" , "embeddings.position_embeddings" ) if "patch_embed.proj" in name: lowerCamelCase_ = name.replace("patch_embed.proj" , "embeddings.patch_embeddings.projection" ) if "blocks" in name: lowerCamelCase_ = name.replace("blocks" , "encoder.layer" ) if "attn.proj" in name: lowerCamelCase_ = name.replace("attn.proj" , "attention.output.dense" ) if "attn" in name: lowerCamelCase_ = name.replace("attn" , "attention.self" ) if "norm1" in name: lowerCamelCase_ = name.replace("norm1" , "layernorm_before" ) if "norm2" in name: lowerCamelCase_ = name.replace("norm2" , "layernorm_after" ) if "mlp.fc1" in name: lowerCamelCase_ = name.replace("mlp.fc1" , "intermediate.dense" ) if "mlp.fc2" in name: lowerCamelCase_ = name.replace("mlp.fc2" , "output.dense" ) if "class_embed" in name: lowerCamelCase_ = name.replace("class_embed" , "class_labels_classifier" ) if "bbox_embed" in name: lowerCamelCase_ = name.replace("bbox_embed" , "bbox_predictor" ) if "vit.norm" in name: lowerCamelCase_ = name.replace("vit.norm" , "vit.layernorm" ) return name def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): for key in orig_state_dict.copy().keys(): lowerCamelCase_ = orig_state_dict.pop(lowerCamelCase__ ) if "qkv" in key: lowerCamelCase_ = key.split("." ) lowerCamelCase_ = int(key_split[2] ) lowerCamelCase_ = model.vit.encoder.layer[layer_num].attention.attention.all_head_size if "weight" in key: lowerCamelCase_ = val[:dim, :] lowerCamelCase_ = val[ dim : dim * 2, : ] lowerCamelCase_ = val[-dim:, :] else: lowerCamelCase_ = val[:dim] lowerCamelCase_ = val[dim : dim * 2] lowerCamelCase_ = val[-dim:] else: lowerCamelCase_ = val return orig_state_dict def lowerCamelCase_ ( ): lowerCamelCase_ = "http://images.cocodataset.org/val2017/000000039769.jpg" lowerCamelCase_ = Image.open(requests.get(lowerCamelCase__ , stream=lowerCamelCase__ ).raw ) return im @torch.no_grad() def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): lowerCamelCase_ = get_yolos_config(lowerCamelCase__ ) # load original state_dict lowerCamelCase_ = torch.load(lowerCamelCase__ , map_location="cpu" )["model"] # load 🤗 model lowerCamelCase_ = YolosForObjectDetection(lowerCamelCase__ ) model.eval() lowerCamelCase_ = convert_state_dict(lowerCamelCase__ , lowerCamelCase__ ) model.load_state_dict(lowerCamelCase__ ) # Check outputs on an image, prepared by YolosImageProcessor lowerCamelCase_ = 8_0_0 if yolos_name != "yolos_ti" else 5_1_2 lowerCamelCase_ = YolosImageProcessor(format="coco_detection" , size=lowerCamelCase__ ) lowerCamelCase_ = image_processor(images=prepare_img() , return_tensors="pt" ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = outputs.logits, outputs.pred_boxes lowerCamelCase_ , lowerCamelCase_ = None, None if yolos_name == "yolos_ti": lowerCamelCase_ = torch.tensor( [[-39.50_22, -11.98_20, -17.68_88], [-29.95_74, -9.97_69, -17.76_91], [-42.32_81, -20.72_00, -30.62_94]] ) lowerCamelCase_ = torch.tensor( [[0.40_21, 0.08_36, 0.79_79], [0.01_84, 0.26_09, 0.03_64], [0.17_81, 0.20_04, 0.20_95]] ) elif yolos_name == "yolos_s_200_pre": lowerCamelCase_ = torch.tensor( [[-24.02_48, -10.30_24, -14.82_90], [-42.03_92, -16.82_00, -27.43_34], [-27.27_43, -11.81_54, -18.71_48]] ) lowerCamelCase_ = torch.tensor( [[0.25_59, 0.54_55, 0.47_06], [0.29_89, 0.72_79, 0.18_75], [0.77_32, 0.40_17, 0.44_62]] ) elif yolos_name == "yolos_s_300_pre": lowerCamelCase_ = torch.tensor( [[-36.22_20, -14.43_85, -23.54_57], [-35.69_70, -14.75_83, -21.39_35], [-31.59_39, -13.60_42, -16.80_49]] ) lowerCamelCase_ = torch.tensor( [[0.76_14, 0.23_16, 0.47_28], [0.71_68, 0.44_95, 0.38_55], [0.49_96, 0.14_66, 0.99_96]] ) elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = torch.tensor( [[-42.86_68, -24.10_49, -41.16_90], [-34.74_56, -14.12_74, -24.91_94], [-33.78_98, -12.19_46, -25.64_95]] ) lowerCamelCase_ = torch.tensor( [[0.55_87, 0.27_73, 0.06_05], [0.50_04, 0.30_14, 0.99_94], [0.49_99, 0.15_48, 0.99_94]] ) elif yolos_name == "yolos_base": lowerCamelCase_ = torch.tensor( [[-40.60_64, -24.30_84, -32.64_47], [-55.19_90, -30.77_19, -35.58_77], [-51.43_11, -33.35_07, -35.64_62]] ) lowerCamelCase_ = torch.tensor( [[0.55_55, 0.27_94, 0.06_55], [0.90_49, 0.26_64, 0.18_94], [0.91_83, 0.19_84, 0.16_35]] ) else: raise ValueError(F'Unknown yolos_name: {yolos_name}' ) assert torch.allclose(logits[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) assert torch.allclose(pred_boxes[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) Path(lowerCamelCase__ ).mkdir(exist_ok=lowerCamelCase__ ) print(F'Saving model {yolos_name} to {pytorch_dump_folder_path}' ) model.save_pretrained(lowerCamelCase__ ) print(F'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(lowerCamelCase__ ) if push_to_hub: lowerCamelCase_ = { "yolos_ti": "yolos-tiny", "yolos_s_200_pre": "yolos-small", "yolos_s_300_pre": "yolos-small-300", "yolos_s_dWr": "yolos-small-dwr", "yolos_base": "yolos-base", } print("Pushing to the hub..." ) lowerCamelCase_ = model_mapping[yolos_name] image_processor.push_to_hub(lowerCamelCase__ , organization="hustvl" ) model.push_to_hub(lowerCamelCase__ , organization="hustvl" ) if __name__ == "__main__": __A =argparse.ArgumentParser() # Required parameters parser.add_argument( '''--yolos_name''', default='''yolos_s_200_pre''', type=str, help=( '''Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\',''' ''' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.''' ), ) parser.add_argument( '''--checkpoint_path''', default=None, type=str, help='''Path to the original state dict (.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.''' ) __A =parser.parse_args() convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
19
0
import numpy # List of input, output pairs lowerCAmelCase__ = ( ((5, 2, 3), 15), ((6, 5, 9), 25), ((11, 12, 13), 41), ((1, 1, 1), 8), ((11, 12, 13), 41), ) lowerCAmelCase__ = (((5_15, 22, 13), 5_55), ((61, 35, 49), 1_50)) lowerCAmelCase__ = [2, 4, 1, 5] lowerCAmelCase__ = len(train_data) lowerCAmelCase__ = 0.0_09 def _UpperCAmelCase (UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Any="train" ): return calculate_hypothesis_value(lowerCamelCase__ , lowerCamelCase__ ) - output( lowerCamelCase__ , lowerCamelCase__ ) def _UpperCAmelCase (UpperCamelCase__ : int ): _A : int = 0 for i in range(len(lowerCamelCase__ ) - 1 ): hyp_val += data_input_tuple[i] * parameter_vector[i + 1] hyp_val += parameter_vector[0] return hyp_val def _UpperCAmelCase (UpperCamelCase__ : Dict , UpperCamelCase__ : Union[str, Any] ): if data_set == "train": return train_data[example_no][1] elif data_set == "test": return test_data[example_no][1] return None def _UpperCAmelCase (UpperCamelCase__ : List[str] , UpperCamelCase__ : List[str] ): if data_set == "train": return _hypothesis_value(train_data[example_no][0] ) elif data_set == "test": return _hypothesis_value(test_data[example_no][0] ) return None def _UpperCAmelCase (UpperCamelCase__ : List[Any] , UpperCamelCase__ : Union[str, Any]=m ): _A : Any = 0 for i in range(lowerCamelCase__ ): if index == -1: summation_value += _error(lowerCamelCase__ ) else: summation_value += _error(lowerCamelCase__ ) * train_data[i][0][index] return summation_value def _UpperCAmelCase (UpperCamelCase__ : Optional[int] ): _A : Optional[int] = summation_of_cost_derivative(lowerCamelCase__ , lowerCamelCase__ ) / m return cost_derivative_value def _UpperCAmelCase (): global parameter_vector # Tune these values to set a tolerance value for predicted output _A : Optional[int] = 0.00_00_02 _A : Union[str, Any] = 0 _A : List[str] = 0 while True: j += 1 _A : Optional[int] = [0, 0, 0, 0] for i in range(0 , len(lowerCamelCase__ ) ): _A : int = get_cost_derivative(i - 1 ) _A : List[Any] = ( parameter_vector[i] - LEARNING_RATE * cost_derivative ) if numpy.allclose( lowerCamelCase__ , lowerCamelCase__ , atol=lowerCamelCase__ , rtol=lowerCamelCase__ , ): break _A : Optional[int] = temp_parameter_vector print(("Number of iterations:", j) ) def _UpperCAmelCase (): for i in range(len(lowerCamelCase__ ) ): print(("Actual output value:", output(lowerCamelCase__ , "test" )) ) print(("Hypothesis output:", calculate_hypothesis_value(lowerCamelCase__ , "test" )) ) if __name__ == "__main__": run_gradient_descent() print('\nTesting gradient descent for a linear hypothesis function.\n') test_gradient_descent()
11
def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [0 for i in range(r + 1 )] # nc0 = 1 lowerCamelCase_ = 1 for i in range(1 , n + 1 ): # to compute current row from previous row. lowerCamelCase_ = min(lowerCamelCase__ , lowerCamelCase__ ) while j > 0: c[j] += c[j - 1] j -= 1 return c[r] print(binomial_coefficient(n=1_0, r=5))
19
0
'''simple docstring''' import unittest import numpy as np import torch from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class a__ ( unittest.TestCase ): @property def SCREAMING_SNAKE_CASE__ ( self : Optional[Any] ): """simple docstring""" torch.manual_seed(0 ) __lowerCamelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''') , up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''') , ) return model def SCREAMING_SNAKE_CASE__ ( self : List[str] ): """simple docstring""" __lowerCamelCase = self.dummy_uncond_unet __lowerCamelCase = PNDMScheduler() __lowerCamelCase = PNDMPipeline(unet=a , scheduler=a ) pndm.to(a ) pndm.set_progress_bar_config(disable=a ) __lowerCamelCase = torch.manual_seed(0 ) __lowerCamelCase = pndm(generator=a , num_inference_steps=20 , output_type='''numpy''' ).images __lowerCamelCase = torch.manual_seed(0 ) __lowerCamelCase = pndm(generator=a , num_inference_steps=20 , output_type='''numpy''' , return_dict=a )[0] __lowerCamelCase = image[0, -3:, -3:, -1] __lowerCamelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) __lowerCamelCase = np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1e-2 @slow @require_torch class a__ ( unittest.TestCase ): def SCREAMING_SNAKE_CASE__ ( self : int ): """simple docstring""" __lowerCamelCase = '''google/ddpm-cifar10-32''' __lowerCamelCase = UNetaDModel.from_pretrained(a ) __lowerCamelCase = PNDMScheduler() __lowerCamelCase = PNDMPipeline(unet=a , scheduler=a ) pndm.to(a ) pndm.set_progress_bar_config(disable=a ) __lowerCamelCase = torch.manual_seed(0 ) __lowerCamelCase = pndm(generator=a , output_type='''numpy''' ).images __lowerCamelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) __lowerCamelCase = np.array([0.15_64, 0.1_46_45, 0.14_06, 0.1_47_15, 0.1_24_25, 0.1_40_45, 0.1_31_15, 0.1_21_75, 0.1_25] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): if 0 not in (x, y): # We use the relation x^y = y*log10(x), where 10 is the base. return y * math.logaa(lowerCamelCase__ ) else: if x == 0: # 0 raised to any number is 0 return 0 elif y == 0: return 1 # any number raised to 0 is 1 raise AssertionError("This should never happen" ) if __name__ == "__main__": # Main function # Read two numbers from input and typecast them to int using map function. # Here x is the base and y is the power. __A ='''Enter the base and the power separated by a comma: ''' __A, __A =map(int, input(prompt).split(''',''')) __A, __A =map(int, input(prompt).split(''',''')) # We find the log of each number, using the function res(), which takes two # arguments. __A =res(xa, ya) __A =res(xa, ya) # We check for the largest number if resa > resa: print('''Largest number is''', xa, '''^''', ya) elif resa > resa: print('''Largest number is''', xa, '''^''', ya) else: print('''Both are equal''')
19
0
import os from shutil import copyfile from typing import List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging SCREAMING_SNAKE_CASE :int = logging.get_logger(__name__) SCREAMING_SNAKE_CASE :Optional[Any] = {'''vocab_file''': '''sentencepiece.model'''} SCREAMING_SNAKE_CASE :Dict = { '''vocab_file''': { '''google/rembert''': '''https://huggingface.co/google/rembert/resolve/main/sentencepiece.model''', }, } SCREAMING_SNAKE_CASE :Optional[int] = { '''google/rembert''': 2_56, } class __lowerCAmelCase ( snake_case_ ): """simple docstring""" _SCREAMING_SNAKE_CASE = VOCAB_FILES_NAMES _SCREAMING_SNAKE_CASE = PRETRAINED_VOCAB_FILES_MAP _SCREAMING_SNAKE_CASE = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self : Tuple , _lowerCAmelCase : List[str] , _lowerCAmelCase : Union[str, Any]=False , _lowerCAmelCase : Tuple=True , _lowerCAmelCase : Optional[Any]=True , _lowerCAmelCase : List[str]="[CLS]" , _lowerCAmelCase : List[str]="[SEP]" , _lowerCAmelCase : Optional[int]="[UNK]" , _lowerCAmelCase : str="[SEP]" , _lowerCAmelCase : Any="[PAD]" , _lowerCAmelCase : Optional[Any]="[CLS]" , _lowerCAmelCase : str="[MASK]" , **_lowerCAmelCase : Any , ) -> str: """simple docstring""" super().__init__( do_lower_case=_lowerCAmelCase , remove_space=_lowerCAmelCase , keep_accents=_lowerCAmelCase , bos_token=_lowerCAmelCase , eos_token=_lowerCAmelCase , unk_token=_lowerCAmelCase , sep_token=_lowerCAmelCase , pad_token=_lowerCAmelCase , cls_token=_lowerCAmelCase , mask_token=_lowerCAmelCase , **_lowerCAmelCase , ) snake_case_ = do_lower_case snake_case_ = remove_space snake_case_ = keep_accents snake_case_ = vocab_file snake_case_ = spm.SentencePieceProcessor() self.sp_model.Load(_lowerCAmelCase ) @property def lowerCAmelCase__ ( self : List[str] ) -> Dict: """simple docstring""" return len(self.sp_model ) def lowerCAmelCase__ ( self : Any ) -> List[Any]: """simple docstring""" snake_case_ = {self.convert_ids_to_tokens(_lowerCAmelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : Optional[int] ) -> Tuple: """simple docstring""" snake_case_ = self.__dict__.copy() snake_case_ = None return state def __setstate__( self : Optional[int] , _lowerCAmelCase : str ) -> Union[str, Any]: """simple docstring""" snake_case_ = d snake_case_ = spm.SentencePieceProcessor() self.sp_model.Load(self.vocab_file ) def lowerCAmelCase__ ( self : Optional[int] , _lowerCAmelCase : Tuple , _lowerCAmelCase : List[str]=False ) -> str: """simple docstring""" snake_case_ = self.sp_model.EncodeAsPieces(_lowerCAmelCase ) return pieces def lowerCAmelCase__ ( self : Optional[int] , _lowerCAmelCase : Dict ) -> Any: """simple docstring""" return self.sp_model.PieceToId(_lowerCAmelCase ) def lowerCAmelCase__ ( self : List[Any] , _lowerCAmelCase : Tuple ) -> Dict: """simple docstring""" return self.sp_model.IdToPiece(_lowerCAmelCase ) def lowerCAmelCase__ ( self : Optional[Any] , _lowerCAmelCase : Optional[Any] ) -> Optional[int]: """simple docstring""" snake_case_ = self.sp_model.decode_pieces(_lowerCAmelCase ) return out_string def lowerCAmelCase__ ( self : List[Any] , _lowerCAmelCase : Tuple , _lowerCAmelCase : Dict = None ) -> List[int]: """simple docstring""" snake_case_ = [self.sep_token_id] snake_case_ = [self.cls_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 lowerCAmelCase__ ( self : Optional[Any] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Optional[int] = None , _lowerCAmelCase : Optional[int] = False ) -> List[int]: """simple docstring""" if already_has_special_tokens: if token_ids_a is not None: raise ValueError( "You should not supply a second sequence if the provided sequence of " "ids is already formatted with special tokens for the model." ) return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCAmelCase )) + [1] + ([0] * len(_lowerCAmelCase )) + [1] return [1] + ([0] * len(_lowerCAmelCase )) + [1] def lowerCAmelCase__ ( self : int , _lowerCAmelCase : int , _lowerCAmelCase : Tuple = None ) -> List[int]: """simple docstring""" snake_case_ = [self.sep_token_id] snake_case_ = [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 lowerCAmelCase__ ( self : int , _lowerCAmelCase : Any , _lowerCAmelCase : Dict = None ) -> Tuple[str]: """simple docstring""" if not os.path.isdir(_lowerCAmelCase ): logger.error("Vocabulary path ({}) should be a directory".format(_lowerCAmelCase ) ) return snake_case_ = os.path.join( _lowerCAmelCase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_lowerCAmelCase ): copyfile(self.vocab_file , _lowerCAmelCase ) return (out_vocab_file,)
159
import os import time from dataclasses import dataclass, field from enum import Enum from typing import Dict, List, Optional, Union import torch from filelock import FileLock from torch.utils.data import Dataset from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features __A =logging.get_logger(__name__) __A =list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys()) __A =tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) @dataclass class _SCREAMING_SNAKE_CASE : lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Model type selected in the list: ' + ', '.join(snake_case_ )} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'The input data dir. Should contain the .json files for the SQuAD task.'} ) lowerCAmelCase__ = field( default=1_28 , metadata={ 'help': ( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) } , ) lowerCAmelCase__ = field( default=1_28 , metadata={'help': 'When splitting up a long document into chunks, how much stride to take between chunks.'} , ) lowerCAmelCase__ = field( default=64 , metadata={ 'help': ( 'The maximum number of tokens for the question. Questions longer than this will ' 'be truncated to this length.' ) } , ) lowerCAmelCase__ = field( default=30 , metadata={ 'help': ( 'The maximum length of an answer that can be generated. This is needed because the start ' 'and end predictions are not conditioned on one another.' ) } , ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Overwrite the cached training and evaluation sets'} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'If true, the SQuAD examples contain some that do not have an answer.'} ) lowerCAmelCase__ = field( default=0.0 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=20 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=0 , metadata={ 'help': ( 'language id of input for language-specific xlm models (see' ' tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)' ) } , ) lowerCAmelCase__ = field(default=1 , metadata={'help': 'multiple threads for converting example to features'} ) class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 'train' lowerCAmelCase__ = 'dev' class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 def __init__( self , lowercase , lowercase , lowercase = None , lowercase = Split.train , lowercase = False , lowercase = None , lowercase = "pt" , ) -> List[str]: lowerCamelCase_ = args lowerCamelCase_ = is_language_sensitive lowerCamelCase_ = SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor() if isinstance(lowercase , lowercase ): try: lowerCamelCase_ = Split[mode] except KeyError: raise KeyError("mode is not a valid split name" ) lowerCamelCase_ = mode # Load data features from cache or dataset file lowerCamelCase_ = "v2" if args.version_2_with_negative else "v1" lowerCamelCase_ = os.path.join( cache_dir if cache_dir is not None else args.data_dir , f'cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}' , ) # Make sure only the first process in distributed training processes the dataset, # and the others will use the cache. lowerCamelCase_ = cached_features_file + ".lock" with FileLock(lowercase ): if os.path.exists(lowercase ) and not args.overwrite_cache: lowerCamelCase_ = time.time() lowerCamelCase_ = torch.load(lowercase ) # Legacy cache files have only features, while new cache files # will have dataset and examples also. lowerCamelCase_ = self.old_features["features"] lowerCamelCase_ = self.old_features.get("dataset" , lowercase ) lowerCamelCase_ = self.old_features.get("examples" , lowercase ) logger.info( f'Loading features from cached file {cached_features_file} [took %.3f s]' , time.time() - start ) if self.dataset is None or self.examples is None: logger.warning( f'Deleting cached file {cached_features_file} will allow dataset and examples to be cached in' " future run" ) else: if mode == Split.dev: lowerCamelCase_ = self.processor.get_dev_examples(args.data_dir ) else: lowerCamelCase_ = self.processor.get_train_examples(args.data_dir ) lowerCamelCase_ , lowerCamelCase_ = squad_convert_examples_to_features( examples=self.examples , tokenizer=lowercase , max_seq_length=args.max_seq_length , doc_stride=args.doc_stride , max_query_length=args.max_query_length , is_training=mode == Split.train , threads=args.threads , return_dataset=lowercase , ) lowerCamelCase_ = time.time() torch.save( {"features": self.features, "dataset": self.dataset, "examples": self.examples} , lowercase , ) # ^ This seems to take a lot of time so I want to investigate why and how we can improve. logger.info( f'Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]' ) def __len__( self ) -> Tuple: return len(self.features ) def __getitem__( self , lowercase ) -> Dict[str, torch.Tensor]: # Convert to Tensors and build dataset lowerCamelCase_ = self.features[i] lowerCamelCase_ = torch.tensor(feature.input_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.attention_mask , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.token_type_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.cls_index , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.p_mask , dtype=torch.float ) lowerCamelCase_ = torch.tensor(feature.is_impossible , dtype=torch.float ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": attention_mask, "token_type_ids": token_type_ids, } if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]: del inputs["token_type_ids"] if self.args.model_type in ["xlnet", "xlm"]: inputs.update({"cls_index": cls_index, "p_mask": p_mask} ) if self.args.version_2_with_negative: inputs.update({"is_impossible": is_impossible} ) if self.is_language_sensitive: inputs.update({"langs": (torch.ones(input_ids.shape , dtype=torch.intaa ) * self.args.lang_id)} ) if self.mode == Split.train: lowerCamelCase_ = torch.tensor(feature.start_position , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.end_position , dtype=torch.long ) inputs.update({"start_positions": start_positions, "end_positions": end_positions} ) return inputs
19
0
"""simple docstring""" import json import pathlib import unittest import numpy as np from transformers.testing_utils import require_torch, require_vision, slow from transformers.utils import is_torch_available, is_vision_available from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import YolosImageProcessor class _UpperCamelCase ( unittest.TestCase ): '''simple docstring''' def __init__( self , __a , __a=7 , __a=3 , __a=30 , __a=4_00 , __a=True , __a=None , __a=True , __a=[0.5, 0.5, 0.5] , __a=[0.5, 0.5, 0.5] , __a=True , __a=1 / 2_55 , __a=True , ): # by setting size["longest_edge"] > max_resolution we're effectively not testing this :p __lowerCAmelCase = size if size is not None else {"shortest_edge": 18, "longest_edge": 13_33} __lowerCAmelCase = parent __lowerCAmelCase = batch_size __lowerCAmelCase = num_channels __lowerCAmelCase = min_resolution __lowerCAmelCase = max_resolution __lowerCAmelCase = do_resize __lowerCAmelCase = size __lowerCAmelCase = do_normalize __lowerCAmelCase = image_mean __lowerCAmelCase = image_std __lowerCAmelCase = do_rescale __lowerCAmelCase = rescale_factor __lowerCAmelCase = do_pad def snake_case ( self ): return { "do_resize": self.do_resize, "size": self.size, "do_normalize": self.do_normalize, "image_mean": self.image_mean, "image_std": self.image_std, "do_rescale": self.do_rescale, "rescale_factor": self.rescale_factor, "do_pad": self.do_pad, } def snake_case ( self , __a , __a=False ): if not batched: __lowerCAmelCase = image_inputs[0] if isinstance(__a , Image.Image ): __lowerCAmelCase , __lowerCAmelCase = image.size else: __lowerCAmelCase , __lowerCAmelCase = image.shape[1], image.shape[2] if w < h: __lowerCAmelCase = int(self.size["shortest_edge"] * h / w ) __lowerCAmelCase = self.size["shortest_edge"] elif w > h: __lowerCAmelCase = self.size["shortest_edge"] __lowerCAmelCase = int(self.size["shortest_edge"] * w / h ) else: __lowerCAmelCase = self.size["shortest_edge"] __lowerCAmelCase = self.size["shortest_edge"] else: __lowerCAmelCase = [] for image in image_inputs: __lowerCAmelCase , __lowerCAmelCase = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) __lowerCAmelCase = max(__a , key=lambda __a : item[0] )[0] __lowerCAmelCase = max(__a , key=lambda __a : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class _UpperCamelCase ( snake_case_ ,unittest.TestCase ): '''simple docstring''' __UpperCAmelCase : Optional[int] =YolosImageProcessor if is_vision_available() else None def snake_case ( self ): __lowerCAmelCase = YolosImageProcessingTester(self ) @property def snake_case ( self ): return self.image_processor_tester.prepare_image_processor_dict() def snake_case ( self ): __lowerCAmelCase = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(__a , "image_mean" ) ) self.assertTrue(hasattr(__a , "image_std" ) ) self.assertTrue(hasattr(__a , "do_normalize" ) ) self.assertTrue(hasattr(__a , "do_resize" ) ) self.assertTrue(hasattr(__a , "size" ) ) def snake_case ( self ): __lowerCAmelCase = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size , {"shortest_edge": 18, "longest_edge": 13_33} ) self.assertEqual(image_processor.do_pad , __a ) __lowerCAmelCase = self.image_processing_class.from_dict( self.image_processor_dict , size=42 , max_size=84 , pad_and_return_pixel_mask=__a ) self.assertEqual(image_processor.size , {"shortest_edge": 42, "longest_edge": 84} ) self.assertEqual(image_processor.do_pad , __a ) def snake_case ( self ): pass def snake_case ( self ): # Initialize image_processing __lowerCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PIL images __lowerCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=__a ) for image in image_inputs: self.assertIsInstance(__a , Image.Image ) # Test not batched input __lowerCAmelCase = image_processing(image_inputs[0] , return_tensors="pt" ).pixel_values __lowerCAmelCase , __lowerCAmelCase = self.image_processor_tester.get_expected_values(__a ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched __lowerCAmelCase , __lowerCAmelCase = self.image_processor_tester.get_expected_values(__a , batched=__a ) __lowerCAmelCase = image_processing(__a , return_tensors="pt" ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def snake_case ( self ): # Initialize image_processing __lowerCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors __lowerCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=__a , numpify=__a ) for image in image_inputs: self.assertIsInstance(__a , np.ndarray ) # Test not batched input __lowerCAmelCase = image_processing(image_inputs[0] , return_tensors="pt" ).pixel_values __lowerCAmelCase , __lowerCAmelCase = self.image_processor_tester.get_expected_values(__a ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched __lowerCAmelCase = image_processing(__a , return_tensors="pt" ).pixel_values __lowerCAmelCase , __lowerCAmelCase = self.image_processor_tester.get_expected_values(__a , batched=__a ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def snake_case ( self ): # Initialize image_processing __lowerCAmelCase = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors __lowerCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=__a , torchify=__a ) for image in image_inputs: self.assertIsInstance(__a , torch.Tensor ) # Test not batched input __lowerCAmelCase = image_processing(image_inputs[0] , return_tensors="pt" ).pixel_values __lowerCAmelCase , __lowerCAmelCase = self.image_processor_tester.get_expected_values(__a ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched __lowerCAmelCase = image_processing(__a , return_tensors="pt" ).pixel_values __lowerCAmelCase , __lowerCAmelCase = self.image_processor_tester.get_expected_values(__a , batched=__a ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def snake_case ( self ): # Initialize image_processings __lowerCAmelCase = self.image_processing_class(**self.image_processor_dict ) __lowerCAmelCase = self.image_processing_class(do_resize=__a , do_normalize=__a , do_rescale=__a ) # create random PyTorch tensors __lowerCAmelCase = prepare_image_inputs(self.image_processor_tester , equal_resolution=__a , torchify=__a ) for image in image_inputs: self.assertIsInstance(__a , torch.Tensor ) # Test whether the method "pad" and calling the image processor return the same tensors __lowerCAmelCase = image_processing_a.pad(__a , return_tensors="pt" ) __lowerCAmelCase = image_processing_a(__a , return_tensors="pt" ) self.assertTrue( torch.allclose(encoded_images_with_method["pixel_values"] , encoded_images["pixel_values"] , atol=1e-4 ) ) @slow def snake_case ( self ): # prepare image and target __lowerCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) with open("./tests/fixtures/tests_samples/COCO/coco_annotations.txt" , "r" ) as f: __lowerCAmelCase = json.loads(f.read() ) __lowerCAmelCase = {"image_id": 3_97_69, "annotations": target} # encode them __lowerCAmelCase = YolosImageProcessor.from_pretrained("hustvl/yolos-small" ) __lowerCAmelCase = image_processing(images=__a , annotations=__a , return_tensors="pt" ) # verify pixel values __lowerCAmelCase = torch.Size([1, 3, 8_00, 10_66] ) self.assertEqual(encoding["pixel_values"].shape , __a ) __lowerCAmelCase = torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1] ) self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3] , __a , atol=1e-4 ) ) # verify area __lowerCAmelCase = torch.tensor([58_87.96_00, 1_12_50.20_61, 48_93_53.84_38, 83_71_22.75_00, 14_79_67.51_56, 16_57_32.34_38] ) self.assertTrue(torch.allclose(encoding["labels"][0]["area"] , __a ) ) # verify boxes __lowerCAmelCase = torch.Size([6, 4] ) self.assertEqual(encoding["labels"][0]["boxes"].shape , __a ) __lowerCAmelCase = torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5] ) self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0] , __a , atol=1e-3 ) ) # verify image_id __lowerCAmelCase = torch.tensor([3_97_69] ) self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"] , __a ) ) # verify is_crowd __lowerCAmelCase = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"] , __a ) ) # verify class_labels __lowerCAmelCase = torch.tensor([75, 75, 63, 65, 17, 17] ) self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"] , __a ) ) # verify orig_size __lowerCAmelCase = torch.tensor([4_80, 6_40] ) self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"] , __a ) ) # verify size __lowerCAmelCase = torch.tensor([8_00, 10_66] ) self.assertTrue(torch.allclose(encoding["labels"][0]["size"] , __a ) ) @slow def snake_case ( self ): # prepare image, target and masks_path __lowerCAmelCase = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" ) with open("./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt" , "r" ) as f: __lowerCAmelCase = json.loads(f.read() ) __lowerCAmelCase = {"file_name": "000000039769.png", "image_id": 3_97_69, "segments_info": target} __lowerCAmelCase = pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic" ) # encode them __lowerCAmelCase = YolosImageProcessor(format="coco_panoptic" ) __lowerCAmelCase = image_processing(images=__a , annotations=__a , masks_path=__a , return_tensors="pt" ) # verify pixel values __lowerCAmelCase = torch.Size([1, 3, 8_00, 10_66] ) self.assertEqual(encoding["pixel_values"].shape , __a ) __lowerCAmelCase = torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1] ) self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3] , __a , atol=1e-4 ) ) # verify area __lowerCAmelCase = torch.tensor([14_79_79.68_75, 16_55_27.04_69, 48_46_38.59_38, 1_12_92.93_75, 58_79.65_62, 76_34.11_47] ) self.assertTrue(torch.allclose(encoding["labels"][0]["area"] , __a ) ) # verify boxes __lowerCAmelCase = torch.Size([6, 4] ) self.assertEqual(encoding["labels"][0]["boxes"].shape , __a ) __lowerCAmelCase = torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5] ) self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0] , __a , atol=1e-3 ) ) # verify image_id __lowerCAmelCase = torch.tensor([3_97_69] ) self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"] , __a ) ) # verify is_crowd __lowerCAmelCase = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"] , __a ) ) # verify class_labels __lowerCAmelCase = torch.tensor([17, 17, 63, 75, 75, 93] ) self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"] , __a ) ) # verify masks __lowerCAmelCase = 82_28_73 self.assertEqual(encoding["labels"][0]["masks"].sum().item() , __a ) # verify orig_size __lowerCAmelCase = torch.tensor([4_80, 6_40] ) self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"] , __a ) ) # verify size __lowerCAmelCase = torch.tensor([8_00, 10_66] ) self.assertTrue(torch.allclose(encoding["labels"][0]["size"] , __a ) )
57
from abc import ABC, abstractmethod from argparse import ArgumentParser class _SCREAMING_SNAKE_CASE ( snake_case_ ): @staticmethod @abstractmethod def SCREAMING_SNAKE_CASE_( lowercase ) -> int: raise NotImplementedError() @abstractmethod def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: raise NotImplementedError()
19
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) lowerCAmelCase__ : Optional[Any] ={ '''configuration_electra''': ['''ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ElectraConfig''', '''ElectraOnnxConfig'''], '''tokenization_electra''': ['''ElectraTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ : Optional[int] =['''ElectraTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ : Tuple =[ '''ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''', '''ElectraForCausalLM''', '''ElectraForMaskedLM''', '''ElectraForMultipleChoice''', '''ElectraForPreTraining''', '''ElectraForQuestionAnswering''', '''ElectraForSequenceClassification''', '''ElectraForTokenClassification''', '''ElectraModel''', '''ElectraPreTrainedModel''', '''load_tf_weights_in_electra''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ : Any =[ '''TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFElectraForMaskedLM''', '''TFElectraForMultipleChoice''', '''TFElectraForPreTraining''', '''TFElectraForQuestionAnswering''', '''TFElectraForSequenceClassification''', '''TFElectraForTokenClassification''', '''TFElectraModel''', '''TFElectraPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCAmelCase__ : Union[str, Any] =[ '''FlaxElectraForCausalLM''', '''FlaxElectraForMaskedLM''', '''FlaxElectraForMultipleChoice''', '''FlaxElectraForPreTraining''', '''FlaxElectraForQuestionAnswering''', '''FlaxElectraForSequenceClassification''', '''FlaxElectraForTokenClassification''', '''FlaxElectraModel''', '''FlaxElectraPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig from .tokenization_electra import ElectraTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_electra_fast import ElectraTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_electra import ( ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST, ElectraForCausalLM, ElectraForMaskedLM, ElectraForMultipleChoice, ElectraForPreTraining, ElectraForQuestionAnswering, ElectraForSequenceClassification, ElectraForTokenClassification, ElectraModel, ElectraPreTrainedModel, load_tf_weights_in_electra, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_electra import ( TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST, TFElectraForMaskedLM, TFElectraForMultipleChoice, TFElectraForPreTraining, TFElectraForQuestionAnswering, TFElectraForSequenceClassification, TFElectraForTokenClassification, TFElectraModel, TFElectraPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_electra import ( FlaxElectraForCausalLM, FlaxElectraForMaskedLM, FlaxElectraForMultipleChoice, FlaxElectraForPreTraining, FlaxElectraForQuestionAnswering, FlaxElectraForSequenceClassification, FlaxElectraForTokenClassification, FlaxElectraModel, FlaxElectraPreTrainedModel, ) else: import sys lowerCAmelCase__ : List[str] =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
257
from typing import Callable, List, Optional, Union import PIL import torch from transformers import ( CLIPImageProcessor, CLIPSegForImageSegmentation, CLIPSegProcessor, CLIPTextModel, CLIPTokenizer, ) from diffusers import DiffusionPipeline from diffusers.configuration_utils import FrozenDict from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler from diffusers.utils import deprecate, is_accelerate_available, logging __A =logging.get_logger(__name__) # pylint: disable=invalid-name class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[Any]: super().__init__() if hasattr(scheduler.config , "steps_offset" ) and scheduler.config.steps_offset != 1: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`' f' should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure ' "to update the config accordingly as leaving `steps_offset` might led to incorrect results" " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub," " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`" " file" ) deprecate("steps_offset!=1" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = 1 lowerCamelCase_ = FrozenDict(lowercase ) if hasattr(scheduler.config , "skip_prk_steps" ) and scheduler.config.skip_prk_steps is False: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} has not set the configuration' " `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make" " sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to" " incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face" " Hub, it would be very nice if you could open a Pull request for the" " `scheduler/scheduler_config.json` file" ) deprecate("skip_prk_steps not set" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = True lowerCamelCase_ = FrozenDict(lowercase ) if safety_checker is None: logger.warning( f'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure' " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered" " results in services or applications open to the public. Both the diffusers team and Hugging Face" " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling" " it only for use-cases that involve analyzing network behavior or auditing its results. For more" " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ." ) self.register_modules( segmentation_model=lowercase , segmentation_processor=lowercase , vae=lowercase , text_encoder=lowercase , tokenizer=lowercase , unet=lowercase , scheduler=lowercase , safety_checker=lowercase , feature_extractor=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase = "auto" ) -> Tuple: if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory lowerCamelCase_ = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: self.enable_attention_slicing(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device("cuda" ) for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: if self.device != torch.device("meta" ) or not hasattr(self.unet , "_hf_hook" ): return self.device for module in self.unet.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() def __call__( self , lowercase , lowercase , lowercase , lowercase = 512 , lowercase = 512 , lowercase = 50 , lowercase = 7.5 , lowercase = None , lowercase = 1 , lowercase = 0.0 , lowercase = None , lowercase = None , lowercase = "pil" , lowercase = True , lowercase = None , lowercase = 1 , **lowercase , ) -> int: lowerCamelCase_ = self.segmentation_processor( text=[text] , images=[image] , padding="max_length" , return_tensors="pt" ).to(self.device ) lowerCamelCase_ = self.segmentation_model(**lowercase ) lowerCamelCase_ = torch.sigmoid(outputs.logits ).cpu().detach().unsqueeze(-1 ).numpy() lowerCamelCase_ = self.numpy_to_pil(lowercase )[0].resize(image.size ) # Run inpainting pipeline with the generated mask lowerCamelCase_ = StableDiffusionInpaintPipeline( vae=self.vae , text_encoder=self.text_encoder , tokenizer=self.tokenizer , unet=self.unet , scheduler=self.scheduler , safety_checker=self.safety_checker , feature_extractor=self.feature_extractor , ) return inpainting_pipeline( prompt=lowercase , image=lowercase , mask_image=lowercase , height=lowercase , width=lowercase , num_inference_steps=lowercase , guidance_scale=lowercase , negative_prompt=lowercase , num_images_per_prompt=lowercase , eta=lowercase , generator=lowercase , latents=lowercase , output_type=lowercase , return_dict=lowercase , callback=lowercase , callback_steps=lowercase , )
19
0
"""simple docstring""" import re from flax.core.frozen_dict import freeze from flax.traverse_util import flatten_dict, unflatten_dict from jax.experimental import PartitionSpec as P # Sentinels _lowercase = object() # For specifying empty leaf dict `{}` _lowercase = object() def _snake_case ( snake_case__ : int , snake_case__ : Optional[Any] ): A = tuple((re.compile(x + '$' ) for x in qs) ) for i in range(len(lowerCamelCase__ ) - len(lowerCamelCase__ ) + 1 ): A = [x.match(lowerCamelCase__ ) for x, y in zip(lowerCamelCase__ , ks[i:] )] if matches and all(lowerCamelCase__ ): return True return False def _snake_case ( snake_case__ : Optional[Any] ): def replace(snake_case__ : str , snake_case__ : Union[str, Any] ): for rule, replacement in rules: if _match(lowerCamelCase__ , lowerCamelCase__ ): return replacement return val return replace def _snake_case ( ): return [ # embeddings (("transformer", "wpe", "embedding"), P('mp' , lowerCamelCase__ )), (("transformer", "wte", "embedding"), P('mp' , lowerCamelCase__ )), # atention (("attention", "(q_proj|k_proj|v_proj)", "kernel"), P(lowerCamelCase__ , 'mp' )), (("attention", "out_proj", "kernel"), P('mp' , lowerCamelCase__ )), (("attention", "out_proj", "bias"), None), # mlp (("mlp", "c_fc", "kernel"), P(lowerCamelCase__ , 'mp' )), (("mlp", "c_fc", "bias"), P('mp' )), (("mlp", "c_proj", "kernel"), P('mp' , lowerCamelCase__ )), (("mlp", "c_proj", "bias"), None), # layer norms ((r"ln_\d+", "bias"), None), ((r"\d+", r"ln_\d+", "scale"), None), (("ln_f", "bias"), None), (("ln_f", "scale"), None), ] def _snake_case ( snake_case__ : List[Any] ): A = _get_partition_rules() A = _replacement_rules(lowerCamelCase__ ) A = {k: _unmatched for k in flatten_dict(lowerCamelCase__ )} A = {k: replace(lowerCamelCase__ , lowerCamelCase__ ) for k, v in initd.items()} assert _unmatched not in result.values(), "Incomplete partition spec." return freeze(unflatten_dict(lowerCamelCase__ ) )
74
from collections import deque def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) lowerCamelCase_ = deque() lowerCamelCase_ = [False for _ in range(lowerCamelCase__ )] lowerCamelCase_ = [-1 for _ in range(lowerCamelCase__ )] lowerCamelCase_ = index_of[:] def strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = index # the number when this node is seen lowerCamelCase_ = index # lowest rank node reachable from here index += 1 stack.append(lowerCamelCase__ ) lowerCamelCase_ = True for w in g[v]: if index_of[w] == -1: lowerCamelCase_ = strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) elif on_stack[w]: lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) if lowlink_of[v] == index_of[v]: lowerCamelCase_ = [] lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) while w != v: lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) components.append(lowerCamelCase__ ) return index lowerCamelCase_ = [] for v in range(lowerCamelCase__ ): if index_of[v] == -1: strong_connect(lowerCamelCase__ , 0 , lowerCamelCase__ ) return components def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [[] for _ in range(lowerCamelCase__ )] for u, v in edges: g[u].append(lowerCamelCase__ ) return g if __name__ == "__main__": # Test __A =7 __A =[0, 0, 1, 2, 3, 3, 4, 4, 6] __A =[1, 3, 2, 0, 1, 4, 5, 6, 5] __A =[(u, v) for u, v in zip(source, target)] __A =create_graph(n_vertices, edges) assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)
19
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) _UpperCamelCase: Tuple = { 'configuration_blenderbot': [ 'BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BlenderbotConfig', 'BlenderbotOnnxConfig', ], 'tokenization_blenderbot': ['BlenderbotTokenizer'], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCamelCase: List[Any] = ['BlenderbotTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCamelCase: str = [ 'BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST', 'BlenderbotForCausalLM', 'BlenderbotForConditionalGeneration', 'BlenderbotModel', 'BlenderbotPreTrainedModel', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCamelCase: List[Any] = [ 'TFBlenderbotForConditionalGeneration', 'TFBlenderbotModel', 'TFBlenderbotPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCamelCase: Union[str, Any] = [ 'FlaxBlenderbotForConditionalGeneration', 'FlaxBlenderbotModel', 'FlaxBlenderbotPreTrainedModel', ] if TYPE_CHECKING: from .configuration_blenderbot import ( BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotConfig, BlenderbotOnnxConfig, ) from .tokenization_blenderbot import BlenderbotTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_fast import BlenderbotTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot import ( BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotForCausalLM, BlenderbotForConditionalGeneration, BlenderbotModel, BlenderbotPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot import ( TFBlenderbotForConditionalGeneration, TFBlenderbotModel, TFBlenderbotPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, FlaxBlenderbotPreTrainedModel, ) else: import sys _UpperCamelCase: Any = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
255
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) __A ={'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizer'''] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''XGLMForCausalLM''', '''XGLMModel''', '''XGLMPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''FlaxXGLMForCausalLM''', '''FlaxXGLMModel''', '''FlaxXGLMPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFXGLMForCausalLM''', '''TFXGLMModel''', '''TFXGLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm import XGLMTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm_fast import XGLMTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_xglm import ( TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFXGLMForCausalLM, TFXGLMModel, TFXGLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure)
19
0
'''simple docstring''' from __future__ import annotations import time import numpy as np a_ = [8, 5, 9, 7] a_ = [ [2, 0, 1, 1], [0, 1, 2, 1], [4, 0, 0, 3], [0, 2, 1, 0], [1, 0, 3, 0], ] a_ = [ [3, 2, 1, 4], [0, 2, 5, 2], [5, 1, 0, 5], [1, 5, 3, 0], [3, 0, 3, 3], ] class __SCREAMING_SNAKE_CASE : def __init__( self : Union[str, Any] , __lowercase : str , __lowercase : List[str] , __lowercase : List[Any] , ) -> None: SCREAMING_SNAKE_CASE__ : Dict =claim_vector SCREAMING_SNAKE_CASE__ : Optional[int] =allocated_resources_table SCREAMING_SNAKE_CASE__ : Tuple =maximum_claim_table def __magic_name__ ( self : int ) -> list[int]: return [ sum(p_item[i] for p_item in self.__allocated_resources_table ) for i in range(len(self.__allocated_resources_table[0] ) ) ] def __magic_name__ ( self : List[str] ) -> list[int]: return np.array(self.__claim_vector ) - np.array( self.__processes_resource_summation() ) def __magic_name__ ( self : int ) -> list[list[int]]: return [ list(np.array(self.__maximum_claim_table[i] ) - np.array(__lowercase ) ) for i, allocated_resource in enumerate(self.__allocated_resources_table ) ] def __magic_name__ ( self : Union[str, Any] ) -> dict[int, list[int]]: return {self.__need().index(__lowercase ): i for i in self.__need()} def __magic_name__ ( self : Tuple , **__lowercase : Optional[int] ) -> None: SCREAMING_SNAKE_CASE__ : Tuple =self.__need() SCREAMING_SNAKE_CASE__ : Any =self.__allocated_resources_table SCREAMING_SNAKE_CASE__ : Optional[int] =self.__available_resources() SCREAMING_SNAKE_CASE__ : List[str] =self.__need_index_manager() for kw, val in kwargs.items(): if kw and val is True: self.__pretty_data() print('''_''' * 50 + '''\n''' ) while need_list: SCREAMING_SNAKE_CASE__ : Tuple =False for each_need in need_list: SCREAMING_SNAKE_CASE__ : str =True for index, need in enumerate(__lowercase ): if need > available_resources[index]: SCREAMING_SNAKE_CASE__ : Any =False break if execution: SCREAMING_SNAKE_CASE__ : Optional[int] =True # get the original index of the process from ind_ctrl db for original_need_index, need_clone in need_index_manager.items(): if each_need == need_clone: SCREAMING_SNAKE_CASE__ : Any =original_need_index print(F"Process {process_number + 1} is executing." ) # remove the process run from stack need_list.remove(__lowercase ) # update available/freed resources stack SCREAMING_SNAKE_CASE__ : Tuple =np.array(__lowercase ) + np.array( alloc_resources_table[process_number] ) print( '''Updated available resource stack for processes: ''' + ''' '''.join([str(__lowercase ) for x in available_resources] ) ) break if safe: print('''The process is in a safe state.\n''' ) else: print('''System in unsafe state. Aborting...\n''' ) break def __magic_name__ ( self : int ) -> int: print(''' ''' * 9 + '''Allocated Resource Table''' ) for item in self.__allocated_resources_table: print( F"P{self.__allocated_resources_table.index(__lowercase ) + 1}" + ''' '''.join(F"{it:>8}" for it in item ) + '''\n''' ) print(''' ''' * 9 + '''System Resource Table''' ) for item in self.__maximum_claim_table: print( F"P{self.__maximum_claim_table.index(__lowercase ) + 1}" + ''' '''.join(F"{it:>8}" for it in item ) + '''\n''' ) print( '''Current Usage by Active Processes: ''' + ''' '''.join(str(__lowercase ) for x in self.__claim_vector ) ) print( '''Initial Available Resources: ''' + ''' '''.join(str(__lowercase ) for x in self.__available_resources() ) ) time.sleep(1 ) if __name__ == "__main__": import doctest doctest.testmod()
152
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __A ={'''configuration_wavlm''': ['''WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WavLMConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''WavLMForAudioFrameClassification''', '''WavLMForCTC''', '''WavLMForSequenceClassification''', '''WavLMForXVector''', '''WavLMModel''', '''WavLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_wavlm import ( WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST, WavLMForAudioFrameClassification, WavLMForCTC, WavLMForSequenceClassification, WavLMForXVector, WavLMModel, WavLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
import os import unittest from transformers.models.phobert.tokenization_phobert import VOCAB_FILES_NAMES, PhobertTokenizer from ...test_tokenization_common import TokenizerTesterMixin class __A ( snake_case_ , unittest.TestCase ): """simple docstring""" UpperCamelCase__ : Optional[int] =PhobertTokenizer UpperCamelCase__ : str =False def __lowercase ( self ): """simple docstring""" super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt __UpperCamelCase : Dict =['T@@', 'i', 'I', 'R@@', 'r', 'e@@'] __UpperCamelCase : List[Any] =dict(zip(lowerCamelCase__ , range(len(lowerCamelCase__ ) ) ) ) __UpperCamelCase : Any =['#version: 0.2', 'l à</w>'] __UpperCamelCase : Tuple ={'unk_token': '<unk>'} __UpperCamelCase : Optional[Any] =os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) __UpperCamelCase : Union[str, Any] =os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['merges_file'] ) with open(self.vocab_file , 'w' , encoding='utf-8' ) as fp: for token in vocab_tokens: fp.write(f'{token} {vocab_tokens[token]}\n' ) with open(self.merges_file , 'w' , encoding='utf-8' ) as fp: fp.write('\n'.join(lowerCamelCase__ ) ) def __lowercase ( self , **lowerCamelCase__ ): """simple docstring""" kwargs.update(self.special_tokens_map ) return PhobertTokenizer.from_pretrained(self.tmpdirname , **lowerCamelCase__ ) def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : Optional[Any] ='Tôi là VinAI Research' __UpperCamelCase : Union[str, Any] ='T<unk> i <unk> <unk> <unk> <unk> <unk> <unk> I Re<unk> e<unk> <unk> <unk> <unk>' return input_text, output_text def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Any =PhobertTokenizer(self.vocab_file , self.merges_file , **self.special_tokens_map ) __UpperCamelCase : List[Any] ='Tôi là VinAI Research' __UpperCamelCase : Optional[Any] ='T@@ ô@@ i l@@ à V@@ i@@ n@@ A@@ I R@@ e@@ s@@ e@@ a@@ r@@ c@@ h'.split() __UpperCamelCase : str =tokenizer.tokenize(lowerCamelCase__ ) print(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__ ) __UpperCamelCase : Dict =tokens + [tokenizer.unk_token] __UpperCamelCase : List[str] =[4, 3, 5, 3, 3, 3, 3, 3, 3, 6, 7, 9, 3, 9, 3, 3, 3, 3, 3] self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) , lowerCamelCase__ )
71
# Lint as: python3 # pylint: enable=line-too-long # pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position __A ='''2.13.1''' import platform import pyarrow from packaging import version if version.parse(platform.python_version()) < version.parse('''3.7'''): raise ImportWarning( '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.''' ) if version.parse(pyarrow.__version__).major < 8: raise ImportWarning( '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n''' '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.''' ) del platform del pyarrow del version from .arrow_dataset import Dataset from .arrow_reader import ReadInstruction from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder from .combine import concatenate_datasets, interleave_datasets from .dataset_dict import DatasetDict, IterableDatasetDict from .download import * from .features import * from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled from .info import DatasetInfo, MetricInfo from .inspect import ( get_dataset_config_info, get_dataset_config_names, get_dataset_infos, get_dataset_split_names, inspect_dataset, inspect_metric, list_datasets, list_metrics, ) from .iterable_dataset import IterableDataset from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric from .metric import Metric from .splits import ( NamedSplit, NamedSplitAll, Split, SplitBase, SplitDict, SplitGenerator, SplitInfo, SubSplitInfo, percent, ) from .tasks import * from .utils import * from .utils import logging # deprecated modules from datasets import arrow_dataset as _arrow_dataset # isort:skip from datasets import utils as _utils # isort:skip from datasets.utils import download_manager as _deprecated_download_manager # isort:skip __A =concatenate_datasets __A =DownloadConfig __A =DownloadManager __A =DownloadMode __A =DownloadConfig __A =DownloadMode __A =DownloadManager del _arrow_dataset, _utils, _deprecated_download_manager
19
0
'''simple docstring''' import unittest import numpy as np import torch from diffusers import DDIMPipeline, DDIMScheduler, UNetaDModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow, torch_device from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class a ( snake_case_ , unittest.TestCase ): _lowerCAmelCase = DDIMPipeline _lowerCAmelCase = UNCONDITIONAL_IMAGE_GENERATION_PARAMS _lowerCAmelCase = PipelineTesterMixin.required_optional_params - { """num_images_per_prompt""", """latents""", """callback""", """callback_steps""", } _lowerCAmelCase = UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS _lowerCAmelCase = False def __UpperCAmelCase ( self ) -> Dict: torch.manual_seed(0 ) _a = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=('DownBlock2D', 'AttnDownBlock2D') , up_block_types=('AttnUpBlock2D', 'UpBlock2D') , ) _a = DDIMScheduler() _a = {'unet': unet, 'scheduler': scheduler} return components def __UpperCAmelCase ( self , __magic_name__ , __magic_name__=0 ) -> Any: if str(__magic_name__ ).startswith('mps' ): _a = torch.manual_seed(__magic_name__ ) else: _a = torch.Generator(device=__magic_name__ ).manual_seed(__magic_name__ ) _a = { 'batch_size': 1, 'generator': generator, 'num_inference_steps': 2, 'output_type': 'numpy', } return inputs def __UpperCAmelCase ( self ) -> int: _a = 'cpu' _a = self.get_dummy_components() _a = self.pipeline_class(**__magic_name__ ) pipe.to(__magic_name__ ) pipe.set_progress_bar_config(disable=__magic_name__ ) _a = self.get_dummy_inputs(__magic_name__ ) _a = pipe(**__magic_name__ ).images _a = image[0, -3:, -3:, -1] self.assertEqual(image.shape , (1, 32, 32, 3) ) _a = np.array( [1.000e00, 5.717e-01, 4.717e-01, 1.000e00, 0.000e00, 1.000e00, 3.000e-04, 0.000e00, 9.000e-04] ) _a = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(__magic_name__ , 1e-3 ) def __UpperCAmelCase ( self ) -> int: super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 ) def __UpperCAmelCase ( self ) -> Union[str, Any]: super().test_save_load_local(expected_max_difference=3e-3 ) def __UpperCAmelCase ( self ) -> List[Any]: super().test_save_load_optional_components(expected_max_difference=3e-3 ) def __UpperCAmelCase ( self ) -> Any: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class a ( unittest.TestCase ): def __UpperCAmelCase ( self ) -> Dict: _a = 'google/ddpm-cifar10-32' _a = UNetaDModel.from_pretrained(__magic_name__ ) _a = DDIMScheduler() _a = DDIMPipeline(unet=__magic_name__ , scheduler=__magic_name__ ) ddim.to(__magic_name__ ) ddim.set_progress_bar_config(disable=__magic_name__ ) _a = torch.manual_seed(0 ) _a = ddim(generator=__magic_name__ , eta=0.0 , output_type='numpy' ).images _a = image[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) _a = np.array([0.1_7_2_3, 0.1_6_1_7, 0.1_6_0_0, 0.1_6_2_6, 0.1_4_9_7, 0.1_5_1_3, 0.1_5_0_5, 0.1_4_4_2, 0.1_4_5_3] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 def __UpperCAmelCase ( self ) -> Dict: _a = 'google/ddpm-ema-bedroom-256' _a = UNetaDModel.from_pretrained(__magic_name__ ) _a = DDIMScheduler.from_pretrained(__magic_name__ ) _a = DDIMPipeline(unet=__magic_name__ , scheduler=__magic_name__ ) ddpm.to(__magic_name__ ) ddpm.set_progress_bar_config(disable=__magic_name__ ) _a = torch.manual_seed(0 ) _a = ddpm(generator=__magic_name__ , output_type='numpy' ).images _a = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _a = np.array([0.0_0_6_0, 0.0_2_0_1, 0.0_3_4_4, 0.0_0_2_4, 0.0_0_1_8, 0.0_0_0_2, 0.0_0_2_2, 0.0_0_0_0, 0.0_0_6_9] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
168
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __A ={ '''configuration_bloom''': ['''BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BloomConfig''', '''BloomOnnxConfig'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''BloomTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''BloomForCausalLM''', '''BloomModel''', '''BloomPreTrainedModel''', '''BloomForSequenceClassification''', '''BloomForTokenClassification''', '''BloomForQuestionAnswering''', ] if TYPE_CHECKING: from .configuration_bloom import BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP, BloomConfig, BloomOnnxConfig try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_bloom_fast import BloomTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_bloom import ( BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST, BloomForCausalLM, BloomForQuestionAnswering, BloomForSequenceClassification, BloomForTokenClassification, BloomModel, BloomPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
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 YolosConfig, YolosForObjectDetection, YolosImageProcessor from transformers.utils import logging logging.set_verbosity_info() lowercase_ = logging.get_logger(__name__) def a ( A__ : Tuple ) -> Any: """simple docstring""" _lowercase =YolosConfig() # size of the architecture if "yolos_ti" in yolos_name: _lowercase =192 _lowercase =768 _lowercase =12 _lowercase =3 _lowercase =[800, 1333] _lowercase =False elif yolos_name == "yolos_s_dWr": _lowercase =330 _lowercase =14 _lowercase =6 _lowercase =1320 elif "yolos_s" in yolos_name: _lowercase =384 _lowercase =1536 _lowercase =12 _lowercase =6 elif "yolos_b" in yolos_name: _lowercase =[800, 1344] _lowercase =91 _lowercase ='huggingface/label-files' _lowercase ='coco-detection-id2label.json' _lowercase =json.load(open(hf_hub_download(lowerCamelCase__ , lowerCamelCase__ , repo_type='dataset' ) , 'r' ) ) _lowercase ={int(lowerCamelCase__ ): v for k, v in idalabel.items()} _lowercase =idalabel _lowercase ={v: k for k, v in idalabel.items()} return config def a ( A__ : List[str] , A__ : Dict , A__ : Optional[Any] = False ) -> List[str]: """simple docstring""" for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) _lowercase =state_dict.pop(F'''blocks.{i}.attn.qkv.weight''' ) _lowercase =state_dict.pop(F'''blocks.{i}.attn.qkv.bias''' ) # next, add query, keys and values (in that order) to the state dict _lowercase =in_proj_weight[: config.hidden_size, :] _lowercase =in_proj_bias[: config.hidden_size] _lowercase =in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] _lowercase =in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] _lowercase =in_proj_weight[-config.hidden_size :, :] _lowercase =in_proj_bias[-config.hidden_size :] def a ( A__ : List[str] ) -> int: """simple docstring""" if "backbone" in name: _lowercase =name.replace('backbone' , 'vit' ) if "cls_token" in name: _lowercase =name.replace('cls_token' , 'embeddings.cls_token' ) if "det_token" in name: _lowercase =name.replace('det_token' , 'embeddings.detection_tokens' ) if "mid_pos_embed" in name: _lowercase =name.replace('mid_pos_embed' , 'encoder.mid_position_embeddings' ) if "pos_embed" in name: _lowercase =name.replace('pos_embed' , 'embeddings.position_embeddings' ) if "patch_embed.proj" in name: _lowercase =name.replace('patch_embed.proj' , 'embeddings.patch_embeddings.projection' ) if "blocks" in name: _lowercase =name.replace('blocks' , 'encoder.layer' ) if "attn.proj" in name: _lowercase =name.replace('attn.proj' , 'attention.output.dense' ) if "attn" in name: _lowercase =name.replace('attn' , 'attention.self' ) if "norm1" in name: _lowercase =name.replace('norm1' , 'layernorm_before' ) if "norm2" in name: _lowercase =name.replace('norm2' , 'layernorm_after' ) if "mlp.fc1" in name: _lowercase =name.replace('mlp.fc1' , 'intermediate.dense' ) if "mlp.fc2" in name: _lowercase =name.replace('mlp.fc2' , 'output.dense' ) if "class_embed" in name: _lowercase =name.replace('class_embed' , 'class_labels_classifier' ) if "bbox_embed" in name: _lowercase =name.replace('bbox_embed' , 'bbox_predictor' ) if "vit.norm" in name: _lowercase =name.replace('vit.norm' , 'vit.layernorm' ) return name def a ( A__ : Tuple , A__ : Optional[Any] ) -> List[str]: """simple docstring""" for key in orig_state_dict.copy().keys(): _lowercase =orig_state_dict.pop(lowerCamelCase__ ) if "qkv" in key: _lowercase =key.split('.' ) _lowercase =int(key_split[2] ) _lowercase =model.vit.encoder.layer[layer_num].attention.attention.all_head_size if "weight" in key: _lowercase =val[:dim, :] _lowercase =val[ dim : dim * 2, : ] _lowercase =val[-dim:, :] else: _lowercase =val[:dim] _lowercase =val[dim : dim * 2] _lowercase =val[-dim:] else: _lowercase =val return orig_state_dict def a ( ) -> Optional[Any]: """simple docstring""" _lowercase ='http://images.cocodataset.org/val2017/000000039769.jpg' _lowercase =Image.open(requests.get(lowerCamelCase__ , stream=lowerCamelCase__ ).raw ) return im @torch.no_grad() def a ( A__ : Dict , A__ : List[str] , A__ : List[str] , A__ : Optional[int] = False ) -> List[str]: """simple docstring""" _lowercase =get_yolos_config(lowerCamelCase__ ) # load original state_dict _lowercase =torch.load(lowerCamelCase__ , map_location='cpu' )['model'] # load 🤗 model _lowercase =YolosForObjectDetection(lowerCamelCase__ ) model.eval() _lowercase =convert_state_dict(lowerCamelCase__ , lowerCamelCase__ ) model.load_state_dict(lowerCamelCase__ ) # Check outputs on an image, prepared by YolosImageProcessor _lowercase =800 if yolos_name != 'yolos_ti' else 512 _lowercase =YolosImageProcessor(format='coco_detection' , size=lowerCamelCase__ ) _lowercase =image_processor(images=prepare_img() , return_tensors='pt' ) _lowercase =model(**lowerCamelCase__ ) _lowercase , _lowercase =outputs.logits, outputs.pred_boxes _lowercase , _lowercase =None, None if yolos_name == "yolos_ti": _lowercase =torch.tensor( [[-39.5022, -11.9820, -17.6888], [-29.9574, -9.9769, -17.7691], [-42.3281, -20.7200, -30.6294]] ) _lowercase =torch.tensor( [[0.4021, 0.0836, 0.7979], [0.0184, 0.2609, 0.0364], [0.1781, 0.2004, 0.2095]] ) elif yolos_name == "yolos_s_200_pre": _lowercase =torch.tensor( [[-24.0248, -10.3024, -14.8290], [-42.0392, -16.8200, -27.4334], [-27.2743, -11.8154, -18.7148]] ) _lowercase =torch.tensor( [[0.2559, 0.5455, 0.4706], [0.2989, 0.7279, 0.1875], [0.7732, 0.4017, 0.4462]] ) elif yolos_name == "yolos_s_300_pre": _lowercase =torch.tensor( [[-36.2220, -14.4385, -23.5457], [-35.6970, -14.7583, -21.3935], [-31.5939, -13.6042, -16.8049]] ) _lowercase =torch.tensor( [[0.7614, 0.2316, 0.4728], [0.7168, 0.4495, 0.3855], [0.4996, 0.1466, 0.9996]] ) elif yolos_name == "yolos_s_dWr": _lowercase =torch.tensor( [[-42.8668, -24.1049, -41.1690], [-34.7456, -14.1274, -24.9194], [-33.7898, -12.1946, -25.6495]] ) _lowercase =torch.tensor( [[0.5587, 0.2773, 0.0605], [0.5004, 0.3014, 0.9994], [0.4999, 0.1548, 0.9994]] ) elif yolos_name == "yolos_base": _lowercase =torch.tensor( [[-40.6064, -24.3084, -32.6447], [-55.1990, -30.7719, -35.5877], [-51.4311, -33.3507, -35.6462]] ) _lowercase =torch.tensor( [[0.5555, 0.2794, 0.0655], [0.9049, 0.2664, 0.1894], [0.9183, 0.1984, 0.1635]] ) else: raise ValueError(F'''Unknown yolos_name: {yolos_name}''' ) assert torch.allclose(logits[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) assert torch.allclose(pred_boxes[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) Path(lowerCamelCase__ ).mkdir(exist_ok=lowerCamelCase__ ) print(F'''Saving model {yolos_name} to {pytorch_dump_folder_path}''' ) model.save_pretrained(lowerCamelCase__ ) print(F'''Saving image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(lowerCamelCase__ ) if push_to_hub: _lowercase ={ 'yolos_ti': 'yolos-tiny', 'yolos_s_200_pre': 'yolos-small', 'yolos_s_300_pre': 'yolos-small-300', 'yolos_s_dWr': 'yolos-small-dwr', 'yolos_base': 'yolos-base', } print('Pushing to the hub...' ) _lowercase =model_mapping[yolos_name] image_processor.push_to_hub(lowerCamelCase__ , organization='hustvl' ) model.push_to_hub(lowerCamelCase__ , organization='hustvl' ) if __name__ == "__main__": lowercase_ = argparse.ArgumentParser() # Required parameters parser.add_argument( '--yolos_name', default='yolos_s_200_pre', type=str, help=( 'Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\',' ' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.' ), ) parser.add_argument( '--checkpoint_path', default=None, type=str, help='Path to the original state dict (.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.' ) lowercase_ = parser.parse_args() convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
205
from __future__ import annotations import unittest from transformers import EsmConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers.models.esm.modeling_tf_esm import ( TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, TFEsmModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , ) -> Optional[int]: lowerCamelCase_ = parent lowerCamelCase_ = 13 lowerCamelCase_ = 7 lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = 99 lowerCamelCase_ = 32 lowerCamelCase_ = 2 lowerCamelCase_ = 4 lowerCamelCase_ = 37 lowerCamelCase_ = "gelu" lowerCamelCase_ = 0.1 lowerCamelCase_ = 0.1 lowerCamelCase_ = 512 lowerCamelCase_ = 16 lowerCamelCase_ = 2 lowerCamelCase_ = 0.0_2 lowerCamelCase_ = 3 lowerCamelCase_ = 4 lowerCamelCase_ = None def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_input_mask: lowerCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = EsmConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , pad_token_id=1 , 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 , initializer_range=self.initializer_range , ) return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def SCREAMING_SNAKE_CASE_( self ) -> List[str]: ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = self.prepare_config_and_inputs() lowerCamelCase_ = True lowerCamelCase_ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Any: lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> Tuple: lowerCamelCase_ = True lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": input_mask, "encoder_hidden_states": encoder_hidden_states, "encoder_attention_mask": encoder_attention_mask, } lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase , encoder_hidden_states=lowercase ) # Also check the case where encoder outputs are not passed lowerCamelCase_ = model(lowercase , attention_mask=lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Optional[int]: lowerCamelCase_ = TFEsmForMaskedLM(config=lowercase ) lowerCamelCase_ = model([input_ids, input_mask] ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = TFEsmForTokenClassification(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_tf class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( ( TFEsmModel, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, ) if is_tf_available() else () ) lowerCAmelCase__ = ( { 'feature-extraction': TFEsmModel, 'fill-mask': TFEsmForMaskedLM, 'text-classification': TFEsmForSequenceClassification, 'token-classification': TFEsmForTokenClassification, 'zero-shot': TFEsmForSequenceClassification, } if is_tf_available() else {} ) lowerCAmelCase__ = False lowerCAmelCase__ = False def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = TFEsmModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , hidden_size=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Dict: for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = TFEsmModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: pass @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> Any: pass def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ , lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCamelCase_ = model_class(lowercase ) assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer ) if model_class is TFEsmForMaskedLM: # Output embedding test differs from the main test because they're a matrix, not a layer lowerCamelCase_ = model.get_bias() assert isinstance(lowercase , lowercase ) for k, v in name.items(): assert isinstance(lowercase , tf.Variable ) else: lowerCamelCase_ = model.get_output_embeddings() assert x is None lowerCamelCase_ = model.get_bias() assert name is None @require_tf class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 1, 2, 3, 4, 5]] ) lowerCamelCase_ = model(lowercase )[0] lowerCamelCase_ = [1, 6, 33] self.assertEqual(list(output.numpy().shape ) , lowercase ) # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7], [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5], [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-2 ) ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] ) lowerCamelCase_ = model(lowercase )[0] # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9], [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2], [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
19
0
def _UpperCAmelCase (UpperCamelCase__ : List[Any] , UpperCamelCase__ : Optional[Any] ): _A : Dict = 0 while b > 0: if b & 1: res += a a += a b >>= 1 return res def _UpperCAmelCase (UpperCamelCase__ : int , UpperCamelCase__ : Any , UpperCamelCase__ : Dict ): _A : Tuple = 0 while b > 0: if b & 1: _A : Optional[Any] = ((res % c) + (a % c)) % c a += a b >>= 1 return res
11
import importlib.util import json import os import warnings from dataclasses import dataclass, field import torch from ..training_args import TrainingArguments from ..utils import cached_property, is_sagemaker_dp_enabled, logging __A =logging.get_logger(__name__) def lowerCamelCase_ ( ): # Get the sagemaker specific mp parameters from smp_options variable. lowerCamelCase_ = os.getenv("SM_HP_MP_PARAMETERS" , "{}" ) try: # Parse it and check the field "partitions" is included, it is required for model parallel. lowerCamelCase_ = json.loads(lowerCamelCase__ ) if "partitions" not in smp_options: return False except json.JSONDecodeError: return False # Get the sagemaker specific framework parameters from mpi_options variable. lowerCamelCase_ = os.getenv("SM_FRAMEWORK_PARAMS" , "{}" ) try: # Parse it and check the field "sagemaker_distributed_dataparallel_enabled". lowerCamelCase_ = json.loads(lowerCamelCase__ ) if not mpi_options.get("sagemaker_mpi_enabled" , lowerCamelCase__ ): return False except json.JSONDecodeError: return False # Lastly, check if the `smdistributed` module is present. return importlib.util.find_spec("smdistributed" ) is not None if is_sagemaker_model_parallel_available(): import smdistributed.modelparallel.torch as smp smp.init() @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = field( default='' , metadata={'help': 'Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'} , ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: super().__post_init__() warnings.warn( "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use " "`TrainingArguments` instead." , lowercase , ) @cached_property def SCREAMING_SNAKE_CASE_( self ) -> "torch.device": logger.info("PyTorch: setting up devices" ) if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1: logger.warning( "torch.distributed process group is initialized, but local_rank == -1. " "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch" ) if self.no_cuda: lowerCamelCase_ = torch.device("cpu" ) lowerCamelCase_ = 0 elif is_sagemaker_model_parallel_available(): lowerCamelCase_ = smp.local_rank() lowerCamelCase_ = torch.device("cuda" , lowercase ) lowerCamelCase_ = 1 elif is_sagemaker_dp_enabled(): import smdistributed.dataparallel.torch.torch_smddp # noqa: F401 torch.distributed.init_process_group(backend="smddp" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = int(os.getenv("SMDATAPARALLEL_LOCAL_RANK" ) ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 elif self.local_rank == -1: # if n_gpu is > 1 we'll use nn.DataParallel. # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0` # Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will # trigger an error that a device index is missing. Index 0 takes into account the # GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0` # will use the first GPU in that env, i.e. GPU#1 lowerCamelCase_ = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" ) # Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at # the default value. lowerCamelCase_ = torch.cuda.device_count() else: # Here, we'll use torch.distributed. # Initializes the distributed backend which will take care of synchronizing nodes/GPUs if not torch.distributed.is_initialized(): torch.distributed.init_process_group(backend="nccl" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 if device.type == "cuda": torch.cuda.set_device(lowercase ) return device @property def SCREAMING_SNAKE_CASE_( self ) -> Tuple: if is_sagemaker_model_parallel_available(): return smp.dp_size() return super().world_size @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: return not is_sagemaker_model_parallel_available() @property def SCREAMING_SNAKE_CASE_( self ) -> Dict: return False
19
0
'''simple docstring''' import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss __UpperCAmelCase =pytest.mark.integration @require_faiss class a__ ( snake_case_ ): def SCREAMING_SNAKE_CASE__ ( self : Dict ): """simple docstring""" __lowerCamelCase = Dataset.from_dict({'''filename''': ['''my_name-train''' + '''_''' + str(a ) for x in np.arange(30 ).tolist()]} ) return dset def SCREAMING_SNAKE_CASE__ ( self : Optional[Any] ): """simple docstring""" import faiss __lowerCamelCase = self._create_dummy_dataset() __lowerCamelCase = dset.map( lambda a , a : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=a , keep_in_memory=a ) __lowerCamelCase = dset.add_faiss_index('''vecs''' , batch_size=1_00 , metric_type=faiss.METRIC_INNER_PRODUCT ) __lowerCamelCase , __lowerCamelCase = dset.get_nearest_examples('''vecs''' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['''filename'''][0] , '''my_name-train_29''' ) dset.drop_index('''vecs''' ) def SCREAMING_SNAKE_CASE__ ( self : str ): """simple docstring""" import faiss __lowerCamelCase = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='''vecs''' , batch_size=1_00 , metric_type=faiss.METRIC_INNER_PRODUCT , ) __lowerCamelCase , __lowerCamelCase = dset.get_nearest_examples('''vecs''' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['''filename'''][0] , '''my_name-train_29''' ) def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ): """simple docstring""" import faiss __lowerCamelCase = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='''vecs''' , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=a ) as tmp_file: dset.save_faiss_index('''vecs''' , tmp_file.name ) dset.load_faiss_index('''vecs2''' , tmp_file.name ) os.unlink(tmp_file.name ) __lowerCamelCase , __lowerCamelCase = dset.get_nearest_examples('''vecs2''' , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples['''filename'''][0] , '''my_name-train_29''' ) def SCREAMING_SNAKE_CASE__ ( self : List[str] ): """simple docstring""" __lowerCamelCase = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name='''vecs''' ) dset.drop_index('''vecs''' ) self.assertRaises(a , partial(dset.get_nearest_examples , '''vecs2''' , np.ones(5 , dtype=np.floataa ) ) ) def SCREAMING_SNAKE_CASE__ ( self : str ): """simple docstring""" from elasticsearch import Elasticsearch __lowerCamelCase = self._create_dummy_dataset() with patch('''elasticsearch.Elasticsearch.search''' ) as mocked_search, patch( '''elasticsearch.client.IndicesClient.create''' ) as mocked_index_create, patch('''elasticsearch.helpers.streaming_bulk''' ) as mocked_bulk: __lowerCamelCase = {'''acknowledged''': True} mocked_bulk.return_value([(True, None)] * 30 ) __lowerCamelCase = {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 29}]}} __lowerCamelCase = Elasticsearch() dset.add_elasticsearch_index('''filename''' , es_client=a ) __lowerCamelCase , __lowerCamelCase = dset.get_nearest_examples('''filename''' , '''my_name-train_29''' ) self.assertEqual(examples['''filename'''][0] , '''my_name-train_29''' ) @require_faiss class a__ ( snake_case_ ): def SCREAMING_SNAKE_CASE__ ( self : Union[str, Any] ): """simple docstring""" import faiss __lowerCamelCase = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query __lowerCamelCase = np.zeros(5 , dtype=np.floataa ) __lowerCamelCase = 1 __lowerCamelCase , __lowerCamelCase = index.search(a ) self.assertRaises(a , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries __lowerCamelCase = np.eye(5 , dtype=np.floataa )[::-1] __lowerCamelCase , __lowerCamelCase = index.search_batch(a ) self.assertRaises(a , index.search_batch , queries[0] ) __lowerCamelCase = [scores[0] for scores in total_scores] __lowerCamelCase = [indices[0] for indices in total_indices] self.assertGreater(np.min(a ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , a ) def SCREAMING_SNAKE_CASE__ ( self : List[str] ): """simple docstring""" import faiss __lowerCamelCase = FaissIndex(string_factory='''Flat''' ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) __lowerCamelCase = FaissIndex(string_factory='''LSH''' ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(a ): __lowerCamelCase = FaissIndex(string_factory='''Flat''' , custom_index=faiss.IndexFlat(5 ) ) def SCREAMING_SNAKE_CASE__ ( self : Any ): """simple docstring""" import faiss __lowerCamelCase = faiss.IndexFlat(5 ) __lowerCamelCase = FaissIndex(custom_index=a ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def SCREAMING_SNAKE_CASE__ ( self : List[Any] ): """simple docstring""" import faiss __lowerCamelCase = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=a ) as tmp_file: index.save(tmp_file.name ) __lowerCamelCase = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) __lowerCamelCase = np.zeros(5 , dtype=np.floataa ) __lowerCamelCase = 1 __lowerCamelCase , __lowerCamelCase = index.search(a ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def __lowerCAmelCase ( UpperCamelCase__ ) -> List[Any]: import faiss __lowerCamelCase = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) __lowerCamelCase = '''index.faiss''' __lowerCamelCase = f"""mock://{index_name}""" index.save(lowerCamelCase__ , storage_options=mockfs.storage_options ) __lowerCamelCase = FaissIndex.load(lowerCamelCase__ , storage_options=mockfs.storage_options ) __lowerCamelCase = np.zeros(5 , dtype=np.floataa ) __lowerCamelCase = 1 __lowerCamelCase , __lowerCamelCase = index.search(lowerCamelCase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class a__ ( snake_case_ ): def SCREAMING_SNAKE_CASE__ ( self : str ): """simple docstring""" from elasticsearch import Elasticsearch with patch('''elasticsearch.Elasticsearch.search''' ) as mocked_search, patch( '''elasticsearch.client.IndicesClient.create''' ) as mocked_index_create, patch('''elasticsearch.helpers.streaming_bulk''' ) as mocked_bulk: __lowerCamelCase = Elasticsearch() __lowerCamelCase = {'''acknowledged''': True} __lowerCamelCase = ElasticSearchIndex(es_client=a ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(['''foo''', '''bar''', '''foobar'''] ) # single query __lowerCamelCase = '''foo''' __lowerCamelCase = {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 0}]}} __lowerCamelCase , __lowerCamelCase = index.search(a ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout __lowerCamelCase = '''foo''' __lowerCamelCase = {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 0}]}} __lowerCamelCase , __lowerCamelCase = index.search(a , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries __lowerCamelCase = ['''foo''', '''bar''', '''foobar'''] __lowerCamelCase = {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 1}]}} __lowerCamelCase , __lowerCamelCase = index.search_batch(a ) __lowerCamelCase = [scores[0] for scores in total_scores] __lowerCamelCase = [indices[0] for indices in total_indices] self.assertGreater(np.min(a ) , 0 ) self.assertListEqual([1, 1, 1] , a ) # batched queries with timeout __lowerCamelCase = ['''foo''', '''bar''', '''foobar'''] __lowerCamelCase = {'''hits''': {'''hits''': [{'''_score''': 1, '''_id''': 1}]}} __lowerCamelCase , __lowerCamelCase = index.search_batch(a , request_timeout=30 ) __lowerCamelCase = [scores[0] for scores in total_scores] __lowerCamelCase = [indices[0] for indices in total_indices] self.assertGreater(np.min(a ) , 0 ) self.assertListEqual([1, 1, 1] , a )
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 0 , lowerCamelCase__ = 0 ): lowerCamelCase_ = end or len(lowerCamelCase__ ) for i in range(lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = i lowerCamelCase_ = array[i] while temp_index != start and temp_index_value < array[temp_index - 1]: lowerCamelCase_ = array[temp_index - 1] temp_index -= 1 lowerCamelCase_ = temp_index_value return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): # Max Heap lowerCamelCase_ = index lowerCamelCase_ = 2 * index + 1 # Left Node lowerCamelCase_ = 2 * index + 2 # Right Node if left_index < heap_size and array[largest] < array[left_index]: lowerCamelCase_ = left_index if right_index < heap_size and array[largest] < array[right_index]: lowerCamelCase_ = right_index if largest != index: lowerCamelCase_ , lowerCamelCase_ = array[largest], array[index] heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) for i in range(n // 2 , -1 , -1 ): heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) for i in range(n - 1 , 0 , -1 ): lowerCamelCase_ , lowerCamelCase_ = array[0], array[i] heapify(lowerCamelCase__ , 0 , lowerCamelCase__ ) return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): if (array[first_index] > array[middle_index]) != ( array[first_index] > array[last_index] ): return array[first_index] elif (array[middle_index] > array[first_index]) != ( array[middle_index] > array[last_index] ): return array[middle_index] else: return array[last_index] def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = low lowerCamelCase_ = high while True: while array[i] < pivot: i += 1 j -= 1 while pivot < array[j]: j -= 1 if i >= j: return i lowerCamelCase_ , lowerCamelCase_ = array[j], array[i] i += 1 def lowerCamelCase_ ( lowerCamelCase__ ): if len(lowerCamelCase__ ) == 0: return array lowerCamelCase_ = 2 * math.ceil(math.loga(len(lowerCamelCase__ ) ) ) lowerCamelCase_ = 1_6 return intro_sort(lowerCamelCase__ , 0 , len(lowerCamelCase__ ) , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): while end - start > size_threshold: if max_depth == 0: return heap_sort(lowerCamelCase__ ) max_depth -= 1 lowerCamelCase_ = median_of_a(lowerCamelCase__ , lowerCamelCase__ , start + ((end - start) // 2) + 1 , end - 1 ) lowerCamelCase_ = partition(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) intro_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = p return insertion_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": import doctest doctest.testmod() __A =input('''Enter numbers separated by a comma : ''').strip() __A =[float(item) for item in user_input.split(''',''')] print(sort(unsorted))
19
0
from __future__ import annotations import unittest from transformers import EsmConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers.models.esm.modeling_tf_esm import ( TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, TFEsmModel, ) class __lowerCAmelCase : """simple docstring""" def __init__( self : List[str] , _lowerCAmelCase : str , ) -> Optional[int]: """simple docstring""" snake_case_ = parent snake_case_ = 1_3 snake_case_ = 7 snake_case_ = True snake_case_ = True snake_case_ = True snake_case_ = 9_9 snake_case_ = 3_2 snake_case_ = 2 snake_case_ = 4 snake_case_ = 3_7 snake_case_ = "gelu" snake_case_ = 0.1 snake_case_ = 0.1 snake_case_ = 5_1_2 snake_case_ = 1_6 snake_case_ = 2 snake_case_ = 0.02 snake_case_ = 3 snake_case_ = 4 snake_case_ = None def lowerCAmelCase__ ( self : List[Any] ) -> Any: """simple docstring""" snake_case_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) snake_case_ = None if self.use_input_mask: snake_case_ = random_attention_mask([self.batch_size, self.seq_length] ) snake_case_ = None snake_case_ = None snake_case_ = None if self.use_labels: snake_case_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) snake_case_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) snake_case_ = ids_tensor([self.batch_size] , self.num_choices ) snake_case_ = EsmConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , pad_token_id=1 , 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 , initializer_range=self.initializer_range , ) return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def lowerCAmelCase__ ( self : Optional[int] ) -> List[str]: """simple docstring""" ( ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ) = self.prepare_config_and_inputs() snake_case_ = True snake_case_ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) snake_case_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def lowerCAmelCase__ ( self : Union[str, Any] , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Tuple , _lowerCAmelCase : int , _lowerCAmelCase : Tuple , _lowerCAmelCase : str ) -> Any: """simple docstring""" snake_case_ = TFEsmModel(config=_lowerCAmelCase ) snake_case_ = {"input_ids": input_ids, "attention_mask": input_mask} snake_case_ = model(_lowerCAmelCase ) snake_case_ = [input_ids, input_mask] snake_case_ = model(_lowerCAmelCase ) snake_case_ = model(_lowerCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def lowerCAmelCase__ ( self : Dict , _lowerCAmelCase : List[str] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : Dict , _lowerCAmelCase : List[Any] , _lowerCAmelCase : int , _lowerCAmelCase : List[str] , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Tuple , ) -> Tuple: """simple docstring""" snake_case_ = True snake_case_ = TFEsmModel(config=_lowerCAmelCase ) snake_case_ = { "input_ids": input_ids, "attention_mask": input_mask, "encoder_hidden_states": encoder_hidden_states, "encoder_attention_mask": encoder_attention_mask, } snake_case_ = model(_lowerCAmelCase ) snake_case_ = [input_ids, input_mask] snake_case_ = model(_lowerCAmelCase , encoder_hidden_states=_lowerCAmelCase ) # Also check the case where encoder outputs are not passed snake_case_ = model(_lowerCAmelCase , attention_mask=_lowerCAmelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def lowerCAmelCase__ ( self : List[str] , _lowerCAmelCase : int , _lowerCAmelCase : Tuple , _lowerCAmelCase : str , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : Tuple , _lowerCAmelCase : List[str] ) -> Optional[int]: """simple docstring""" snake_case_ = TFEsmForMaskedLM(config=_lowerCAmelCase ) snake_case_ = model([input_ids, input_mask] ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def lowerCAmelCase__ ( self : Optional[Any] , _lowerCAmelCase : Dict , _lowerCAmelCase : List[Any] , _lowerCAmelCase : Union[str, Any] , _lowerCAmelCase : str , _lowerCAmelCase : Any , _lowerCAmelCase : Union[str, Any] ) -> int: """simple docstring""" snake_case_ = self.num_labels snake_case_ = TFEsmForTokenClassification(config=_lowerCAmelCase ) snake_case_ = {"input_ids": input_ids, "attention_mask": input_mask} snake_case_ = model(_lowerCAmelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def lowerCAmelCase__ ( self : Union[str, Any] ) -> List[str]: """simple docstring""" snake_case_ = self.prepare_config_and_inputs() ( ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ( snake_case_ ) , ) = config_and_inputs snake_case_ = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_tf class __lowerCAmelCase ( snake_case_ , snake_case_ , unittest.TestCase ): """simple docstring""" _SCREAMING_SNAKE_CASE = ( ( TFEsmModel, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, ) if is_tf_available() else () ) _SCREAMING_SNAKE_CASE = ( { 'feature-extraction': TFEsmModel, 'fill-mask': TFEsmForMaskedLM, 'text-classification': TFEsmForSequenceClassification, 'token-classification': TFEsmForTokenClassification, 'zero-shot': TFEsmForSequenceClassification, } if is_tf_available() else {} ) _SCREAMING_SNAKE_CASE = False _SCREAMING_SNAKE_CASE = False def lowerCAmelCase__ ( self : Any ) -> List[str]: """simple docstring""" snake_case_ = TFEsmModelTester(self ) snake_case_ = ConfigTester(self , config_class=_lowerCAmelCase , hidden_size=3_7 ) def lowerCAmelCase__ ( self : int ) -> Any: """simple docstring""" self.config_tester.run_common_tests() def lowerCAmelCase__ ( self : str ) -> str: """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_lowerCAmelCase ) def lowerCAmelCase__ ( self : Optional[int] ) -> Tuple: """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*_lowerCAmelCase ) def lowerCAmelCase__ ( self : int ) -> Dict: """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*_lowerCAmelCase ) def lowerCAmelCase__ ( self : Dict ) -> List[str]: """simple docstring""" snake_case_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*_lowerCAmelCase ) @slow def lowerCAmelCase__ ( self : Tuple ) -> Dict: """simple docstring""" for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: snake_case_ = TFEsmModel.from_pretrained(_lowerCAmelCase ) self.assertIsNotNone(_lowerCAmelCase ) @unittest.skip("Protein models do not support embedding resizing." ) def lowerCAmelCase__ ( self : Tuple ) -> List[Any]: """simple docstring""" pass @unittest.skip("Protein models do not support embedding resizing." ) def lowerCAmelCase__ ( self : int ) -> Any: """simple docstring""" pass def lowerCAmelCase__ ( self : Optional[int] ) -> Optional[Any]: """simple docstring""" snake_case_ , snake_case_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: snake_case_ = model_class(_lowerCAmelCase ) assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer ) if model_class is TFEsmForMaskedLM: # Output embedding test differs from the main test because they're a matrix, not a layer snake_case_ = model.get_bias() assert isinstance(_lowerCAmelCase , _lowerCAmelCase ) for k, v in name.items(): assert isinstance(_lowerCAmelCase , tf.Variable ) else: snake_case_ = model.get_output_embeddings() assert x is None snake_case_ = model.get_bias() assert name is None @require_tf class __lowerCAmelCase ( unittest.TestCase ): """simple docstring""" @slow def lowerCAmelCase__ ( self : Optional[Any] ) -> Optional[Any]: """simple docstring""" snake_case_ = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" ) snake_case_ = tf.constant([[0, 1, 2, 3, 4, 5]] ) snake_case_ = model(_lowerCAmelCase )[0] snake_case_ = [1, 6, 3_3] self.assertEqual(list(output.numpy().shape ) , _lowerCAmelCase ) # compare the actual values for a slice. snake_case_ = tf.constant( [ [ [8.921_518, -1_0.5_8_9_8_1_4, -6.4_671_307], [-6.3_967_156, -1_3.9_1_1_3_7_7, -1.1_211_915], [-7.781_247, -1_3.9_5_1_5_5_7, -3.740_592], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-2 ) ) @slow def lowerCAmelCase__ ( self : Union[str, Any] ) -> Optional[Any]: """simple docstring""" snake_case_ = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" ) snake_case_ = tf.constant([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]] ) snake_case_ = model(_lowerCAmelCase )[0] # compare the actual values for a slice. snake_case_ = tf.constant( [ [ [0.14_443_092, 0.54_125_327, 0.3_247_739], [0.30_340_484, 0.00_526_676, 0.31_077_722], [0.32_278_043, -0.24_987_096, 0.3_414_628], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
159
import math import time from typing import Dict, List, Optional from torch.utils.data import Dataset from transformers import SeqaSeqTrainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , *lowercase , lowercase=None , lowercase=None , **lowercase ) -> List[str]: super().__init__(*lowercase , **lowercase ) lowerCamelCase_ = eval_examples lowerCamelCase_ = post_process_function def SCREAMING_SNAKE_CASE_( self , lowercase = None , lowercase=None , lowercase = None , lowercase = "eval" , **lowercase , ) -> Dict[str, float]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = ( gen_kwargs["max_length"] if gen_kwargs.get("max_length" ) is not None else self.args.generation_max_length ) lowerCamelCase_ = ( gen_kwargs["num_beams"] if gen_kwargs.get("num_beams" ) is not None else self.args.generation_num_beams ) lowerCamelCase_ = gen_kwargs lowerCamelCase_ = self.eval_dataset if eval_dataset is None else eval_dataset lowerCamelCase_ = self.get_eval_dataloader(lowercase ) lowerCamelCase_ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Evaluation" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) else: lowerCamelCase_ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(lowercase ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) lowerCamelCase_ = self.callback_handler.on_evaluate(self.args , self.state , self.control , lowercase ) return metrics def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=None , lowercase = "test" , **lowercase ) -> Union[str, Any]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = self.get_test_dataloader(lowercase ) # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Prediction" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase , "predict" ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=lowercase )
19
0
"""simple docstring""" def _lowerCamelCase ( _UpperCamelCase ): '''simple docstring''' if divisor % 5 == 0 or divisor % 2 == 0: return 0 __lowerCAmelCase = 1 __lowerCAmelCase = 1 while repunit: __lowerCAmelCase = (10 * repunit + 1) % divisor repunit_index += 1 return repunit_index def _lowerCamelCase ( _UpperCamelCase = 100_0000 ): '''simple docstring''' __lowerCAmelCase = limit - 1 if divisor % 2 == 0: divisor += 1 while least_divisible_repunit(lowerCamelCase__ ) <= limit: divisor += 2 return divisor if __name__ == "__main__": print(f'''{solution() = }''')
57
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __A =logging.get_logger(__name__) # pylint: disable=invalid-name __A =''' Examples: ```py >>> from PIL import Image >>> import torch >>> from diffusers import DiffusionPipeline >>> from diffusers.utils import export_to_gif, load_image >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu") >>> repo = "openai/shap-e-img2img" >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16) >>> pipe = pipe.to(device) >>> guidance_scale = 3.0 >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png" >>> image = load_image(image_url).convert("RGB") >>> images = pipe( ... image, ... guidance_scale=guidance_scale, ... num_inference_steps=64, ... frame_size=256, ... ).images >>> gif_path = export_to_gif(images[0], "corgi_3d.gif") ``` ''' @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: super().__init__() self.register_modules( prior=lowercase , image_encoder=lowercase , image_processor=lowercase , scheduler=lowercase , renderer=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if latents is None: lowerCamelCase_ = randn_tensor(lowercase , generator=lowercase , device=lowercase , dtype=lowercase ) else: if latents.shape != shape: raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {shape}' ) lowerCamelCase_ = latents.to(lowercase ) lowerCamelCase_ = latents * scheduler.init_noise_sigma return latents def SCREAMING_SNAKE_CASE_( self , lowercase=0 ) -> int: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device(f'cuda:{gpu_id}' ) lowerCamelCase_ = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: if self.device != torch.device("meta" ) or not hasattr(self.image_encoder , "_hf_hook" ): return self.device for module in self.image_encoder.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: if isinstance(lowercase , lowercase ) and isinstance(image[0] , torch.Tensor ): lowerCamelCase_ = torch.cat(lowercase , axis=0 ) if image[0].ndim == 4 else torch.stack(lowercase , axis=0 ) if not isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = self.image_processor(lowercase , return_tensors="pt" ).pixel_values[0].unsqueeze(0 ) lowerCamelCase_ = image.to(dtype=self.image_encoder.dtype , device=lowercase ) lowerCamelCase_ = self.image_encoder(lowercase )["last_hidden_state"] lowerCamelCase_ = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 lowerCamelCase_ = image_embeds.repeat_interleave(lowercase , dim=0 ) if do_classifier_free_guidance: lowerCamelCase_ = torch.zeros_like(lowercase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes lowerCamelCase_ = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(lowercase ) def __call__( self , lowercase , lowercase = 1 , lowercase = 25 , lowercase = None , lowercase = None , lowercase = 4.0 , lowercase = 64 , lowercase = "pil" , lowercase = True , ) -> Union[str, Any]: if isinstance(lowercase , PIL.Image.Image ): lowerCamelCase_ = 1 elif isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = image.shape[0] elif isinstance(lowercase , lowercase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): lowerCamelCase_ = len(lowercase ) else: raise ValueError( f'`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(lowercase )}' ) lowerCamelCase_ = self._execution_device lowerCamelCase_ = batch_size * num_images_per_prompt lowerCamelCase_ = guidance_scale > 1.0 lowerCamelCase_ = self._encode_image(lowercase , lowercase , lowercase , lowercase ) # prior self.scheduler.set_timesteps(lowercase , device=lowercase ) lowerCamelCase_ = self.scheduler.timesteps lowerCamelCase_ = self.prior.config.num_embeddings lowerCamelCase_ = self.prior.config.embedding_dim lowerCamelCase_ = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , lowercase , lowercase , lowercase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim lowerCamelCase_ = latents.reshape(latents.shape[0] , lowercase , lowercase ) for i, t in enumerate(self.progress_bar(lowercase ) ): # expand the latents if we are doing classifier free guidance lowerCamelCase_ = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents lowerCamelCase_ = self.scheduler.scale_model_input(lowercase , lowercase ) lowerCamelCase_ = self.prior( lowercase , timestep=lowercase , proj_embedding=lowercase , ).predicted_image_embedding # remove the variance lowerCamelCase_ , lowerCamelCase_ = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: lowerCamelCase_ , lowerCamelCase_ = noise_pred.chunk(2 ) lowerCamelCase_ = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) lowerCamelCase_ = self.scheduler.step( lowercase , timestep=lowercase , sample=lowercase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=lowercase ) lowerCamelCase_ = [] for i, latent in enumerate(lowercase ): print() lowerCamelCase_ = self.renderer.decode( latent[None, :] , lowercase , size=lowercase , ray_batch_size=4096 , n_coarse_samples=64 , n_fine_samples=128 , ) images.append(lowercase ) lowerCamelCase_ = torch.stack(lowercase ) if output_type not in ["np", "pil"]: raise ValueError(f'Only the output types `pil` and `np` are supported not output_type={output_type}' ) lowerCamelCase_ = images.cpu().numpy() if output_type == "pil": lowerCamelCase_ = [self.numpy_to_pil(lowercase ) for image in images] # Offload last model to CPU if hasattr(self , "final_offload_hook" ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=lowercase )
19
0
def __lowercase ( a__ ) -> Tuple: assert ( isinstance(lowerCamelCase__ , lowerCamelCase__ ) and number_of_steps > 0 ), f"""number_of_steps needs to be positive integer, your input {number_of_steps}""" if number_of_steps == 1: return 1 __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = 1, 1 for _ in range(number_of_steps - 1 ): __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = current + previous, current return current if __name__ == "__main__": import doctest doctest.testmod()
257
from collections import defaultdict from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst def lowerCamelCase_ ( ): lowerCamelCase_ , lowerCamelCase_ = 9, 1_4 # noqa: F841 lowerCamelCase_ = [ [0, 1, 4], [0, 7, 8], [1, 2, 8], [7, 8, 7], [7, 6, 1], [2, 8, 2], [8, 6, 6], [2, 3, 7], [2, 5, 4], [6, 5, 2], [3, 5, 1_4], [3, 4, 9], [5, 4, 1_0], [1, 7, 1_1], ] lowerCamelCase_ = defaultdict(lowerCamelCase__ ) for nodea, nodea, cost in edges: adjancency[nodea].append([nodea, cost] ) adjancency[nodea].append([nodea, cost] ) lowerCamelCase_ = mst(lowerCamelCase__ ) lowerCamelCase_ = [ [7, 6, 1], [2, 8, 2], [6, 5, 2], [0, 1, 4], [2, 5, 4], [2, 3, 7], [0, 7, 8], [3, 4, 9], ] for answer in expected: lowerCamelCase_ = tuple(answer[:2] ) lowerCamelCase_ = tuple(edge[::-1] ) assert edge in result or reverse in result
19
0
"""simple docstring""" import math def _snake_case ( snake_case__ : int ): A = [True] * n A = False A = False A = True for i in range(3 , int(n**0.5 + 1 ) , 2 ): A = i * 2 while index < n: A = False A = index + i A = [2] for i in range(3 , lowerCamelCase__ , 2 ): if is_prime[i]: primes.append(lowerCamelCase__ ) return primes def _snake_case ( snake_case__ : Tuple = 9999_6666_3333 ): A = math.floor(math.sqrt(lowerCamelCase__ ) ) + 100 A = prime_sieve(lowerCamelCase__ ) A = 0 A = 0 A = primes[prime_index] while (last_prime**2) <= limit: A = primes[prime_index + 1] A = last_prime**2 A = next_prime**2 # Get numbers divisible by lps(current) A = lower_bound + last_prime while upper_bound > current <= limit: matches_sum += current current += last_prime # Reset the upper_bound while (upper_bound - next_prime) > limit: upper_bound -= next_prime # Add the numbers divisible by ups(current) A = upper_bound - next_prime while current > lower_bound: matches_sum += current current -= next_prime # Remove the numbers divisible by both ups and lps A = 0 while upper_bound > current <= limit: if current <= lower_bound: # Increment the current number current += last_prime * next_prime continue if current > limit: break # Remove twice since it was added by both ups and lps matches_sum -= current * 2 # Increment the current number current += last_prime * next_prime # Setup for next pair A = next_prime prime_index += 1 return matches_sum if __name__ == "__main__": print(solution())
74
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, # specifically showcasing the experiment tracking capability, # and builds off the `nlp_example.py` script. # # 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 help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## __A =1_6 __A =3_2 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 1_6 ): lowerCamelCase_ = AutoTokenizer.from_pretrained("bert-base-cased" ) lowerCamelCase_ = load_dataset("glue" , "mrpc" ) def tokenize_function(lowerCamelCase__ ): # max_length=None => use the model max length (it's actually the default) lowerCamelCase_ = tokenizer(examples["sentence1"] , examples["sentence2"] , truncation=lowerCamelCase__ , max_length=lowerCamelCase__ ) 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(): lowerCamelCase_ = datasets.map( lowerCamelCase__ , batched=lowerCamelCase__ , 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 lowerCamelCase_ = tokenized_datasets.rename_column("label" , "labels" ) def collate_fn(lowerCamelCase__ ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCamelCase_ = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCamelCase_ = 1_6 elif accelerator.mixed_precision != "no": lowerCamelCase_ = 8 else: lowerCamelCase_ = None return tokenizer.pad( lowerCamelCase__ , padding="longest" , max_length=lowerCamelCase__ , pad_to_multiple_of=lowerCamelCase__ , return_tensors="pt" , ) # Instantiate dataloaders. lowerCamelCase_ = DataLoader( tokenized_datasets["train"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) lowerCamelCase_ = DataLoader( tokenized_datasets["validation"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) 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 __A =mocked_dataloaders # noqa: F811 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): # For testing only if os.environ.get("TESTING_MOCKED_DATALOADERS" , lowerCamelCase__ ) == "1": lowerCamelCase_ = 2 # Initialize Accelerator # New Code # # We pass in "all" to `log_with` to grab all available trackers in the environment # Note: If using a custom `Tracker` class, should be passed in here such as: # >>> log_with = ["all", MyCustomTrackerClassInstance()] if args.with_tracking: lowerCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , log_with="all" , project_dir=args.project_dir ) else: lowerCamelCase_ = Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCamelCase_ = config["lr"] lowerCamelCase_ = int(config["num_epochs"] ) lowerCamelCase_ = int(config["seed"] ) lowerCamelCase_ = int(config["batch_size"] ) set_seed(lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = get_dataloaders(lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = evaluate.load("glue" , "mrpc" ) # If the batch size is too big we use gradient accumulation lowerCamelCase_ = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: lowerCamelCase_ = batch_size // MAX_GPU_BATCH_SIZE lowerCamelCase_ = MAX_GPU_BATCH_SIZE # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCamelCase_ = AutoModelForSequenceClassification.from_pretrained("bert-base-cased" , return_dict=lowerCamelCase__ ) # 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). lowerCamelCase_ = model.to(accelerator.device ) # Instantiate optimizer lowerCamelCase_ = AdamW(params=model.parameters() , lr=lowerCamelCase__ ) # Instantiate scheduler lowerCamelCase_ = get_linear_schedule_with_warmup( optimizer=lowerCamelCase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowerCamelCase__ ) * num_epochs) // gradient_accumulation_steps , ) # 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. lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = accelerator.prepare( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # New Code # # We need to initialize the trackers we use. Overall configurations can also be stored if args.with_tracking: lowerCamelCase_ = os.path.split(lowerCamelCase__ )[-1].split("." )[0] accelerator.init_trackers(lowerCamelCase__ , lowerCamelCase__ ) # Now we train the model for epoch in range(lowerCamelCase__ ): model.train() # New Code # # For our tracking example, we will log the total loss of each epoch if args.with_tracking: lowerCamelCase_ = 0 for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.loss # New Code # if args.with_tracking: total_loss += loss.detach().float() lowerCamelCase_ = loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True` (the default). batch.to(accelerator.device ) with torch.no_grad(): lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.logits.argmax(dim=-1 ) lowerCamelCase_ , lowerCamelCase_ = accelerator.gather_for_metrics((predictions, batch["labels"]) ) metric.add_batch( predictions=lowerCamelCase__ , references=lowerCamelCase__ , ) lowerCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(F'epoch {epoch}:' , lowerCamelCase__ ) # New Code # # To actually log, we call `Accelerator.log` # The values passed can be of `str`, `int`, `float` or `dict` of `str` to `float`/`int` if args.with_tracking: accelerator.log( { "accuracy": eval_metric["accuracy"], "f1": eval_metric["f1"], "train_loss": total_loss.item() / len(lowerCamelCase__ ), "epoch": epoch, } , step=lowerCamelCase__ , ) # New Code # # When a run is finished, you should call `accelerator.end_training()` # to close all of the open trackers if args.with_tracking: accelerator.end_training() def lowerCamelCase_ ( ): lowerCamelCase_ = argparse.ArgumentParser(description="Simple example of training script." ) parser.add_argument( "--mixed_precision" , type=lowerCamelCase__ , default=lowerCamelCase__ , 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." , ) parser.add_argument("--cpu" , action="store_true" , help="If passed, will train on the CPU." ) parser.add_argument( "--with_tracking" , action="store_true" , help="Whether to load in all available experiment trackers from the environment and use them for logging." , ) parser.add_argument( "--project_dir" , type=lowerCamelCase__ , default="logs" , help="Location on where to store experiment tracking logs` and relevent project information" , ) lowerCamelCase_ = parser.parse_args() lowerCamelCase_ = {"lr": 2e-5, "num_epochs": 3, "seed": 4_2, "batch_size": 1_6} training_function(lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": main()
19
0
"""simple docstring""" import argparse from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration _UpperCamelCase: List[Any] = [ # tf -> hf ('/', '.'), ('layer_', 'layers.'), ('kernel', 'weight'), ('beta', 'bias'), ('gamma', 'weight'), ('pegasus', 'model'), ] _UpperCamelCase: Tuple = [ ('.output.dense', '.fc2'), ('intermediate.LayerNorm', 'final_layer_norm'), ('intermediate.dense', 'fc1'), ] _UpperCamelCase: Tuple = ( INIT_COMMON + [ ('attention.self.LayerNorm', 'self_attn_layer_norm'), ('attention.output.dense', 'self_attn.out_proj'), ('attention.self', 'self_attn'), ('attention.encdec.LayerNorm', 'encoder_attn_layer_norm'), ('attention.encdec_output.dense', 'encoder_attn.out_proj'), ('attention.encdec', 'encoder_attn'), ('key', 'k_proj'), ('value', 'v_proj'), ('query', 'q_proj'), ('decoder.LayerNorm', 'decoder.layernorm_embedding'), ] + END_COMMON ) _UpperCamelCase: List[Any] = ( INIT_COMMON + [ ('embeddings.word_embeddings', 'shared.weight'), ('embeddings.position_embeddings', 'embed_positions.weight'), ('attention.self.LayerNorm', 'self_attn_layer_norm'), ('attention.output.dense', 'self_attn.output'), ('attention.self', 'self_attn.self'), ('encoder.LayerNorm', 'encoder.layernorm_embedding'), ] + END_COMMON ) _UpperCamelCase: Any = [ 'encdec/key/bias', 'encdec/query/bias', 'encdec/value/bias', 'self/key/bias', 'self/query/bias', 'self/value/bias', 'encdec_output/dense/bias', 'attention/output/dense/bias', ] def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase ) -> Union[str, Any]: '''simple docstring''' for tf_name, hf_name in patterns: lowercase : Optional[int] = k.replace(lowerCamelCase__ , lowerCamelCase__ ) return k def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase ) -> Any: '''simple docstring''' lowercase : str = BigBirdPegasusConfig(**lowerCamelCase__ ) lowercase : Tuple = BigBirdPegasusForConditionalGeneration(lowerCamelCase__ ) lowercase : List[str] = torch_model.state_dict() lowercase : Optional[int] = {} # separating decoder weights lowercase : Any = {k: tf_weights[k] for k in tf_weights if k.startswith('pegasus/decoder' )} lowercase : int = {k: tf_weights[k] for k in tf_weights if not k.startswith('pegasus/decoder' )} for k, v in tqdm(decoder_weights.items() , 'tf -> hf conversion' ): lowercase : Dict = [k.endswith(lowerCamelCase__ ) for ending in KEYS_TO_IGNORE] if any(lowerCamelCase__ ): continue lowercase : Tuple = DECODER_PATTERNS lowercase : Dict = rename_state_dict_key(lowerCamelCase__ , lowerCamelCase__ ) if new_k not in state_dict: raise ValueError(f'''could not find new key {new_k} in state dict. (converted from {k})''' ) if any(True if i in k else False for i in ['dense', 'query', 'key', 'value'] ): lowercase : Union[str, Any] = v.T lowercase : Optional[int] = torch.from_numpy(lowerCamelCase__ ) assert v.shape == state_dict[new_k].shape, f'''{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}''' for k, v in tqdm(remaining_weights.items() , 'tf -> hf conversion' ): lowercase : List[str] = [k.endswith(lowerCamelCase__ ) for ending in KEYS_TO_IGNORE] if any(lowerCamelCase__ ): continue lowercase : Dict = REMAINING_PATTERNS lowercase : Optional[int] = rename_state_dict_key(lowerCamelCase__ , lowerCamelCase__ ) if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings": raise ValueError(f'''could not find new key {new_k} in state dict. (converted from {k})''' ) if any(True if i in k else False for i in ['dense', 'query', 'key', 'value'] ): lowercase : Union[str, Any] = v.T lowercase : List[Any] = torch.from_numpy(lowerCamelCase__ ) if k != "pegasus/embeddings/position_embeddings": assert v.shape == state_dict[new_k].shape, f'''{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}''' lowercase : List[Any] = mapping['model.embed_positions.weight'] lowercase : Dict = mapping.pop('model.embed_positions.weight' ) lowercase , lowercase : int = torch_model.load_state_dict(lowerCamelCase__ , strict=lowerCamelCase__ ) lowercase : Tuple = [ k for k in missing if k not in [ 'final_logits_bias', 'model.encoder.embed_tokens.weight', 'model.decoder.embed_tokens.weight', 'lm_head.weight', ] ] assert unexpected_missing == [], f'''no matches found for the following torch keys {unexpected_missing}''' assert extra == [], f'''no matches found for the following tf keys {extra}''' return torch_model def lowercase__ ( _UpperCAmelCase ) -> Optional[int]: '''simple docstring''' lowercase : int = tf.train.list_variables(lowerCamelCase__ ) lowercase : Dict = {} lowercase : Tuple = ['global_step'] for name, shape in tqdm(lowerCamelCase__ , desc='converting tf checkpoint to dict' ): lowercase : Optional[int] = any(pat in name for pat in ignore_name ) if skip_key: continue lowercase : List[Any] = tf.train.load_variable(lowerCamelCase__ , lowerCamelCase__ ) lowercase : Any = array return tf_weights def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> List[Any]: '''simple docstring''' lowercase : Optional[Any] = get_tf_weights_as_numpy(lowerCamelCase__ ) lowercase : Optional[int] = convert_bigbird_pegasus(lowerCamelCase__ , lowerCamelCase__ ) torch_model.save_pretrained(lowerCamelCase__ ) if __name__ == "__main__": _UpperCamelCase: List[Any] = argparse.ArgumentParser() parser.add_argument('--tf_ckpt_path', type=str, help='passed to tf.train.list_variables') parser.add_argument('--save_dir', default=None, type=str, help='Path to the output PyTorch model.') _UpperCamelCase: List[Any] = parser.parse_args() _UpperCamelCase: Any = {} convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
255
import os from shutil import copyfile from typing import List, Optional, Tuple from tokenizers import processors from ...tokenization_utils import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_mbart import MBartTokenizer else: __A =None __A =logging.get_logger(__name__) __A ={'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''} __A ={ '''vocab_file''': { '''facebook/mbart-large-en-ro''': ( '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model''' ), '''facebook/mbart-large-cc25''': ( '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model''' ), }, '''tokenizer_file''': { '''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''', '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''', }, } __A ={ '''facebook/mbart-large-en-ro''': 1_0_2_4, '''facebook/mbart-large-cc25''': 1_0_2_4, } # fmt: off __A =['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN'''] class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = VOCAB_FILES_NAMES lowerCAmelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowerCAmelCase__ = PRETRAINED_VOCAB_FILES_MAP lowerCAmelCase__ = ['input_ids', 'attention_mask'] lowerCAmelCase__ = MBartTokenizer lowerCAmelCase__ = [] lowerCAmelCase__ = [] def __init__( self , lowercase=None , lowercase=None , lowercase="<s>" , lowercase="</s>" , lowercase="</s>" , lowercase="<s>" , lowercase="<unk>" , lowercase="<pad>" , lowercase="<mask>" , lowercase=None , lowercase=None , lowercase=None , **lowercase , ) -> Dict: # Mask token behave like a normal word, i.e. include the space before it lowerCamelCase_ = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else mask_token super().__init__( vocab_file=lowercase , tokenizer_file=lowercase , bos_token=lowercase , eos_token=lowercase , sep_token=lowercase , cls_token=lowercase , unk_token=lowercase , pad_token=lowercase , mask_token=lowercase , src_lang=lowercase , tgt_lang=lowercase , additional_special_tokens=lowercase , **lowercase , ) lowerCamelCase_ = vocab_file lowerCamelCase_ = False if not self.vocab_file else True lowerCamelCase_ = FAIRSEQ_LANGUAGE_CODES.copy() if additional_special_tokens is not None: # Only add those special tokens if they are not already there. _additional_special_tokens.extend( [t for t in additional_special_tokens if t not in _additional_special_tokens] ) self.add_special_tokens({"additional_special_tokens": _additional_special_tokens} ) lowerCamelCase_ = { lang_code: self.convert_tokens_to_ids(lowercase ) for lang_code in FAIRSEQ_LANGUAGE_CODES } lowerCamelCase_ = src_lang if src_lang is not None else "en_XX" lowerCamelCase_ = self.convert_tokens_to_ids(self._src_lang ) lowerCamelCase_ = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def SCREAMING_SNAKE_CASE_( self ) -> str: return self._src_lang @src_lang.setter def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: lowerCamelCase_ = [self.sep_token_id] lowerCamelCase_ = [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 SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , **lowercase ) -> List[Any]: if src_lang is None or tgt_lang is None: raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model" ) lowerCamelCase_ = src_lang lowerCamelCase_ = self(lowercase , add_special_tokens=lowercase , return_tensors=lowercase , **lowercase ) lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = tgt_lang_id return inputs def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = "en_XX" , lowercase = None , lowercase = "ro_RO" , **lowercase , ) -> BatchEncoding: lowerCamelCase_ = src_lang lowerCamelCase_ = tgt_lang return super().prepare_seqaseq_batch(lowercase , lowercase , **lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: return self.set_src_lang_special_tokens(self.src_lang ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> Tuple[str]: if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(lowercase ): logger.error(f'Vocabulary path ({save_directory}) should be a directory.' ) return lowerCamelCase_ = os.path.join( lowercase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowercase ): copyfile(self.vocab_file , lowercase ) return (out_vocab_file,)
19
0
'''simple docstring''' import os from shutil import copyfile from typing import List, Optional, Tuple from tokenizers import processors from ...tokenization_utils import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_mbart import MBartTokenizer else: a_ = None a_ = logging.get_logger(__name__) a_ = {'vocab_file': 'sentencepiece.bpe.model', 'tokenizer_file': 'tokenizer.json'} a_ = { 'vocab_file': { 'facebook/mbart-large-en-ro': ( 'https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model' ), 'facebook/mbart-large-cc25': ( 'https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model' ), }, 'tokenizer_file': { 'facebook/mbart-large-en-ro': 'https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json', 'facebook/mbart-large-cc25': 'https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json', }, } a_ = { 'facebook/mbart-large-en-ro': 1_0_2_4, 'facebook/mbart-large-cc25': 1_0_2_4, } # fmt: off a_ = ['ar_AR', 'cs_CZ', 'de_DE', 'en_XX', 'es_XX', 'et_EE', 'fi_FI', 'fr_XX', 'gu_IN', 'hi_IN', 'it_IT', 'ja_XX', 'kk_KZ', 'ko_KR', 'lt_LT', 'lv_LV', 'my_MM', 'ne_NP', 'nl_XX', 'ro_RO', 'ru_RU', 'si_LK', 'tr_TR', 'vi_VN', 'zh_CN'] class __SCREAMING_SNAKE_CASE ( snake_case_ ): snake_case_ = VOCAB_FILES_NAMES snake_case_ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES snake_case_ = PRETRAINED_VOCAB_FILES_MAP snake_case_ = ["""input_ids""", """attention_mask"""] snake_case_ = MBartTokenizer snake_case_ = [] snake_case_ = [] def __init__( self : int , __lowercase : int=None , __lowercase : Dict=None , __lowercase : Dict="<s>" , __lowercase : List[str]="</s>" , __lowercase : str="</s>" , __lowercase : int="<s>" , __lowercase : Tuple="<unk>" , __lowercase : Dict="<pad>" , __lowercase : Tuple="<mask>" , __lowercase : int=None , __lowercase : int=None , __lowercase : Union[str, Any]=None , **__lowercase : Dict , ) -> Dict: # Mask token behave like a normal word, i.e. include the space before it SCREAMING_SNAKE_CASE__ : List[str] =AddedToken(__lowercase , lstrip=__lowercase , rstrip=__lowercase ) if isinstance(__lowercase , __lowercase ) else mask_token super().__init__( vocab_file=__lowercase , tokenizer_file=__lowercase , bos_token=__lowercase , eos_token=__lowercase , sep_token=__lowercase , cls_token=__lowercase , unk_token=__lowercase , pad_token=__lowercase , mask_token=__lowercase , src_lang=__lowercase , tgt_lang=__lowercase , additional_special_tokens=__lowercase , **__lowercase , ) SCREAMING_SNAKE_CASE__ : Dict =vocab_file SCREAMING_SNAKE_CASE__ : List[str] =False if not self.vocab_file else True SCREAMING_SNAKE_CASE__ : int =FAIRSEQ_LANGUAGE_CODES.copy() if additional_special_tokens is not None: # Only add those special tokens if they are not already there. _additional_special_tokens.extend( [t for t in additional_special_tokens if t not in _additional_special_tokens] ) self.add_special_tokens({'''additional_special_tokens''': _additional_special_tokens} ) SCREAMING_SNAKE_CASE__ : str ={ lang_code: self.convert_tokens_to_ids(__lowercase ) for lang_code in FAIRSEQ_LANGUAGE_CODES } SCREAMING_SNAKE_CASE__ : int =src_lang if src_lang is not None else '''en_XX''' SCREAMING_SNAKE_CASE__ : List[Any] =self.convert_tokens_to_ids(self._src_lang ) SCREAMING_SNAKE_CASE__ : Tuple =tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def __magic_name__ ( self : int ) -> str: return self._src_lang @src_lang.setter def __magic_name__ ( self : List[Any] , __lowercase : str ) -> None: SCREAMING_SNAKE_CASE__ : Tuple =new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def __magic_name__ ( self : Tuple , __lowercase : Tuple , __lowercase : List[str] = None ) -> List[int]: if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def __magic_name__ ( self : List[Any] , __lowercase : Tuple , __lowercase : Tuple = None ) -> List[int]: SCREAMING_SNAKE_CASE__ : Tuple =[self.sep_token_id] SCREAMING_SNAKE_CASE__ : str =[self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0] def __magic_name__ ( self : Union[str, Any] , __lowercase : Any , __lowercase : List[Any] , __lowercase : Optional[int] , __lowercase : Dict , **__lowercase : Optional[Any] ) -> List[Any]: if src_lang is None or tgt_lang is None: raise ValueError('''Translation requires a `src_lang` and a `tgt_lang` for this model''' ) SCREAMING_SNAKE_CASE__ : Tuple =src_lang SCREAMING_SNAKE_CASE__ : Dict =self(__lowercase , add_special_tokens=__lowercase , return_tensors=__lowercase , **__lowercase ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =self.convert_tokens_to_ids(__lowercase ) SCREAMING_SNAKE_CASE__ : Tuple =tgt_lang_id return inputs def __magic_name__ ( self : Any , __lowercase : int , __lowercase : Any = "en_XX" , __lowercase : List[Any] = None , __lowercase : Dict = "ro_RO" , **__lowercase : str , ) -> BatchEncoding: SCREAMING_SNAKE_CASE__ : List[str] =src_lang SCREAMING_SNAKE_CASE__ : str =tgt_lang return super().prepare_seqaseq_batch(__lowercase , __lowercase , **__lowercase ) def __magic_name__ ( self : Optional[int] ) -> Dict: return self.set_src_lang_special_tokens(self.src_lang ) def __magic_name__ ( self : Optional[int] ) -> Optional[Any]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def __magic_name__ ( self : int , __lowercase : Union[str, Any] ) -> None: SCREAMING_SNAKE_CASE__ : Optional[int] =self.convert_tokens_to_ids(__lowercase ) SCREAMING_SNAKE_CASE__ : Tuple =[] SCREAMING_SNAKE_CASE__ : Tuple =[self.eos_token_id, self.cur_lang_code] SCREAMING_SNAKE_CASE__ : List[str] =self.convert_ids_to_tokens(self.prefix_tokens ) SCREAMING_SNAKE_CASE__ : str =self.convert_ids_to_tokens(self.suffix_tokens ) SCREAMING_SNAKE_CASE__ : List[Any] =processors.TemplateProcessing( single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str , pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def __magic_name__ ( self : Any , __lowercase : Dict ) -> None: SCREAMING_SNAKE_CASE__ : str =self.convert_tokens_to_ids(__lowercase ) SCREAMING_SNAKE_CASE__ : Optional[int] =[] SCREAMING_SNAKE_CASE__ : List[str] =[self.eos_token_id, self.cur_lang_code] SCREAMING_SNAKE_CASE__ : Dict =self.convert_ids_to_tokens(self.prefix_tokens ) SCREAMING_SNAKE_CASE__ : Optional[int] =self.convert_ids_to_tokens(self.suffix_tokens ) SCREAMING_SNAKE_CASE__ : List[Any] =processors.TemplateProcessing( single=prefix_tokens_str + ['''$A'''] + suffix_tokens_str , pair=prefix_tokens_str + ['''$A''', '''$B'''] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def __magic_name__ ( self : Any , __lowercase : int , __lowercase : List[str] = None ) -> Tuple[str]: if not self.can_save_slow_tokenizer: raise ValueError( '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow ''' '''tokenizer.''' ) if not os.path.isdir(__lowercase ): logger.error(F"Vocabulary path ({save_directory}) should be a directory." ) return SCREAMING_SNAKE_CASE__ : List[Any] =os.path.join( __lowercase , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(__lowercase ): copyfile(self.vocab_file , __lowercase ) return (out_vocab_file,)
152
import os import tempfile from functools import partial from unittest import TestCase from unittest.mock import patch import numpy as np import pytest from datasets.arrow_dataset import Dataset from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex from .utils import require_elasticsearch, require_faiss __A =pytest.mark.integration @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = Dataset.from_dict({"filename": ["my_name-train" + "_" + str(lowercase ) for x in np.arange(30 ).tolist()]} ) return dset def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: import faiss lowerCamelCase_ = self._create_dummy_dataset() lowerCamelCase_ = dset.map( lambda lowercase , lowercase : {"vecs": i * np.ones(5 , dtype=np.floataa )} , with_indices=lowercase , keep_in_memory=lowercase ) lowerCamelCase_ = dset.add_faiss_index("vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) dset.drop_index("vecs" ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , batch_size=100 , metric_type=faiss.METRIC_INNER_PRODUCT , ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" , metric_type=faiss.METRIC_INNER_PRODUCT , ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: dset.save_faiss_index("vecs" , tmp_file.name ) dset.load_faiss_index("vecs2" , tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("vecs2" , np.ones(5 , dtype=np.floataa ) ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self._create_dummy_dataset() dset.add_faiss_index_from_external_arrays( external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1 , 1 ) , index_name="vecs" ) dset.drop_index("vecs" ) self.assertRaises(lowercase , partial(dset.get_nearest_examples , "vecs2" , np.ones(5 , dtype=np.floataa ) ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: from elasticsearch import Elasticsearch lowerCamelCase_ = self._create_dummy_dataset() with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = {"acknowledged": True} mocked_bulk.return_value([(True, None)] * 30 ) lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 29}]}} lowerCamelCase_ = Elasticsearch() dset.add_elasticsearch_index("filename" , es_client=lowercase ) lowerCamelCase_ , lowerCamelCase_ = dset.get_nearest_examples("filename" , "my_name-train_29" ) self.assertEqual(examples["filename"][0] , "my_name-train_29" ) @require_faiss class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Tuple: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) # add vectors index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsNotNone(index.faiss_index ) self.assertEqual(index.faiss_index.ntotal , 5 ) index.add_vectors(np.zeros((5, 5) , dtype=np.floataa ) ) self.assertEqual(index.faiss_index.ntotal , 10 ) # single query lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertRaises(lowercase , index.search , query.reshape(-1 , 1 ) ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) # batched queries lowerCamelCase_ = np.eye(5 , dtype=np.floataa )[::-1] lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) self.assertRaises(lowercase , index.search_batch , queries[0] ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([4, 3, 2, 1, 0] , lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Any: import faiss lowerCamelCase_ = FaissIndex(string_factory="Flat" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) lowerCamelCase_ = FaissIndex(string_factory="LSH" ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexLSH ) with self.assertRaises(lowercase ): lowerCamelCase_ = FaissIndex(string_factory="Flat" , custom_index=faiss.IndexFlat(5 ) ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[int]: import faiss lowerCamelCase_ = faiss.IndexFlat(5 ) lowerCamelCase_ = FaissIndex(custom_index=lowercase ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) self.assertIsInstance(index.faiss_index , faiss.IndexFlat ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) # Setting delete=False and unlinking manually is not pretty... but it is required on Windows to # ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue. # see https://bugs.python.org/issue14243 and # https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515 with tempfile.NamedTemporaryFile(delete=lowercase ) as tmp_file: index.save(tmp_file.name ) lowerCamelCase_ = FaissIndex.load(tmp_file.name ) os.unlink(tmp_file.name ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertGreater(scores[0] , 0 ) self.assertEqual(indices[0] , 1 ) @require_faiss def lowerCamelCase_ ( lowerCamelCase__ ): import faiss lowerCamelCase_ = FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT ) index.add_vectors(np.eye(5 , dtype=np.floataa ) ) lowerCamelCase_ = "index.faiss" lowerCamelCase_ = F'mock://{index_name}' index.save(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = FaissIndex.load(lowerCamelCase__ , storage_options=mockfs.storage_options ) lowerCamelCase_ = np.zeros(5 , dtype=np.floataa ) lowerCamelCase_ = 1 lowerCamelCase_ , lowerCamelCase_ = index.search(lowerCamelCase__ ) assert scores[0] > 0 assert indices[0] == 1 @require_elasticsearch class _SCREAMING_SNAKE_CASE ( snake_case_ ): def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: from elasticsearch import Elasticsearch with patch("elasticsearch.Elasticsearch.search" ) as mocked_search, patch( "elasticsearch.client.IndicesClient.create" ) as mocked_index_create, patch("elasticsearch.helpers.streaming_bulk" ) as mocked_bulk: lowerCamelCase_ = Elasticsearch() lowerCamelCase_ = {"acknowledged": True} lowerCamelCase_ = ElasticSearchIndex(es_client=lowercase ) mocked_bulk.return_value([(True, None)] * 3 ) index.add_documents(["foo", "bar", "foobar"] ) # single query lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # single query with timeout lowerCamelCase_ = "foo" lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 0}]}} lowerCamelCase_ , lowerCamelCase_ = index.search(lowercase , request_timeout=30 ) self.assertEqual(scores[0] , 1 ) self.assertEqual(indices[0] , 0 ) # batched queries lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase ) # batched queries with timeout lowerCamelCase_ = ["foo", "bar", "foobar"] lowerCamelCase_ = {"hits": {"hits": [{"_score": 1, "_id": 1}]}} lowerCamelCase_ , lowerCamelCase_ = index.search_batch(lowercase , request_timeout=30 ) lowerCamelCase_ = [scores[0] for scores in total_scores] lowerCamelCase_ = [indices[0] for indices in total_indices] self.assertGreater(np.min(lowercase ) , 0 ) self.assertListEqual([1, 1, 1] , lowercase )
19
0
import json import os import unittest from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES, BioGptTokenizer from transformers.testing_utils import slow from ...test_tokenization_common import TokenizerTesterMixin class __A ( snake_case_ , unittest.TestCase ): """simple docstring""" UpperCamelCase__ : Optional[Any] =BioGptTokenizer UpperCamelCase__ : List[str] =False def __lowercase ( self ): """simple docstring""" super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt __UpperCamelCase : Optional[int] =[ 'l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'w</w>', 'r</w>', 't</w>', 'lo', 'low', 'er</w>', 'low</w>', 'lowest</w>', 'newer</w>', 'wider</w>', '<unk>', ] __UpperCamelCase : Dict =dict(zip(lowerCamelCase__ , range(len(lowerCamelCase__ ) ) ) ) __UpperCamelCase : List[str] =['l o 123', 'lo w 1456', 'e r</w> 1789', ''] __UpperCamelCase : Tuple =os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['vocab_file'] ) __UpperCamelCase : List[str] =os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['merges_file'] ) with open(self.vocab_file , 'w' ) as fp: fp.write(json.dumps(lowerCamelCase__ ) ) with open(self.merges_file , 'w' ) as fp: fp.write('\n'.join(lowerCamelCase__ ) ) def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : List[Any] ='lower newer' __UpperCamelCase : str ='lower newer' return input_text, output_text def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Tuple =BioGptTokenizer(self.vocab_file , self.merges_file ) __UpperCamelCase : List[Any] ='lower' __UpperCamelCase : Union[str, Any] =['low', 'er</w>'] __UpperCamelCase : int =tokenizer.tokenize(lowerCamelCase__ ) self.assertListEqual(lowerCamelCase__ , lowerCamelCase__ ) __UpperCamelCase : Dict =tokens + ['<unk>'] __UpperCamelCase : Dict =[14, 15, 20] self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__ ) , lowerCamelCase__ ) @slow def __lowercase ( self ): """simple docstring""" __UpperCamelCase : Tuple =BioGptTokenizer.from_pretrained('microsoft/biogpt' ) __UpperCamelCase : Optional[int] =tokenizer.encode('sequence builders' , add_special_tokens=lowerCamelCase__ ) __UpperCamelCase : int =tokenizer.encode('multi-sequence build' , add_special_tokens=lowerCamelCase__ ) __UpperCamelCase : List[str] =tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ ) __UpperCamelCase : List[Any] =tokenizer.build_inputs_with_special_tokens(lowerCamelCase__ , lowerCamelCase__ ) self.assertTrue(encoded_sentence == [2] + text ) self.assertTrue(encoded_pair == [2] + text + [2] + text_a )
71
import unittest from transformers import is_torch_available 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 from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST, OpenAIGPTConfig, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification, OpenAIGPTLMHeadModel, OpenAIGPTModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , lowercase=13 , lowercase=7 , lowercase=True , lowercase=True , lowercase=True , lowercase=99 , lowercase=32 , lowercase=5 , lowercase=4 , lowercase=37 , lowercase="gelu" , lowercase=0.1 , lowercase=0.1 , lowercase=512 , lowercase=16 , lowercase=2 , lowercase=0.0_2 , lowercase=3 , lowercase=4 , lowercase=None , ) -> List[str]: lowerCamelCase_ = parent lowerCamelCase_ = batch_size lowerCamelCase_ = seq_length lowerCamelCase_ = is_training lowerCamelCase_ = use_token_type_ids lowerCamelCase_ = use_labels lowerCamelCase_ = vocab_size lowerCamelCase_ = hidden_size lowerCamelCase_ = num_hidden_layers lowerCamelCase_ = num_attention_heads lowerCamelCase_ = intermediate_size lowerCamelCase_ = hidden_act lowerCamelCase_ = hidden_dropout_prob lowerCamelCase_ = attention_probs_dropout_prob lowerCamelCase_ = max_position_embeddings lowerCamelCase_ = type_vocab_size lowerCamelCase_ = type_sequence_label_size lowerCamelCase_ = initializer_range lowerCamelCase_ = num_labels lowerCamelCase_ = num_choices lowerCamelCase_ = scope lowerCamelCase_ = self.vocab_size - 1 def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_token_type_ids: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = OpenAIGPTConfig( 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 , pad_token_id=self.pad_token_id , ) lowerCamelCase_ = ids_tensor([self.num_hidden_layers, self.num_attention_heads] , 2 ) return ( config, input_ids, head_mask, token_type_ids, sequence_labels, token_labels, choice_labels, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTModel(config=lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , head_mask=lowercase ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = OpenAIGPTLMHeadModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> Dict: lowerCamelCase_ = OpenAIGPTDoubleHeadsModel(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , *lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = OpenAIGPTForSequenceClassification(lowercase ) model.to(lowercase ) model.eval() lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = model(lowercase , token_type_ids=lowercase , labels=lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = { "input_ids": input_ids, "token_type_ids": token_type_ids, "head_mask": head_mask, } return config, inputs_dict @require_torch class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( (OpenAIGPTModel, OpenAIGPTLMHeadModel, OpenAIGPTDoubleHeadsModel, OpenAIGPTForSequenceClassification) if is_torch_available() else () ) lowerCAmelCase__ = ( (OpenAIGPTLMHeadModel,) if is_torch_available() else () ) # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly lowerCAmelCase__ = ( { 'feature-extraction': OpenAIGPTModel, 'text-classification': OpenAIGPTForSequenceClassification, 'text-generation': OpenAIGPTLMHeadModel, 'zero-shot': OpenAIGPTForSequenceClassification, } if is_torch_available() else {} ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests": # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers. # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a # tiny config could not be created. return True return False def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=False ) -> Any: lowerCamelCase_ = super()._prepare_for_class(lowercase , lowercase , return_labels=lowercase ) if return_labels: if model_class.__name__ == "OpenAIGPTDoubleHeadsModel": lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices, self.model_tester.seq_length) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = inputs_dict["labels"] lowerCamelCase_ = torch.zeros( (self.model_tester.batch_size, self.model_tester.num_choices) , dtype=torch.long , device=lowercase , ) lowerCamelCase_ = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowercase ) return inputs_dict def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = OpenAIGPTModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , n_embd=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_double_lm_head_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Any: for model_name in OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = OpenAIGPTModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @require_torch class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = OpenAIGPTLMHeadModel.from_pretrained("openai-gpt" ) model.to(lowercase ) lowerCamelCase_ = torch.tensor([[481, 4735, 544]] , dtype=torch.long , device=lowercase ) # the president is lowerCamelCase_ = [ 481, 4735, 544, 246, 963, 870, 762, 239, 244, 40477, 244, 249, 719, 881, 487, 544, 240, 244, 603, 481, ] # the president is a very good man. " \n " i\'m sure he is, " said the lowerCamelCase_ = model.generate(lowercase , do_sample=lowercase ) self.assertListEqual(output_ids[0].tolist() , lowercase )
19
0
'''simple docstring''' import json from typing import TYPE_CHECKING, List, Optional, Tuple from tokenizers import pre_tokenizers, processors from ...tokenization_utils_base import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_blenderbot import BlenderbotTokenizer if TYPE_CHECKING: from transformers.pipelines.conversational import Conversation a_ : List[Any] = logging.get_logger(__name__) a_ : Tuple = { "vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_config_file": "tokenizer_config.json", } a_ : Union[str, Any] = { "vocab_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"}, "merges_file": {"facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"}, "tokenizer_config_file": { "facebook/blenderbot-3B": "https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json" }, } a_ : List[Any] = {"facebook/blenderbot-3B": 1_2_8} class a ( snake_case_ ): _lowerCAmelCase = VOCAB_FILES_NAMES _lowerCAmelCase = PRETRAINED_VOCAB_FILES_MAP _lowerCAmelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES _lowerCAmelCase = ["""input_ids""", """attention_mask"""] _lowerCAmelCase = BlenderbotTokenizer def __init__( self , __magic_name__=None , __magic_name__=None , __magic_name__=None , __magic_name__="replace" , __magic_name__="<s>" , __magic_name__="</s>" , __magic_name__="</s>" , __magic_name__="<s>" , __magic_name__="<unk>" , __magic_name__="<pad>" , __magic_name__="<mask>" , __magic_name__=False , __magic_name__=True , **__magic_name__ , ) -> Any: super().__init__( __magic_name__ , __magic_name__ , tokenizer_file=__magic_name__ , errors=__magic_name__ , bos_token=__magic_name__ , eos_token=__magic_name__ , sep_token=__magic_name__ , cls_token=__magic_name__ , unk_token=__magic_name__ , pad_token=__magic_name__ , mask_token=__magic_name__ , add_prefix_space=__magic_name__ , trim_offsets=__magic_name__ , **__magic_name__ , ) _a = json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__() ) if pre_tok_state.get('add_prefix_space' , __magic_name__ ) != add_prefix_space: _a = getattr(__magic_name__ , pre_tok_state.pop('type' ) ) _a = add_prefix_space _a = pre_tok_class(**__magic_name__ ) _a = add_prefix_space _a = 'post_processor' _a = getattr(self.backend_tokenizer , __magic_name__ , __magic_name__ ) if tokenizer_component_instance: _a = 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: _a = tuple(state['sep'] ) if "cls" in state: _a = tuple(state['cls'] ) _a = False if state.get('add_prefix_space' , __magic_name__ ) != add_prefix_space: _a = add_prefix_space _a = True if state.get('trim_offsets' , __magic_name__ ) != trim_offsets: _a = trim_offsets _a = True if changes_to_apply: _a = getattr(__magic_name__ , state.pop('type' ) ) _a = component_class(**__magic_name__ ) setattr(self.backend_tokenizer , __magic_name__ , __magic_name__ ) @property # Copied from transformers.models.roberta.tokenization_roberta_fast.RobertaTokenizerFast.mask_token with Roberta->Blenderbot, RoBERTa->Blenderbot 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 , __magic_name__ ) -> List[str]: _a = AddedToken(__magic_name__ , lstrip=__magic_name__ , rstrip=__magic_name__ ) if isinstance(__magic_name__ , __magic_name__ ) else value _a = value def __UpperCAmelCase ( self , *__magic_name__ , **__magic_name__ ) -> BatchEncoding: _a = kwargs.get('is_split_into_words' , __magic_name__ ) 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(*__magic_name__ , **__magic_name__ ) def __UpperCAmelCase ( self , *__magic_name__ , **__magic_name__ ) -> BatchEncoding: _a = kwargs.get('is_split_into_words' , __magic_name__ ) 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(*__magic_name__ , **__magic_name__ ) def __UpperCAmelCase ( self , __magic_name__ , __magic_name__ = None ) -> Tuple[str]: _a = self._tokenizer.model.save(__magic_name__ , name=__magic_name__ ) return tuple(__magic_name__ ) def __UpperCAmelCase ( self , __magic_name__ , __magic_name__ = None ) -> List[int]: _a = [self.sep_token_id] _a = [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 , __magic_name__ , __magic_name__ = None ) -> int: return token_ids_a + [self.eos_token_id] def __UpperCAmelCase ( self , __magic_name__ ) -> List[int]: _a = [] for is_user, text in conversation.iter_texts(): if is_user: # We need to space prefix as it's being done within blenderbot inputs.append(' ' + text ) else: # Generated responses should contain them already. inputs.append(__magic_name__ ) _a = ' '.join(__magic_name__ ) _a = self.encode(__magic_name__ ) if len(__magic_name__ ) > self.model_max_length: _a = input_ids[-self.model_max_length :] logger.warning(f'Trimmed input from conversation as it was longer than {self.model_max_length} tokens.' ) return input_ids
168
__A ={str(digit): digit**5 for digit in range(1_0)} def lowerCamelCase_ ( lowerCamelCase__ ): return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCamelCase__ ) ) def lowerCamelCase_ ( ): return sum( number for number in range(1_0_0_0 , 1_0_0_0_0_0_0 ) if number == digits_fifth_powers_sum(lowerCamelCase__ ) ) if __name__ == "__main__": print(solution())
19
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tensorflow_text_available, is_torch_available lowercase_ = { 'configuration_ernie': ['ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ErnieConfig', 'ErnieOnnxConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowercase_ = [ 'ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST', 'ErnieForCausalLM', 'ErnieForMaskedLM', 'ErnieForMultipleChoice', 'ErnieForNextSentencePrediction', 'ErnieForPreTraining', 'ErnieForQuestionAnswering', 'ErnieForSequenceClassification', 'ErnieForTokenClassification', 'ErnieModel', 'ErniePreTrainedModel', ] if TYPE_CHECKING: from .configuration_ernie import ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieConfig, ErnieOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_ernie import ( ERNIE_PRETRAINED_MODEL_ARCHIVE_LIST, ErnieForCausalLM, ErnieForMaskedLM, ErnieForMultipleChoice, ErnieForNextSentencePrediction, ErnieForPreTraining, ErnieForQuestionAnswering, ErnieForSequenceClassification, ErnieForTokenClassification, ErnieModel, ErniePreTrainedModel, ) else: import sys lowercase_ = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
205
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 YolosConfig, YolosForObjectDetection, YolosImageProcessor from transformers.utils import logging logging.set_verbosity_info() __A =logging.get_logger(__name__) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = YolosConfig() # size of the architecture if "yolos_ti" in yolos_name: lowerCamelCase_ = 1_9_2 lowerCamelCase_ = 7_6_8 lowerCamelCase_ = 1_2 lowerCamelCase_ = 3 lowerCamelCase_ = [8_0_0, 1_3_3_3] lowerCamelCase_ = False elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = 3_3_0 lowerCamelCase_ = 1_4 lowerCamelCase_ = 6 lowerCamelCase_ = 1_3_2_0 elif "yolos_s" in yolos_name: lowerCamelCase_ = 3_8_4 lowerCamelCase_ = 1_5_3_6 lowerCamelCase_ = 1_2 lowerCamelCase_ = 6 elif "yolos_b" in yolos_name: lowerCamelCase_ = [8_0_0, 1_3_4_4] lowerCamelCase_ = 9_1 lowerCamelCase_ = "huggingface/label-files" lowerCamelCase_ = "coco-detection-id2label.json" lowerCamelCase_ = json.load(open(hf_hub_download(lowerCamelCase__ , lowerCamelCase__ , repo_type="dataset" ) , "r" ) ) lowerCamelCase_ = {int(lowerCamelCase__ ): v for k, v in idalabel.items()} lowerCamelCase_ = idalabel lowerCamelCase_ = {v: k for k, v in idalabel.items()} return config def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): for i in range(config.num_hidden_layers ): # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.weight' ) lowerCamelCase_ = state_dict.pop(F'blocks.{i}.attn.qkv.bias' ) # next, add query, keys and values (in that order) to the state dict lowerCamelCase_ = in_proj_weight[: config.hidden_size, :] lowerCamelCase_ = in_proj_bias[: config.hidden_size] lowerCamelCase_ = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] lowerCamelCase_ = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] lowerCamelCase_ = in_proj_weight[-config.hidden_size :, :] lowerCamelCase_ = in_proj_bias[-config.hidden_size :] def lowerCamelCase_ ( lowerCamelCase__ ): if "backbone" in name: lowerCamelCase_ = name.replace("backbone" , "vit" ) if "cls_token" in name: lowerCamelCase_ = name.replace("cls_token" , "embeddings.cls_token" ) if "det_token" in name: lowerCamelCase_ = name.replace("det_token" , "embeddings.detection_tokens" ) if "mid_pos_embed" in name: lowerCamelCase_ = name.replace("mid_pos_embed" , "encoder.mid_position_embeddings" ) if "pos_embed" in name: lowerCamelCase_ = name.replace("pos_embed" , "embeddings.position_embeddings" ) if "patch_embed.proj" in name: lowerCamelCase_ = name.replace("patch_embed.proj" , "embeddings.patch_embeddings.projection" ) if "blocks" in name: lowerCamelCase_ = name.replace("blocks" , "encoder.layer" ) if "attn.proj" in name: lowerCamelCase_ = name.replace("attn.proj" , "attention.output.dense" ) if "attn" in name: lowerCamelCase_ = name.replace("attn" , "attention.self" ) if "norm1" in name: lowerCamelCase_ = name.replace("norm1" , "layernorm_before" ) if "norm2" in name: lowerCamelCase_ = name.replace("norm2" , "layernorm_after" ) if "mlp.fc1" in name: lowerCamelCase_ = name.replace("mlp.fc1" , "intermediate.dense" ) if "mlp.fc2" in name: lowerCamelCase_ = name.replace("mlp.fc2" , "output.dense" ) if "class_embed" in name: lowerCamelCase_ = name.replace("class_embed" , "class_labels_classifier" ) if "bbox_embed" in name: lowerCamelCase_ = name.replace("bbox_embed" , "bbox_predictor" ) if "vit.norm" in name: lowerCamelCase_ = name.replace("vit.norm" , "vit.layernorm" ) return name def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): for key in orig_state_dict.copy().keys(): lowerCamelCase_ = orig_state_dict.pop(lowerCamelCase__ ) if "qkv" in key: lowerCamelCase_ = key.split("." ) lowerCamelCase_ = int(key_split[2] ) lowerCamelCase_ = model.vit.encoder.layer[layer_num].attention.attention.all_head_size if "weight" in key: lowerCamelCase_ = val[:dim, :] lowerCamelCase_ = val[ dim : dim * 2, : ] lowerCamelCase_ = val[-dim:, :] else: lowerCamelCase_ = val[:dim] lowerCamelCase_ = val[dim : dim * 2] lowerCamelCase_ = val[-dim:] else: lowerCamelCase_ = val return orig_state_dict def lowerCamelCase_ ( ): lowerCamelCase_ = "http://images.cocodataset.org/val2017/000000039769.jpg" lowerCamelCase_ = Image.open(requests.get(lowerCamelCase__ , stream=lowerCamelCase__ ).raw ) return im @torch.no_grad() def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ = False ): lowerCamelCase_ = get_yolos_config(lowerCamelCase__ ) # load original state_dict lowerCamelCase_ = torch.load(lowerCamelCase__ , map_location="cpu" )["model"] # load 🤗 model lowerCamelCase_ = YolosForObjectDetection(lowerCamelCase__ ) model.eval() lowerCamelCase_ = convert_state_dict(lowerCamelCase__ , lowerCamelCase__ ) model.load_state_dict(lowerCamelCase__ ) # Check outputs on an image, prepared by YolosImageProcessor lowerCamelCase_ = 8_0_0 if yolos_name != "yolos_ti" else 5_1_2 lowerCamelCase_ = YolosImageProcessor(format="coco_detection" , size=lowerCamelCase__ ) lowerCamelCase_ = image_processor(images=prepare_img() , return_tensors="pt" ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = outputs.logits, outputs.pred_boxes lowerCamelCase_ , lowerCamelCase_ = None, None if yolos_name == "yolos_ti": lowerCamelCase_ = torch.tensor( [[-39.50_22, -11.98_20, -17.68_88], [-29.95_74, -9.97_69, -17.76_91], [-42.32_81, -20.72_00, -30.62_94]] ) lowerCamelCase_ = torch.tensor( [[0.40_21, 0.08_36, 0.79_79], [0.01_84, 0.26_09, 0.03_64], [0.17_81, 0.20_04, 0.20_95]] ) elif yolos_name == "yolos_s_200_pre": lowerCamelCase_ = torch.tensor( [[-24.02_48, -10.30_24, -14.82_90], [-42.03_92, -16.82_00, -27.43_34], [-27.27_43, -11.81_54, -18.71_48]] ) lowerCamelCase_ = torch.tensor( [[0.25_59, 0.54_55, 0.47_06], [0.29_89, 0.72_79, 0.18_75], [0.77_32, 0.40_17, 0.44_62]] ) elif yolos_name == "yolos_s_300_pre": lowerCamelCase_ = torch.tensor( [[-36.22_20, -14.43_85, -23.54_57], [-35.69_70, -14.75_83, -21.39_35], [-31.59_39, -13.60_42, -16.80_49]] ) lowerCamelCase_ = torch.tensor( [[0.76_14, 0.23_16, 0.47_28], [0.71_68, 0.44_95, 0.38_55], [0.49_96, 0.14_66, 0.99_96]] ) elif yolos_name == "yolos_s_dWr": lowerCamelCase_ = torch.tensor( [[-42.86_68, -24.10_49, -41.16_90], [-34.74_56, -14.12_74, -24.91_94], [-33.78_98, -12.19_46, -25.64_95]] ) lowerCamelCase_ = torch.tensor( [[0.55_87, 0.27_73, 0.06_05], [0.50_04, 0.30_14, 0.99_94], [0.49_99, 0.15_48, 0.99_94]] ) elif yolos_name == "yolos_base": lowerCamelCase_ = torch.tensor( [[-40.60_64, -24.30_84, -32.64_47], [-55.19_90, -30.77_19, -35.58_77], [-51.43_11, -33.35_07, -35.64_62]] ) lowerCamelCase_ = torch.tensor( [[0.55_55, 0.27_94, 0.06_55], [0.90_49, 0.26_64, 0.18_94], [0.91_83, 0.19_84, 0.16_35]] ) else: raise ValueError(F'Unknown yolos_name: {yolos_name}' ) assert torch.allclose(logits[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) assert torch.allclose(pred_boxes[0, :3, :3] , lowerCamelCase__ , atol=1e-4 ) Path(lowerCamelCase__ ).mkdir(exist_ok=lowerCamelCase__ ) print(F'Saving model {yolos_name} to {pytorch_dump_folder_path}' ) model.save_pretrained(lowerCamelCase__ ) print(F'Saving image processor to {pytorch_dump_folder_path}' ) image_processor.save_pretrained(lowerCamelCase__ ) if push_to_hub: lowerCamelCase_ = { "yolos_ti": "yolos-tiny", "yolos_s_200_pre": "yolos-small", "yolos_s_300_pre": "yolos-small-300", "yolos_s_dWr": "yolos-small-dwr", "yolos_base": "yolos-base", } print("Pushing to the hub..." ) lowerCamelCase_ = model_mapping[yolos_name] image_processor.push_to_hub(lowerCamelCase__ , organization="hustvl" ) model.push_to_hub(lowerCamelCase__ , organization="hustvl" ) if __name__ == "__main__": __A =argparse.ArgumentParser() # Required parameters parser.add_argument( '''--yolos_name''', default='''yolos_s_200_pre''', type=str, help=( '''Name of the YOLOS model you\'d like to convert. Should be one of \'yolos_ti\', \'yolos_s_200_pre\',''' ''' \'yolos_s_300_pre\', \'yolos_s_dWr\', \'yolos_base\'.''' ), ) parser.add_argument( '''--checkpoint_path''', default=None, type=str, help='''Path to the original state dict (.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.''' ) __A =parser.parse_args() convert_yolos_checkpoint(args.yolos_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub)
19
0
import collections import inspect import unittest from typing import Dict, List, Tuple from transformers import MaskFormerSwinConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device from transformers.utils import is_torch_available from ...test_backbone_common import BackboneTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import MaskFormerSwinBackbone from transformers.models.maskformer import MaskFormerSwinModel class lowerCAmelCase__ : '''simple docstring''' def __init__( self , __lowerCamelCase , __lowerCamelCase=1_3 , __lowerCamelCase=3_2 , __lowerCamelCase=2 , __lowerCamelCase=3 , __lowerCamelCase=1_6 , __lowerCamelCase=[1, 2, 1] , __lowerCamelCase=[2, 2, 4] , __lowerCamelCase=2 , __lowerCamelCase=2.0 , __lowerCamelCase=True , __lowerCamelCase=0.0 , __lowerCamelCase=0.0 , __lowerCamelCase=0.1 , __lowerCamelCase="gelu" , __lowerCamelCase=False , __lowerCamelCase=True , __lowerCamelCase=0.0_2 , __lowerCamelCase=1e-5 , __lowerCamelCase=True , __lowerCamelCase=None , __lowerCamelCase=True , __lowerCamelCase=1_0 , __lowerCamelCase=8 , __lowerCamelCase=["stage1", "stage2", "stage3"] , __lowerCamelCase=[1, 2, 3] , ) -> List[str]: _A : List[str] = parent _A : Any = batch_size _A : Optional[Any] = image_size _A : Tuple = patch_size _A : Dict = num_channels _A : str = embed_dim _A : Tuple = depths _A : Dict = num_heads _A : List[Any] = window_size _A : Tuple = mlp_ratio _A : Dict = qkv_bias _A : Dict = hidden_dropout_prob _A : Optional[Any] = attention_probs_dropout_prob _A : Union[str, Any] = drop_path_rate _A : Optional[Any] = hidden_act _A : Optional[int] = use_absolute_embeddings _A : int = patch_norm _A : str = layer_norm_eps _A : int = initializer_range _A : Dict = is_training _A : List[str] = scope _A : List[str] = use_labels _A : Any = type_sequence_label_size _A : int = encoder_stride _A : List[str] = out_features _A : List[Any] = out_indices def _lowerCamelCase ( self) -> int: _A : Dict = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]) _A : Union[str, Any] = None if self.use_labels: _A : str = ids_tensor([self.batch_size] , self.type_sequence_label_size) _A : List[Any] = self.get_config() return config, pixel_values, labels def _lowerCamelCase ( self) -> Union[str, Any]: return MaskFormerSwinConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , embed_dim=self.embed_dim , depths=self.depths , num_heads=self.num_heads , window_size=self.window_size , mlp_ratio=self.mlp_ratio , qkv_bias=self.qkv_bias , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , drop_path_rate=self.drop_path_rate , hidden_act=self.hidden_act , use_absolute_embeddings=self.use_absolute_embeddings , path_norm=self.patch_norm , layer_norm_eps=self.layer_norm_eps , initializer_range=self.initializer_range , encoder_stride=self.encoder_stride , out_features=self.out_features , out_indices=self.out_indices , ) def _lowerCamelCase ( self , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase) -> List[Any]: _A : List[str] = MaskFormerSwinModel(config=__lowerCamelCase) model.to(__lowerCamelCase) model.eval() _A : Optional[Any] = model(__lowerCamelCase) _A : List[Any] = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1)) _A : int = int(config.embed_dim * 2 ** (len(config.depths) - 1)) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, expected_seq_len, expected_dim)) def _lowerCamelCase ( self , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase) -> Union[str, Any]: _A : Tuple = MaskFormerSwinBackbone(config=__lowerCamelCase) model.to(__lowerCamelCase) model.eval() _A : Any = model(__lowerCamelCase) # verify feature maps self.parent.assertEqual(len(result.feature_maps) , len(config.out_features)) self.parent.assertListEqual(list(result.feature_maps[0].shape) , [1_3, 1_6, 1_6, 1_6]) # verify channels self.parent.assertEqual(len(model.channels) , len(config.out_features)) self.parent.assertListEqual(model.channels , [1_6, 3_2, 6_4]) # verify ValueError with self.parent.assertRaises(__lowerCamelCase): _A : int = ["stem"] _A : List[Any] = MaskFormerSwinBackbone(config=__lowerCamelCase) def _lowerCamelCase ( self) -> List[Any]: _A : Optional[Any] = self.prepare_config_and_inputs() _A , _A , _A : str = config_and_inputs _A : List[str] = {"pixel_values": pixel_values} return config, inputs_dict @require_torch class lowerCAmelCase__ ( snake_case_ , snake_case_ , unittest.TestCase): '''simple docstring''' __SCREAMING_SNAKE_CASE = ( ( MaskFormerSwinModel, MaskFormerSwinBackbone, ) if is_torch_available() else () ) __SCREAMING_SNAKE_CASE = {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {} __SCREAMING_SNAKE_CASE = False __SCREAMING_SNAKE_CASE = False __SCREAMING_SNAKE_CASE = False __SCREAMING_SNAKE_CASE = False __SCREAMING_SNAKE_CASE = False def _lowerCamelCase ( self) -> Tuple: _A : str = MaskFormerSwinModelTester(self) _A : List[str] = ConfigTester(self , config_class=__lowerCamelCase , embed_dim=3_7) @require_torch_multi_gpu @unittest.skip( reason=( "`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with" " `nn.DataParallel`" )) def _lowerCamelCase ( self) -> List[Any]: pass def _lowerCamelCase ( self) -> List[str]: self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def _lowerCamelCase ( self) -> Tuple: return def _lowerCamelCase ( self) -> str: _A : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__lowerCamelCase) def _lowerCamelCase ( self) -> int: _A : Any = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_backbone(*__lowerCamelCase) @unittest.skip("Swin does not use inputs_embeds") def _lowerCamelCase ( self) -> List[str]: pass @unittest.skip("Swin does not support feedforward chunking") def _lowerCamelCase ( self) -> Union[str, Any]: pass def _lowerCamelCase ( self) -> Optional[int]: _A , _A : int = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _A : Tuple = model_class(__lowerCamelCase) self.assertIsInstance(model.get_input_embeddings() , (nn.Module)) _A : Optional[int] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__lowerCamelCase , nn.Linear)) def _lowerCamelCase ( self) -> Union[str, Any]: _A , _A : str = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _A : List[Any] = model_class(__lowerCamelCase) _A : List[Any] = inspect.signature(model.forward) # signature.parameters is an OrderedDict => so arg_names order is deterministic _A : Any = [*signature.parameters.keys()] _A : List[str] = ["pixel_values"] self.assertListEqual(arg_names[:1] , __lowerCamelCase) @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions") def _lowerCamelCase ( self) -> int: pass @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone") def _lowerCamelCase ( self) -> List[Any]: pass def _lowerCamelCase ( self , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase) -> List[Any]: _A : Any = model_class(__lowerCamelCase) model.to(__lowerCamelCase) model.eval() with torch.no_grad(): _A : str = model(**self._prepare_for_class(__lowerCamelCase , __lowerCamelCase)) _A : Any = outputs.hidden_states _A : Any = getattr( self.model_tester , "expected_num_hidden_layers" , len(self.model_tester.depths) + 1) self.assertEqual(len(__lowerCamelCase) , __lowerCamelCase) # Swin has a different seq_length _A : List[Any] = ( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable) else (config.patch_size, config.patch_size) ) _A : Union[str, Any] = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0]) self.assertListEqual( list(hidden_states[0].shape[-2:]) , [num_patches, self.model_tester.embed_dim] , ) def _lowerCamelCase ( self) -> Dict: _A , _A : Optional[int] = self.model_tester.prepare_config_and_inputs_for_common() _A : Dict = ( self.model_tester.image_size if isinstance(self.model_tester.image_size , collections.abc.Iterable) else (self.model_tester.image_size, self.model_tester.image_size) ) for model_class in self.all_model_classes: _A : Any = True self.check_hidden_states_output(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _A : int = True self.check_hidden_states_output(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase) def _lowerCamelCase ( self) -> str: _A , _A : Any = self.model_tester.prepare_config_and_inputs_for_common() _A : int = 3 _A : Dict = ( self.model_tester.image_size if isinstance(self.model_tester.image_size , collections.abc.Iterable) else (self.model_tester.image_size, self.model_tester.image_size) ) _A : Dict = ( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable) else (config.patch_size, config.patch_size) ) _A : Optional[Any] = image_size[0] + patch_size[0] - (image_size[0] % patch_size[0]) _A : int = image_size[1] + patch_size[1] - (image_size[1] % patch_size[1]) for model_class in self.all_model_classes: _A : Tuple = True self.check_hidden_states_output(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , (padded_height, padded_width)) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _A : Optional[int] = True self.check_hidden_states_output(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , (padded_height, padded_width)) @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints") def _lowerCamelCase ( self) -> Dict: pass @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin") def _lowerCamelCase ( self) -> Dict: pass @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin") def _lowerCamelCase ( self) -> List[str]: pass def _lowerCamelCase ( self) -> List[Any]: _A , _A : Tuple = self.model_tester.prepare_config_and_inputs_for_common() def set_nan_tensor_to_zero(__lowerCamelCase): _A : Optional[int] = 0 return t def check_equivalence(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , __lowerCamelCase={}): with torch.no_grad(): _A : Any = model(**__lowerCamelCase , return_dict=__lowerCamelCase , **__lowerCamelCase) _A : Optional[Any] = model(**__lowerCamelCase , return_dict=__lowerCamelCase , **__lowerCamelCase).to_tuple() def recursive_check(__lowerCamelCase , __lowerCamelCase): if isinstance(__lowerCamelCase , (List, Tuple)): for tuple_iterable_value, dict_iterable_value in zip(__lowerCamelCase , __lowerCamelCase): recursive_check(__lowerCamelCase , __lowerCamelCase) elif isinstance(__lowerCamelCase , __lowerCamelCase): for tuple_iterable_value, dict_iterable_value in zip( tuple_object.values() , dict_object.values()): recursive_check(__lowerCamelCase , __lowerCamelCase) elif tuple_object is None: return else: self.assertTrue( torch.allclose( set_nan_tensor_to_zero(__lowerCamelCase) , set_nan_tensor_to_zero(__lowerCamelCase) , atol=1e-5) , msg=( "Tuple and dict output are not equal. Difference:" F" {torch.max(torch.abs(tuple_object - dict_object))}. Tuple has `nan`:" F" {torch.isnan(__lowerCamelCase).any()} and `inf`: {torch.isinf(__lowerCamelCase)}. Dict has" F" `nan`: {torch.isnan(__lowerCamelCase).any()} and `inf`: {torch.isinf(__lowerCamelCase)}." ) , ) recursive_check(__lowerCamelCase , __lowerCamelCase) for model_class in self.all_model_classes: _A : Optional[int] = model_class(__lowerCamelCase) model.to(__lowerCamelCase) model.eval() _A : str = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase) _A : str = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase) check_equivalence(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase) _A : Tuple = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase , return_labels=__lowerCamelCase) _A : List[Any] = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase , return_labels=__lowerCamelCase) check_equivalence(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase) _A : Union[str, Any] = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase) _A : Tuple = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase) check_equivalence(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , {"output_hidden_states": True}) _A : List[Any] = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase , return_labels=__lowerCamelCase) _A : int = self._prepare_for_class(__lowerCamelCase , __lowerCamelCase , return_labels=__lowerCamelCase) check_equivalence(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase , {"output_hidden_states": True}) @require_torch class lowerCAmelCase__ ( unittest.TestCase , snake_case_): '''simple docstring''' __SCREAMING_SNAKE_CASE = (MaskFormerSwinBackbone,) if is_torch_available() else () __SCREAMING_SNAKE_CASE = MaskFormerSwinConfig def _lowerCamelCase ( self) -> Any: _A : List[Any] = MaskFormerSwinModelTester(self) def _lowerCamelCase ( self) -> List[str]: _A , _A : List[str] = self.model_tester.prepare_config_and_inputs_for_common() _A : Tuple = inputs_dict["pixel_values"].shape[0] for backbone_class in self.all_model_classes: _A : Tuple = backbone_class(__lowerCamelCase) backbone.to(__lowerCamelCase) backbone.eval() _A : Union[str, Any] = backbone(**__lowerCamelCase) # Test default outputs and verify feature maps self.assertIsInstance(outputs.feature_maps , __lowerCamelCase) self.assertTrue(len(outputs.feature_maps) == len(backbone.channels)) for feature_map, n_channels in zip(outputs.feature_maps , backbone.channels): self.assertTrue(feature_map.shape[:2] , (batch_size, n_channels)) self.assertIsNone(outputs.hidden_states) self.assertIsNone(outputs.attentions) # Test output_hidden_states=True _A : List[str] = backbone(**__lowerCamelCase , output_hidden_states=__lowerCamelCase) self.assertIsNotNone(outputs.hidden_states) self.assertTrue(len(outputs.hidden_states) , len(backbone.stage_names)) # We skip the stem layer for hidden_states, n_channels in zip(outputs.hidden_states[1:] , backbone.channels): for hidden_state in hidden_states: # Hidden states are in the format (batch_size, (height * width), n_channels) _A , _A , _A : int = hidden_state.shape self.assertTrue((h_batch_size, h_n_channels) , (batch_size, n_channels)) # Test output_attentions=True if self.has_attentions: _A : Tuple = backbone(**__lowerCamelCase , output_attentions=__lowerCamelCase) self.assertIsNotNone(outputs.attentions)
11
def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [0 for i in range(r + 1 )] # nc0 = 1 lowerCamelCase_ = 1 for i in range(1 , n + 1 ): # to compute current row from previous row. lowerCamelCase_ = min(lowerCamelCase__ , lowerCamelCase__ ) while j > 0: c[j] += c[j - 1] j -= 1 return c[r] print(binomial_coefficient(n=1_0, r=5))
19
0
'''simple docstring''' import json import os from typing import Optional, Tuple from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging __UpperCAmelCase =logging.get_logger(__name__) __UpperCAmelCase ={"vocab_file": "vocab.json"} __UpperCAmelCase ={ "vocab_file": { "mgp-str": "https://huggingface.co/alibaba-damo/mgp-str-base/blob/main/vocab.json", } } __UpperCAmelCase ={"mgp-str": 2_7} class a__ ( snake_case_ ): lowerCamelCase : Union[str, Any] =VOCAB_FILES_NAMES lowerCamelCase : Union[str, Any] =PRETRAINED_VOCAB_FILES_MAP lowerCamelCase : Any =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self : Optional[int] , a : Union[str, Any] , a : List[Any]="[GO]" , a : Any="[GO]" , a : str="[s]" , a : List[Any]="[GO]" , **a : Any ): """simple docstring""" super().__init__( unk_token=a , bos_token=a , eos_token=a , pad_token=a , **a , ) with open(a , encoding='''utf-8''' ) as vocab_handle: __lowerCamelCase = json.load(a ) __lowerCamelCase = {v: k for k, v in self.vocab.items()} @property def SCREAMING_SNAKE_CASE__ ( self : Tuple ): """simple docstring""" return len(self.vocab ) def SCREAMING_SNAKE_CASE__ ( self : str ): """simple docstring""" return dict(self.vocab , **self.added_tokens_encoder ) def SCREAMING_SNAKE_CASE__ ( self : int , a : List[Any] ): """simple docstring""" __lowerCamelCase = [] for s in text: char_tokens.extend(a ) return char_tokens def SCREAMING_SNAKE_CASE__ ( self : Dict , a : Optional[int] ): """simple docstring""" return self.vocab.get(a , self.vocab.get(self.unk_token ) ) def SCREAMING_SNAKE_CASE__ ( self : Any , a : Any ): """simple docstring""" return self.decoder.get(a ) def SCREAMING_SNAKE_CASE__ ( self : List[str] , a : int , a : List[str] = None ): """simple docstring""" if not os.path.isdir(a ): logger.error('''Vocabulary path ({}) should be a directory'''.format(a ) ) return __lowerCamelCase = os.path.join( a , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) with open(a , '''w''' , encoding='''utf-8''' ) as f: f.write(json.dumps(self.vocab , indent=2 , sort_keys=a , ensure_ascii=a ) + '''\n''' ) return (vocab_file,)
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): if 0 not in (x, y): # We use the relation x^y = y*log10(x), where 10 is the base. return y * math.logaa(lowerCamelCase__ ) else: if x == 0: # 0 raised to any number is 0 return 0 elif y == 0: return 1 # any number raised to 0 is 1 raise AssertionError("This should never happen" ) if __name__ == "__main__": # Main function # Read two numbers from input and typecast them to int using map function. # Here x is the base and y is the power. __A ='''Enter the base and the power separated by a comma: ''' __A, __A =map(int, input(prompt).split(''',''')) __A, __A =map(int, input(prompt).split(''',''')) # We find the log of each number, using the function res(), which takes two # arguments. __A =res(xa, ya) __A =res(xa, ya) # We check for the largest number if resa > resa: print('''Largest number is''', xa, '''^''', ya) elif resa > resa: print('''Largest number is''', xa, '''^''', ya) else: print('''Both are equal''')
19
0
import numpy as np from sklearn.datasets import fetch_california_housing from sklearn.metrics import mean_absolute_error, mean_squared_error from sklearn.model_selection import train_test_split from xgboost import XGBRegressor def _lowerCAmelCase ( lowerCAmelCase_ :Union[str, Any] )->int: '''simple docstring''' return (data["data"], data["target"]) def _lowerCAmelCase ( lowerCAmelCase_ :List[Any] , lowerCAmelCase_ :Dict , lowerCAmelCase_ :Dict )->Optional[Any]: '''simple docstring''' snake_case_ = XGBRegressor(verbosity=0 , random_state=42 ) xgb.fit(lowerCamelCase__ , lowerCamelCase__ ) # Predict target for test data snake_case_ = xgb.predict(lowerCamelCase__ ) snake_case_ = predictions.reshape(len(lowerCamelCase__ ) , 1 ) return predictions def _lowerCAmelCase ( )->List[str]: '''simple docstring''' snake_case_ = fetch_california_housing() snake_case_ , snake_case_ = data_handling(lowerCamelCase__ ) snake_case_ , snake_case_ , snake_case_ , snake_case_ = train_test_split( lowerCamelCase__ , lowerCamelCase__ , test_size=0.2_5 , random_state=1 ) snake_case_ = xgboost(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # Error printing print(F'''Mean Absolute Error : {mean_absolute_error(lowerCamelCase__ , lowerCamelCase__ )}''' ) print(F'''Mean Square Error : {mean_squared_error(lowerCamelCase__ , lowerCamelCase__ )}''' ) if __name__ == "__main__": import doctest doctest.testmod(verbose=True) main()
159
import os import time from dataclasses import dataclass, field from enum import Enum from typing import Dict, List, Optional, Union import torch from filelock import FileLock from torch.utils.data import Dataset from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features __A =logging.get_logger(__name__) __A =list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys()) __A =tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) @dataclass class _SCREAMING_SNAKE_CASE : lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Model type selected in the list: ' + ', '.join(snake_case_ )} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'The input data dir. Should contain the .json files for the SQuAD task.'} ) lowerCAmelCase__ = field( default=1_28 , metadata={ 'help': ( 'The maximum total input sequence length after tokenization. Sequences longer ' 'than this will be truncated, sequences shorter will be padded.' ) } , ) lowerCAmelCase__ = field( default=1_28 , metadata={'help': 'When splitting up a long document into chunks, how much stride to take between chunks.'} , ) lowerCAmelCase__ = field( default=64 , metadata={ 'help': ( 'The maximum number of tokens for the question. Questions longer than this will ' 'be truncated to this length.' ) } , ) lowerCAmelCase__ = field( default=30 , metadata={ 'help': ( 'The maximum length of an answer that can be generated. This is needed because the start ' 'and end predictions are not conditioned on one another.' ) } , ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'Overwrite the cached training and evaluation sets'} ) lowerCAmelCase__ = field( default=snake_case_ , metadata={'help': 'If true, the SQuAD examples contain some that do not have an answer.'} ) lowerCAmelCase__ = field( default=0.0 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=20 , metadata={'help': 'If null_score - best_non_null is greater than the threshold predict null.'} ) lowerCAmelCase__ = field( default=0 , metadata={ 'help': ( 'language id of input for language-specific xlm models (see' ' tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)' ) } , ) lowerCAmelCase__ = field(default=1 , metadata={'help': 'multiple threads for converting example to features'} ) class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 'train' lowerCAmelCase__ = 'dev' class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 lowerCAmelCase__ = 42 def __init__( self , lowercase , lowercase , lowercase = None , lowercase = Split.train , lowercase = False , lowercase = None , lowercase = "pt" , ) -> List[str]: lowerCamelCase_ = args lowerCamelCase_ = is_language_sensitive lowerCamelCase_ = SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor() if isinstance(lowercase , lowercase ): try: lowerCamelCase_ = Split[mode] except KeyError: raise KeyError("mode is not a valid split name" ) lowerCamelCase_ = mode # Load data features from cache or dataset file lowerCamelCase_ = "v2" if args.version_2_with_negative else "v1" lowerCamelCase_ = os.path.join( cache_dir if cache_dir is not None else args.data_dir , f'cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}' , ) # Make sure only the first process in distributed training processes the dataset, # and the others will use the cache. lowerCamelCase_ = cached_features_file + ".lock" with FileLock(lowercase ): if os.path.exists(lowercase ) and not args.overwrite_cache: lowerCamelCase_ = time.time() lowerCamelCase_ = torch.load(lowercase ) # Legacy cache files have only features, while new cache files # will have dataset and examples also. lowerCamelCase_ = self.old_features["features"] lowerCamelCase_ = self.old_features.get("dataset" , lowercase ) lowerCamelCase_ = self.old_features.get("examples" , lowercase ) logger.info( f'Loading features from cached file {cached_features_file} [took %.3f s]' , time.time() - start ) if self.dataset is None or self.examples is None: logger.warning( f'Deleting cached file {cached_features_file} will allow dataset and examples to be cached in' " future run" ) else: if mode == Split.dev: lowerCamelCase_ = self.processor.get_dev_examples(args.data_dir ) else: lowerCamelCase_ = self.processor.get_train_examples(args.data_dir ) lowerCamelCase_ , lowerCamelCase_ = squad_convert_examples_to_features( examples=self.examples , tokenizer=lowercase , max_seq_length=args.max_seq_length , doc_stride=args.doc_stride , max_query_length=args.max_query_length , is_training=mode == Split.train , threads=args.threads , return_dataset=lowercase , ) lowerCamelCase_ = time.time() torch.save( {"features": self.features, "dataset": self.dataset, "examples": self.examples} , lowercase , ) # ^ This seems to take a lot of time so I want to investigate why and how we can improve. logger.info( f'Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]' ) def __len__( self ) -> Tuple: return len(self.features ) def __getitem__( self , lowercase ) -> Dict[str, torch.Tensor]: # Convert to Tensors and build dataset lowerCamelCase_ = self.features[i] lowerCamelCase_ = torch.tensor(feature.input_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.attention_mask , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.token_type_ids , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.cls_index , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.p_mask , dtype=torch.float ) lowerCamelCase_ = torch.tensor(feature.is_impossible , dtype=torch.float ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": attention_mask, "token_type_ids": token_type_ids, } if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]: del inputs["token_type_ids"] if self.args.model_type in ["xlnet", "xlm"]: inputs.update({"cls_index": cls_index, "p_mask": p_mask} ) if self.args.version_2_with_negative: inputs.update({"is_impossible": is_impossible} ) if self.is_language_sensitive: inputs.update({"langs": (torch.ones(input_ids.shape , dtype=torch.intaa ) * self.args.lang_id)} ) if self.mode == Split.train: lowerCamelCase_ = torch.tensor(feature.start_position , dtype=torch.long ) lowerCamelCase_ = torch.tensor(feature.end_position , dtype=torch.long ) inputs.update({"start_positions": start_positions, "end_positions": end_positions} ) return inputs
19
0
"""simple docstring""" import importlib import shutil import threading import warnings from typing import List import fsspec import fsspec.asyn from . import compression from .hffilesystem import HfFileSystem A : Optional[int] = importlib.util.find_spec("s3fs") is not None if _has_safs: from .safilesystem import SaFileSystem # noqa: F401 A : Union[str, Any] = [ compression.BzaFileSystem, compression.GzipFileSystem, compression.LzaFileSystem, compression.XzFileSystem, compression.ZstdFileSystem, ] # Register custom filesystems for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]: if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class: warnings.warn(f'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''') fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True) def _lowerCamelCase ( _UpperCamelCase ): '''simple docstring''' if "://" in dataset_path: __lowerCAmelCase = dataset_path.split("://" )[1] return dataset_path def _lowerCamelCase ( _UpperCamelCase ): '''simple docstring''' if fs is not None and fs.protocol != "file": return True else: return False def _lowerCamelCase ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): '''simple docstring''' __lowerCAmelCase = not is_remote_filesystem(lowerCamelCase__ ) if is_local: # LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory shutil.move(fs._strip_protocol(lowerCamelCase__ ) , fs._strip_protocol(lowerCamelCase__ ) ) else: fs.mv(lowerCamelCase__ , lowerCamelCase__ , recursive=lowerCamelCase__ ) def _lowerCamelCase ( ): '''simple docstring''' if hasattr(fsspec.asyn , "reset_lock" ): # for future fsspec>2022.05.0 fsspec.asyn.reset_lock() else: __lowerCAmelCase = None __lowerCAmelCase = None __lowerCAmelCase = threading.Lock()
57
from abc import ABC, abstractmethod from argparse import ArgumentParser class _SCREAMING_SNAKE_CASE ( snake_case_ ): @staticmethod @abstractmethod def SCREAMING_SNAKE_CASE_( lowercase ) -> int: raise NotImplementedError() @abstractmethod def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: raise NotImplementedError()
19
0
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, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, logging lowerCAmelCase__ : Any =logging.get_logger(__name__) class UpperCAmelCase_ ( snake_case_ ): '''simple docstring''' UpperCamelCase__ : Optional[Any] = ['''pixel_values'''] def __init__( self , _A = True , _A = None , _A = PILImageResampling.BILINEAR , _A = True , _A = None , _A = True , _A = 1 / 255 , _A = True , _A = None , _A = None , **_A , ): '''simple docstring''' super().__init__(**_A ) __SCREAMING_SNAKE_CASE = size if size is not None else {'shortest_edge': 256} __SCREAMING_SNAKE_CASE = get_size_dict(_A , default_to_square=_A ) __SCREAMING_SNAKE_CASE = crop_size if crop_size is not None else {'height': 224, 'width': 224} __SCREAMING_SNAKE_CASE = get_size_dict(_A ) __SCREAMING_SNAKE_CASE = do_resize __SCREAMING_SNAKE_CASE = size __SCREAMING_SNAKE_CASE = resample __SCREAMING_SNAKE_CASE = do_center_crop __SCREAMING_SNAKE_CASE = crop_size __SCREAMING_SNAKE_CASE = do_rescale __SCREAMING_SNAKE_CASE = rescale_factor __SCREAMING_SNAKE_CASE = do_normalize __SCREAMING_SNAKE_CASE = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN __SCREAMING_SNAKE_CASE = image_std if image_std is not None else IMAGENET_STANDARD_STD def _A ( self , _A , _A , _A = PILImageResampling.BICUBIC , _A = None , **_A , ): '''simple docstring''' __SCREAMING_SNAKE_CASE = get_size_dict(_A , default_to_square=_A ) if "shortest_edge" not in size: raise ValueError(f"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}""" ) __SCREAMING_SNAKE_CASE = get_resize_output_image_size(_A , size=size['shortest_edge'] , default_to_square=_A ) return resize(_A , size=_A , resample=_A , data_format=_A , **_A ) def _A ( self , _A , _A , _A = None , **_A , ): '''simple docstring''' __SCREAMING_SNAKE_CASE = get_size_dict(_A ) return center_crop(_A , size=(size['height'], size['width']) , data_format=_A , **_A ) def _A ( self , _A , _A , _A = None , **_A ): '''simple docstring''' return rescale(_A , scale=_A , data_format=_A , **_A ) def _A ( self , _A , _A , _A , _A = None , **_A , ): '''simple docstring''' return normalize(_A , mean=_A , std=_A , data_format=_A , **_A ) def _A ( self , _A , _A = None , _A = None , _A = None , _A = None , _A = None , _A = None , _A = None , _A = None , _A = None , _A = None , _A = None , _A = ChannelDimension.FIRST , **_A , ): '''simple docstring''' __SCREAMING_SNAKE_CASE = do_resize if do_resize is not None else self.do_resize __SCREAMING_SNAKE_CASE = size if size is not None else self.size __SCREAMING_SNAKE_CASE = get_size_dict(_A , default_to_square=_A ) __SCREAMING_SNAKE_CASE = resample if resample is not None else self.resample __SCREAMING_SNAKE_CASE = do_center_crop if do_center_crop is not None else self.do_center_crop __SCREAMING_SNAKE_CASE = crop_size if crop_size is not None else self.crop_size __SCREAMING_SNAKE_CASE = get_size_dict(_A ) __SCREAMING_SNAKE_CASE = do_rescale if do_rescale is not None else self.do_rescale __SCREAMING_SNAKE_CASE = rescale_factor if rescale_factor is not None else self.rescale_factor __SCREAMING_SNAKE_CASE = do_normalize if do_normalize is not None else self.do_normalize __SCREAMING_SNAKE_CASE = image_mean if image_mean is not None else self.image_mean __SCREAMING_SNAKE_CASE = image_std if image_std is not None else self.image_std __SCREAMING_SNAKE_CASE = make_list_of_images(_A ) if not valid_images(_A ): raise ValueError( 'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, ' 'torch.Tensor, tf.Tensor or jax.ndarray.' ) if do_resize and size is None: raise ValueError('Size 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. __SCREAMING_SNAKE_CASE = [to_numpy_array(_A ) for image in images] if do_resize: __SCREAMING_SNAKE_CASE = [self.resize(image=_A , size=_A , resample=_A ) for image in images] if do_center_crop: __SCREAMING_SNAKE_CASE = [self.center_crop(image=_A , size=_A ) for image in images] if do_rescale: __SCREAMING_SNAKE_CASE = [self.rescale(image=_A , scale=_A ) for image in images] if do_normalize: __SCREAMING_SNAKE_CASE = [self.normalize(image=_A , mean=_A , std=_A ) for image in images] __SCREAMING_SNAKE_CASE = [to_channel_dimension_format(_A , _A ) for image in images] __SCREAMING_SNAKE_CASE = {'pixel_values': images} return BatchFeature(data=_A , tensor_type=_A )
257
from typing import Callable, List, Optional, Union import PIL import torch from transformers import ( CLIPImageProcessor, CLIPSegForImageSegmentation, CLIPSegProcessor, CLIPTextModel, CLIPTokenizer, ) from diffusers import DiffusionPipeline from diffusers.configuration_utils import FrozenDict from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler from diffusers.utils import deprecate, is_accelerate_available, logging __A =logging.get_logger(__name__) # pylint: disable=invalid-name class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[Any]: super().__init__() if hasattr(scheduler.config , "steps_offset" ) and scheduler.config.steps_offset != 1: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`' f' should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure ' "to update the config accordingly as leaving `steps_offset` might led to incorrect results" " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub," " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`" " file" ) deprecate("steps_offset!=1" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = 1 lowerCamelCase_ = FrozenDict(lowercase ) if hasattr(scheduler.config , "skip_prk_steps" ) and scheduler.config.skip_prk_steps is False: lowerCamelCase_ = ( f'The configuration file of this scheduler: {scheduler} has not set the configuration' " `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make" " sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to" " incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face" " Hub, it would be very nice if you could open a Pull request for the" " `scheduler/scheduler_config.json` file" ) deprecate("skip_prk_steps not set" , "1.0.0" , lowercase , standard_warn=lowercase ) lowerCamelCase_ = dict(scheduler.config ) lowerCamelCase_ = True lowerCamelCase_ = FrozenDict(lowercase ) if safety_checker is None: logger.warning( f'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure' " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered" " results in services or applications open to the public. Both the diffusers team and Hugging Face" " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling" " it only for use-cases that involve analyzing network behavior or auditing its results. For more" " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ." ) self.register_modules( segmentation_model=lowercase , segmentation_processor=lowercase , vae=lowercase , text_encoder=lowercase , tokenizer=lowercase , unet=lowercase , scheduler=lowercase , safety_checker=lowercase , feature_extractor=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase = "auto" ) -> Tuple: if slice_size == "auto": # half the attention head size is usually a good trade-off between # speed and memory lowerCamelCase_ = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: self.enable_attention_slicing(lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> str: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device("cuda" ) for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def SCREAMING_SNAKE_CASE_( self ) -> Union[str, Any]: if self.device != torch.device("meta" ) or not hasattr(self.unet , "_hf_hook" ): return self.device for module in self.unet.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device @torch.no_grad() def __call__( self , lowercase , lowercase , lowercase , lowercase = 512 , lowercase = 512 , lowercase = 50 , lowercase = 7.5 , lowercase = None , lowercase = 1 , lowercase = 0.0 , lowercase = None , lowercase = None , lowercase = "pil" , lowercase = True , lowercase = None , lowercase = 1 , **lowercase , ) -> int: lowerCamelCase_ = self.segmentation_processor( text=[text] , images=[image] , padding="max_length" , return_tensors="pt" ).to(self.device ) lowerCamelCase_ = self.segmentation_model(**lowercase ) lowerCamelCase_ = torch.sigmoid(outputs.logits ).cpu().detach().unsqueeze(-1 ).numpy() lowerCamelCase_ = self.numpy_to_pil(lowercase )[0].resize(image.size ) # Run inpainting pipeline with the generated mask lowerCamelCase_ = StableDiffusionInpaintPipeline( vae=self.vae , text_encoder=self.text_encoder , tokenizer=self.tokenizer , unet=self.unet , scheduler=self.scheduler , safety_checker=self.safety_checker , feature_extractor=self.feature_extractor , ) return inpainting_pipeline( prompt=lowercase , image=lowercase , mask_image=lowercase , height=lowercase , width=lowercase , num_inference_steps=lowercase , guidance_scale=lowercase , negative_prompt=lowercase , num_images_per_prompt=lowercase , eta=lowercase , generator=lowercase , latents=lowercase , output_type=lowercase , return_dict=lowercase , callback=lowercase , callback_steps=lowercase , )
19
0
"""simple docstring""" import inspect import math import tempfile import unittest import numpy as np from transformers import ViTMAEConfig from transformers.testing_utils import require_torch, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_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 ViTMAEForPreTraining, ViTMAEModel from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class lowerCAmelCase_ : '''simple docstring''' def __init__( self : Union[str, Any] ,A_ : Dict ,A_ : Union[str, Any]=13 ,A_ : Optional[Any]=30 ,A_ : str=2 ,A_ : List[Any]=3 ,A_ : str=True ,A_ : int=True ,A_ : str=32 ,A_ : Dict=5 ,A_ : Optional[int]=4 ,A_ : Any=37 ,A_ : Optional[Any]="gelu" ,A_ : int=0.1 ,A_ : Any=0.1 ,A_ : Dict=10 ,A_ : Dict=0.02 ,A_ : List[Any]=3 ,A_ : Optional[Any]=0.6 ,A_ : str=None ,) -> Tuple: A = parent A = batch_size A = image_size A = patch_size A = num_channels A = is_training A = use_labels A = hidden_size A = num_hidden_layers A = num_attention_heads A = intermediate_size A = hidden_act A = hidden_dropout_prob A = attention_probs_dropout_prob A = type_sequence_label_size A = initializer_range A = mask_ratio A = scope # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above # (we add 1 for the [CLS] token) A = (image_size // patch_size) ** 2 A = int(math.ceil((1 - mask_ratio) * (num_patches + 1) ) ) def _SCREAMING_SNAKE_CASE ( self : Tuple ) -> int: A = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) A = None if self.use_labels: A = ids_tensor([self.batch_size] ,self.type_sequence_label_size ) A = self.get_config() return config, pixel_values, labels def _SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> List[str]: return ViTMAEConfig( 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=A_ ,initializer_range=self.initializer_range ,mask_ratio=self.mask_ratio ,) def _SCREAMING_SNAKE_CASE ( self : int ,A_ : Any ,A_ : Dict ,A_ : int ) -> str: A = ViTMAEModel(config=A_ ) model.to(A_ ) model.eval() A = model(A_ ) self.parent.assertEqual(result.last_hidden_state.shape ,(self.batch_size, self.seq_length, self.hidden_size) ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ,A_ : Optional[int] ,A_ : Dict ,A_ : Dict ) -> int: A = ViTMAEForPreTraining(A_ ) model.to(A_ ) model.eval() A = model(A_ ) A = (self.image_size // self.patch_size) ** 2 A = self.patch_size**2 * self.num_channels self.parent.assertEqual(result.logits.shape ,(self.batch_size, num_patches, expected_num_channels) ) # test greyscale images A = 1 A = ViTMAEForPreTraining(A_ ) model.to(A_ ) model.eval() A = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) A = model(A_ ) A = self.patch_size**2 self.parent.assertEqual(result.logits.shape ,(self.batch_size, num_patches, expected_num_channels) ) def _SCREAMING_SNAKE_CASE ( self : Tuple ) -> Optional[int]: A = self.prepare_config_and_inputs() A , A , A = config_and_inputs A = {'pixel_values': pixel_values} return config, inputs_dict @require_torch class lowerCAmelCase_ ( snake_case_ , snake_case_ , unittest.TestCase ): '''simple docstring''' _lowerCamelCase: str = (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else () _lowerCamelCase: Tuple = {'''feature-extraction''': ViTMAEModel} if is_torch_available() else {} _lowerCamelCase: Optional[int] = False _lowerCamelCase: Any = False _lowerCamelCase: Union[str, Any] = False _lowerCamelCase: List[Any] = False def _SCREAMING_SNAKE_CASE ( self : Any ) -> Optional[Any]: A = ViTMAEModelTester(self ) A = ConfigTester(self ,config_class=A_ ,has_text_modality=A_ ,hidden_size=37 ) def _SCREAMING_SNAKE_CASE ( self : Any ) -> Union[str, Any]: self.config_tester.run_common_tests() @unittest.skip(reason='ViTMAE does not use inputs_embeds' ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> str: pass def _SCREAMING_SNAKE_CASE ( self : Any ) -> Optional[Any]: A , A = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: A = model_class(A_ ) self.assertIsInstance(model.get_input_embeddings() ,(nn.Module) ) A = model.get_output_embeddings() self.assertTrue(x is None or isinstance(A_ ,nn.Linear ) ) def _SCREAMING_SNAKE_CASE ( self : Any ) -> Union[str, Any]: A , A = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: A = model_class(A_ ) A = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic A = [*signature.parameters.keys()] A = ['pixel_values'] self.assertListEqual(arg_names[:1] ,A_ ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Tuple: A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A_ ) def _SCREAMING_SNAKE_CASE ( self : Dict ) -> Tuple: A = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*A_ ) def _SCREAMING_SNAKE_CASE ( self : Optional[int] ,A_ : Optional[int] ,A_ : Tuple ,A_ : Union[str, Any] ) -> Optional[Any]: # make masks reproducible np.random.seed(2 ) A = int((pt_model.config.image_size // pt_model.config.patch_size) ** 2 ) A = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) A = torch.from_numpy(A_ ) # Add `noise` argument. # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument A = pt_noise super().check_pt_tf_models(A_ ,A_ ,A_ ) def _SCREAMING_SNAKE_CASE ( self : Any ) -> Optional[Any]: A , A = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: A = model_class(A_ ) model.to(A_ ) model.eval() # make random mask reproducible torch.manual_seed(2 ) with torch.no_grad(): A = model(**self._prepare_for_class(A_ ,A_ ) ) A = outputs[0].cpu().numpy() A = 0 with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(A_ ) A = model_class.from_pretrained(A_ ) model.to(A_ ) # make random mask reproducible torch.manual_seed(2 ) with torch.no_grad(): A = model(**self._prepare_for_class(A_ ,A_ ) ) # Make sure we don't have nans A = after_outputs[0].cpu().numpy() A = 0 A = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(A_ ,1e-5 ) @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.' ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> Union[str, Any]: pass @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.' ) def _SCREAMING_SNAKE_CASE ( self : Tuple ) -> str: pass @unittest.skip( reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n to get deterministic results.' ) def _SCREAMING_SNAKE_CASE ( self : Tuple ) -> Union[str, Any]: pass @unittest.skip(reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load' ) def _SCREAMING_SNAKE_CASE ( self : str ) -> Union[str, Any]: pass @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.' ) def _SCREAMING_SNAKE_CASE ( self : List[Any] ) -> int: pass @slow def _SCREAMING_SNAKE_CASE ( self : Tuple ) -> List[Any]: for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: A = ViTMAEModel.from_pretrained(A_ ) self.assertIsNotNone(A_ ) def _snake_case ( ): A = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' ) return image @require_torch @require_vision class lowerCAmelCase_ ( unittest.TestCase ): '''simple docstring''' @cached_property def _SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> Optional[int]: return ViTImageProcessor.from_pretrained('facebook/vit-mae-base' ) if is_vision_available() else None @slow def _SCREAMING_SNAKE_CASE ( self : List[str] ) -> Tuple: # make random mask reproducible across the PT and TF model np.random.seed(2 ) A = ViTMAEForPreTraining.from_pretrained('facebook/vit-mae-base' ).to(A_ ) A = self.default_image_processor A = prepare_img() A = image_processor(images=A_ ,return_tensors='pt' ).to(A_ ) # prepare a noise vector that will be also used for testing the TF model # (this way we can ensure that the PT and TF models operate on the same inputs) A = ViTMAEConfig() A = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2 ) A = np.random.uniform(size=(1, num_patches) ) # forward pass with torch.no_grad(): A = model(**A_ ,noise=torch.from_numpy(A_ ).to(device=A_ ) ) # verify the logits A = torch.Size((1, 196, 768) ) self.assertEqual(outputs.logits.shape ,A_ ) A = torch.tensor( [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]] ) self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] ,expected_slice.to(A_ ) ,atol=1e-4 ) )
74
from collections import deque def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) lowerCamelCase_ = deque() lowerCamelCase_ = [False for _ in range(lowerCamelCase__ )] lowerCamelCase_ = [-1 for _ in range(lowerCamelCase__ )] lowerCamelCase_ = index_of[:] def strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = index # the number when this node is seen lowerCamelCase_ = index # lowest rank node reachable from here index += 1 stack.append(lowerCamelCase__ ) lowerCamelCase_ = True for w in g[v]: if index_of[w] == -1: lowerCamelCase_ = strong_connect(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) elif on_stack[w]: lowerCamelCase_ = ( lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v] ) if lowlink_of[v] == index_of[v]: lowerCamelCase_ = [] lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) while w != v: lowerCamelCase_ = stack.pop() lowerCamelCase_ = False component.append(lowerCamelCase__ ) components.append(lowerCamelCase__ ) return index lowerCamelCase_ = [] for v in range(lowerCamelCase__ ): if index_of[v] == -1: strong_connect(lowerCamelCase__ , 0 , lowerCamelCase__ ) return components def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = [[] for _ in range(lowerCamelCase__ )] for u, v in edges: g[u].append(lowerCamelCase__ ) return g if __name__ == "__main__": # Test __A =7 __A =[0, 0, 1, 2, 3, 3, 4, 4, 6] __A =[1, 3, 2, 0, 1, 4, 5, 6, 5] __A =[(u, v) for u, v in zip(source, target)] __A =create_graph(n_vertices, edges) assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)
19
0
"""simple docstring""" from collections.abc import Callable def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: '''simple docstring''' lowercase : Dict = a lowercase : List[str] = b if function(lowerCamelCase__ ) == 0: # one of the a or b is a root for the function return a elif function(lowerCamelCase__ ) == 0: return b elif ( function(lowerCamelCase__ ) * function(lowerCamelCase__ ) > 0 ): # if none of these are root and they are both positive or negative, # then this algorithm can't find the root raise ValueError('could not find root in given interval.' ) else: lowercase : Optional[Any] = start + (end - start) / 2.0 while abs(start - mid ) > 10**-7: # until precisely equals to 10^-7 if function(lowerCamelCase__ ) == 0: return mid elif function(lowerCamelCase__ ) * function(lowerCamelCase__ ) < 0: lowercase : Optional[int] = mid else: lowercase : List[str] = mid lowercase : str = start + (end - start) / 2.0 return mid def lowercase__ ( _UpperCAmelCase ) -> str: '''simple docstring''' return x**3 - 2 * x - 5 if __name__ == "__main__": print(bisection(f, 1, 1_0_0_0)) import doctest doctest.testmod()
255
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) __A ={'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizer'''] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''XGLMTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''XGLMForCausalLM''', '''XGLMModel''', '''XGLMPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''FlaxXGLMForCausalLM''', '''FlaxXGLMModel''', '''FlaxXGLMPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFXGLMForCausalLM''', '''TFXGLMModel''', '''TFXGLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm import XGLMTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_xglm_fast import XGLMTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_xglm import ( TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, TFXGLMForCausalLM, TFXGLMModel, TFXGLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure)
19
0
'''simple docstring''' 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 __SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , unittest.TestCase ): snake_case_ = StableDiffusionSAGPipeline snake_case_ = TEXT_TO_IMAGE_PARAMS snake_case_ = TEXT_TO_IMAGE_BATCH_PARAMS snake_case_ = TEXT_TO_IMAGE_IMAGE_PARAMS snake_case_ = TEXT_TO_IMAGE_IMAGE_PARAMS snake_case_ = False def __magic_name__ ( self : List[str] ) -> List[str]: torch.manual_seed(0 ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =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 , ) SCREAMING_SNAKE_CASE__ : Dict =DDIMScheduler( beta_start=0.00085 , beta_end=0.012 , beta_schedule='''scaled_linear''' , clip_sample=__lowercase , set_alpha_to_one=__lowercase , ) torch.manual_seed(0 ) SCREAMING_SNAKE_CASE__ : Optional[int] =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 ) SCREAMING_SNAKE_CASE__ : int =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=10_00 , ) SCREAMING_SNAKE_CASE__ : Optional[Any] =CLIPTextModel(__lowercase ) SCREAMING_SNAKE_CASE__ : Optional[int] =CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' ) SCREAMING_SNAKE_CASE__ : Tuple ={ '''unet''': unet, '''scheduler''': scheduler, '''vae''': vae, '''text_encoder''': text_encoder, '''tokenizer''': tokenizer, '''safety_checker''': None, '''feature_extractor''': None, } return components def __magic_name__ ( self : Optional[int] , __lowercase : Any , __lowercase : Any=0 ) -> List[str]: if str(__lowercase ).startswith('''mps''' ): SCREAMING_SNAKE_CASE__ : str =torch.manual_seed(__lowercase ) else: SCREAMING_SNAKE_CASE__ : Optional[Any] =torch.Generator(device=__lowercase ).manual_seed(__lowercase ) SCREAMING_SNAKE_CASE__ : List[Any] ={ '''prompt''': '''.''', '''generator''': generator, '''num_inference_steps''': 2, '''guidance_scale''': 1.0, '''sag_scale''': 1.0, '''output_type''': '''numpy''', } return inputs def __magic_name__ ( self : Tuple ) -> Optional[Any]: super().test_inference_batch_single_identical(expected_max_diff=3e-3 ) @slow @require_torch_gpu class __SCREAMING_SNAKE_CASE ( unittest.TestCase ): def __magic_name__ ( self : str ) -> Optional[int]: # clean up the VRAM after each test super().tearDown() gc.collect() torch.cuda.empty_cache() def __magic_name__ ( self : Optional[Any] ) -> Tuple: SCREAMING_SNAKE_CASE__ : Optional[int] =StableDiffusionSAGPipeline.from_pretrained('''CompVis/stable-diffusion-v1-4''' ) SCREAMING_SNAKE_CASE__ : Optional[Any] =sag_pipe.to(__lowercase ) sag_pipe.set_progress_bar_config(disable=__lowercase ) SCREAMING_SNAKE_CASE__ : Any ='''.''' SCREAMING_SNAKE_CASE__ : Optional[int] =torch.manual_seed(0 ) SCREAMING_SNAKE_CASE__ : int =sag_pipe( [prompt] , generator=__lowercase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='''np''' ) SCREAMING_SNAKE_CASE__ : Union[str, Any] =output.images SCREAMING_SNAKE_CASE__ : Optional[Any] =image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) SCREAMING_SNAKE_CASE__ : Optional[Any] =np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def __magic_name__ ( self : Any ) -> Tuple: SCREAMING_SNAKE_CASE__ : Union[str, Any] =StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''' ) SCREAMING_SNAKE_CASE__ : List[str] =sag_pipe.to(__lowercase ) sag_pipe.set_progress_bar_config(disable=__lowercase ) SCREAMING_SNAKE_CASE__ : Any ='''.''' SCREAMING_SNAKE_CASE__ : Optional[int] =torch.manual_seed(0 ) SCREAMING_SNAKE_CASE__ : Any =sag_pipe( [prompt] , generator=__lowercase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='''np''' ) SCREAMING_SNAKE_CASE__ : Dict =output.images SCREAMING_SNAKE_CASE__ : List[Any] =image[0, -3:, -3:, -1] assert image.shape == (1, 5_12, 5_12, 3) SCREAMING_SNAKE_CASE__ : Union[str, Any] =np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-2 def __magic_name__ ( self : List[Any] ) -> str: SCREAMING_SNAKE_CASE__ : Optional[Any] =StableDiffusionSAGPipeline.from_pretrained('''stabilityai/stable-diffusion-2-1-base''' ) SCREAMING_SNAKE_CASE__ : str =sag_pipe.to(__lowercase ) sag_pipe.set_progress_bar_config(disable=__lowercase ) SCREAMING_SNAKE_CASE__ : List[str] ='''.''' SCREAMING_SNAKE_CASE__ : Optional[int] =torch.manual_seed(0 ) SCREAMING_SNAKE_CASE__ : int =sag_pipe( [prompt] , width=7_68 , height=5_12 , generator=__lowercase , guidance_scale=7.5 , sag_scale=1.0 , num_inference_steps=20 , output_type='''np''' , ) SCREAMING_SNAKE_CASE__ : Dict =output.images assert image.shape == (1, 5_12, 7_68, 3)
152
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available __A ={'''configuration_wavlm''': ['''WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''WavLMConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''WavLMForAudioFrameClassification''', '''WavLMForCTC''', '''WavLMForSequenceClassification''', '''WavLMForXVector''', '''WavLMModel''', '''WavLMPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_wavlm import WAVLM_PRETRAINED_CONFIG_ARCHIVE_MAP, WavLMConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_wavlm import ( WAVLM_PRETRAINED_MODEL_ARCHIVE_LIST, WavLMForAudioFrameClassification, WavLMForCTC, WavLMForSequenceClassification, WavLMForXVector, WavLMModel, WavLMPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
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""" UpperCamelCase__ : List[str] =MODEL_FOR_MASKED_LM_MAPPING UpperCamelCase__ : Tuple =TF_MODEL_FOR_MASKED_LM_MAPPING def __lowercase ( self ): """simple docstring""" 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 __lowercase ( self ): """simple docstring""" __UpperCamelCase : Optional[int] =pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='tf' ) __UpperCamelCase : List[Any] =unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(lowerCamelCase__ , 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 : Any =unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(lowerCamelCase__ , 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 : List[Any] =unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(lowerCamelCase__ , 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 __lowercase ( self ): """simple docstring""" __UpperCamelCase : Optional[Any] =pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , top_k=2 , framework='pt' ) __UpperCamelCase : Optional[int] =unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(lowerCamelCase__ , 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 : Optional[int] =unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(lowerCamelCase__ , 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 : Union[str, Any] =unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(lowerCamelCase__ , 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 : int =unmasker('My name is <mask> <mask>' , top_k=2 ) self.assertEqual( nested_simplify(lowerCamelCase__ , 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 __lowercase ( self ): """simple docstring""" __UpperCamelCase : Any =pipeline('fill-mask' , model='hf-internal-testing/tiny-random-distilbert' , device=0 , framework='pt' ) # convert model to fp16 pipe.model.half() __UpperCamelCase : List[Any] =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(lowerCamelCase__ , lowerCamelCase__ ) @slow @require_torch def __lowercase ( self ): """simple docstring""" __UpperCamelCase : str =pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='pt' ) self.run_large_test(lowerCamelCase__ ) @slow @require_tf def __lowercase ( self ): """simple docstring""" __UpperCamelCase : str =pipeline(task='fill-mask' , model='distilroberta-base' , top_k=2 , framework='tf' ) self.run_large_test(lowerCamelCase__ ) def __lowercase ( self , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : int =unmasker('My name is <mask>' ) self.assertEqual( nested_simplify(lowerCamelCase__ ) , [ {'sequence': 'My name is John', 'score': 0.008, 'token': 610, 'token_str': ' John'}, {'sequence': 'My name is Chris', 'score': 0.007, 'token': 1573, 'token_str': ' Chris'}, ] , ) __UpperCamelCase : Optional[Any] =unmasker('The largest city in France is <mask>' ) self.assertEqual( nested_simplify(lowerCamelCase__ ) , [ { 'sequence': 'The largest city in France is Paris', 'score': 0.251, 'token': 2201, 'token_str': ' Paris', }, { 'sequence': 'The largest city in France is Lyon', 'score': 0.214, 'token': 12790, 'token_str': ' Lyon', }, ] , ) __UpperCamelCase : int =unmasker('My name is <mask>' , targets=[' Patrick', ' Clara', ' Teven'] , top_k=3 ) self.assertEqual( nested_simplify(lowerCamelCase__ ) , [ {'sequence': 'My name is Patrick', 'score': 0.005, 'token': 3499, 'token_str': ' Patrick'}, {'sequence': 'My name is Clara', 'score': 0.000, 'token': 13606, 'token_str': ' Clara'}, {'sequence': 'My name is Te', 'score': 0.000, 'token': 2941, 'token_str': ' Te'}, ] , ) @require_torch def __lowercase ( self ): """simple docstring""" __UpperCamelCase : List[str] =pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='pt' ) __UpperCamelCase : List[str] =None __UpperCamelCase : Union[str, Any] =None self.run_pipeline_test(lowerCamelCase__ , [] ) @require_tf def __lowercase ( self ): """simple docstring""" __UpperCamelCase : str =pipeline(task='fill-mask' , model='sshleifer/tiny-distilroberta-base' , framework='tf' ) __UpperCamelCase : str =None __UpperCamelCase : Tuple =None self.run_pipeline_test(lowerCamelCase__ , [] ) def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" 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 : Tuple =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ ) __UpperCamelCase : List[str] =[ f'This is another {tokenizer.mask_token} test', ] return fill_masker, examples def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : str =fill_masker.tokenizer __UpperCamelCase : Optional[Any] =fill_masker.model __UpperCamelCase : Tuple =fill_masker( f'This is a {tokenizer.mask_token}' , ) self.assertEqual( lowerCamelCase__ , [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ] , ) __UpperCamelCase : str =fill_masker([f'This is a {tokenizer.mask_token}'] ) self.assertEqual( lowerCamelCase__ , [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ] , ) __UpperCamelCase : List[Any] =fill_masker([f'This is a {tokenizer.mask_token}', f'Another {tokenizer.mask_token} great test.'] ) self.assertEqual( lowerCamelCase__ , [ [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ], [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ], ] , ) with self.assertRaises(lowerCamelCase__ ): fill_masker([None] ) # No mask_token is not supported with self.assertRaises(lowerCamelCase__ ): fill_masker('This is' ) self.run_test_top_k(lowerCamelCase__ , lowerCamelCase__ ) self.run_test_targets(lowerCamelCase__ , lowerCamelCase__ ) self.run_test_top_k_targets(lowerCamelCase__ , lowerCamelCase__ ) self.fill_mask_with_duplicate_targets_and_top_k(lowerCamelCase__ , lowerCamelCase__ ) self.fill_mask_with_multiple_masks(lowerCamelCase__ , lowerCamelCase__ ) def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : List[str] =tokenizer.get_vocab() __UpperCamelCase : List[str] =sorted(vocab.keys() )[:2] # Pipeline argument __UpperCamelCase : Optional[Any] =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ , targets=lowerCamelCase__ ) __UpperCamelCase : Optional[int] =fill_masker(f'This is a {tokenizer.mask_token}' ) self.assertEqual( lowerCamelCase__ , [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ] , ) __UpperCamelCase : Any ={vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , lowerCamelCase__ ) __UpperCamelCase : str =[tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(lowerCamelCase__ ) ) # Call argument __UpperCamelCase : Union[str, Any] =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ ) __UpperCamelCase : Union[str, Any] =fill_masker(f'This is a {tokenizer.mask_token}' , targets=lowerCamelCase__ ) self.assertEqual( lowerCamelCase__ , [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ] , ) __UpperCamelCase : List[Any] ={vocab[el] for el in targets} self.assertEqual({el['token'] for el in outputs} , lowerCamelCase__ ) __UpperCamelCase : Tuple =[tokenizer.decode([x] ) for x in target_ids] self.assertEqual({el['token_str'] for el in outputs} , set(lowerCamelCase__ ) ) # Score equivalence __UpperCamelCase : List[Any] =fill_masker(f'This is a {tokenizer.mask_token}' , targets=lowerCamelCase__ ) __UpperCamelCase : Optional[Any] =[top_mask['token_str'] for top_mask in outputs] __UpperCamelCase : Dict =[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(lowerCamelCase__ ) == set(lowerCamelCase__ ): __UpperCamelCase : Dict =fill_masker(f'This is a {tokenizer.mask_token}' , targets=lowerCamelCase__ ) __UpperCamelCase : Tuple =[top_mask['score'] for top_mask in unmasked_targets] self.assertEqual(nested_simplify(lowerCamelCase__ ) , nested_simplify(lowerCamelCase__ ) ) # Raises with invalid with self.assertRaises(lowerCamelCase__ ): __UpperCamelCase : Tuple =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(lowerCamelCase__ ): __UpperCamelCase : Any =fill_masker(f'This is a {tokenizer.mask_token}' , targets=[''] ) with self.assertRaises(lowerCamelCase__ ): __UpperCamelCase : Dict =fill_masker(f'This is a {tokenizer.mask_token}' , targets='' ) def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : Any =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ , top_k=2 ) __UpperCamelCase : Dict =fill_masker(f'This is a {tokenizer.mask_token}' ) self.assertEqual( lowerCamelCase__ , [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ] , ) __UpperCamelCase : Optional[int] =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ ) __UpperCamelCase : str =fill_masker(f'This is a {tokenizer.mask_token}' , top_k=2 ) self.assertEqual( lowerCamelCase__ , [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ] , ) self.assertEqual(nested_simplify(lowerCamelCase__ ) , nested_simplify(lowerCamelCase__ ) ) def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : Dict =tokenizer.get_vocab() __UpperCamelCase : Dict =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ ) # top_k=2, ntargets=3 __UpperCamelCase : Any =sorted(vocab.keys() )[:3] __UpperCamelCase : Any =fill_masker(f'This is a {tokenizer.mask_token}' , top_k=2 , targets=lowerCamelCase__ ) # If we use the most probably targets, and filter differently, we should still # have the same results __UpperCamelCase : Any =[el['token_str'] for el in sorted(lowerCamelCase__ , key=lambda lowerCamelCase__ : x["score"] , reverse=lowerCamelCase__ )] # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`. if set(lowerCamelCase__ ).issubset(lowerCamelCase__ ): __UpperCamelCase : List[Any] =fill_masker(f'This is a {tokenizer.mask_token}' , top_k=3 , targets=lowerCamelCase__ ) # They should yield exactly the same result self.assertEqual(nested_simplify(lowerCamelCase__ ) , nested_simplify(lowerCamelCase__ ) ) def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : int =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ ) __UpperCamelCase : Optional[Any] =tokenizer.get_vocab() # String duplicates + id duplicates __UpperCamelCase : Tuple =sorted(vocab.keys() )[:3] __UpperCamelCase : int =[targets[0], targets[1], targets[0], targets[2], targets[1]] __UpperCamelCase : Dict =fill_masker(f'My name is {tokenizer.mask_token}' , targets=lowerCamelCase__ , top_k=10 ) # The target list contains duplicates, so we can't output more # than them self.assertEqual(len(lowerCamelCase__ ) , 3 ) def __lowercase ( self , lowerCamelCase__ , lowerCamelCase__ ): """simple docstring""" __UpperCamelCase : int =FillMaskPipeline(model=lowerCamelCase__ , tokenizer=lowerCamelCase__ ) __UpperCamelCase : List[str] =fill_masker( f'This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}' , top_k=2 ) self.assertEqual( lowerCamelCase__ , [ [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ], [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ], [ {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, {'sequence': ANY(lowerCamelCase__ ), 'score': ANY(lowerCamelCase__ ), 'token': ANY(lowerCamelCase__ ), 'token_str': ANY(lowerCamelCase__ )}, ], ] , )
71
# Lint as: python3 # pylint: enable=line-too-long # pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position __A ='''2.13.1''' import platform import pyarrow from packaging import version if version.parse(platform.python_version()) < version.parse('''3.7'''): raise ImportWarning( '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.''' ) if version.parse(pyarrow.__version__).major < 8: raise ImportWarning( '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n''' '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.''' ) del platform del pyarrow del version from .arrow_dataset import Dataset from .arrow_reader import ReadInstruction from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder from .combine import concatenate_datasets, interleave_datasets from .dataset_dict import DatasetDict, IterableDatasetDict from .download import * from .features import * from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled from .info import DatasetInfo, MetricInfo from .inspect import ( get_dataset_config_info, get_dataset_config_names, get_dataset_infos, get_dataset_split_names, inspect_dataset, inspect_metric, list_datasets, list_metrics, ) from .iterable_dataset import IterableDataset from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric from .metric import Metric from .splits import ( NamedSplit, NamedSplitAll, Split, SplitBase, SplitDict, SplitGenerator, SplitInfo, SubSplitInfo, percent, ) from .tasks import * from .utils import * from .utils import logging # deprecated modules from datasets import arrow_dataset as _arrow_dataset # isort:skip from datasets import utils as _utils # isort:skip from datasets.utils import download_manager as _deprecated_download_manager # isort:skip __A =concatenate_datasets __A =DownloadConfig __A =DownloadManager __A =DownloadMode __A =DownloadConfig __A =DownloadMode __A =DownloadManager del _arrow_dataset, _utils, _deprecated_download_manager
19
0
'''simple docstring''' import os import time from dataclasses import dataclass, field from enum import Enum from typing import Dict, List, Optional, Union import torch from filelock import FileLock from torch.utils.data import Dataset from ...models.auto.modeling_auto import MODEL_FOR_QUESTION_ANSWERING_MAPPING from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging from ..processors.squad import SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features a_ : Optional[int] = logging.get_logger(__name__) a_ : Optional[Any] = list(MODEL_FOR_QUESTION_ANSWERING_MAPPING.keys()) a_ : Any = tuple(conf.model_type for conf in MODEL_CONFIG_CLASSES) @dataclass class a : _lowerCAmelCase = field( default=snake_case_ , metadata={"""help""": """Model type selected in the list: """ + """, """.join(snake_case_ )} ) _lowerCAmelCase = field( default=snake_case_ , metadata={"""help""": """The input data dir. Should contain the .json files for the SQuAD task."""} ) _lowerCAmelCase = field( default=1_2_8 , metadata={ """help""": ( """The maximum total input sequence length after tokenization. Sequences longer """ """than this will be truncated, sequences shorter will be padded.""" ) } , ) _lowerCAmelCase = field( default=1_2_8 , metadata={"""help""": """When splitting up a long document into chunks, how much stride to take between chunks."""} , ) _lowerCAmelCase = field( default=6_4 , metadata={ """help""": ( """The maximum number of tokens for the question. Questions longer than this will """ """be truncated to this length.""" ) } , ) _lowerCAmelCase = field( default=3_0 , metadata={ """help""": ( """The maximum length of an answer that can be generated. This is needed because the start """ """and end predictions are not conditioned on one another.""" ) } , ) _lowerCAmelCase = field( default=snake_case_ , metadata={"""help""": """Overwrite the cached training and evaluation sets"""} ) _lowerCAmelCase = field( default=snake_case_ , metadata={"""help""": """If true, the SQuAD examples contain some that do not have an answer."""} ) _lowerCAmelCase = field( default=0.0 , metadata={"""help""": """If null_score - best_non_null is greater than the threshold predict null."""} ) _lowerCAmelCase = field( default=2_0 , metadata={"""help""": """If null_score - best_non_null is greater than the threshold predict null."""} ) _lowerCAmelCase = field( default=0 , metadata={ """help""": ( """language id of input for language-specific xlm models (see""" """ tokenization_xlm.PRETRAINED_INIT_CONFIGURATION)""" ) } , ) _lowerCAmelCase = field(default=1 , metadata={"""help""": """multiple threads for converting example to features"""} ) class a ( snake_case_ ): _lowerCAmelCase = """train""" _lowerCAmelCase = """dev""" class a ( snake_case_ ): _lowerCAmelCase = 4_2 _lowerCAmelCase = 4_2 _lowerCAmelCase = 4_2 _lowerCAmelCase = 4_2 def __init__( self , __magic_name__ , __magic_name__ , __magic_name__ = None , __magic_name__ = Split.train , __magic_name__ = False , __magic_name__ = None , __magic_name__ = "pt" , ) -> List[str]: _a = args _a = is_language_sensitive _a = SquadVaProcessor() if args.version_2_with_negative else SquadVaProcessor() if isinstance(__magic_name__ , __magic_name__ ): try: _a = Split[mode] except KeyError: raise KeyError('mode is not a valid split name' ) _a = mode # Load data features from cache or dataset file _a = 'v2' if args.version_2_with_negative else 'v1' _a = os.path.join( cache_dir if cache_dir is not None else args.data_dir , f'cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{version_tag}' , ) # Make sure only the first process in distributed training processes the dataset, # and the others will use the cache. _a = cached_features_file + '.lock' with FileLock(__magic_name__ ): if os.path.exists(__magic_name__ ) and not args.overwrite_cache: _a = time.time() _a = torch.load(__magic_name__ ) # Legacy cache files have only features, while new cache files # will have dataset and examples also. _a = self.old_features['features'] _a = self.old_features.get('dataset' , __magic_name__ ) _a = self.old_features.get('examples' , __magic_name__ ) logger.info( f'Loading features from cached file {cached_features_file} [took %.3f s]' , time.time() - start ) if self.dataset is None or self.examples is None: logger.warning( f'Deleting cached file {cached_features_file} will allow dataset and examples to be cached in' ' future run' ) else: if mode == Split.dev: _a = self.processor.get_dev_examples(args.data_dir ) else: _a = self.processor.get_train_examples(args.data_dir ) _a , _a = squad_convert_examples_to_features( examples=self.examples , tokenizer=__magic_name__ , max_seq_length=args.max_seq_length , doc_stride=args.doc_stride , max_query_length=args.max_query_length , is_training=mode == Split.train , threads=args.threads , return_dataset=__magic_name__ , ) _a = time.time() torch.save( {'features': self.features, 'dataset': self.dataset, 'examples': self.examples} , __magic_name__ , ) # ^ This seems to take a lot of time so I want to investigate why and how we can improve. logger.info( f'Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]' ) def __len__( self ) -> Tuple: return len(self.features ) def __getitem__( self , __magic_name__ ) -> Dict[str, torch.Tensor]: # Convert to Tensors and build dataset _a = self.features[i] _a = torch.tensor(feature.input_ids , dtype=torch.long ) _a = torch.tensor(feature.attention_mask , dtype=torch.long ) _a = torch.tensor(feature.token_type_ids , dtype=torch.long ) _a = torch.tensor(feature.cls_index , dtype=torch.long ) _a = torch.tensor(feature.p_mask , dtype=torch.float ) _a = torch.tensor(feature.is_impossible , dtype=torch.float ) _a = { 'input_ids': input_ids, 'attention_mask': attention_mask, 'token_type_ids': token_type_ids, } if self.args.model_type in ["xlm", "roberta", "distilbert", "camembert"]: del inputs["token_type_ids"] if self.args.model_type in ["xlnet", "xlm"]: inputs.update({'cls_index': cls_index, 'p_mask': p_mask} ) if self.args.version_2_with_negative: inputs.update({'is_impossible': is_impossible} ) if self.is_language_sensitive: inputs.update({'langs': (torch.ones(input_ids.shape , dtype=torch.intaa ) * self.args.lang_id)} ) if self.mode == Split.train: _a = torch.tensor(feature.start_position , dtype=torch.long ) _a = torch.tensor(feature.end_position , dtype=torch.long ) inputs.update({'start_positions': start_positions, 'end_positions': end_positions} ) return inputs
168
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available __A ={ '''configuration_bloom''': ['''BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BloomConfig''', '''BloomOnnxConfig'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =['''BloomTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ '''BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST''', '''BloomForCausalLM''', '''BloomModel''', '''BloomPreTrainedModel''', '''BloomForSequenceClassification''', '''BloomForTokenClassification''', '''BloomForQuestionAnswering''', ] if TYPE_CHECKING: from .configuration_bloom import BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP, BloomConfig, BloomOnnxConfig try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_bloom_fast import BloomTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_bloom import ( BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST, BloomForCausalLM, BloomForQuestionAnswering, BloomForSequenceClassification, BloomForTokenClassification, BloomModel, BloomPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
from __future__ import annotations lowercase_ = list[list[int]] # assigning initial values to the grid lowercase_ = [ [3, 0, 6, 5, 0, 8, 4, 0, 0], [5, 2, 0, 0, 0, 0, 0, 0, 0], [0, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] # a grid with no solution lowercase_ = [ [5, 0, 6, 5, 0, 8, 4, 0, 3], [5, 2, 0, 0, 0, 0, 0, 0, 2], [1, 8, 7, 0, 0, 0, 0, 3, 1], [0, 0, 3, 0, 1, 0, 0, 8, 0], [9, 0, 0, 8, 6, 3, 0, 0, 5], [0, 5, 0, 0, 9, 0, 6, 0, 0], [1, 3, 0, 0, 0, 0, 2, 5, 0], [0, 0, 0, 0, 0, 0, 0, 7, 4], [0, 0, 5, 2, 0, 6, 3, 0, 0], ] def a ( A__ : Tuple , A__ : Dict , A__ : List[Any] , A__ : Union[str, Any] ) -> List[str]: """simple docstring""" for i in range(9 ): if grid[row][i] == n or grid[i][column] == n: return False for i in range(3 ): for j in range(3 ): if grid[(row - row % 3) + i][(column - column % 3) + j] == n: return False return True def a ( A__ : int ) -> Any: """simple docstring""" for i in range(9 ): for j in range(9 ): if grid[i][j] == 0: return i, j return None def a ( A__ : int ) -> Optional[int]: """simple docstring""" if location := find_empty_location(lowerCamelCase__ ): _lowercase , _lowercase =location else: # If the location is ``None``, then the grid is solved. return grid for digit in range(1 , 10 ): if is_safe(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): _lowercase =digit if sudoku(lowerCamelCase__ ) is not None: return grid _lowercase =0 return None def a ( A__ : Optional[Any] ) -> Any: """simple docstring""" for row in grid: for cell in row: print(lowerCamelCase__ , end=' ' ) print() if __name__ == "__main__": # make a copy of grid so that you can compare with the unmodified grid for example_grid in (initial_grid, no_solution): print('\nExample grid:\n' + '=' * 2_0) print_solution(example_grid) print('\nExample grid solution:') lowercase_ = sudoku(example_grid) if solution is not None: print_solution(solution) else: print('Cannot find a solution.')
205
from __future__ import annotations import unittest from transformers import EsmConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers.models.esm.modeling_tf_esm import ( TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, TFEsmModel, ) class _SCREAMING_SNAKE_CASE : def __init__( self , lowercase , ) -> Optional[int]: lowerCamelCase_ = parent lowerCamelCase_ = 13 lowerCamelCase_ = 7 lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = True lowerCamelCase_ = 99 lowerCamelCase_ = 32 lowerCamelCase_ = 2 lowerCamelCase_ = 4 lowerCamelCase_ = 37 lowerCamelCase_ = "gelu" lowerCamelCase_ = 0.1 lowerCamelCase_ = 0.1 lowerCamelCase_ = 512 lowerCamelCase_ = 16 lowerCamelCase_ = 2 lowerCamelCase_ = 0.0_2 lowerCamelCase_ = 3 lowerCamelCase_ = 4 lowerCamelCase_ = None def SCREAMING_SNAKE_CASE_( self ) -> Any: lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCamelCase_ = None if self.use_input_mask: lowerCamelCase_ = random_attention_mask([self.batch_size, self.seq_length] ) lowerCamelCase_ = None lowerCamelCase_ = None lowerCamelCase_ = None if self.use_labels: lowerCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) lowerCamelCase_ = ids_tensor([self.batch_size] , self.num_choices ) lowerCamelCase_ = EsmConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , pad_token_id=1 , 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 , initializer_range=self.initializer_range , ) return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels def SCREAMING_SNAKE_CASE_( self ) -> List[str]: ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = self.prepare_config_and_inputs() lowerCamelCase_ = True lowerCamelCase_ = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) lowerCamelCase_ = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2 ) return ( config, input_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Any: lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> Tuple: lowerCamelCase_ = True lowerCamelCase_ = TFEsmModel(config=lowercase ) lowerCamelCase_ = { "input_ids": input_ids, "attention_mask": input_mask, "encoder_hidden_states": encoder_hidden_states, "encoder_attention_mask": encoder_attention_mask, } lowerCamelCase_ = model(lowercase ) lowerCamelCase_ = [input_ids, input_mask] lowerCamelCase_ = model(lowercase , encoder_hidden_states=lowercase ) # Also check the case where encoder outputs are not passed lowerCamelCase_ = model(lowercase , attention_mask=lowercase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> Optional[int]: lowerCamelCase_ = TFEsmForMaskedLM(config=lowercase ) lowerCamelCase_ = model([input_ids, input_mask] ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: lowerCamelCase_ = self.num_labels lowerCamelCase_ = TFEsmForTokenClassification(config=lowercase ) lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} lowerCamelCase_ = model(lowercase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.prepare_config_and_inputs() ( ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ( lowerCamelCase_ ) , ) = config_and_inputs lowerCamelCase_ = {"input_ids": input_ids, "attention_mask": input_mask} return config, inputs_dict @require_tf class _SCREAMING_SNAKE_CASE ( snake_case_ , snake_case_ , unittest.TestCase ): lowerCAmelCase__ = ( ( TFEsmModel, TFEsmForMaskedLM, TFEsmForSequenceClassification, TFEsmForTokenClassification, ) if is_tf_available() else () ) lowerCAmelCase__ = ( { 'feature-extraction': TFEsmModel, 'fill-mask': TFEsmForMaskedLM, 'text-classification': TFEsmForSequenceClassification, 'token-classification': TFEsmForTokenClassification, 'zero-shot': TFEsmForSequenceClassification, } if is_tf_available() else {} ) lowerCAmelCase__ = False lowerCAmelCase__ = False def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = TFEsmModelTester(self ) lowerCamelCase_ = ConfigTester(self , config_class=lowercase , hidden_size=37 ) def SCREAMING_SNAKE_CASE_( self ) -> Any: self.config_tester.run_common_tests() def SCREAMING_SNAKE_CASE_( self ) -> str: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> List[str]: lowerCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*lowercase ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Dict: for model_name in TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: lowerCamelCase_ = TFEsmModel.from_pretrained(lowercase ) self.assertIsNotNone(lowercase ) @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> List[Any]: pass @unittest.skip("Protein models do not support embedding resizing." ) def SCREAMING_SNAKE_CASE_( self ) -> Any: pass def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ , lowerCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: lowerCamelCase_ = model_class(lowercase ) assert isinstance(model.get_input_embeddings() , tf.keras.layers.Layer ) if model_class is TFEsmForMaskedLM: # Output embedding test differs from the main test because they're a matrix, not a layer lowerCamelCase_ = model.get_bias() assert isinstance(lowercase , lowercase ) for k, v in name.items(): assert isinstance(lowercase , tf.Variable ) else: lowerCamelCase_ = model.get_output_embeddings() assert x is None lowerCamelCase_ = model.get_bias() assert name is None @require_tf class _SCREAMING_SNAKE_CASE ( unittest.TestCase ): @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmForMaskedLM.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 1, 2, 3, 4, 5]] ) lowerCamelCase_ = model(lowercase )[0] lowerCamelCase_ = [1, 6, 33] self.assertEqual(list(output.numpy().shape ) , lowercase ) # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [8.9_2_1_5_1_8, -1_0.5_8_9_8_1_4, -6.4_6_7_1_3_0_7], [-6.3_9_6_7_1_5_6, -1_3.9_1_1_3_7_7, -1.1_2_1_1_9_1_5], [-7.7_8_1_2_4_7, -1_3.9_5_1_5_5_7, -3.7_4_0_5_9_2], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-2 ) ) @slow def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: lowerCamelCase_ = TFEsmModel.from_pretrained("facebook/esm2_t6_8M_UR50D" ) lowerCamelCase_ = tf.constant([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]] ) lowerCamelCase_ = model(lowercase )[0] # compare the actual values for a slice. lowerCamelCase_ = tf.constant( [ [ [0.1_4_4_4_3_0_9_2, 0.5_4_1_2_5_3_2_7, 0.3_2_4_7_7_3_9], [0.3_0_3_4_0_4_8_4, 0.0_0_5_2_6_6_7_6, 0.3_1_0_7_7_7_2_2], [0.3_2_2_7_8_0_4_3, -0.2_4_9_8_7_0_9_6, 0.3_4_1_4_6_2_8], ] ] ) self.assertTrue(numpy.allclose(output[:, :3, :3].numpy() , expected_slice.numpy() , atol=1e-4 ) )
19
0
lowerCAmelCase__ = {str(digit): digit**5 for digit in range(10)} def _UpperCAmelCase (UpperCamelCase__ : List[Any] ): return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCamelCase__ ) ) def _UpperCAmelCase (): return sum( number for number in range(1000 , 1000000 ) if number == digits_fifth_powers_sum(lowerCamelCase__ ) ) if __name__ == "__main__": print(solution())
11
import importlib.util import json import os import warnings from dataclasses import dataclass, field import torch from ..training_args import TrainingArguments from ..utils import cached_property, is_sagemaker_dp_enabled, logging __A =logging.get_logger(__name__) def lowerCamelCase_ ( ): # Get the sagemaker specific mp parameters from smp_options variable. lowerCamelCase_ = os.getenv("SM_HP_MP_PARAMETERS" , "{}" ) try: # Parse it and check the field "partitions" is included, it is required for model parallel. lowerCamelCase_ = json.loads(lowerCamelCase__ ) if "partitions" not in smp_options: return False except json.JSONDecodeError: return False # Get the sagemaker specific framework parameters from mpi_options variable. lowerCamelCase_ = os.getenv("SM_FRAMEWORK_PARAMS" , "{}" ) try: # Parse it and check the field "sagemaker_distributed_dataparallel_enabled". lowerCamelCase_ = json.loads(lowerCamelCase__ ) if not mpi_options.get("sagemaker_mpi_enabled" , lowerCamelCase__ ): return False except json.JSONDecodeError: return False # Lastly, check if the `smdistributed` module is present. return importlib.util.find_spec("smdistributed" ) is not None if is_sagemaker_model_parallel_available(): import smdistributed.modelparallel.torch as smp smp.init() @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = field( default='' , metadata={'help': 'Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'} , ) def SCREAMING_SNAKE_CASE_( self ) -> Tuple: super().__post_init__() warnings.warn( "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use " "`TrainingArguments` instead." , lowercase , ) @cached_property def SCREAMING_SNAKE_CASE_( self ) -> "torch.device": logger.info("PyTorch: setting up devices" ) if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1: logger.warning( "torch.distributed process group is initialized, but local_rank == -1. " "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch" ) if self.no_cuda: lowerCamelCase_ = torch.device("cpu" ) lowerCamelCase_ = 0 elif is_sagemaker_model_parallel_available(): lowerCamelCase_ = smp.local_rank() lowerCamelCase_ = torch.device("cuda" , lowercase ) lowerCamelCase_ = 1 elif is_sagemaker_dp_enabled(): import smdistributed.dataparallel.torch.torch_smddp # noqa: F401 torch.distributed.init_process_group(backend="smddp" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = int(os.getenv("SMDATAPARALLEL_LOCAL_RANK" ) ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 elif self.local_rank == -1: # if n_gpu is > 1 we'll use nn.DataParallel. # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0` # Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will # trigger an error that a device index is missing. Index 0 takes into account the # GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0` # will use the first GPU in that env, i.e. GPU#1 lowerCamelCase_ = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" ) # Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at # the default value. lowerCamelCase_ = torch.cuda.device_count() else: # Here, we'll use torch.distributed. # Initializes the distributed backend which will take care of synchronizing nodes/GPUs if not torch.distributed.is_initialized(): torch.distributed.init_process_group(backend="nccl" , timeout=self.ddp_timeout_delta ) lowerCamelCase_ = torch.device("cuda" , self.local_rank ) lowerCamelCase_ = 1 if device.type == "cuda": torch.cuda.set_device(lowercase ) return device @property def SCREAMING_SNAKE_CASE_( self ) -> Tuple: if is_sagemaker_model_parallel_available(): return smp.dp_size() return super().world_size @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: return not is_sagemaker_model_parallel_available() @property def SCREAMING_SNAKE_CASE_( self ) -> Dict: return False
19
0
'''simple docstring''' from cva import destroyAllWindows, imread, imshow, waitKey def __lowerCAmelCase ( UpperCamelCase__ ) -> Any: # getting number of pixels in the image __lowerCamelCase , __lowerCamelCase = img.shape[0], img.shape[1] # converting each pixel's color to its negative for i in range(lowerCamelCase__ ): for j in range(lowerCamelCase__ ): __lowerCamelCase = [2_55, 2_55, 2_55] - img[i][j] return img if __name__ == "__main__": # read original image __UpperCAmelCase =imread("image_data/lena.jpg", 1) # convert to its negative __UpperCAmelCase =convert_to_negative(img) # show result image imshow("negative of original image", img) waitKey(0) destroyAllWindows()
67
import math def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 0 , lowerCamelCase__ = 0 ): lowerCamelCase_ = end or len(lowerCamelCase__ ) for i in range(lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = i lowerCamelCase_ = array[i] while temp_index != start and temp_index_value < array[temp_index - 1]: lowerCamelCase_ = array[temp_index - 1] temp_index -= 1 lowerCamelCase_ = temp_index_value return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): # Max Heap lowerCamelCase_ = index lowerCamelCase_ = 2 * index + 1 # Left Node lowerCamelCase_ = 2 * index + 2 # Right Node if left_index < heap_size and array[largest] < array[left_index]: lowerCamelCase_ = left_index if right_index < heap_size and array[largest] < array[right_index]: lowerCamelCase_ = right_index if largest != index: lowerCamelCase_ , lowerCamelCase_ = array[largest], array[index] heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ ): lowerCamelCase_ = len(lowerCamelCase__ ) for i in range(n // 2 , -1 , -1 ): heapify(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) for i in range(n - 1 , 0 , -1 ): lowerCamelCase_ , lowerCamelCase_ = array[0], array[i] heapify(lowerCamelCase__ , 0 , lowerCamelCase__ ) return array def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): if (array[first_index] > array[middle_index]) != ( array[first_index] > array[last_index] ): return array[first_index] elif (array[middle_index] > array[first_index]) != ( array[middle_index] > array[last_index] ): return array[middle_index] else: return array[last_index] def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): lowerCamelCase_ = low lowerCamelCase_ = high while True: while array[i] < pivot: i += 1 j -= 1 while pivot < array[j]: j -= 1 if i >= j: return i lowerCamelCase_ , lowerCamelCase_ = array[j], array[i] i += 1 def lowerCamelCase_ ( lowerCamelCase__ ): if len(lowerCamelCase__ ) == 0: return array lowerCamelCase_ = 2 * math.ceil(math.loga(len(lowerCamelCase__ ) ) ) lowerCamelCase_ = 1_6 return intro_sort(lowerCamelCase__ , 0 , len(lowerCamelCase__ ) , lowerCamelCase__ , lowerCamelCase__ ) def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ): while end - start > size_threshold: if max_depth == 0: return heap_sort(lowerCamelCase__ ) max_depth -= 1 lowerCamelCase_ = median_of_a(lowerCamelCase__ , lowerCamelCase__ , start + ((end - start) // 2) + 1 , end - 1 ) lowerCamelCase_ = partition(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) intro_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = p return insertion_sort(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": import doctest doctest.testmod() __A =input('''Enter numbers separated by a comma : ''').strip() __A =[float(item) for item in user_input.split(''',''')] print(sort(unsorted))
19
0
import importlib import sys from argparse import REMAINDER, ArgumentParser from pathlib import Path import torch_xla.distributed.xla_multiprocessing as xmp def _lowerCAmelCase ( )->List[Any]: '''simple docstring''' snake_case_ = ArgumentParser( description=( "PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes" ) ) # Optional arguments for the launch helper parser.add_argument("--num_cores" , type=lowerCamelCase__ , default=1 , help="Number of TPU cores to use (1 or 8)." ) # positional parser.add_argument( "training_script" , type=lowerCamelCase__ , help=( "The full path to the single TPU training " "program/script to be launched in parallel, " "followed by all the arguments for the " "training script" ) , ) # rest from the training program parser.add_argument("training_script_args" , nargs=lowerCamelCase__ ) return parser.parse_args() def _lowerCAmelCase ( )->Any: '''simple docstring''' snake_case_ = parse_args() # Import training_script as a module. snake_case_ = Path(args.training_script ) sys.path.append(str(script_fpath.parent.resolve() ) ) snake_case_ = script_fpath.stem snake_case_ = importlib.import_module(lowerCamelCase__ ) # Patch sys.argv snake_case_ = [args.training_script] + args.training_script_args + ["--tpu_num_cores", str(args.num_cores )] xmp.spawn(mod._mp_fn , args=() , nprocs=args.num_cores ) if __name__ == "__main__": main()
159
import math import time from typing import Dict, List, Optional from torch.utils.data import Dataset from transformers import SeqaSeqTrainer, is_torch_tpu_available from transformers.trainer_utils import PredictionOutput, speed_metrics if is_torch_tpu_available(check_device=False): import torch_xla.core.xla_model as xm import torch_xla.debug.metrics as met class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , *lowercase , lowercase=None , lowercase=None , **lowercase ) -> List[str]: super().__init__(*lowercase , **lowercase ) lowerCamelCase_ = eval_examples lowerCamelCase_ = post_process_function def SCREAMING_SNAKE_CASE_( self , lowercase = None , lowercase=None , lowercase = None , lowercase = "eval" , **lowercase , ) -> Dict[str, float]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = ( gen_kwargs["max_length"] if gen_kwargs.get("max_length" ) is not None else self.args.generation_max_length ) lowerCamelCase_ = ( gen_kwargs["num_beams"] if gen_kwargs.get("num_beams" ) is not None else self.args.generation_num_beams ) lowerCamelCase_ = gen_kwargs lowerCamelCase_ = self.eval_dataset if eval_dataset is None else eval_dataset lowerCamelCase_ = self.get_eval_dataloader(lowercase ) lowerCamelCase_ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Evaluation" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save: # Only the main node write the results by default lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) else: lowerCamelCase_ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(lowercase ) if self.args.tpu_metrics_debug or self.args.debug: # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.) xm.master_print(met.metrics_report() ) lowerCamelCase_ = self.callback_handler.on_evaluate(self.args , self.state , self.control , lowercase ) return metrics def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase=None , lowercase = "test" , **lowercase ) -> Union[str, Any]: lowerCamelCase_ = gen_kwargs.copy() lowerCamelCase_ = self.get_test_dataloader(lowercase ) # Temporarily disable metric computation, we will do it in the loop here. lowerCamelCase_ = self.compute_metrics lowerCamelCase_ = None lowerCamelCase_ = time.time() lowerCamelCase_ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: lowerCamelCase_ = eval_loop( lowercase , description="Prediction" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=lowercase , metric_key_prefix=lowercase , ) finally: lowerCamelCase_ = compute_metrics lowerCamelCase_ = self.args.eval_batch_size * self.args.world_size if f'{metric_key_prefix}_jit_compilation_time' in output.metrics: start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time'] output.metrics.update( speed_metrics( lowercase , lowercase , num_samples=output.num_samples , num_steps=math.ceil(output.num_samples / total_batch_size ) , ) ) if self.post_process_function is None or self.compute_metrics is None: return output lowerCamelCase_ = self.post_process_function(lowercase , lowercase , lowercase , "predict" ) lowerCamelCase_ = self.compute_metrics(lowercase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f'{metric_key_prefix}_' ): lowerCamelCase_ = metrics.pop(lowercase ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=lowercase )
19
0
"""simple docstring""" import unittest from transformers import is_torch_available from transformers.testing_utils import require_torch if is_torch_available(): import torch from transformers.generation import DisjunctiveConstraint @require_torch class _UpperCamelCase ( unittest.TestCase ): '''simple docstring''' def snake_case ( self ): # For consistency across different places the DisjunctiveConstraint is called, # dc.token_ids is a list of integers. It is also initialized only by integers. __lowerCAmelCase = [[1, 2, 4], [1, 2, 3, 4]] __lowerCAmelCase = DisjunctiveConstraint(__a ) self.assertTrue(isinstance(dc.token_ids , __a ) ) with self.assertRaises(__a ): DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]] ) ) with self.assertRaises(__a ): DisjunctiveConstraint([torch.LongTensor([1, 2, 4] ), torch.LongTensor([1, 2, 3, 4, 5] )] ) def snake_case ( self ): # We can't have constraints that are complete subsets of another. This leads to a preverse # interpretation of "constraint fulfillment": does generating [1,2,3] fulfill the constraint? # It would mean that it generated [1,2] which fulfills it, but it's in the middle of potentially # fulfilling [1,2,3,4]. If we believe that [1,2,3] does fulfill the constraint, then the algorithm # will necessarily never reach [1,2,3,4], giving users a false sense of control (better to just not allow it). __lowerCAmelCase = [[1, 2], [1, 2, 3, 4]] with self.assertRaises(__a ): DisjunctiveConstraint(__a ) # fails here def snake_case ( self ): __lowerCAmelCase = [[1, 2, 3], [1, 2, 4]] __lowerCAmelCase = DisjunctiveConstraint(__a ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(1 ) __lowerCAmelCase = stepped is True and completed is False and reset is False self.assertTrue(__a ) self.assertTrue(not dc.completed ) self.assertTrue(dc.current_seq == [1] ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(2 ) __lowerCAmelCase = stepped is True and completed is False and reset is False self.assertTrue(__a ) self.assertTrue(not dc.completed ) self.assertTrue(dc.current_seq == [1, 2] ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(3 ) __lowerCAmelCase = stepped is True and completed is True and reset is False self.assertTrue(__a ) self.assertTrue(dc.completed ) # Completed! self.assertTrue(dc.current_seq == [1, 2, 3] ) def snake_case ( self ): __lowerCAmelCase = [[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]] __lowerCAmelCase = DisjunctiveConstraint(__a ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(1 ) self.assertTrue(not dc.completed ) self.assertTrue(dc.current_seq == [1] ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(2 ) self.assertTrue(not dc.completed ) self.assertTrue(dc.current_seq == [1, 2] ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(4 ) self.assertTrue(not dc.completed ) self.assertTrue(dc.current_seq == [1, 2, 4] ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(5 ) self.assertTrue(dc.completed ) # Completed! self.assertTrue(dc.current_seq == [1, 2, 4, 5] ) dc.reset() __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(1 ) self.assertTrue(not dc.completed ) self.assertTrue(dc.remaining() == 3 ) self.assertTrue(dc.current_seq == [1] ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(2 ) self.assertTrue(not dc.completed ) self.assertTrue(dc.remaining() == 2 ) self.assertTrue(dc.current_seq == [1, 2] ) __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = dc.update(5 ) self.assertTrue(dc.completed ) # Completed! self.assertTrue(dc.remaining() == 0 ) self.assertTrue(dc.current_seq == [1, 2, 5] )
57
from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import PIL import torch from transformers import CLIPImageProcessor, CLIPVisionModel from ...models import PriorTransformer from ...pipelines import DiffusionPipeline from ...schedulers import HeunDiscreteScheduler from ...utils import ( BaseOutput, is_accelerate_available, logging, randn_tensor, replace_example_docstring, ) from .renderer import ShapERenderer __A =logging.get_logger(__name__) # pylint: disable=invalid-name __A =''' Examples: ```py >>> from PIL import Image >>> import torch >>> from diffusers import DiffusionPipeline >>> from diffusers.utils import export_to_gif, load_image >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu") >>> repo = "openai/shap-e-img2img" >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16) >>> pipe = pipe.to(device) >>> guidance_scale = 3.0 >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png" >>> image = load_image(image_url).convert("RGB") >>> images = pipe( ... image, ... guidance_scale=guidance_scale, ... num_inference_steps=64, ... frame_size=256, ... ).images >>> gif_path = export_to_gif(images[0], "corgi_3d.gif") ``` ''' @dataclass class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = 42 class _SCREAMING_SNAKE_CASE ( snake_case_ ): def __init__( self , lowercase , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: super().__init__() self.register_modules( prior=lowercase , image_encoder=lowercase , image_processor=lowercase , scheduler=lowercase , renderer=lowercase , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , lowercase , lowercase ) -> int: if latents is None: lowerCamelCase_ = randn_tensor(lowercase , generator=lowercase , device=lowercase , dtype=lowercase ) else: if latents.shape != shape: raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {shape}' ) lowerCamelCase_ = latents.to(lowercase ) lowerCamelCase_ = latents * scheduler.init_noise_sigma return latents def SCREAMING_SNAKE_CASE_( self , lowercase=0 ) -> int: if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError("Please install accelerate via `pip install accelerate`" ) lowerCamelCase_ = torch.device(f'cuda:{gpu_id}' ) lowerCamelCase_ = [self.image_encoder, self.prior] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(lowercase , lowercase ) @property def SCREAMING_SNAKE_CASE_( self ) -> List[str]: if self.device != torch.device("meta" ) or not hasattr(self.image_encoder , "_hf_hook" ): return self.device for module in self.image_encoder.modules(): if ( hasattr(lowercase , "_hf_hook" ) and hasattr(module._hf_hook , "execution_device" ) and module._hf_hook.execution_device is not None ): return torch.device(module._hf_hook.execution_device ) return self.device def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , ) -> List[str]: if isinstance(lowercase , lowercase ) and isinstance(image[0] , torch.Tensor ): lowerCamelCase_ = torch.cat(lowercase , axis=0 ) if image[0].ndim == 4 else torch.stack(lowercase , axis=0 ) if not isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = self.image_processor(lowercase , return_tensors="pt" ).pixel_values[0].unsqueeze(0 ) lowerCamelCase_ = image.to(dtype=self.image_encoder.dtype , device=lowercase ) lowerCamelCase_ = self.image_encoder(lowercase )["last_hidden_state"] lowerCamelCase_ = image_embeds[:, 1:, :].contiguous() # batch_size, dim, 256 lowerCamelCase_ = image_embeds.repeat_interleave(lowercase , dim=0 ) if do_classifier_free_guidance: lowerCamelCase_ = torch.zeros_like(lowercase ) # For classifier free guidance, we need to do two forward passes. # Here we concatenate the unconditional and text embeddings into a single batch # to avoid doing two forward passes lowerCamelCase_ = torch.cat([negative_image_embeds, image_embeds] ) return image_embeds @torch.no_grad() @replace_example_docstring(lowercase ) def __call__( self , lowercase , lowercase = 1 , lowercase = 25 , lowercase = None , lowercase = None , lowercase = 4.0 , lowercase = 64 , lowercase = "pil" , lowercase = True , ) -> Union[str, Any]: if isinstance(lowercase , PIL.Image.Image ): lowerCamelCase_ = 1 elif isinstance(lowercase , torch.Tensor ): lowerCamelCase_ = image.shape[0] elif isinstance(lowercase , lowercase ) and isinstance(image[0] , (torch.Tensor, PIL.Image.Image) ): lowerCamelCase_ = len(lowercase ) else: raise ValueError( f'`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(lowercase )}' ) lowerCamelCase_ = self._execution_device lowerCamelCase_ = batch_size * num_images_per_prompt lowerCamelCase_ = guidance_scale > 1.0 lowerCamelCase_ = self._encode_image(lowercase , lowercase , lowercase , lowercase ) # prior self.scheduler.set_timesteps(lowercase , device=lowercase ) lowerCamelCase_ = self.scheduler.timesteps lowerCamelCase_ = self.prior.config.num_embeddings lowerCamelCase_ = self.prior.config.embedding_dim lowerCamelCase_ = self.prepare_latents( (batch_size, num_embeddings * embedding_dim) , image_embeds.dtype , lowercase , lowercase , lowercase , self.scheduler , ) # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim lowerCamelCase_ = latents.reshape(latents.shape[0] , lowercase , lowercase ) for i, t in enumerate(self.progress_bar(lowercase ) ): # expand the latents if we are doing classifier free guidance lowerCamelCase_ = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents lowerCamelCase_ = self.scheduler.scale_model_input(lowercase , lowercase ) lowerCamelCase_ = self.prior( lowercase , timestep=lowercase , proj_embedding=lowercase , ).predicted_image_embedding # remove the variance lowerCamelCase_ , lowerCamelCase_ = noise_pred.split( scaled_model_input.shape[2] , dim=2 ) # batch_size, num_embeddings, embedding_dim if do_classifier_free_guidance is not None: lowerCamelCase_ , lowerCamelCase_ = noise_pred.chunk(2 ) lowerCamelCase_ = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond) lowerCamelCase_ = self.scheduler.step( lowercase , timestep=lowercase , sample=lowercase , ).prev_sample if output_type == "latent": return ShapEPipelineOutput(images=lowercase ) lowerCamelCase_ = [] for i, latent in enumerate(lowercase ): print() lowerCamelCase_ = self.renderer.decode( latent[None, :] , lowercase , size=lowercase , ray_batch_size=4096 , n_coarse_samples=64 , n_fine_samples=128 , ) images.append(lowercase ) lowerCamelCase_ = torch.stack(lowercase ) if output_type not in ["np", "pil"]: raise ValueError(f'Only the output types `pil` and `np` are supported not output_type={output_type}' ) lowerCamelCase_ = images.cpu().numpy() if output_type == "pil": lowerCamelCase_ = [self.numpy_to_pil(lowercase ) for image in images] # Offload last model to CPU if hasattr(self , "final_offload_hook" ) and self.final_offload_hook is not None: self.final_offload_hook.offload() if not return_dict: return (images,) return ShapEPipelineOutput(images=lowercase )
19
0
from argparse import ArgumentParser from datasets.commands.convert import ConvertCommand from datasets.commands.dummy_data import DummyDataCommand from datasets.commands.env import EnvironmentCommand from datasets.commands.run_beam import RunBeamCommand from datasets.commands.test import TestCommand from datasets.utils.logging import set_verbosity_info def __lowercase ( a__ ) -> Optional[Any]: return {key.lstrip('-' ): value for key, value in zip(unknown_args[::2] , unknown_args[1::2] )} def __lowercase ( ) -> Dict: __SCREAMING_SNAKE_CASE = ArgumentParser( 'HuggingFace Datasets CLI tool' , usage='datasets-cli <command> [<args>]' , allow_abbrev=lowerCamelCase__ ) __SCREAMING_SNAKE_CASE = parser.add_subparsers(help='datasets-cli command helpers' ) set_verbosity_info() # Register commands ConvertCommand.register_subcommand(lowerCamelCase__ ) EnvironmentCommand.register_subcommand(lowerCamelCase__ ) TestCommand.register_subcommand(lowerCamelCase__ ) RunBeamCommand.register_subcommand(lowerCamelCase__ ) DummyDataCommand.register_subcommand(lowerCamelCase__ ) # Parse args __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE = parser.parse_known_args() if not hasattr(lowerCamelCase__ , 'func' ): parser.print_help() exit(1 ) __SCREAMING_SNAKE_CASE = parse_unknown_args(lowerCamelCase__ ) # Run __SCREAMING_SNAKE_CASE = args.func(lowerCamelCase__ , **lowerCamelCase__ ) service.run() if __name__ == "__main__": main()
257
from collections import defaultdict from graphs.minimum_spanning_tree_prims import prisms_algorithm as mst def lowerCamelCase_ ( ): lowerCamelCase_ , lowerCamelCase_ = 9, 1_4 # noqa: F841 lowerCamelCase_ = [ [0, 1, 4], [0, 7, 8], [1, 2, 8], [7, 8, 7], [7, 6, 1], [2, 8, 2], [8, 6, 6], [2, 3, 7], [2, 5, 4], [6, 5, 2], [3, 5, 1_4], [3, 4, 9], [5, 4, 1_0], [1, 7, 1_1], ] lowerCamelCase_ = defaultdict(lowerCamelCase__ ) for nodea, nodea, cost in edges: adjancency[nodea].append([nodea, cost] ) adjancency[nodea].append([nodea, cost] ) lowerCamelCase_ = mst(lowerCamelCase__ ) lowerCamelCase_ = [ [7, 6, 1], [2, 8, 2], [6, 5, 2], [0, 1, 4], [2, 5, 4], [2, 3, 7], [0, 7, 8], [3, 4, 9], ] for answer in expected: lowerCamelCase_ = tuple(answer[:2] ) lowerCamelCase_ = tuple(edge[::-1] ) assert edge in result or reverse in result
19
0
"""simple docstring""" from typing import Dict import numpy as np import torch from . import residue_constants as rc from .tensor_utils import tensor_tree_map, tree_map def _snake_case ( snake_case__ : Optional[int] ): A = [] A = [] A = [] for rt in rc.restypes: A = rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]] restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names] ) A = {name: i for i, name in enumerate(lowerCamelCase__ )} restype_atomaa_to_atomaa_list.append( [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types] ) restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names] ) # Add dummy mapping for restype 'UNK' restype_atomaa_to_atomaa_list.append([0] * 14 ) restype_atomaa_to_atomaa_list.append([0] * 37 ) restype_atomaa_mask_list.append([0.0] * 14 ) A = torch.tensor( lowerCamelCase__ , dtype=torch.intaa , device=protein['aatype'].device , ) A = torch.tensor( lowerCamelCase__ , dtype=torch.intaa , device=protein['aatype'].device , ) A = torch.tensor( lowerCamelCase__ , dtype=torch.floataa , device=protein['aatype'].device , ) A = protein['aatype'].to(torch.long ) # create the mapping for (residx, atom14) --> atom37, i.e. an array # with shape (num_res, 14) containing the atom37 indices for this protein A = restype_atomaa_to_atomaa[protein_aatype] A = restype_atomaa_mask[protein_aatype] A = residx_atomaa_mask A = residx_atomaa_to_atomaa.long() # create the gather indices for mapping back A = restype_atomaa_to_atomaa[protein_aatype] A = residx_atomaa_to_atomaa.long() # create the corresponding mask A = torch.zeros([21, 37] , dtype=torch.floataa , device=protein['aatype'].device ) for restype, restype_letter in enumerate(rc.restypes ): A = rc.restype_atoa[restype_letter] A = rc.residue_atoms[restype_name] for atom_name in atom_names: A = rc.atom_order[atom_name] A = 1 A = restype_atomaa_mask[protein_aatype] A = residx_atomaa_mask return protein def _snake_case ( snake_case__ : List[Any] ): A = tree_map(lambda snake_case__ : torch.tensor(lowerCamelCase__ , device=batch['aatype'].device ) , lowerCamelCase__ , np.ndarray ) A = tensor_tree_map(lambda snake_case__ : np.array(lowerCamelCase__ ) , make_atomaa_masks(lowerCamelCase__ ) ) return out
74
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, # specifically showcasing the experiment tracking capability, # and builds off the `nlp_example.py` script. # # 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 help focus on the differences in the code, building `DataLoaders` # was refactored into its own function. # New additions from the base script can be found quickly by # looking for the # New Code # tags # # 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 # ######################################################################## __A =1_6 __A =3_2 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ = 1_6 ): lowerCamelCase_ = AutoTokenizer.from_pretrained("bert-base-cased" ) lowerCamelCase_ = load_dataset("glue" , "mrpc" ) def tokenize_function(lowerCamelCase__ ): # max_length=None => use the model max length (it's actually the default) lowerCamelCase_ = tokenizer(examples["sentence1"] , examples["sentence2"] , truncation=lowerCamelCase__ , max_length=lowerCamelCase__ ) 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(): lowerCamelCase_ = datasets.map( lowerCamelCase__ , batched=lowerCamelCase__ , 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 lowerCamelCase_ = tokenized_datasets.rename_column("label" , "labels" ) def collate_fn(lowerCamelCase__ ): # On TPU it's best to pad everything to the same length or training will be very slow. lowerCamelCase_ = 1_2_8 if accelerator.distributed_type == DistributedType.TPU else None # When using mixed precision we want round multiples of 8/16 if accelerator.mixed_precision == "fp8": lowerCamelCase_ = 1_6 elif accelerator.mixed_precision != "no": lowerCamelCase_ = 8 else: lowerCamelCase_ = None return tokenizer.pad( lowerCamelCase__ , padding="longest" , max_length=lowerCamelCase__ , pad_to_multiple_of=lowerCamelCase__ , return_tensors="pt" , ) # Instantiate dataloaders. lowerCamelCase_ = DataLoader( tokenized_datasets["train"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) lowerCamelCase_ = DataLoader( tokenized_datasets["validation"] , shuffle=lowerCamelCase__ , collate_fn=lowerCamelCase__ , batch_size=lowerCamelCase__ ) 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 __A =mocked_dataloaders # noqa: F811 def lowerCamelCase_ ( lowerCamelCase__ , lowerCamelCase__ ): # For testing only if os.environ.get("TESTING_MOCKED_DATALOADERS" , lowerCamelCase__ ) == "1": lowerCamelCase_ = 2 # Initialize Accelerator # New Code # # We pass in "all" to `log_with` to grab all available trackers in the environment # Note: If using a custom `Tracker` class, should be passed in here such as: # >>> log_with = ["all", MyCustomTrackerClassInstance()] if args.with_tracking: lowerCamelCase_ = Accelerator( cpu=args.cpu , mixed_precision=args.mixed_precision , log_with="all" , project_dir=args.project_dir ) else: lowerCamelCase_ = Accelerator(cpu=args.cpu , mixed_precision=args.mixed_precision ) # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs lowerCamelCase_ = config["lr"] lowerCamelCase_ = int(config["num_epochs"] ) lowerCamelCase_ = int(config["seed"] ) lowerCamelCase_ = int(config["batch_size"] ) set_seed(lowerCamelCase__ ) lowerCamelCase_ , lowerCamelCase_ = get_dataloaders(lowerCamelCase__ , lowerCamelCase__ ) lowerCamelCase_ = evaluate.load("glue" , "mrpc" ) # If the batch size is too big we use gradient accumulation lowerCamelCase_ = 1 if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU: lowerCamelCase_ = batch_size // MAX_GPU_BATCH_SIZE lowerCamelCase_ = MAX_GPU_BATCH_SIZE # Instantiate the model (we build the model here so that the seed also control new weights initialization) lowerCamelCase_ = AutoModelForSequenceClassification.from_pretrained("bert-base-cased" , return_dict=lowerCamelCase__ ) # 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). lowerCamelCase_ = model.to(accelerator.device ) # Instantiate optimizer lowerCamelCase_ = AdamW(params=model.parameters() , lr=lowerCamelCase__ ) # Instantiate scheduler lowerCamelCase_ = get_linear_schedule_with_warmup( optimizer=lowerCamelCase__ , num_warmup_steps=1_0_0 , num_training_steps=(len(lowerCamelCase__ ) * num_epochs) // gradient_accumulation_steps , ) # 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. lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = accelerator.prepare( lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) # New Code # # We need to initialize the trackers we use. Overall configurations can also be stored if args.with_tracking: lowerCamelCase_ = os.path.split(lowerCamelCase__ )[-1].split("." )[0] accelerator.init_trackers(lowerCamelCase__ , lowerCamelCase__ ) # Now we train the model for epoch in range(lowerCamelCase__ ): model.train() # New Code # # For our tracking example, we will log the total loss of each epoch if args.with_tracking: lowerCamelCase_ = 0 for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True`. batch.to(accelerator.device ) lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.loss # New Code # if args.with_tracking: total_loss += loss.detach().float() lowerCamelCase_ = loss / gradient_accumulation_steps accelerator.backward(lowerCamelCase__ ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() model.eval() for step, batch in enumerate(lowerCamelCase__ ): # We could avoid this line since we set the accelerator with `device_placement=True` (the default). batch.to(accelerator.device ) with torch.no_grad(): lowerCamelCase_ = model(**lowerCamelCase__ ) lowerCamelCase_ = outputs.logits.argmax(dim=-1 ) lowerCamelCase_ , lowerCamelCase_ = accelerator.gather_for_metrics((predictions, batch["labels"]) ) metric.add_batch( predictions=lowerCamelCase__ , references=lowerCamelCase__ , ) lowerCamelCase_ = metric.compute() # Use accelerator.print to print only on the main process. accelerator.print(F'epoch {epoch}:' , lowerCamelCase__ ) # New Code # # To actually log, we call `Accelerator.log` # The values passed can be of `str`, `int`, `float` or `dict` of `str` to `float`/`int` if args.with_tracking: accelerator.log( { "accuracy": eval_metric["accuracy"], "f1": eval_metric["f1"], "train_loss": total_loss.item() / len(lowerCamelCase__ ), "epoch": epoch, } , step=lowerCamelCase__ , ) # New Code # # When a run is finished, you should call `accelerator.end_training()` # to close all of the open trackers if args.with_tracking: accelerator.end_training() def lowerCamelCase_ ( ): lowerCamelCase_ = argparse.ArgumentParser(description="Simple example of training script." ) parser.add_argument( "--mixed_precision" , type=lowerCamelCase__ , default=lowerCamelCase__ , 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." , ) parser.add_argument("--cpu" , action="store_true" , help="If passed, will train on the CPU." ) parser.add_argument( "--with_tracking" , action="store_true" , help="Whether to load in all available experiment trackers from the environment and use them for logging." , ) parser.add_argument( "--project_dir" , type=lowerCamelCase__ , default="logs" , help="Location on where to store experiment tracking logs` and relevent project information" , ) lowerCamelCase_ = parser.parse_args() lowerCamelCase_ = {"lr": 2e-5, "num_epochs": 3, "seed": 4_2, "batch_size": 1_6} training_function(lowerCamelCase__ , lowerCamelCase__ ) if __name__ == "__main__": main()
19
0
"""simple docstring""" import argparse import os import re import packaging.version _UpperCamelCase: str = 'examples/' _UpperCamelCase: List[str] = { 'examples': (re.compile(R'^check_min_version\("[^"]+"\)\s*$', re.MULTILINE), 'check_min_version("VERSION")\n'), 'init': (re.compile(R'^__version__\s+=\s+"([^"]+)"\s*$', re.MULTILINE), '__version__ = "VERSION"\n'), 'setup': (re.compile(R'^(\s*)version\s*=\s*"[^"]+",', re.MULTILINE), R'\1version="VERSION",'), 'doc': (re.compile(R'^(\s*)release\s*=\s*"[^"]+"$', re.MULTILINE), 'release = "VERSION"\n'), } _UpperCamelCase: Any = { 'init': 'src/diffusers/__init__.py', 'setup': 'setup.py', } _UpperCamelCase: Union[str, Any] = 'README.md' def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) -> Dict: '''simple docstring''' with open(lowerCamelCase__ , 'r' , encoding='utf-8' , newline='\n' ) as f: lowercase : List[str] = f.read() lowercase , lowercase : int = REPLACE_PATTERNS[pattern] lowercase : str = replace.replace('VERSION' , lowerCamelCase__ ) lowercase : Dict = re_pattern.sub(lowerCamelCase__ , lowerCamelCase__ ) with open(lowerCamelCase__ , 'w' , encoding='utf-8' , newline='\n' ) as f: f.write(lowerCamelCase__ ) def lowercase__ ( _UpperCAmelCase ) -> Dict: '''simple docstring''' for folder, directories, fnames in os.walk(lowerCamelCase__ ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove('research_projects' ) if "legacy" in directories: directories.remove('legacy' ) for fname in fnames: if fname.endswith('.py' ): update_version_in_file(os.path.join(lowerCamelCase__ , lowerCamelCase__ ) , lowerCamelCase__ , pattern='examples' ) def lowercase__ ( _UpperCAmelCase , _UpperCAmelCase=False ) -> str: '''simple docstring''' for pattern, fname in REPLACE_FILES.items(): update_version_in_file(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) if not patch: update_version_in_examples(lowerCamelCase__ ) def lowercase__ ( ) -> Any: '''simple docstring''' lowercase : str = '🤗 Transformers currently provides the following architectures' lowercase : Optional[int] = '1. Want to contribute a new model?' with open(lowerCamelCase__ , 'r' , encoding='utf-8' , newline='\n' ) as f: lowercase : Union[str, Any] = f.readlines() # Find the start of the list. lowercase : str = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 lowercase : Union[str, Any] = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith('1.' ): lowercase : str = lines[index].replace( 'https://huggingface.co/docs/diffusers/main/model_doc' , 'https://huggingface.co/docs/diffusers/model_doc' , ) index += 1 with open(lowerCamelCase__ , 'w' , encoding='utf-8' , newline='\n' ) as f: f.writelines(lowerCamelCase__ ) def lowercase__ ( ) -> Optional[int]: '''simple docstring''' with open(REPLACE_FILES['init'] , 'r' ) as f: lowercase : Union[str, Any] = f.read() lowercase : Optional[Any] = REPLACE_PATTERNS['init'][0].search(lowerCamelCase__ ).groups()[0] return packaging.version.parse(lowerCamelCase__ ) def lowercase__ ( _UpperCAmelCase=False ) -> List[Any]: '''simple docstring''' lowercase : List[Any] = get_version() if patch and default_version.is_devrelease: raise ValueError('Can\'t create a patch version from the dev branch, checkout a released version!' ) if default_version.is_devrelease: lowercase : Union[str, Any] = default_version.base_version elif patch: lowercase : Dict = f'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}''' else: lowercase : Tuple = f'''{default_version.major}.{default_version.minor + 1}.0''' # Now let's ask nicely if that's the right one. lowercase : Tuple = input(f'''Which version are you releasing? [{default_version}]''' ) if len(lowerCamelCase__ ) == 0: lowercase : Dict = default_version print(f'''Updating version to {version}.''' ) global_version_update(lowerCamelCase__ , patch=lowerCamelCase__ ) def lowercase__ ( ) -> Optional[int]: '''simple docstring''' lowercase : int = get_version() lowercase : Optional[Any] = f'''{current_version.major}.{current_version.minor + 1}.0.dev0''' lowercase : Any = current_version.base_version # Check with the user we got that right. lowercase : int = input(f'''Which version are we developing now? [{dev_version}]''' ) if len(lowerCamelCase__ ) == 0: lowercase : str = dev_version print(f'''Updating version to {version}.''' ) global_version_update(lowerCamelCase__ ) # print("Cleaning main README, don't forget to run `make fix-copies`.") # clean_main_ref_in_model_list() if __name__ == "__main__": _UpperCamelCase: Optional[Any] = argparse.ArgumentParser() parser.add_argument('--post_release', action='store_true', help='Whether this is pre or post release.') parser.add_argument('--patch', action='store_true', help='Whether or not this is a patch release.') _UpperCamelCase: Any = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('Nothing to do after a patch :-)') else: post_release_work()
255
import os from shutil import copyfile from typing import List, Optional, Tuple from tokenizers import processors from ...tokenization_utils import AddedToken, BatchEncoding from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_mbart import MBartTokenizer else: __A =None __A =logging.get_logger(__name__) __A ={'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''} __A ={ '''vocab_file''': { '''facebook/mbart-large-en-ro''': ( '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model''' ), '''facebook/mbart-large-cc25''': ( '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model''' ), }, '''tokenizer_file''': { '''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''', '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''', }, } __A ={ '''facebook/mbart-large-en-ro''': 1_0_2_4, '''facebook/mbart-large-cc25''': 1_0_2_4, } # fmt: off __A =['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN'''] class _SCREAMING_SNAKE_CASE ( snake_case_ ): lowerCAmelCase__ = VOCAB_FILES_NAMES lowerCAmelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowerCAmelCase__ = PRETRAINED_VOCAB_FILES_MAP lowerCAmelCase__ = ['input_ids', 'attention_mask'] lowerCAmelCase__ = MBartTokenizer lowerCAmelCase__ = [] lowerCAmelCase__ = [] def __init__( self , lowercase=None , lowercase=None , lowercase="<s>" , lowercase="</s>" , lowercase="</s>" , lowercase="<s>" , lowercase="<unk>" , lowercase="<pad>" , lowercase="<mask>" , lowercase=None , lowercase=None , lowercase=None , **lowercase , ) -> Dict: # Mask token behave like a normal word, i.e. include the space before it lowerCamelCase_ = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else mask_token super().__init__( vocab_file=lowercase , tokenizer_file=lowercase , bos_token=lowercase , eos_token=lowercase , sep_token=lowercase , cls_token=lowercase , unk_token=lowercase , pad_token=lowercase , mask_token=lowercase , src_lang=lowercase , tgt_lang=lowercase , additional_special_tokens=lowercase , **lowercase , ) lowerCamelCase_ = vocab_file lowerCamelCase_ = False if not self.vocab_file else True lowerCamelCase_ = FAIRSEQ_LANGUAGE_CODES.copy() if additional_special_tokens is not None: # Only add those special tokens if they are not already there. _additional_special_tokens.extend( [t for t in additional_special_tokens if t not in _additional_special_tokens] ) self.add_special_tokens({"additional_special_tokens": _additional_special_tokens} ) lowerCamelCase_ = { lang_code: self.convert_tokens_to_ids(lowercase ) for lang_code in FAIRSEQ_LANGUAGE_CODES } lowerCamelCase_ = src_lang if src_lang is not None else "en_XX" lowerCamelCase_ = self.convert_tokens_to_ids(self._src_lang ) lowerCamelCase_ = tgt_lang self.set_src_lang_special_tokens(self._src_lang ) @property def SCREAMING_SNAKE_CASE_( self ) -> str: return self._src_lang @src_lang.setter def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = new_src_lang self.set_src_lang_special_tokens(self._src_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: if token_ids_a is None: return self.prefix_tokens + token_ids_a + self.suffix_tokens # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> List[int]: lowerCamelCase_ = [self.sep_token_id] lowerCamelCase_ = [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 SCREAMING_SNAKE_CASE_( self , lowercase , lowercase , lowercase , lowercase , **lowercase ) -> List[Any]: if src_lang is None or tgt_lang is None: raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model" ) lowerCamelCase_ = src_lang lowerCamelCase_ = self(lowercase , add_special_tokens=lowercase , return_tensors=lowercase , **lowercase ) lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = tgt_lang_id return inputs def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = "en_XX" , lowercase = None , lowercase = "ro_RO" , **lowercase , ) -> BatchEncoding: lowerCamelCase_ = src_lang lowerCamelCase_ = tgt_lang return super().prepare_seqaseq_batch(lowercase , lowercase , **lowercase ) def SCREAMING_SNAKE_CASE_( self ) -> Dict: return self.set_src_lang_special_tokens(self.src_lang ) def SCREAMING_SNAKE_CASE_( self ) -> Optional[Any]: return self.set_tgt_lang_special_tokens(self.tgt_lang ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase ) -> None: lowerCamelCase_ = self.convert_tokens_to_ids(lowercase ) lowerCamelCase_ = [] lowerCamelCase_ = [self.eos_token_id, self.cur_lang_code] lowerCamelCase_ = self.convert_ids_to_tokens(self.prefix_tokens ) lowerCamelCase_ = self.convert_ids_to_tokens(self.suffix_tokens ) lowerCamelCase_ = processors.TemplateProcessing( single=prefix_tokens_str + ["$A"] + suffix_tokens_str , pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str , special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str , self.prefix_tokens + self.suffix_tokens ) ) , ) def SCREAMING_SNAKE_CASE_( self , lowercase , lowercase = None ) -> Tuple[str]: if not self.can_save_slow_tokenizer: raise ValueError( "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow " "tokenizer." ) if not os.path.isdir(lowercase ): logger.error(f'Vocabulary path ({save_directory}) should be a directory.' ) return lowerCamelCase_ = os.path.join( lowercase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowercase ): copyfile(self.vocab_file , lowercase ) return (out_vocab_file,)
19
0