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""" import json import os from functools import lru_cache from typing import List, Optional, Tuple import regex as re from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import logging lowercase__ = logging.get_logger(__name__) lowercase__ = {'vocab_file': 'vocab.json', 'merges_file': 'merges.txt'} lowercase__ = { 'vocab_file': { 'allenai/longformer-base-4096': 'https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json', 'allenai/longformer-large-4096': ( 'https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json' ), 'allenai/longformer-large-4096-finetuned-triviaqa': ( 'https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json' ), 'allenai/longformer-base-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json' ), 'allenai/longformer-large-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json' ), }, 'merges_file': { 'allenai/longformer-base-4096': 'https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt', 'allenai/longformer-large-4096': ( 'https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt' ), 'allenai/longformer-large-4096-finetuned-triviaqa': ( 'https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt' ), 'allenai/longformer-base-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt' ), 'allenai/longformer-large-4096-extra.pos.embd.only': ( 'https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt' ), }, } lowercase__ = { 'allenai/longformer-base-4096': 4096, 'allenai/longformer-large-4096': 4096, 'allenai/longformer-large-4096-finetuned-triviaqa': 4096, 'allenai/longformer-base-4096-extra.pos.embd.only': 4096, 'allenai/longformer-large-4096-extra.pos.embd.only': 4096, } @lru_cache() # Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode def _snake_case ( ): _lowerCamelCase : Any = ( list(range(ord('!' ) , ord('~' ) + 1 ) ) + list(range(ord('¡' ) , ord('¬' ) + 1 ) ) + list(range(ord('®' ) , ord('ÿ' ) + 1 ) ) ) _lowerCamelCase : int = bs[:] _lowerCamelCase : str = 0 for b in range(2**8 ): if b not in bs: bs.append(UpperCAmelCase_ ) cs.append(2**8 + n ) n += 1 _lowerCamelCase : Tuple = [chr(UpperCAmelCase_ ) for n in cs] return dict(zip(UpperCAmelCase_ , UpperCAmelCase_ ) ) def _snake_case ( lowercase__ ): _lowerCamelCase : List[str] = set() _lowerCamelCase : List[Any] = word[0] for char in word[1:]: pairs.add((prev_char, char) ) _lowerCamelCase : str = char return pairs class lowerCAmelCase__ ( _lowerCamelCase ): '''simple docstring''' lowerCamelCase__ = VOCAB_FILES_NAMES lowerCamelCase__ = PRETRAINED_VOCAB_FILES_MAP lowerCamelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowerCamelCase__ = ["""input_ids""", """attention_mask"""] def __init__( self , lowercase , lowercase , lowercase="replace" , lowercase="<s>" , lowercase="</s>" , lowercase="</s>" , lowercase="<s>" , lowercase="<unk>" , lowercase="<pad>" , lowercase="<mask>" , lowercase=False , **lowercase , ): _lowerCamelCase : List[str] = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else bos_token _lowerCamelCase : Optional[int] = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else eos_token _lowerCamelCase : Tuple = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else sep_token _lowerCamelCase : Tuple = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else cls_token _lowerCamelCase : List[Any] = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else unk_token _lowerCamelCase : int = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else pad_token # Mask token behave like a normal word, i.e. include the space before it _lowerCamelCase : Tuple = AddedToken(lowercase , lstrip=lowercase , rstrip=lowercase ) if isinstance(lowercase , lowercase ) else mask_token super().__init__( errors=lowercase , bos_token=lowercase , eos_token=lowercase , unk_token=lowercase , sep_token=lowercase , cls_token=lowercase , pad_token=lowercase , mask_token=lowercase , add_prefix_space=lowercase , **lowercase , ) with open(lowercase , encoding='utf-8' ) as vocab_handle: _lowerCamelCase : Union[str, Any] = json.load(lowercase ) _lowerCamelCase : Union[str, Any] = {v: k for k, v in self.encoder.items()} _lowerCamelCase : Optional[Any] = errors # how to handle errors in decoding _lowerCamelCase : List[Any] = bytes_to_unicode() _lowerCamelCase : Optional[Any] = {v: k for k, v in self.byte_encoder.items()} with open(lowercase , encoding='utf-8' ) as merges_handle: _lowerCamelCase : List[str] = merges_handle.read().split('\n' )[1:-1] _lowerCamelCase : List[Any] = [tuple(merge.split() ) for merge in bpe_merges] _lowerCamelCase : int = dict(zip(lowercase , range(len(lowercase ) ) ) ) _lowerCamelCase : Union[str, Any] = {} _lowerCamelCase : List[str] = add_prefix_space # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions _lowerCamelCase : List[str] = re.compile(r'\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+' ) @property def A_ ( self ): return len(self.encoder ) def A_ ( self ): return dict(self.encoder , **self.added_tokens_encoder ) def A_ ( self , lowercase ): if token in self.cache: return self.cache[token] _lowerCamelCase : Optional[int] = tuple(lowercase ) _lowerCamelCase : Tuple = get_pairs(lowercase ) if not pairs: return token while True: _lowerCamelCase : List[str] = min(lowercase , key=lambda lowercase : self.bpe_ranks.get(lowercase , float('inf' ) ) ) if bigram not in self.bpe_ranks: break _lowerCamelCase, _lowerCamelCase : Optional[Any] = bigram _lowerCamelCase : Tuple = [] _lowerCamelCase : Union[str, Any] = 0 while i < len(lowercase ): try: _lowerCamelCase : Tuple = word.index(lowercase , lowercase ) except ValueError: new_word.extend(word[i:] ) break else: new_word.extend(word[i:j] ) _lowerCamelCase : Any = j if word[i] == first and i < len(lowercase ) - 1 and word[i + 1] == second: new_word.append(first + second ) i += 2 else: new_word.append(word[i] ) i += 1 _lowerCamelCase : Any = tuple(lowercase ) _lowerCamelCase : Tuple = new_word if len(lowercase ) == 1: break else: _lowerCamelCase : Optional[Any] = get_pairs(lowercase ) _lowerCamelCase : List[Any] = ' '.join(lowercase ) _lowerCamelCase : Any = word return word def A_ ( self , lowercase ): _lowerCamelCase : Optional[Any] = [] for token in re.findall(self.pat , lowercase ): _lowerCamelCase : Dict = ''.join( self.byte_encoder[b] for b in token.encode('utf-8' ) ) # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case) bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowercase ).split(' ' ) ) return bpe_tokens def A_ ( self , lowercase ): return self.encoder.get(lowercase , self.encoder.get(self.unk_token ) ) def A_ ( self , lowercase ): return self.decoder.get(lowercase ) def A_ ( self , lowercase ): _lowerCamelCase : List[Any] = ''.join(lowercase ) _lowerCamelCase : Optional[int] = bytearray([self.byte_decoder[c] for c in text] ).decode('utf-8' , errors=self.errors ) return text def A_ ( self , lowercase , lowercase = None ): if not os.path.isdir(lowercase ): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' ) return _lowerCamelCase : Optional[int] = os.path.join( lowercase , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'] ) _lowerCamelCase : Union[str, Any] = os.path.join( lowercase , (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file'] ) with open(lowercase , 'w' , encoding='utf-8' ) as f: f.write(json.dumps(self.encoder , indent=2 , sort_keys=lowercase , ensure_ascii=lowercase ) + '\n' ) _lowerCamelCase : str = 0 with open(lowercase , 'w' , encoding='utf-8' ) as writer: writer.write('#version: 0.2\n' ) for bpe_tokens, token_index in sorted(self.bpe_ranks.items() , key=lambda lowercase : kv[1] ): if index != token_index: logger.warning( F'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.''' ' Please check that the tokenizer is not corrupted!' ) _lowerCamelCase : List[Any] = token_index writer.write(' '.join(lowercase ) + '\n' ) index += 1 return vocab_file, merge_file def A_ ( self , lowercase , lowercase = None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] _lowerCamelCase : Optional[Any] = [self.cls_token_id] _lowerCamelCase : Union[str, Any] = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def A_ ( self , lowercase , lowercase = None , lowercase = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=lowercase , token_ids_a=lowercase , already_has_special_tokens=lowercase ) if token_ids_a is None: return [1] + ([0] * len(lowercase )) + [1] return [1] + ([0] * len(lowercase )) + [1, 1] + ([0] * len(lowercase )) + [1] def A_ ( self , lowercase , lowercase = None ): _lowerCamelCase : Tuple = [self.sep_token_id] _lowerCamelCase : Dict = [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 A_ ( self , lowercase , lowercase=False , **lowercase ): _lowerCamelCase : Tuple = kwargs.pop('add_prefix_space' , self.add_prefix_space ) if (is_split_into_words or add_prefix_space) and (len(lowercase ) > 0 and not text[0].isspace()): _lowerCamelCase : Dict = ' ' + text return (text, kwargs)
96
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available SCREAMING_SNAKE_CASE_ : int = { 'configuration_megatron_bert': ['MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MegatronBertConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE_ : Tuple = [ 'MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'MegatronBertForCausalLM', 'MegatronBertForMaskedLM', 'MegatronBertForMultipleChoice', 'MegatronBertForNextSentencePrediction', 'MegatronBertForPreTraining', 'MegatronBertForQuestionAnswering', 'MegatronBertForSequenceClassification', 'MegatronBertForTokenClassification', 'MegatronBertModel', 'MegatronBertPreTrainedModel', ] if TYPE_CHECKING: from .configuration_megatron_bert import MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, MegatronBertConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_megatron_bert import ( MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST, MegatronBertForCausalLM, MegatronBertForMaskedLM, MegatronBertForMultipleChoice, MegatronBertForNextSentencePrediction, MegatronBertForPreTraining, MegatronBertForQuestionAnswering, MegatronBertForSequenceClassification, MegatronBertForTokenClassification, MegatronBertModel, MegatronBertPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE_ : str = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
335
0
"""simple docstring""" 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 lowercase ( _lowerCamelCase , unittest.TestCase): __lowerCAmelCase : Dict = BioGptTokenizer __lowerCAmelCase : Optional[int] = False def a_ ( self : Optional[Any] ): """simple docstring""" super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt A_ : List[str] = [ '''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>''', ] A_ : Optional[int] = dict(zip(_lowerCamelCase , range(len(_lowerCamelCase ) ) ) ) A_ : Optional[Any] = ['''l o 123''', '''lo w 1456''', '''e r</w> 1789''', ''''''] A_ : Tuple = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file'''] ) A_ : List[Any] = 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 a_ ( self : int , _lowerCamelCase : Any ): """simple docstring""" A_ : int = '''lower newer''' A_ : str = '''lower newer''' return input_text, output_text def a_ ( self : int ): """simple docstring""" A_ : Tuple = BioGptTokenizer(self.vocab_file , self.merges_file ) A_ : List[str] = '''lower''' A_ : Optional[Any] = ['''low''', '''er</w>'''] A_ : Optional[int] = tokenizer.tokenize(_lowerCamelCase ) self.assertListEqual(_lowerCamelCase , _lowerCamelCase ) A_ : Union[str, Any] = tokens + ['''<unk>'''] A_ : List[Any] = [14, 15, 20] self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCamelCase ) , _lowerCamelCase ) @slow def a_ ( self : Any ): """simple docstring""" A_ : Optional[Any] = BioGptTokenizer.from_pretrained('''microsoft/biogpt''' ) A_ : List[Any] = tokenizer.encode('''sequence builders''' , add_special_tokens=_lowerCamelCase ) A_ : Dict = tokenizer.encode('''multi-sequence build''' , add_special_tokens=_lowerCamelCase ) A_ : Optional[Any] = tokenizer.build_inputs_with_special_tokens(_lowerCamelCase ) A_ : str = tokenizer.build_inputs_with_special_tokens(_lowerCamelCase , _lowerCamelCase ) self.assertTrue(encoded_sentence == [2] + text ) self.assertTrue(encoded_pair == [2] + text + [2] + text_a )
167
"""simple docstring""" import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( """kwargs, expected""" , [ ({"""num_shards""": 0, """max_num_jobs""": 1}, []), ({"""num_shards""": 10, """max_num_jobs""": 1}, [range(10 )]), ({"""num_shards""": 10, """max_num_jobs""": 10}, [range(UpperCAmelCase_ , i + 1 ) for i in range(10 )]), ({"""num_shards""": 1, """max_num_jobs""": 10}, [range(1 )]), ({"""num_shards""": 10, """max_num_jobs""": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"""num_shards""": 3, """max_num_jobs""": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def _snake_case ( UpperCAmelCase_ : List[str] , UpperCAmelCase_ : int ): A__ = _distribute_shards(**UpperCAmelCase_ ) assert out == expected @pytest.mark.parametrize( """gen_kwargs, max_num_jobs, expected""" , [ ({"""foo""": 0}, 10, [{"""foo""": 0}]), ({"""shards""": [0, 1, 2, 3]}, 1, [{"""shards""": [0, 1, 2, 3]}]), ({"""shards""": [0, 1, 2, 3]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}, {"""shards""": [2]}, {"""shards""": [3]}]), ({"""shards""": [0, 1]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}]), ({"""shards""": [0, 1, 2, 3]}, 2, [{"""shards""": [0, 1]}, {"""shards""": [2, 3]}]), ] , ) def _snake_case ( UpperCAmelCase_ : str , UpperCAmelCase_ : Dict , UpperCAmelCase_ : List[Any] ): A__ = _split_gen_kwargs(UpperCAmelCase_ , UpperCAmelCase_ ) assert out == expected @pytest.mark.parametrize( """gen_kwargs, expected""" , [ ({"""foo""": 0}, 1), ({"""shards""": [0]}, 1), ({"""shards""": [0, 1, 2, 3]}, 4), ({"""shards""": [0, 1, 2, 3], """foo""": 0}, 4), ({"""shards""": [0, 1, 2, 3], """other""": (0, 1)}, 4), ({"""shards""": [0, 1, 2, 3], """shards2""": [0, 1]}, RuntimeError), ] , ) def _snake_case ( UpperCAmelCase_ : Optional[int] , UpperCAmelCase_ : Optional[int] ): if expected is RuntimeError: with pytest.raises(UpperCAmelCase_ ): _number_of_shards_in_gen_kwargs(UpperCAmelCase_ ) else: A__ = _number_of_shards_in_gen_kwargs(UpperCAmelCase_ ) assert out == expected
335
0
'''simple docstring''' from __future__ import absolute_import, division, print_function, unicode_literals from torch import nn from torch.nn import CrossEntropyLoss, MSELoss from transformers import RobertaConfig from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward from transformers.models.roberta.modeling_roberta import ( ROBERTA_INPUTS_DOCSTRING, ROBERTA_START_DOCSTRING, RobertaEmbeddings, ) from .modeling_highway_bert import BertPreTrainedModel, DeeBertModel, HighwayException, entropy @add_start_docstrings( "The RoBERTa Model transformer with early exiting (DeeRoBERTa). " ,_lowerCamelCase ,) class lowerCAmelCase_ ( _lowerCamelCase ): __lowerCamelCase : List[Any] = RobertaConfig __lowerCamelCase : List[str] = "roberta" def __init__( self , _lowerCAmelCase ) -> Any: super().__init__(_lowerCAmelCase ) _lowerCAmelCase = RobertaEmbeddings(_lowerCAmelCase ) self.init_weights() @add_start_docstrings( "RoBERTa Model (with early exiting - DeeRoBERTa) with a classifier on top,\n also takes care of multi-layer training. " ,_lowerCamelCase ,) class lowerCAmelCase_ ( _lowerCamelCase ): __lowerCamelCase : List[str] = RobertaConfig __lowerCamelCase : Tuple = "roberta" def __init__( self , _lowerCAmelCase ) -> Optional[int]: super().__init__(_lowerCAmelCase ) _lowerCAmelCase = config.num_labels _lowerCAmelCase = config.num_hidden_layers _lowerCAmelCase = DeeRobertaModel(_lowerCAmelCase ) _lowerCAmelCase = nn.Dropout(config.hidden_dropout_prob ) _lowerCAmelCase = nn.Linear(config.hidden_size , self.config.num_labels ) @add_start_docstrings_to_model_forward(_lowerCAmelCase ) def _snake_case ( self , _lowerCAmelCase=None , _lowerCAmelCase=None , _lowerCAmelCase=None , _lowerCAmelCase=None , _lowerCAmelCase=None , _lowerCAmelCase=None , _lowerCAmelCase=None , _lowerCAmelCase=-1 , _lowerCAmelCase=False , ) -> Dict: _lowerCAmelCase = self.num_layers try: _lowerCAmelCase = self.roberta( _lowerCAmelCase , attention_mask=_lowerCAmelCase , token_type_ids=_lowerCAmelCase , position_ids=_lowerCAmelCase , head_mask=_lowerCAmelCase , inputs_embeds=_lowerCAmelCase , ) _lowerCAmelCase = outputs[1] _lowerCAmelCase = self.dropout(_lowerCAmelCase ) _lowerCAmelCase = self.classifier(_lowerCAmelCase ) _lowerCAmelCase = (logits,) + outputs[2:] # add hidden states and attention if they are here except HighwayException as e: _lowerCAmelCase = e.message _lowerCAmelCase = e.exit_layer _lowerCAmelCase = outputs[0] if not self.training: _lowerCAmelCase = entropy(_lowerCAmelCase ) _lowerCAmelCase = [] _lowerCAmelCase = [] if labels is not None: if self.num_labels == 1: # We are doing regression _lowerCAmelCase = MSELoss() _lowerCAmelCase = loss_fct(logits.view(-1 ) , labels.view(-1 ) ) else: _lowerCAmelCase = CrossEntropyLoss() _lowerCAmelCase = loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) # work with highway exits _lowerCAmelCase = [] for highway_exit in outputs[-1]: _lowerCAmelCase = highway_exit[0] if not self.training: highway_logits_all.append(_lowerCAmelCase ) highway_entropy.append(highway_exit[2] ) if self.num_labels == 1: # We are doing regression _lowerCAmelCase = MSELoss() _lowerCAmelCase = loss_fct(highway_logits.view(-1 ) , labels.view(-1 ) ) else: _lowerCAmelCase = CrossEntropyLoss() _lowerCAmelCase = loss_fct(highway_logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) highway_losses.append(_lowerCAmelCase ) if train_highway: _lowerCAmelCase = (sum(highway_losses[:-1] ),) + outputs # exclude the final highway, of course else: _lowerCAmelCase = (loss,) + outputs if not self.training: _lowerCAmelCase = outputs + ((original_entropy, highway_entropy), exit_layer) if output_layer >= 0: _lowerCAmelCase = ( (outputs[0],) + (highway_logits_all[output_layer],) + outputs[2:] ) # use the highway of the last layer return outputs # (loss), logits, (hidden_states), (attentions), entropy
158
"""simple docstring""" import importlib.metadata from typing import Union from packaging.version import Version, parse from .constants import STR_OPERATION_TO_FUNC SCREAMING_SNAKE_CASE_ : str = parse(importlib.metadata.version('torch')) def _snake_case ( UpperCAmelCase_ : Union[str, Version] , UpperCAmelCase_ : str , UpperCAmelCase_ : str ): if operation not in STR_OPERATION_TO_FUNC.keys(): raise ValueError(F"""`operation` must be one of {list(STR_OPERATION_TO_FUNC.keys() )}, received {operation}""" ) A__ = STR_OPERATION_TO_FUNC[operation] if isinstance(UpperCAmelCase_ , UpperCAmelCase_ ): A__ = parse(importlib.metadata.version(UpperCAmelCase_ ) ) return operation(UpperCAmelCase_ , parse(UpperCAmelCase_ ) ) def _snake_case ( UpperCAmelCase_ : str , UpperCAmelCase_ : str ): return compare_versions(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ )
335
0
import argparse import os from pathlib import Path from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import PegasusConfig, PegasusForConditionalGeneration, PegasusTokenizer from transformers.models.pegasus.configuration_pegasus import DEFAULTS, task_specific_params lowercase__ =[ # replace left string with right string to get the relevant state_dict key (identical state dict to bart) ['memory_attention', 'encoder_attn'], ['attention', 'attn'], ['/', '.'], ['.LayerNorm.gamma', '_layer_norm.weight'], ['.LayerNorm.beta', '_layer_norm.bias'], ['r.layer_', 'r.layers.'], ['output_proj', 'out_proj'], ['ffn.dense_1.', 'fc2.'], ['ffn.dense.', 'fc1.'], ['ffn_layer_norm', 'final_layer_norm'], ['kernel', 'weight'], ['encoder_layer_norm.', 'encoder.layer_norm.'], ['decoder_layer_norm.', 'decoder.layer_norm.'], ['embeddings.weights', 'shared.weight'], ] def __UpperCamelCase ( lowerCAmelCase__ : Dict ): for pegasus_name, hf_name in PATTERNS: __a : str = k.replace(UpperCAmelCase_ , UpperCAmelCase_ ) return k def __UpperCamelCase ( lowerCAmelCase__ : dict , lowerCAmelCase__ : dict ): __a : Optional[Any] = DEFAULTS.copy() cfg_kwargs.update(UpperCAmelCase_ ) __a : Union[str, Any] = PegasusConfig(**UpperCAmelCase_ ) __a : Dict = PegasusForConditionalGeneration(UpperCAmelCase_ ) __a : List[Any] = torch_model.model.state_dict() __a : Optional[int] = {} for k, v in tf_weights.items(): __a : int = rename_state_dict_key(UpperCAmelCase_ ) if new_k not in sd: raise ValueError(f"could not find new key {new_k} in state dict. (converted from {k})" ) if "dense" in k or "proj" in new_k: __a : Any = v.T __a : Dict = torch.tensor(UpperCAmelCase_ , dtype=sd[new_k].dtype ) assert v.shape == sd[new_k].shape, f"{new_k}, {k}, {v.shape}, {sd[new_k].shape}" # make sure embedding.padding_idx is respected __a : str = torch.zeros_like(mapping['''shared.weight'''][cfg.pad_token_id + 1] ) __a : List[str] = mapping['''shared.weight'''] __a : Optional[Any] = mapping['''shared.weight'''] __a : Optional[int] = {k: torch.zeros_like(UpperCAmelCase_ ) for k, v in sd.items() if k.endswith('''bias''' ) and k not in mapping} mapping.update(**UpperCAmelCase_ ) __a , __a : int = torch_model.model.load_state_dict(UpperCAmelCase_ , strict=UpperCAmelCase_ ) __a : Union[str, Any] = [ k for k in missing if k not in ['''encoder.embed_positions.weight''', '''decoder.embed_positions.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 __UpperCamelCase ( lowerCAmelCase__ : Optional[int]="./ckpt/aeslc/model.ckpt-32000" ): __a : Union[str, Any] = tf.train.list_variables(UpperCAmelCase_ ) __a : List[Any] = {} __a : List[str] = ['''Adafactor''', '''global_step'''] for name, shape in tqdm(UpperCAmelCase_ , desc='''converting tf checkpoint to dict''' ): __a : Tuple = any(pat in name for pat in ignore_name ) if skip_key: continue __a : str = tf.train.load_variable(UpperCAmelCase_ , UpperCAmelCase_ ) __a : Union[str, Any] = array return tf_weights def __UpperCamelCase ( lowerCAmelCase__ : str , lowerCAmelCase__ : str ): # save tokenizer first __a : Optional[Any] = Path(UpperCAmelCase_ ).parent.name __a : Tuple = task_specific_params[f"summarization_{dataset}"]['''max_position_embeddings'''] __a : Any = PegasusTokenizer.from_pretrained('''sshleifer/pegasus''' , model_max_length=UpperCAmelCase_ ) assert tok.model_max_length == desired_max_model_length tok.save_pretrained(UpperCAmelCase_ ) # convert model __a : int = get_tf_weights_as_numpy(UpperCAmelCase_ ) __a : str = task_specific_params[f"summarization_{dataset}"] if dataset == "large": __a : str = task_specific_params __a : Optional[Any] = convert_pegasus(UpperCAmelCase_ , UpperCAmelCase_ ) torch_model.save_pretrained(UpperCAmelCase_ ) __a : Optional[int] = torch_model.state_dict() sd.pop('''model.decoder.embed_positions.weight''' ) sd.pop('''model.encoder.embed_positions.weight''' ) torch.save(UpperCAmelCase_ , Path(UpperCAmelCase_ ) / '''pytorch_model.bin''' ) if __name__ == "__main__": lowercase__ =argparse.ArgumentParser() # Required parameters 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.') lowercase__ =parser.parse_args() if args.save_dir is None: lowercase__ =Path(args.tf_ckpt_path).parent.name lowercase__ =os.path.join('pegasus', dataset) convert_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir)
216
"""simple docstring""" import sacrebleu as scb from packaging import version from sacrebleu import CHRF import datasets SCREAMING_SNAKE_CASE_ : Dict = '\\n@inproceedings{popovic-2015-chrf,\n title = "chr{F}: character n-gram {F}-score for automatic {MT} evaluation",\n author = "Popovi{\'c}, Maja",\n booktitle = "Proceedings of the Tenth Workshop on Statistical Machine Translation",\n month = sep,\n year = "2015",\n address = "Lisbon, Portugal",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/W15-3049",\n doi = "10.18653/v1/W15-3049",\n pages = "392--395",\n}\n@inproceedings{popovic-2017-chrf,\n title = "chr{F}++: words helping character n-grams",\n author = "Popovi{\'c}, Maja",\n booktitle = "Proceedings of the Second Conference on Machine Translation",\n month = sep,\n year = "2017",\n address = "Copenhagen, Denmark",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/W17-4770",\n doi = "10.18653/v1/W17-4770",\n pages = "612--618",\n}\n@inproceedings{post-2018-call,\n title = "A Call for Clarity in Reporting {BLEU} Scores",\n author = "Post, Matt",\n booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n month = oct,\n year = "2018",\n address = "Belgium, Brussels",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W18-6319",\n pages = "186--191",\n}\n' SCREAMING_SNAKE_CASE_ : str = '\\nChrF and ChrF++ are two MT evaluation metrics. They both use the F-score statistic for character n-gram matches,\nand ChrF++ adds word n-grams as well which correlates more strongly with direct assessment. We use the implementation\nthat is already present in sacrebleu.\n\nThe implementation here is slightly different from sacrebleu in terms of the required input format. The length of\nthe references and hypotheses lists need to be the same, so you may need to transpose your references compared to\nsacrebleu\'s required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534\n\nSee the README.md file at https://github.com/mjpost/sacreBLEU#chrf--chrf for more information.\n' SCREAMING_SNAKE_CASE_ : List[str] = '\nProduces ChrF(++) scores for hypotheses given reference translations.\n\nArgs:\n predictions (list of str): The predicted sentences.\n references (list of list of str): The references. There should be one reference sub-list for each prediction sentence.\n char_order (int): Character n-gram order. Defaults to `6`.\n word_order (int): Word n-gram order. If equals to `2`, the metric is referred to as chrF++. Defaults to `0`.\n beta (int): Determine the importance of recall w.r.t precision. Defaults to `2`.\n lowercase (bool): if `True`, enables case-insensitivity. Defaults to `False`.\n whitespace (bool): If `True`, include whitespaces when extracting character n-grams.\n eps_smoothing (bool): If `True`, applies epsilon smoothing similar\n to reference chrF++.py, NLTK and Moses implementations. If `False`,\n it takes into account effective match order similar to sacreBLEU < 2.0.0. Defaults to `False`.\n\nReturns:\n \'score\' (float): The chrF (chrF++) score,\n \'char_order\' (int): The character n-gram order,\n \'word_order\' (int): The word n-gram order. If equals to 2, the metric is referred to as chrF++,\n \'beta\' (int): Determine the importance of recall w.r.t precision\n\nExamples:\n Example 1--a simple example of calculating chrF:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = datasets.load_metric("chrf")\n >>> results = chrf.compute(predictions=prediction, references=reference)\n >>> print(results)\n {\'score\': 84.64214891738334, \'char_order\': 6, \'word_order\': 0, \'beta\': 2}\n\n Example 2--the same example, but with the argument word_order=2, to calculate chrF++ instead of chrF:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = datasets.load_metric("chrf")\n >>> results = chrf.compute(predictions=prediction,\n ... references=reference,\n ... word_order=2)\n >>> print(results)\n {\'score\': 82.87263732906315, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}\n\n Example 3--the same chrF++ example as above, but with `lowercase=True` to normalize all case:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = datasets.load_metric("chrf")\n >>> results = chrf.compute(predictions=prediction,\n ... references=reference,\n ... word_order=2,\n ... lowercase=True)\n >>> print(results)\n {\'score\': 92.12853119829202, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}\n' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION ) class a ( datasets.Metric ): """simple docstring""" def UpperCamelCase ( self: List[str] ): """simple docstring""" if version.parse(scb.__version__ ) < version.parse("""1.4.12""" ): raise ImportWarning( """To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n""" """You can install it with `pip install \"sacrebleu>=1.4.12\"`.""" ) return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , homepage="""https://github.com/mjpost/sacreBLEU#chrf--chrf""" , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Value("""string""" , id="""sequence""" ), """references""": datasets.Sequence(datasets.Value("""string""" , id="""sequence""" ) , id="""references""" ), } ) , codebase_urls=["""https://github.com/mjpost/sacreBLEU#chrf--chrf"""] , reference_urls=[ """https://github.com/m-popovic/chrF""", ] , ) def UpperCamelCase ( self: List[Any] , UpperCamelCase: Union[str, Any] , UpperCamelCase: Optional[Any] , UpperCamelCase: int = CHRF.CHAR_ORDER , UpperCamelCase: int = CHRF.WORD_ORDER , UpperCamelCase: int = CHRF.BETA , UpperCamelCase: bool = False , UpperCamelCase: bool = False , UpperCamelCase: bool = False , ): """simple docstring""" A__ = len(references[0] ) if any(len(UpperCamelCase ) != references_per_prediction for refs in references ): raise ValueError("""Sacrebleu requires the same number of references for each prediction""" ) A__ = [[refs[i] for refs in references] for i in range(UpperCamelCase )] A__ = CHRF(UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase ) A__ = sb_chrf.corpus_score(UpperCamelCase , UpperCamelCase ) return { "score": output.score, "char_order": output.char_order, "word_order": output.word_order, "beta": output.beta, }
335
0
"""simple docstring""" from __future__ import annotations def lowercase (snake_case__ : int = 4 ) -> List[Any]: '''simple docstring''' lowerCAmelCase = abs(UpperCAmelCase_ ) or 4 return [[1 + x + y * row_size for x in range(UpperCAmelCase_ )] for y in range(UpperCAmelCase_ )] def lowercase (snake_case__ : list[list[int]] ) -> Union[str, Any]: '''simple docstring''' return reverse_row(transpose(UpperCAmelCase_ ) ) # OR.. transpose(reverse_column(matrix)) def lowercase (snake_case__ : list[list[int]] ) -> int: '''simple docstring''' return reverse_row(reverse_column(UpperCAmelCase_ ) ) # OR.. reverse_column(reverse_row(matrix)) def lowercase (snake_case__ : list[list[int]] ) -> Dict: '''simple docstring''' return reverse_column(transpose(UpperCAmelCase_ ) ) # OR.. transpose(reverse_row(matrix)) def lowercase (snake_case__ : list[list[int]] ) -> Dict: '''simple docstring''' lowerCAmelCase = [list(UpperCAmelCase_ ) for x in zip(*UpperCAmelCase_ )] return matrix def lowercase (snake_case__ : list[list[int]] ) -> Tuple: '''simple docstring''' lowerCAmelCase = matrix[::-1] return matrix def lowercase (snake_case__ : list[list[int]] ) -> Optional[Any]: '''simple docstring''' lowerCAmelCase = [x[::-1] for x in matrix] return matrix def lowercase (snake_case__ : list[list[int]] ) -> Optional[Any]: '''simple docstring''' for i in matrix: print(*UpperCAmelCase_ ) if __name__ == "__main__": a = make_matrix() print('\norigin:\n') print_matrix(matrix) print('\nrotate 90 counterclockwise:\n') print_matrix(rotate_aa(matrix)) a = make_matrix() print('\norigin:\n') print_matrix(matrix) print('\nrotate 180:\n') print_matrix(rotate_aaa(matrix)) a = make_matrix() print('\norigin:\n') print_matrix(matrix) print('\nrotate 270 counterclockwise:\n') print_matrix(rotate_aaa(matrix))
155
"""simple docstring""" 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 a ( _lowerCamelCase ): """simple docstring""" def __init__( self: Optional[int] , *UpperCamelCase: Optional[Any] , UpperCamelCase: Tuple=None , UpperCamelCase: Tuple=None , **UpperCamelCase: Dict ): """simple docstring""" super().__init__(*UpperCamelCase , **UpperCamelCase ) A__ = eval_examples A__ = post_process_function def UpperCamelCase ( self: Optional[Any] , UpperCamelCase: Optional[Dataset] = None , UpperCamelCase: List[Any]=None , UpperCamelCase: Optional[List[str]] = None , UpperCamelCase: str = "eval" , **UpperCamelCase: Optional[int] , ): """simple docstring""" A__ = gen_kwargs.copy() A__ = ( gen_kwargs["""max_length"""] if gen_kwargs.get("""max_length""" ) is not None else self.args.generation_max_length ) A__ = ( gen_kwargs["""num_beams"""] if gen_kwargs.get("""num_beams""" ) is not None else self.args.generation_num_beams ) A__ = gen_kwargs A__ = self.eval_dataset if eval_dataset is None else eval_dataset A__ = self.get_eval_dataloader(UpperCamelCase ) A__ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. A__ = self.compute_metrics A__ = None A__ = time.time() A__ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: A__ = eval_loop( UpperCamelCase , description="""Evaluation""" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=UpperCamelCase , metric_key_prefix=UpperCamelCase , ) finally: A__ = compute_metrics A__ = 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( UpperCamelCase , UpperCamelCase , 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 A__ = self.post_process_function(UpperCamelCase , UpperCamelCase , UpperCamelCase ) A__ = self.compute_metrics(UpperCamelCase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f"""{metric_key_prefix}_""" ): A__ = metrics.pop(UpperCamelCase ) metrics.update(output.metrics ) else: A__ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(UpperCamelCase ) 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() ) A__ = self.callback_handler.on_evaluate(self.args , self.state , self.control , UpperCamelCase ) return metrics def UpperCamelCase ( self: List[Any] , UpperCamelCase: Dict , UpperCamelCase: List[str] , UpperCamelCase: Dict=None , UpperCamelCase: str = "test" , **UpperCamelCase: Optional[int] ): """simple docstring""" A__ = gen_kwargs.copy() A__ = self.get_test_dataloader(UpperCamelCase ) # Temporarily disable metric computation, we will do it in the loop here. A__ = self.compute_metrics A__ = None A__ = time.time() A__ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: A__ = eval_loop( UpperCamelCase , description="""Prediction""" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=UpperCamelCase , metric_key_prefix=UpperCamelCase , ) finally: A__ = compute_metrics A__ = 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( UpperCamelCase , UpperCamelCase , 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 A__ = self.post_process_function(UpperCamelCase , UpperCamelCase , UpperCamelCase , """predict""" ) A__ = self.compute_metrics(UpperCamelCase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f"""{metric_key_prefix}_""" ): A__ = metrics.pop(UpperCamelCase ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=UpperCamelCase )
335
0
"""simple docstring""" __SCREAMING_SNAKE_CASE ='0.18.2' from .configuration_utils import ConfigMixin from .utils import ( OptionalDependencyNotAvailable, is_flax_available, is_inflect_available, is_invisible_watermark_available, is_k_diffusion_available, is_k_diffusion_version, is_librosa_available, is_note_seq_available, is_onnx_available, is_scipy_available, is_torch_available, is_torchsde_available, is_transformers_available, is_transformers_version, is_unidecode_available, logging, ) try: if not is_onnx_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_onnx_objects import * # noqa F403 else: from .pipelines import OnnxRuntimeModel try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_pt_objects import * # noqa F403 else: from .models import ( AutoencoderKL, ControlNetModel, ModelMixin, PriorTransformer, TaFilmDecoder, TransformeraDModel, UNetaDModel, UNetaDConditionModel, UNetaDModel, UNetaDConditionModel, VQModel, ) from .optimization import ( get_constant_schedule, get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup, get_cosine_with_hard_restarts_schedule_with_warmup, get_linear_schedule_with_warmup, get_polynomial_decay_schedule_with_warmup, get_scheduler, ) from .pipelines import ( AudioPipelineOutput, ConsistencyModelPipeline, DanceDiffusionPipeline, DDIMPipeline, DDPMPipeline, DiffusionPipeline, DiTPipeline, ImagePipelineOutput, KarrasVePipeline, LDMPipeline, LDMSuperResolutionPipeline, PNDMPipeline, RePaintPipeline, ScoreSdeVePipeline, ) from .schedulers import ( CMStochasticIterativeScheduler, DDIMInverseScheduler, DDIMParallelScheduler, DDIMScheduler, DDPMParallelScheduler, DDPMScheduler, DEISMultistepScheduler, DPMSolverMultistepInverseScheduler, DPMSolverMultistepScheduler, DPMSolverSinglestepScheduler, EulerAncestralDiscreteScheduler, EulerDiscreteScheduler, HeunDiscreteScheduler, IPNDMScheduler, KarrasVeScheduler, KDPMaAncestralDiscreteScheduler, KDPMaDiscreteScheduler, PNDMScheduler, RePaintScheduler, SchedulerMixin, ScoreSdeVeScheduler, UnCLIPScheduler, UniPCMultistepScheduler, VQDiffusionScheduler, ) from .training_utils import EMAModel try: if not (is_torch_available() and is_scipy_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_scipy_objects import * # noqa F403 else: from .schedulers import LMSDiscreteScheduler try: if not (is_torch_available() and is_torchsde_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_torchsde_objects import * # noqa F403 else: from .schedulers import DPMSolverSDEScheduler try: if not (is_torch_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipelines import ( AltDiffusionImgaImgPipeline, AltDiffusionPipeline, AudioLDMPipeline, CycleDiffusionPipeline, IFImgaImgPipeline, IFImgaImgSuperResolutionPipeline, IFInpaintingPipeline, IFInpaintingSuperResolutionPipeline, IFPipeline, IFSuperResolutionPipeline, ImageTextPipelineOutput, KandinskyImgaImgPipeline, KandinskyInpaintPipeline, KandinskyPipeline, KandinskyPriorPipeline, KandinskyVaaControlnetImgaImgPipeline, KandinskyVaaControlnetPipeline, KandinskyVaaImgaImgPipeline, KandinskyVaaInpaintPipeline, KandinskyVaaPipeline, KandinskyVaaPriorEmbaEmbPipeline, KandinskyVaaPriorPipeline, LDMTextToImagePipeline, PaintByExamplePipeline, SemanticStableDiffusionPipeline, ShapEImgaImgPipeline, ShapEPipeline, StableDiffusionAttendAndExcitePipeline, StableDiffusionControlNetImgaImgPipeline, StableDiffusionControlNetInpaintPipeline, StableDiffusionControlNetPipeline, StableDiffusionDepthaImgPipeline, StableDiffusionDiffEditPipeline, StableDiffusionImageVariationPipeline, StableDiffusionImgaImgPipeline, StableDiffusionInpaintPipeline, StableDiffusionInpaintPipelineLegacy, StableDiffusionInstructPixaPixPipeline, StableDiffusionLatentUpscalePipeline, StableDiffusionLDMaDPipeline, StableDiffusionModelEditingPipeline, StableDiffusionPanoramaPipeline, StableDiffusionParadigmsPipeline, StableDiffusionPipeline, StableDiffusionPipelineSafe, StableDiffusionPixaPixZeroPipeline, StableDiffusionSAGPipeline, StableDiffusionUpscalePipeline, StableUnCLIPImgaImgPipeline, StableUnCLIPPipeline, TextToVideoSDPipeline, TextToVideoZeroPipeline, UnCLIPImageVariationPipeline, UnCLIPPipeline, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder, VersatileDiffusionDualGuidedPipeline, VersatileDiffusionImageVariationPipeline, VersatileDiffusionPipeline, VersatileDiffusionTextToImagePipeline, VideoToVideoSDPipeline, VQDiffusionPipeline, ) try: if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import * # noqa F403 else: from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline try: if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import * # noqa F403 else: from .pipelines import StableDiffusionKDiffusionPipeline try: if not (is_torch_available() and is_transformers_available() and is_onnx_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_transformers_and_onnx_objects import * # noqa F403 else: from .pipelines import ( OnnxStableDiffusionImgaImgPipeline, OnnxStableDiffusionInpaintPipeline, OnnxStableDiffusionInpaintPipelineLegacy, OnnxStableDiffusionPipeline, OnnxStableDiffusionUpscalePipeline, StableDiffusionOnnxPipeline, ) try: if not (is_torch_available() and is_librosa_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_torch_and_librosa_objects import * # noqa F403 else: from .pipelines import AudioDiffusionPipeline, Mel try: if not (is_transformers_available() and is_torch_available() and is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_transformers_and_torch_and_note_seq_objects import * # noqa F403 else: from .pipelines import SpectrogramDiffusionPipeline try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_objects import * # noqa F403 else: from .models.controlnet_flax import FlaxControlNetModel from .models.modeling_flax_utils import FlaxModelMixin from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel from .models.vae_flax import FlaxAutoencoderKL from .pipelines import FlaxDiffusionPipeline from .schedulers import ( FlaxDDIMScheduler, FlaxDDPMScheduler, FlaxDPMSolverMultistepScheduler, FlaxKarrasVeScheduler, FlaxLMSDiscreteScheduler, FlaxPNDMScheduler, FlaxSchedulerMixin, FlaxScoreSdeVeScheduler, ) try: if not (is_flax_available() and is_transformers_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_flax_and_transformers_objects import * # noqa F403 else: from .pipelines import ( FlaxStableDiffusionControlNetPipeline, FlaxStableDiffusionImgaImgPipeline, FlaxStableDiffusionInpaintPipeline, FlaxStableDiffusionPipeline, ) try: if not (is_note_seq_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from .utils.dummy_note_seq_objects import * # noqa F403 else: from .pipelines import MidiProcessor
213
"""simple docstring""" class a : """simple docstring""" def __init__( self: Dict ): """simple docstring""" A__ = {} def UpperCamelCase ( self: List[str] ): """simple docstring""" print(self.vertex ) for i in self.vertex: print(UpperCamelCase , """ -> """ , """ -> """.join([str(UpperCamelCase ) for j in self.vertex[i]] ) ) def UpperCamelCase ( self: Any , UpperCamelCase: int , UpperCamelCase: int ): """simple docstring""" if from_vertex in self.vertex: self.vertex[from_vertex].append(UpperCamelCase ) else: # else make a new vertex A__ = [to_vertex] def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = [False] * len(self.vertex ) # call the recursive helper function for i in range(len(self.vertex ) ): if not visited[i]: self.dfs_recursive(UpperCamelCase , UpperCamelCase ) def UpperCamelCase ( self: str , UpperCamelCase: int , UpperCamelCase: list ): """simple docstring""" A__ = True print(UpperCamelCase , end=""" """ ) # Recur for all the vertices that are adjacent to this node for i in self.vertex: if not visited[i]: self.dfs_recursive(UpperCamelCase , UpperCamelCase ) if __name__ == "__main__": SCREAMING_SNAKE_CASE_ : Optional[int] = Graph() g.add_edge(0, 1) g.add_edge(0, 2) g.add_edge(1, 2) g.add_edge(2, 0) g.add_edge(2, 3) g.add_edge(3, 3) g.print_graph() print('DFS:') g.dfs() # OUTPUT: # 0 -> 1 -> 2 # 1 -> 2 # 2 -> 0 -> 3 # 3 -> 3 # DFS: # 0 1 2 3
335
0
"""simple docstring""" import inspect from typing import Callable, List, Optional, Union import torch from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer from diffusers import DiffusionPipeline from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler from diffusers.utils import logging _SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) # pylint: disable=invalid-name class a ( _lowerCamelCase ): def __init__( self : List[str] , __SCREAMING_SNAKE_CASE : AutoencoderKL , __SCREAMING_SNAKE_CASE : CLIPTextModel , __SCREAMING_SNAKE_CASE : CLIPTokenizer , __SCREAMING_SNAKE_CASE : UNetaDConditionModel , __SCREAMING_SNAKE_CASE : Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler] , __SCREAMING_SNAKE_CASE : StableDiffusionSafetyChecker , __SCREAMING_SNAKE_CASE : CLIPImageProcessor , ) -> Any: super().__init__() self.register_modules( vae=__SCREAMING_SNAKE_CASE , text_encoder=__SCREAMING_SNAKE_CASE , tokenizer=__SCREAMING_SNAKE_CASE , unet=__SCREAMING_SNAKE_CASE , scheduler=__SCREAMING_SNAKE_CASE , safety_checker=__SCREAMING_SNAKE_CASE , feature_extractor=__SCREAMING_SNAKE_CASE , ) def UpperCamelCase ( self : Dict , __SCREAMING_SNAKE_CASE : Optional[Union[str, int]] = "auto" ) -> List[Any]: 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(__SCREAMING_SNAKE_CASE ) def UpperCamelCase ( self : Any ) -> Optional[Any]: self.enable_attention_slicing(__SCREAMING_SNAKE_CASE ) @torch.no_grad() def __call__( self : Union[str, Any] , __SCREAMING_SNAKE_CASE : Union[str, List[str]] , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 512 , __SCREAMING_SNAKE_CASE : int = 50 , __SCREAMING_SNAKE_CASE : float = 7.5 , __SCREAMING_SNAKE_CASE : Optional[Union[str, List[str]]] = None , __SCREAMING_SNAKE_CASE : Optional[int] = 1 , __SCREAMING_SNAKE_CASE : float = 0.0 , __SCREAMING_SNAKE_CASE : Optional[torch.Generator] = None , __SCREAMING_SNAKE_CASE : Optional[torch.FloatTensor] = None , __SCREAMING_SNAKE_CASE : Optional[str] = "pil" , __SCREAMING_SNAKE_CASE : bool = True , __SCREAMING_SNAKE_CASE : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , __SCREAMING_SNAKE_CASE : int = 1 , __SCREAMING_SNAKE_CASE : Optional[torch.FloatTensor] = None , **__SCREAMING_SNAKE_CASE : Tuple , ) -> Any: if isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): lowerCamelCase_ = 1 elif isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): lowerCamelCase_ = len(__SCREAMING_SNAKE_CASE ) else: raise ValueError(F'''`prompt` has to be of type `str` or `list` but is {type(__SCREAMING_SNAKE_CASE )}''' ) 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 (callback_steps is None) or ( callback_steps is not None and (not isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) or callback_steps <= 0) ): raise ValueError( F'''`callback_steps` has to be a positive integer but is {callback_steps} of type''' F''' {type(__SCREAMING_SNAKE_CASE )}.''' ) # get prompt text embeddings lowerCamelCase_ = self.tokenizer( __SCREAMING_SNAKE_CASE , padding='max_length' , max_length=self.tokenizer.model_max_length , return_tensors='pt' , ) lowerCamelCase_ = text_inputs.input_ids if text_input_ids.shape[-1] > self.tokenizer.model_max_length: lowerCamelCase_ = self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :] ) logger.warning( 'The following part of your input was truncated because CLIP can only handle sequences up to' F''' {self.tokenizer.model_max_length} tokens: {removed_text}''' ) lowerCamelCase_ = text_input_ids[:, : self.tokenizer.model_max_length] if text_embeddings is None: lowerCamelCase_ = self.text_encoder(text_input_ids.to(self.device ) )[0] # duplicate text embeddings for each generation per prompt, using mps friendly method lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ = text_embeddings.shape lowerCamelCase_ = text_embeddings.repeat(1 , __SCREAMING_SNAKE_CASE , 1 ) lowerCamelCase_ = text_embeddings.view(bs_embed * num_images_per_prompt , __SCREAMING_SNAKE_CASE , -1 ) # 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. lowerCamelCase_ = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: lowerCamelCase_ = 42 if negative_prompt is None: lowerCamelCase_ = [''] elif type(__SCREAMING_SNAKE_CASE ) is not type(__SCREAMING_SNAKE_CASE ): raise TypeError( F'''`negative_prompt` should be the same type to `prompt`, but got {type(__SCREAMING_SNAKE_CASE )} !=''' F''' {type(__SCREAMING_SNAKE_CASE )}.''' ) elif isinstance(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ): lowerCamelCase_ = [negative_prompt] elif batch_size != len(__SCREAMING_SNAKE_CASE ): raise ValueError( F'''`negative_prompt`: {negative_prompt} has batch size {len(__SCREAMING_SNAKE_CASE )}, but `prompt`:''' F''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches''' ' the batch size of `prompt`.' ) else: lowerCamelCase_ = negative_prompt lowerCamelCase_ = text_input_ids.shape[-1] lowerCamelCase_ = self.tokenizer( __SCREAMING_SNAKE_CASE , padding='max_length' , max_length=__SCREAMING_SNAKE_CASE , truncation=__SCREAMING_SNAKE_CASE , return_tensors='pt' , ) lowerCamelCase_ = self.text_encoder(uncond_input.input_ids.to(self.device ) )[0] # duplicate unconditional embeddings for each generation per prompt, using mps friendly method lowerCamelCase_ = uncond_embeddings.shape[1] lowerCamelCase_ = uncond_embeddings.repeat(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , 1 ) lowerCamelCase_ = uncond_embeddings.view(batch_size * num_images_per_prompt , __SCREAMING_SNAKE_CASE , -1 ) # 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([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`. lowerCamelCase_ = (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8) lowerCamelCase_ = (batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64) lowerCamelCase_ = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not exist on mps lowerCamelCase_ = torch.randn( __SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , device='cpu' , dtype=__SCREAMING_SNAKE_CASE ).to(self.device ) lowerCamelCase_ = torch.randn(__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , device='cpu' , dtype=__SCREAMING_SNAKE_CASE ).to( self.device ) else: lowerCamelCase_ = torch.randn( __SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , device=self.device , dtype=__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = torch.randn(__SCREAMING_SNAKE_CASE , generator=__SCREAMING_SNAKE_CASE , device=self.device , dtype=__SCREAMING_SNAKE_CASE ) else: if latents_reference.shape != latents_shape: raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}''' ) lowerCamelCase_ = latents_reference.to(self.device ) lowerCamelCase_ = latents.to(self.device ) # This is the key part of the pipeline where we # try to ensure that the generated images w/ the same seed # but different sizes actually result in similar images lowerCamelCase_ = (latents_shape[3] - latents_shape_reference[3]) // 2 lowerCamelCase_ = (latents_shape[2] - latents_shape_reference[2]) // 2 lowerCamelCase_ = latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx lowerCamelCase_ = latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy lowerCamelCase_ = 0 if dx < 0 else dx lowerCamelCase_ = 0 if dy < 0 else dy lowerCamelCase_ = max(-dx , 0 ) lowerCamelCase_ = max(-dy , 0 ) # import pdb # pdb.set_trace() lowerCamelCase_ = latents_reference[:, :, dy : dy + h, dx : dx + w] # set timesteps self.scheduler.set_timesteps(__SCREAMING_SNAKE_CASE ) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand lowerCamelCase_ = self.scheduler.timesteps.to(self.device ) # scale the initial noise by the standard deviation required by the scheduler lowerCamelCase_ = 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] lowerCamelCase_ = 'eta' in set(inspect.signature(self.scheduler.step ).parameters.keys() ) lowerCamelCase_ = {} if accepts_eta: lowerCamelCase_ = eta for i, t in enumerate(self.progress_bar(__SCREAMING_SNAKE_CASE ) ): # 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(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) # predict the noise residual lowerCamelCase_ = self.unet(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , encoder_hidden_states=__SCREAMING_SNAKE_CASE ).sample # perform guidance if do_classifier_free_guidance: lowerCamelCase_ , lowerCamelCase_ = noise_pred.chunk(2 ) lowerCamelCase_ = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # compute the previous noisy sample x_t -> x_t-1 lowerCamelCase_ = self.scheduler.step(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE ).prev_sample # call the callback, if provided if callback is not None and i % callback_steps == 0: callback(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE ) lowerCamelCase_ = 1 / 0.18_215 * latents lowerCamelCase_ = self.vae.decode(__SCREAMING_SNAKE_CASE ).sample lowerCamelCase_ = (image / 2 + 0.5).clamp(0 , 1 ) # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16 lowerCamelCase_ = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if self.safety_checker is not None: lowerCamelCase_ = self.feature_extractor(self.numpy_to_pil(__SCREAMING_SNAKE_CASE ) , return_tensors='pt' ).to( self.device ) lowerCamelCase_ , lowerCamelCase_ = self.safety_checker( images=__SCREAMING_SNAKE_CASE , clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype ) ) else: lowerCamelCase_ = None if output_type == "pil": lowerCamelCase_ = self.numpy_to_pil(__SCREAMING_SNAKE_CASE ) if not return_dict: return (image, has_nsfw_concept) return StableDiffusionPipelineOutput(images=__SCREAMING_SNAKE_CASE , nsfw_content_detected=__SCREAMING_SNAKE_CASE )
183
"""simple docstring""" def _snake_case ( UpperCAmelCase_ : int = 10 ): if not isinstance(UpperCAmelCase_ , UpperCAmelCase_ ) or n < 0: raise ValueError("""Invalid input""" ) A__ = 10**n A__ = 2_8433 * (pow(2 , 783_0457 , UpperCAmelCase_ )) + 1 return str(number % modulus ) if __name__ == "__main__": from doctest import testmod testmod() print(f"""{solution(1_0) = }""")
335
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available __A ={ 'configuration_longt5': ['LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LongT5Config', 'LongT5OnnxConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ 'LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST', 'LongT5EncoderModel', 'LongT5ForConditionalGeneration', 'LongT5Model', 'LongT5PreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A =[ 'FlaxLongT5ForConditionalGeneration', 'FlaxLongT5Model', 'FlaxLongT5PreTrainedModel', ] if TYPE_CHECKING: from .configuration_longta import LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP, LongTaConfig, LongTaOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_longta import ( LONGT5_PRETRAINED_MODEL_ARCHIVE_LIST, LongTaEncoderModel, LongTaForConditionalGeneration, LongTaModel, LongTaPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_longta import ( FlaxLongTaForConditionalGeneration, FlaxLongTaModel, FlaxLongTaPreTrainedModel, ) else: import sys __A =_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
226
"""simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = tuple[float, float, float] SCREAMING_SNAKE_CASE_ : Optional[int] = tuple[float, float, float] def _snake_case ( UpperCAmelCase_ : Pointad , UpperCAmelCase_ : Pointad ): A__ = end_pointa[0] - end_pointa[0] A__ = end_pointa[1] - end_pointa[1] A__ = end_pointa[2] - end_pointa[2] return (x, y, z) def _snake_case ( UpperCAmelCase_ : Vectorad , UpperCAmelCase_ : Vectorad ): A__ = ab[1] * ac[2] - ab[2] * ac[1] # *i A__ = (ab[0] * ac[2] - ab[2] * ac[0]) * -1 # *j A__ = ab[0] * ac[1] - ab[1] * ac[0] # *k return (x, y, z) def _snake_case ( UpperCAmelCase_ : Vectorad , UpperCAmelCase_ : int ): return tuple(round(UpperCAmelCase_ , UpperCAmelCase_ ) for x in vector ) == (0, 0, 0) def _snake_case ( UpperCAmelCase_ : Pointad , UpperCAmelCase_ : Pointad , UpperCAmelCase_ : Pointad , UpperCAmelCase_ : int = 10 ): A__ = create_vector(UpperCAmelCase_ , UpperCAmelCase_ ) A__ = create_vector(UpperCAmelCase_ , UpperCAmelCase_ ) return is_zero_vector(get_ad_vectors_cross(UpperCAmelCase_ , UpperCAmelCase_ ) , UpperCAmelCase_ )
335
0
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, ) SCREAMING_SNAKE_CASE :Union[str, Any] = {'configuration_mbart': ['MBART_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MBartConfig', 'MBartOnnxConfig']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE :Any = ['MBartTokenizer'] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE :Optional[Any] = ['MBartTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE :int = [ 'MBART_PRETRAINED_MODEL_ARCHIVE_LIST', 'MBartForCausalLM', 'MBartForConditionalGeneration', 'MBartForQuestionAnswering', 'MBartForSequenceClassification', 'MBartModel', 'MBartPreTrainedModel', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE :Optional[int] = [ 'TFMBartForConditionalGeneration', 'TFMBartModel', 'TFMBartPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE :Optional[int] = [ 'FlaxMBartForConditionalGeneration', 'FlaxMBartForQuestionAnswering', 'FlaxMBartForSequenceClassification', 'FlaxMBartModel', 'FlaxMBartPreTrainedModel', ] if TYPE_CHECKING: from .configuration_mbart import MBART_PRETRAINED_CONFIG_ARCHIVE_MAP, MBartConfig, MBartOnnxConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mbart import MBartTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_mbart_fast import MBartTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mbart import ( MBART_PRETRAINED_MODEL_ARCHIVE_LIST, MBartForCausalLM, MBartForConditionalGeneration, MBartForQuestionAnswering, MBartForSequenceClassification, MBartModel, MBartPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_mbart import TFMBartForConditionalGeneration, TFMBartModel, TFMBartPreTrainedModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_mbart import ( FlaxMBartForConditionalGeneration, FlaxMBartForQuestionAnswering, FlaxMBartForSequenceClassification, FlaxMBartModel, FlaxMBartPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE :Any = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
15
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available SCREAMING_SNAKE_CASE_ : Optional[int] = { 'configuration_pegasus_x': ['PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP', 'PegasusXConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE_ : Any = [ 'PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST', 'PegasusXForConditionalGeneration', 'PegasusXModel', 'PegasusXPreTrainedModel', ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE_ : str = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
335
0
from typing import Callable, Optional from .. import Features from ..packaged_modules.generator.generator import Generator from .abc import AbstractDatasetInputStream class _lowercase ( _lowerCamelCase ): """simple docstring""" def __init__(self , lowerCamelCase_ , lowerCamelCase_ = None , lowerCamelCase_ = None , lowerCamelCase_ = False , lowerCamelCase_ = False , lowerCamelCase_ = None , lowerCamelCase_ = None , **lowerCamelCase_ , ): """simple docstring""" super().__init__( features=lowerCamelCase_ , cache_dir=lowerCamelCase_ , keep_in_memory=lowerCamelCase_ , streaming=lowerCamelCase_ , num_proc=lowerCamelCase_ , **lowerCamelCase_ , ) a = Generator( cache_dir=lowerCamelCase_ , features=lowerCamelCase_ , generator=lowerCamelCase_ , gen_kwargs=lowerCamelCase_ , **lowerCamelCase_ , ) def UpperCamelCase_ (self ): """simple docstring""" if self.streaming: a = self.builder.as_streaming_dataset(split="train" ) # Build regular (map-style) dataset else: a = None a = None a = None a = None self.builder.download_and_prepare( download_config=lowerCamelCase_ , download_mode=lowerCamelCase_ , verification_mode=lowerCamelCase_ , base_path=lowerCamelCase_ , num_proc=self.num_proc , ) a = self.builder.as_dataset( split="train" , verification_mode=lowerCamelCase_ , in_memory=self.keep_in_memory ) return dataset
227
"""simple docstring""" import math class a : """simple docstring""" def __init__( self: List[Any] , UpperCamelCase: List[str]=0 ): # a graph with Node 0,1,...,N-1 """simple docstring""" A__ = n A__ = [ [math.inf for j in range(0 , UpperCamelCase )] for i in range(0 , UpperCamelCase ) ] # adjacency matrix for weight A__ = [ [math.inf for j in range(0 , UpperCamelCase )] for i in range(0 , UpperCamelCase ) ] # dp[i][j] stores minimum distance from i to j def UpperCamelCase ( self: Union[str, Any] , UpperCamelCase: Optional[int] , UpperCamelCase: Union[str, Any] , UpperCamelCase: Tuple ): """simple docstring""" A__ = w def UpperCamelCase ( self: int ): """simple docstring""" for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): A__ = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def UpperCamelCase ( self: int , UpperCamelCase: List[str] , UpperCamelCase: Dict ): """simple docstring""" return self.dp[u][v] if __name__ == "__main__": SCREAMING_SNAKE_CASE_ : List[Any] = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 1_0) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 1_0) graph.add_edge(3, 1, 2) graph.add_edge(3, 2, 1) graph.add_edge(3, 4, 6) graph.add_edge(4, 1, 3) graph.add_edge(4, 2, 4) graph.add_edge(4, 3, 9) graph.floyd_warshall() graph.show_min(1, 4) graph.show_min(0, 3)
335
0
import math import os import unittest from transformers import MegatronBertConfig, is_torch_available from transformers.models.auto import get_values from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( MODEL_FOR_PRETRAINING_MAPPING, MegatronBertForCausalLM, MegatronBertForMaskedLM, MegatronBertForMultipleChoice, MegatronBertForNextSentencePrediction, MegatronBertForPreTraining, MegatronBertForQuestionAnswering, MegatronBertForSequenceClassification, MegatronBertForTokenClassification, MegatronBertModel, ) class __lowerCAmelCase : """simple docstring""" def __init__( self , lowerCamelCase__ , lowerCamelCase__=13 , lowerCamelCase__=7 , lowerCamelCase__=True , lowerCamelCase__=True , lowerCamelCase__=True , lowerCamelCase__=True , lowerCamelCase__=99 , lowerCamelCase__=64 , lowerCamelCase__=32 , lowerCamelCase__=5 , lowerCamelCase__=4 , lowerCamelCase__=37 , lowerCamelCase__="gelu" , lowerCamelCase__=0.1 , lowerCamelCase__=0.1 , lowerCamelCase__=512 , lowerCamelCase__=16 , lowerCamelCase__=2 , lowerCamelCase__=0.02 , lowerCamelCase__=3 , lowerCamelCase__=4 , lowerCamelCase__=None , ) -> Dict: '''simple docstring''' __lowerCamelCase = parent __lowerCamelCase = batch_size __lowerCamelCase = seq_length __lowerCamelCase = is_training __lowerCamelCase = use_input_mask __lowerCamelCase = use_token_type_ids __lowerCamelCase = use_labels __lowerCamelCase = vocab_size __lowerCamelCase = hidden_size __lowerCamelCase = embedding_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 def lowercase_ ( self ) -> Union[str, Any]: '''simple docstring''' __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 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 = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def lowercase_ ( self ) -> int: '''simple docstring''' return MegatronBertConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , embedding_size=self.embedding_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=lowerCamelCase__ , initializer_range=self.initializer_range , ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> List[Any]: '''simple docstring''' __lowerCamelCase = MegatronBertModel(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model(lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ ) __lowerCamelCase = model(lowerCamelCase__ , token_type_ids=lowerCamelCase__ ) __lowerCamelCase = model(lowerCamelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.hidden_size) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> Any: '''simple docstring''' __lowerCamelCase = MegatronBertForMaskedLM(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model(lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , labels=lowerCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> str: '''simple docstring''' __lowerCamelCase = MegatronBertForCausalLM(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model(lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , labels=lowerCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> Optional[int]: '''simple docstring''' __lowerCamelCase = MegatronBertForNextSentencePrediction(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model( lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , labels=lowerCamelCase__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, 2) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> Tuple: '''simple docstring''' __lowerCamelCase = MegatronBertForPreTraining(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model( lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , labels=lowerCamelCase__ , next_sentence_label=lowerCamelCase__ , ) self.parent.assertEqual(result.prediction_logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) self.parent.assertEqual(result.seq_relationship_logits.shape , (self.batch_size, 2) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> Dict: '''simple docstring''' __lowerCamelCase = MegatronBertForQuestionAnswering(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model( lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , start_positions=lowerCamelCase__ , end_positions=lowerCamelCase__ , ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> Any: '''simple docstring''' __lowerCamelCase = self.num_labels __lowerCamelCase = MegatronBertForSequenceClassification(lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model(lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , labels=lowerCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> Optional[int]: '''simple docstring''' __lowerCamelCase = self.num_labels __lowerCamelCase = MegatronBertForTokenClassification(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = model(lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , labels=lowerCamelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) -> str: '''simple docstring''' __lowerCamelCase = self.num_choices __lowerCamelCase = MegatronBertForMultipleChoice(config=lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.eval() __lowerCamelCase = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowerCamelCase = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowerCamelCase = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() __lowerCamelCase = model( lowerCamelCase__ , attention_mask=lowerCamelCase__ , token_type_ids=lowerCamelCase__ , labels=lowerCamelCase__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def lowercase_ ( self ) -> str: '''simple docstring''' __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, 'attention_mask': input_mask} return config, inputs_dict @require_torch class __lowerCAmelCase ( _lowerCamelCase , _lowerCamelCase , unittest.TestCase ): """simple docstring""" snake_case_ = ( ( MegatronBertModel, MegatronBertForMaskedLM, MegatronBertForCausalLM, MegatronBertForMultipleChoice, MegatronBertForNextSentencePrediction, MegatronBertForPreTraining, MegatronBertForQuestionAnswering, MegatronBertForSequenceClassification, MegatronBertForTokenClassification, ) if is_torch_available() else () ) snake_case_ = ( { '''feature-extraction''': MegatronBertModel, '''fill-mask''': MegatronBertForMaskedLM, '''question-answering''': MegatronBertForQuestionAnswering, '''text-classification''': MegatronBertForSequenceClassification, '''text-generation''': MegatronBertForCausalLM, '''token-classification''': MegatronBertForTokenClassification, '''zero-shot''': MegatronBertForSequenceClassification, } if is_torch_available() else {} ) snake_case_ = True # test_resize_embeddings = False snake_case_ = False def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__=False ) -> Optional[int]: '''simple docstring''' __lowerCamelCase = super()._prepare_for_class(lowerCamelCase__ , lowerCamelCase__ , return_labels=lowerCamelCase__ ) if return_labels: if model_class in get_values(lowerCamelCase__ ): __lowerCamelCase = torch.zeros( (self.model_tester.batch_size, self.model_tester.seq_length) , dtype=torch.long , device=lowerCamelCase__ ) __lowerCamelCase = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowerCamelCase__ ) return inputs_dict def lowercase_ ( self ) -> List[Any]: '''simple docstring''' __lowerCamelCase = MegatronBertModelTester(self ) __lowerCamelCase = ConfigTester(self , config_class=lowerCamelCase__ , hidden_size=37 ) def lowercase_ ( self ) -> int: '''simple docstring''' self.config_tester.run_common_tests() def lowercase_ ( self ) -> int: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_model(*lowerCamelCase__ ) def lowercase_ ( self ) -> Dict: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_masked_lm(*lowerCamelCase__ ) def lowercase_ ( self ) -> Optional[Any]: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_multiple_choice(*lowerCamelCase__ ) def lowercase_ ( self ) -> List[Any]: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_next_sequence_prediction(*lowerCamelCase__ ) def lowercase_ ( self ) -> Union[str, Any]: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_pretraining(*lowerCamelCase__ ) def lowercase_ ( self ) -> Any: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_question_answering(*lowerCamelCase__ ) def lowercase_ ( self ) -> Optional[Any]: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_sequence_classification(*lowerCamelCase__ ) def lowercase_ ( self ) -> Union[str, Any]: '''simple docstring''' __lowerCamelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_megatron_bert_for_token_classification(*lowerCamelCase__ ) def lowerCamelCase_ ( UpperCamelCase__ : List[Any] ) -> List[str]: """simple docstring""" return torch.tensor( UpperCAmelCase_ , dtype=torch.long , device=UpperCAmelCase_ , ) __A = 1e-4 @require_torch @require_sentencepiece @require_tokenizers class __lowerCAmelCase ( unittest.TestCase ): """simple docstring""" @slow @unittest.skip('Model is not available.' ) def lowercase_ ( self ) -> str: '''simple docstring''' __lowerCamelCase = 'nvidia/megatron-bert-uncased-345m' if "MYDIR" in os.environ: __lowerCamelCase = os.path.join(os.environ['MYDIR'] , lowerCamelCase__ ) __lowerCamelCase = MegatronBertModel.from_pretrained(lowerCamelCase__ ) model.to(lowerCamelCase__ ) model.half() __lowerCamelCase = _long_tensor([[101, 7_110, 1_005, 1_056, 2_023, 11_333, 17_413, 1_029, 102]] ) with torch.no_grad(): __lowerCamelCase = model(lowerCamelCase__ )[0] __lowerCamelCase = torch.Size((1, 9, 1_024) ) self.assertEqual(output.shape , lowerCamelCase__ ) __lowerCamelCase = [-0.60_40, -0.25_17, -0.10_25, 0.34_20, -0.67_58, -0.00_17, -0.10_89, -0.19_90, 0.57_28] for ii in range(3 ): for jj in range(3 ): __lowerCamelCase = output[0, ii, jj] __lowerCamelCase = expected[3 * ii + jj] __lowerCamelCase = 'ii={} jj={} a={} b={}'.format(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) self.assertTrue(math.isclose(lowerCamelCase__ , lowerCamelCase__ , rel_tol=lowerCamelCase__ , abs_tol=lowerCamelCase__ ) , msg=lowerCamelCase__ )
90
"""simple docstring""" import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import MgpstrTokenizer from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES from transformers.testing_utils import require_torch, require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_torch_available, is_vision_available if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import MgpstrProcessor, ViTImageProcessor @require_torch @require_vision class a ( unittest.TestCase ): """simple docstring""" UpperCAmelCase = ViTImageProcessor if is_vision_available() else None @property def UpperCamelCase ( self: str ): """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def UpperCamelCase ( self: List[Any] ): """simple docstring""" A__ = (3, 32, 1_28) A__ = tempfile.mkdtemp() # fmt: off A__ = ["""[GO]""", """[s]""", """0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9""", """a""", """b""", """c""", """d""", """e""", """f""", """g""", """h""", """i""", """j""", """k""", """l""", """m""", """n""", """o""", """p""", """q""", """r""", """s""", """t""", """u""", """v""", """w""", """x""", """y""", """z"""] # fmt: on A__ = dict(zip(UpperCamelCase , range(len(UpperCamelCase ) ) ) ) A__ = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as fp: fp.write(json.dumps(UpperCamelCase ) + """\n""" ) A__ = { """do_normalize""": False, """do_resize""": True, """image_processor_type""": """ViTImageProcessor""", """resample""": 3, """size""": {"""height""": 32, """width""": 1_28}, } A__ = os.path.join(self.tmpdirname , UpperCamelCase ) with open(self.image_processor_file , """w""" , encoding="""utf-8""" ) as fp: json.dump(UpperCamelCase , UpperCamelCase ) def UpperCamelCase ( self: List[str] , **UpperCamelCase: Union[str, Any] ): """simple docstring""" return MgpstrTokenizer.from_pretrained(self.tmpdirname , **UpperCamelCase ) def UpperCamelCase ( self: List[Any] , **UpperCamelCase: str ): """simple docstring""" return ViTImageProcessor.from_pretrained(self.tmpdirname , **UpperCamelCase ) def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" shutil.rmtree(self.tmpdirname ) def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta ) A__ = Image.fromarray(np.moveaxis(UpperCamelCase , 0 , -1 ) ) return image_input def UpperCamelCase ( self: Tuple ): """simple docstring""" A__ = self.get_tokenizer() A__ = self.get_image_processor() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) processor.save_pretrained(self.tmpdirname ) A__ = MgpstrProcessor.from_pretrained(self.tmpdirname , use_fast=UpperCamelCase ) self.assertEqual(processor.char_tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.char_tokenizer , UpperCamelCase ) self.assertEqual(processor.image_processor.to_json_string() , image_processor.to_json_string() ) self.assertIsInstance(processor.image_processor , UpperCamelCase ) def UpperCamelCase ( self: Dict ): """simple docstring""" A__ = self.get_tokenizer() A__ = self.get_image_processor() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) processor.save_pretrained(self.tmpdirname ) A__ = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) A__ = self.get_image_processor(do_normalize=UpperCamelCase , padding_value=1.0 ) A__ = MgpstrProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=UpperCamelCase , padding_value=1.0 ) self.assertEqual(processor.char_tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.char_tokenizer , UpperCamelCase ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , UpperCamelCase ) def UpperCamelCase ( self: List[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = self.prepare_image_inputs() A__ = image_processor(UpperCamelCase , return_tensors="""np""" ) A__ = processor(images=UpperCamelCase , return_tensors="""np""" ) for key in input_image_proc.keys(): self.assertAlmostEqual(input_image_proc[key].sum() , input_processor[key].sum() , delta=1e-2 ) def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = """test""" A__ = processor(text=UpperCamelCase ) A__ = tokenizer(UpperCamelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = """test""" A__ = self.prepare_image_inputs() A__ = processor(text=UpperCamelCase , images=UpperCamelCase ) self.assertListEqual(list(inputs.keys() ) , ["""pixel_values""", """labels"""] ) # test if it raises when no input is passed with pytest.raises(UpperCamelCase ): processor() def UpperCamelCase ( self: List[str] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9], [3, 4, 3, 1, 1, 8, 9]] A__ = processor.char_decode(UpperCamelCase ) A__ = tokenizer.batch_decode(UpperCamelCase ) A__ = [seq.replace(""" """ , """""" ) for seq in decoded_tok] self.assertListEqual(UpperCamelCase , UpperCamelCase ) def UpperCamelCase ( self: List[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = None A__ = self.prepare_image_inputs() A__ = processor(text=UpperCamelCase , images=UpperCamelCase ) self.assertListEqual(list(inputs.keys() ) , processor.model_input_names ) def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = torch.randn(1 , 27 , 38 ) A__ = torch.randn(1 , 27 , 5_02_57 ) A__ = torch.randn(1 , 27 , 3_05_22 ) A__ = processor.batch_decode([char_input, bpe_input, wp_input] ) self.assertListEqual(list(results.keys() ) , ["""generated_text""", """scores""", """char_preds""", """bpe_preds""", """wp_preds"""] )
335
0
"""simple docstring""" from dataclasses import dataclass from typing import Optional, Tuple, Union import torch import torch.nn as nn from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, apply_forward_hook from .modeling_utils import ModelMixin from .vae import Decoder, DecoderOutput, Encoder, VectorQuantizer @dataclass class lowerCAmelCase__ ( _lowerCamelCase ): '''simple docstring''' lowerCamelCase__ = 42 class lowerCAmelCase__ ( _lowerCamelCase, _lowerCamelCase ): '''simple docstring''' @register_to_config def __init__( self , lowercase = 3 , lowercase = 3 , lowercase = ("DownEncoderBlock2D",) , lowercase = ("UpDecoderBlock2D",) , lowercase = (64,) , lowercase = 1 , lowercase = "silu" , lowercase = 3 , lowercase = 32 , lowercase = 256 , lowercase = 32 , lowercase = None , lowercase = 0.1_82_15 , lowercase = "group" , ): super().__init__() # pass init params to Encoder _lowerCamelCase : Dict = Encoder( in_channels=lowercase , out_channels=lowercase , down_block_types=lowercase , block_out_channels=lowercase , layers_per_block=lowercase , act_fn=lowercase , norm_num_groups=lowercase , double_z=lowercase , ) _lowerCamelCase : Any = vq_embed_dim if vq_embed_dim is not None else latent_channels _lowerCamelCase : Dict = nn.Convad(lowercase , lowercase , 1 ) _lowerCamelCase : str = VectorQuantizer(lowercase , lowercase , beta=0.25 , remap=lowercase , sane_index_shape=lowercase ) _lowerCamelCase : Union[str, Any] = nn.Convad(lowercase , lowercase , 1 ) # pass init params to Decoder _lowerCamelCase : Union[str, Any] = Decoder( in_channels=lowercase , out_channels=lowercase , up_block_types=lowercase , block_out_channels=lowercase , layers_per_block=lowercase , act_fn=lowercase , norm_num_groups=lowercase , norm_type=lowercase , ) @apply_forward_hook def A_ ( self , lowercase , lowercase = True ): _lowerCamelCase : Any = self.encoder(lowercase ) _lowerCamelCase : Optional[int] = self.quant_conv(lowercase ) if not return_dict: return (h,) return VQEncoderOutput(latents=lowercase ) @apply_forward_hook def A_ ( self , lowercase , lowercase = False , lowercase = True ): if not force_not_quantize: _lowerCamelCase, _lowerCamelCase, _lowerCamelCase : str = self.quantize(lowercase ) else: _lowerCamelCase : List[Any] = h _lowerCamelCase : Tuple = self.post_quant_conv(lowercase ) _lowerCamelCase : str = self.decoder(lowercase , quant if self.config.norm_type == 'spatial' else None ) if not return_dict: return (dec,) return DecoderOutput(sample=lowercase ) def A_ ( self , lowercase , lowercase = True ): _lowerCamelCase : List[Any] = sample _lowerCamelCase : Dict = self.encode(lowercase ).latents _lowerCamelCase : Any = self.decode(lowercase ).sample if not return_dict: return (dec,) return DecoderOutput(sample=lowercase )
96
"""simple docstring""" import math def _snake_case ( UpperCAmelCase_ : float , UpperCAmelCase_ : float ): if initial_intensity < 0: raise ValueError("""The value of intensity cannot be negative""" ) # handling of negative values of initial intensity if angle < 0 or angle > 360: raise ValueError("""In Malus Law, the angle is in the range 0-360 degrees""" ) # handling of values out of allowed range return initial_intensity * (math.cos(math.radians(UpperCAmelCase_ ) ) ** 2) if __name__ == "__main__": import doctest doctest.testmod(name='malus_law')
335
0
"""simple docstring""" import logging from dataclasses import dataclass, field from pathlib import Path from typing import Optional, Union from .generation.configuration_utils import GenerationConfig from .training_args import TrainingArguments from .utils import add_start_docstrings _lowerCamelCase : Any = logging.getLogger(__name__) @dataclass @add_start_docstrings(TrainingArguments.__doc__) class lowercase ( _lowerCamelCase): __lowerCAmelCase : int = field(default=_lowerCamelCase , metadata={"""help""": """Whether to use SortishSampler or not."""}) __lowerCAmelCase : int = field( default=_lowerCamelCase , metadata={"""help""": """Whether to use generate to calculate generative metrics (ROUGE, BLEU)."""}) __lowerCAmelCase : Optional[int] = field( default=_lowerCamelCase , metadata={ """help""": ( """The `max_length` to use on each evaluation loop when `predict_with_generate=True`. Will default """ """to the `max_length` value of the model configuration.""" ) } , ) __lowerCAmelCase : Dict = field( default=_lowerCamelCase , metadata={ """help""": ( """The `num_beams` to use on each evaluation loop when `predict_with_generate=True`. Will default """ """to the `num_beams` value of the model configuration.""" ) } , ) __lowerCAmelCase : Optional[Any] = field( default=_lowerCamelCase , metadata={ """help""": """Model id, file path or url pointing to a GenerationConfig json file, to use during prediction.""" } , ) def a_ ( self : int ): """simple docstring""" A_ : int = super().to_dict() for k, v in d.items(): if isinstance(_lowerCamelCase , _lowerCamelCase ): A_ : List[str] = v.to_dict() return d
167
"""simple docstring""" import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class a ( unittest.TestCase ): """simple docstring""" def UpperCamelCase ( self: Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self: Dict ): """simple docstring""" A__ = 1 A__ = 3 A__ = (32, 32) A__ = floats_tensor((batch_size, num_channels) + sizes , rng=random.Random(0 ) ).to(UpperCamelCase ) return image @property def UpperCamelCase ( self: int ): """simple docstring""" torch.manual_seed(0 ) A__ = 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 , ) return model @property def UpperCamelCase ( self: Tuple ): """simple docstring""" torch.manual_seed(0 ) A__ = 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 , ) return model @property def UpperCamelCase ( self: List[Any] ): """simple docstring""" torch.manual_seed(0 ) A__ = RobertaSeriesConfig( hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-0_5 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=50_06 , ) return RobertaSeriesModelWithTransformation(UpperCamelCase ) @property def UpperCamelCase ( self: str ): """simple docstring""" def extract(*UpperCamelCase: List[str] , **UpperCamelCase: Any ): class a : """simple docstring""" def __init__( self: Any ): """simple docstring""" A__ = torch.ones([0] ) def UpperCamelCase ( self: Dict , UpperCamelCase: Optional[Any] ): """simple docstring""" self.pixel_values.to(UpperCamelCase ) return self return Out() return extract def UpperCamelCase ( self: str ): """simple docstring""" A__ = """cpu""" # ensure determinism for the device-dependent torch.Generator A__ = self.dummy_cond_unet A__ = PNDMScheduler(skip_prk_steps=UpperCamelCase ) A__ = self.dummy_vae A__ = self.dummy_text_encoder A__ = XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta""" ) A__ = 77 A__ = self.dummy_image.to(UpperCamelCase ) A__ = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk A__ = AltDiffusionImgaImgPipeline( unet=UpperCamelCase , scheduler=UpperCamelCase , vae=UpperCamelCase , text_encoder=UpperCamelCase , tokenizer=UpperCamelCase , safety_checker=UpperCamelCase , feature_extractor=self.dummy_extractor , ) A__ = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=UpperCamelCase ) A__ = alt_pipe.to(UpperCamelCase ) alt_pipe.set_progress_bar_config(disable=UpperCamelCase ) A__ = """A painting of a squirrel eating a burger""" A__ = torch.Generator(device=UpperCamelCase ).manual_seed(0 ) A__ = alt_pipe( [prompt] , generator=UpperCamelCase , guidance_scale=6.0 , num_inference_steps=2 , output_type="""np""" , image=UpperCamelCase , ) A__ = output.images A__ = torch.Generator(device=UpperCamelCase ).manual_seed(0 ) A__ = alt_pipe( [prompt] , generator=UpperCamelCase , guidance_scale=6.0 , num_inference_steps=2 , output_type="""np""" , image=UpperCamelCase , return_dict=UpperCamelCase , )[0] A__ = image[0, -3:, -3:, -1] A__ = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) A__ = np.array([0.4_427, 0.3_731, 0.4_249, 0.4_941, 0.4_546, 0.4_148, 0.4_193, 0.4_666, 0.4_499] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 5e-3 @unittest.skipIf(torch_device != """cuda""" , """This test requires a GPU""" ) def UpperCamelCase ( self: int ): """simple docstring""" A__ = self.dummy_cond_unet A__ = PNDMScheduler(skip_prk_steps=UpperCamelCase ) A__ = self.dummy_vae A__ = self.dummy_text_encoder A__ = XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta""" ) A__ = 77 A__ = self.dummy_image.to(UpperCamelCase ) # put models in fp16 A__ = unet.half() A__ = vae.half() A__ = bert.half() # make sure here that pndm scheduler skips prk A__ = AltDiffusionImgaImgPipeline( unet=UpperCamelCase , scheduler=UpperCamelCase , vae=UpperCamelCase , text_encoder=UpperCamelCase , tokenizer=UpperCamelCase , safety_checker=UpperCamelCase , feature_extractor=self.dummy_extractor , ) A__ = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=UpperCamelCase ) A__ = alt_pipe.to(UpperCamelCase ) alt_pipe.set_progress_bar_config(disable=UpperCamelCase ) A__ = """A painting of a squirrel eating a burger""" A__ = torch.manual_seed(0 ) A__ = alt_pipe( [prompt] , generator=UpperCamelCase , num_inference_steps=2 , output_type="""np""" , image=UpperCamelCase , ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != """cuda""" , """This test requires a GPU""" ) def UpperCamelCase ( self: str ): """simple docstring""" A__ = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/img2img/sketch-mountains-input.jpg""" ) # resize to resolution that is divisible by 8 but not 16 or 32 A__ = init_image.resize((7_60, 5_04) ) A__ = """BAAI/AltDiffusion""" A__ = AltDiffusionImgaImgPipeline.from_pretrained( UpperCamelCase , safety_checker=UpperCamelCase , ) pipe.to(UpperCamelCase ) pipe.set_progress_bar_config(disable=UpperCamelCase ) pipe.enable_attention_slicing() A__ = """A fantasy landscape, trending on artstation""" A__ = torch.manual_seed(0 ) A__ = pipe( prompt=UpperCamelCase , image=UpperCamelCase , strength=0.75 , guidance_scale=7.5 , generator=UpperCamelCase , output_type="""np""" , ) A__ = output.images[0] A__ = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) A__ = np.array([0.9_358, 0.9_397, 0.9_599, 0.9_901, 1.0_000, 1.0_000, 0.9_882, 1.0_000, 1.0_000] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 @slow @require_torch_gpu class a ( unittest.TestCase ): """simple docstring""" def UpperCamelCase ( self: Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self: List[str] ): """simple docstring""" A__ = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/img2img/sketch-mountains-input.jpg""" ) A__ = init_image.resize((7_68, 5_12) ) A__ = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy""" ) A__ = """BAAI/AltDiffusion""" A__ = AltDiffusionImgaImgPipeline.from_pretrained( UpperCamelCase , safety_checker=UpperCamelCase , ) pipe.to(UpperCamelCase ) pipe.set_progress_bar_config(disable=UpperCamelCase ) pipe.enable_attention_slicing() A__ = """A fantasy landscape, trending on artstation""" A__ = torch.manual_seed(0 ) A__ = pipe( prompt=UpperCamelCase , image=UpperCamelCase , strength=0.75 , guidance_scale=7.5 , generator=UpperCamelCase , output_type="""np""" , ) A__ = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image ).max() < 1e-2
335
0
'''simple docstring''' import argparse import torch # Step 1. clone https://github.com/microsoft/unilm # Step 2. git checkout to https://github.com/microsoft/unilm/commit/b94ec76c36f02fb2b0bf0dcb0b8554a2185173cd # Step 3. cd unilm # Step 4. ln -s $(realpath wavlm/modules.py) ./ # create simlink # import classes from unilm.wavlm.WavLM import WavLM as WavLMOrig from unilm.wavlm.WavLM import WavLMConfig as WavLMConfigOrig from transformers import WavLMConfig, WavLMModel, logging logging.set_verbosity_info() _SCREAMING_SNAKE_CASE = logging.get_logger(__name__) _SCREAMING_SNAKE_CASE = { '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.grep_linear': 'encoder.layers.*.attention.gru_rel_pos_linear', 'self_attn.relative_attention_bias': 'encoder.layers.*.attention.rel_attn_embed', 'self_attn.grep_a': 'encoder.layers.*.attention.gru_rel_pos_const', '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', } _SCREAMING_SNAKE_CASE = [ 'ctc_proj', 'quantizer.weight_proj', 'quantizer.codevectors', 'project_q', 'project_hid', ] def __a(SCREAMING_SNAKE_CASE_ : List[Any] , SCREAMING_SNAKE_CASE_ : Optional[int] , SCREAMING_SNAKE_CASE_ : Union[str, Any] , SCREAMING_SNAKE_CASE_ : int , SCREAMING_SNAKE_CASE_ : Optional[Any] ): '''simple docstring''' for attribute in key.split("." ): _lowerCAmelCase = getattr(UpperCAmelCase_ , UpperCAmelCase_ ) if weight_type is not None: _lowerCAmelCase = getattr(UpperCAmelCase_ , UpperCAmelCase_ ).shape else: _lowerCAmelCase = 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": _lowerCAmelCase = value elif weight_type == "weight_g": _lowerCAmelCase = value elif weight_type == "weight_v": _lowerCAmelCase = value elif weight_type == "bias": _lowerCAmelCase = value else: _lowerCAmelCase = value logger.info(F'''{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.''' ) def __a(SCREAMING_SNAKE_CASE_ : int , SCREAMING_SNAKE_CASE_ : Dict ): '''simple docstring''' _lowerCAmelCase = [] _lowerCAmelCase = fairseq_model.state_dict() _lowerCAmelCase = hf_model.feature_extractor for name, value in fairseq_dict.items(): _lowerCAmelCase = False if "conv_layers" in name: load_conv_layer( UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , hf_model.config.feat_extract_norm == "group" , ) _lowerCAmelCase = True else: for key, mapped_key in MAPPING.items(): if key in name or key.split("w2v_model." )[-1] == name.split("." )[0]: _lowerCAmelCase = True if "*" in mapped_key: _lowerCAmelCase = name.split(UpperCAmelCase_ )[0].split("." )[-2] _lowerCAmelCase = mapped_key.replace("*" , UpperCAmelCase_ ) if "weight_g" in name: _lowerCAmelCase = "weight_g" elif "weight_v" in name: _lowerCAmelCase = "weight_v" elif "bias" in name and "relative_attention_bias" not in name: _lowerCAmelCase = "bias" elif "weight" in name: # TODO: don't match quantizer.weight_proj _lowerCAmelCase = "weight" else: _lowerCAmelCase = None set_recursively(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) continue if not is_used: unused_weights.append(UpperCAmelCase_ ) logger.warning(F'''Unused weights: {unused_weights}''' ) def __a(SCREAMING_SNAKE_CASE_ : List[str] , SCREAMING_SNAKE_CASE_ : int , SCREAMING_SNAKE_CASE_ : Tuple , SCREAMING_SNAKE_CASE_ : Any , SCREAMING_SNAKE_CASE_ : Dict ): '''simple docstring''' _lowerCAmelCase = full_name.split("conv_layers." )[-1] _lowerCAmelCase = name.split("." ) _lowerCAmelCase = int(items[0] ) _lowerCAmelCase = 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.''' ) _lowerCAmelCase = 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.''' ) _lowerCAmelCase = 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." ) _lowerCAmelCase = 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.''' ) _lowerCAmelCase = value logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' ) else: unused_weights.append(UpperCAmelCase_ ) @torch.no_grad() def __a(SCREAMING_SNAKE_CASE_ : List[Any] , SCREAMING_SNAKE_CASE_ : Union[str, Any] , SCREAMING_SNAKE_CASE_ : Optional[int]=None ): '''simple docstring''' _lowerCAmelCase = torch.load(UpperCAmelCase_ ) _lowerCAmelCase = WavLMConfigOrig(checkpoint["cfg"] ) _lowerCAmelCase = WavLMOrig(UpperCAmelCase_ ) model.load_state_dict(checkpoint["model"] ) model.eval() if config_path is not None: _lowerCAmelCase = WavLMConfig.from_pretrained(UpperCAmelCase_ ) else: _lowerCAmelCase = WavLMConfig() _lowerCAmelCase = WavLMModel(UpperCAmelCase_ ) recursively_load_weights(UpperCAmelCase_ , UpperCAmelCase_ ) hf_wavlm.save_pretrained(UpperCAmelCase_ ) if __name__ == "__main__": _SCREAMING_SNAKE_CASE = argparse.ArgumentParser() parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.") parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") _SCREAMING_SNAKE_CASE = parser.parse_args() convert_wavlm_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
158
"""simple docstring""" import os import time import pytest from datasets.utils.filelock import FileLock, Timeout def _snake_case ( UpperCAmelCase_ : List[Any] ): A__ = FileLock(str(tmpdir / """foo.lock""" ) ) A__ = FileLock(str(tmpdir / """foo.lock""" ) ) A__ = 0.01 with locka.acquire(): with pytest.raises(UpperCAmelCase_ ): A__ = time.time() locka.acquire(UpperCAmelCase_ ) assert time.time() - _start > timeout def _snake_case ( UpperCAmelCase_ : List[Any] ): A__ = """a""" * 1000 + """.lock""" A__ = FileLock(str(tmpdir / filename ) ) assert locka._lock_file.endswith(""".lock""" ) assert not locka._lock_file.endswith(UpperCAmelCase_ ) assert len(os.path.basename(locka._lock_file ) ) <= 255 A__ = FileLock(tmpdir / filename ) with locka.acquire(): with pytest.raises(UpperCAmelCase_ ): locka.acquire(0 )
335
0
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 DeformableDetrImageProcessor class UpperCamelCase__ ( unittest.TestCase ): def __init__(self : Optional[int] , snake_case_ : List[str] , snake_case_ : List[Any]=7 , snake_case_ : Tuple=3 , snake_case_ : Any=3_0 , snake_case_ : Union[str, Any]=4_0_0 , snake_case_ : Optional[int]=True , snake_case_ : int=None , snake_case_ : List[str]=True , snake_case_ : Tuple=[0.5, 0.5, 0.5] , snake_case_ : Any=[0.5, 0.5, 0.5] , snake_case_ : int=True , snake_case_ : Optional[Any]=1 / 2_5_5 , snake_case_ : str=True , ): __a : Optional[int] = size if size is not None else {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3} __a : Dict = parent __a : Optional[int] = batch_size __a : str = num_channels __a : Optional[int] = min_resolution __a : str = max_resolution __a : Optional[Any] = do_resize __a : Any = size __a : str = do_normalize __a : List[Any] = image_mean __a : List[Any] = image_std __a : List[Any] = do_rescale __a : Tuple = rescale_factor __a : Union[str, Any] = do_pad def lowerCAmelCase (self : Tuple ): 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 lowerCAmelCase (self : Union[str, Any] , snake_case_ : Union[str, Any] , snake_case_ : int=False ): if not batched: __a : List[Any] = image_inputs[0] if isinstance(snake_case_ , Image.Image ): __a , __a : int = image.size else: __a , __a : Union[str, Any] = image.shape[1], image.shape[2] if w < h: __a : Union[str, Any] = int(self.size['''shortest_edge'''] * h / w ) __a : Union[str, Any] = self.size['''shortest_edge'''] elif w > h: __a : Tuple = self.size['''shortest_edge'''] __a : Tuple = int(self.size['''shortest_edge'''] * w / h ) else: __a : List[str] = self.size['''shortest_edge'''] __a : Tuple = self.size['''shortest_edge'''] else: __a : Optional[Any] = [] for image in image_inputs: __a , __a : Optional[Any] = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) __a : Union[str, Any] = max(snake_case_ , key=lambda snake_case_ : item[0] )[0] __a : Any = max(snake_case_ , key=lambda snake_case_ : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class UpperCamelCase__ ( _lowerCamelCase ,unittest.TestCase ): _SCREAMING_SNAKE_CASE : str = DeformableDetrImageProcessor if is_vision_available() else None def lowerCAmelCase (self : Any ): __a : Dict = DeformableDetrImageProcessingTester(self ) @property def lowerCAmelCase (self : Any ): return self.image_processor_tester.prepare_image_processor_dict() def lowerCAmelCase (self : Optional[int] ): __a : List[str] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(snake_case_ , '''image_mean''' ) ) self.assertTrue(hasattr(snake_case_ , '''image_std''' ) ) self.assertTrue(hasattr(snake_case_ , '''do_normalize''' ) ) self.assertTrue(hasattr(snake_case_ , '''do_resize''' ) ) self.assertTrue(hasattr(snake_case_ , '''do_rescale''' ) ) self.assertTrue(hasattr(snake_case_ , '''do_pad''' ) ) self.assertTrue(hasattr(snake_case_ , '''size''' ) ) def lowerCAmelCase (self : int ): __a : Any = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size , {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3} ) self.assertEqual(image_processor.do_pad , snake_case_ ) __a : Optional[Any] = self.image_processing_class.from_dict( self.image_processor_dict , size=4_2 , max_size=8_4 , pad_and_return_pixel_mask=snake_case_ ) self.assertEqual(image_processor.size , {'''shortest_edge''': 4_2, '''longest_edge''': 8_4} ) self.assertEqual(image_processor.do_pad , snake_case_ ) def lowerCAmelCase (self : Tuple ): pass def lowerCAmelCase (self : List[Any] ): __a : Union[str, Any] = self.image_processing_class(**self.image_processor_dict ) # create random PIL images __a : List[Any] = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case_ ) for image in image_inputs: self.assertIsInstance(snake_case_ , Image.Image ) # Test not batched input __a : Tuple = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values __a , __a : Union[str, Any] = self.image_processor_tester.get_expected_values(snake_case_ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched __a , __a : List[Any] = self.image_processor_tester.get_expected_values(snake_case_ , batched=snake_case_ ) __a : Dict = image_processing(snake_case_ , 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 lowerCAmelCase (self : Union[str, Any] ): __a : int = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors __a : Tuple = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case_ , numpify=snake_case_ ) for image in image_inputs: self.assertIsInstance(snake_case_ , np.ndarray ) # Test not batched input __a : Tuple = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values __a , __a : str = self.image_processor_tester.get_expected_values(snake_case_ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched __a : Any = image_processing(snake_case_ , return_tensors='''pt''' ).pixel_values __a , __a : str = self.image_processor_tester.get_expected_values(snake_case_ , batched=snake_case_ ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def lowerCAmelCase (self : Any ): __a : List[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors __a : Tuple = prepare_image_inputs(self.image_processor_tester , equal_resolution=snake_case_ , torchify=snake_case_ ) for image in image_inputs: self.assertIsInstance(snake_case_ , torch.Tensor ) # Test not batched input __a : Any = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values __a , __a : Optional[int] = self.image_processor_tester.get_expected_values(snake_case_ ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched __a : str = image_processing(snake_case_ , return_tensors='''pt''' ).pixel_values __a , __a : str = self.image_processor_tester.get_expected_values(snake_case_ , batched=snake_case_ ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) @slow def lowerCAmelCase (self : Union[str, Any] ): __a : Optional[Any] = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) with open('''./tests/fixtures/tests_samples/COCO/coco_annotations.txt''' , '''r''' ) as f: __a : str = json.loads(f.read() ) __a : List[Any] = {'''image_id''': 3_9_7_6_9, '''annotations''': target} # encode them __a : Dict = DeformableDetrImageProcessor() __a : Dict = image_processing(images=snake_case_ , annotations=snake_case_ , return_tensors='''pt''' ) # verify pixel values __a : List[str] = torch.Size([1, 3, 8_0_0, 1_0_6_6] ) self.assertEqual(encoding['''pixel_values'''].shape , snake_case_ ) __a : Tuple = torch.tensor([0.2796, 0.3138, 0.3481] ) self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3] , snake_case_ , atol=1E-4 ) ) # verify area __a : int = torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area'''] , snake_case_ ) ) # verify boxes __a : List[str] = torch.Size([6, 4] ) self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape , snake_case_ ) __a : List[str] = torch.tensor([0.5503, 0.2765, 0.0604, 0.2215] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0] , snake_case_ , atol=1E-3 ) ) # verify image_id __a : Any = torch.tensor([3_9_7_6_9] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id'''] , snake_case_ ) ) # verify is_crowd __a : str = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd'''] , snake_case_ ) ) # verify class_labels __a : int = torch.tensor([7_5, 7_5, 6_3, 6_5, 1_7, 1_7] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels'''] , snake_case_ ) ) # verify orig_size __a : Any = torch.tensor([4_8_0, 6_4_0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size'''] , snake_case_ ) ) # verify size __a : str = torch.tensor([8_0_0, 1_0_6_6] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size'''] , snake_case_ ) ) @slow def lowerCAmelCase (self : int ): __a : str = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) with open('''./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt''' , '''r''' ) as f: __a : Optional[Any] = json.loads(f.read() ) __a : int = {'''file_name''': '''000000039769.png''', '''image_id''': 3_9_7_6_9, '''segments_info''': target} __a : int = pathlib.Path('''./tests/fixtures/tests_samples/COCO/coco_panoptic''' ) # encode them __a : Tuple = DeformableDetrImageProcessor(format='''coco_panoptic''' ) __a : Tuple = image_processing(images=snake_case_ , annotations=snake_case_ , masks_path=snake_case_ , return_tensors='''pt''' ) # verify pixel values __a : Tuple = torch.Size([1, 3, 8_0_0, 1_0_6_6] ) self.assertEqual(encoding['''pixel_values'''].shape , snake_case_ ) __a : Dict = torch.tensor([0.2796, 0.3138, 0.3481] ) self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3] , snake_case_ , atol=1E-4 ) ) # verify area __a : str = torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area'''] , snake_case_ ) ) # verify boxes __a : Union[str, Any] = torch.Size([6, 4] ) self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape , snake_case_ ) __a : List[Any] = torch.tensor([0.2625, 0.5437, 0.4688, 0.8625] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0] , snake_case_ , atol=1E-3 ) ) # verify image_id __a : Union[str, Any] = torch.tensor([3_9_7_6_9] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id'''] , snake_case_ ) ) # verify is_crowd __a : int = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd'''] , snake_case_ ) ) # verify class_labels __a : List[str] = torch.tensor([1_7, 1_7, 6_3, 7_5, 7_5, 9_3] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels'''] , snake_case_ ) ) # verify masks __a : Optional[Any] = 8_2_2_8_7_3 self.assertEqual(encoding['''labels'''][0]['''masks'''].sum().item() , snake_case_ ) # verify orig_size __a : Tuple = torch.tensor([4_8_0, 6_4_0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size'''] , snake_case_ ) ) # verify size __a : Optional[int] = torch.tensor([8_0_0, 1_0_6_6] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size'''] , snake_case_ ) )
216
"""simple docstring""" # Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import TYPE_CHECKING import torch from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor from ..utils import requires_backends from .base import PipelineTool if TYPE_CHECKING: from PIL import Image class a ( _lowerCamelCase ): """simple docstring""" UpperCAmelCase = "dandelin/vilt-b32-finetuned-vqa" UpperCAmelCase = ( "This is a tool that answers a question about an image. It takes an input named `image` which should be the " "image containing the information, as well as a `question` which should be the question in English. It " "returns a text that is the answer to the question." ) UpperCAmelCase = "image_qa" UpperCAmelCase = AutoProcessor UpperCAmelCase = AutoModelForVisualQuestionAnswering UpperCAmelCase = ["image", "text"] UpperCAmelCase = ["text"] def __init__( self: List[str] , *UpperCamelCase: Dict , **UpperCamelCase: List[str] ): """simple docstring""" requires_backends(self , ["""vision"""] ) super().__init__(*UpperCamelCase , **UpperCamelCase ) def UpperCamelCase ( self: str , UpperCamelCase: "Image" , UpperCamelCase: str ): """simple docstring""" return self.pre_processor(UpperCamelCase , UpperCamelCase , return_tensors="""pt""" ) def UpperCamelCase ( self: str , UpperCamelCase: str ): """simple docstring""" with torch.no_grad(): return self.model(**UpperCamelCase ).logits def UpperCamelCase ( self: Union[str, Any] , UpperCamelCase: int ): """simple docstring""" A__ = outputs.argmax(-1 ).item() return self.model.config.idalabel[idx]
335
0
"""simple docstring""" from typing import TYPE_CHECKING import torch from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor from ..utils import requires_backends from .base import PipelineTool if TYPE_CHECKING: from PIL import Image class SCREAMING_SNAKE_CASE__ ( _lowerCamelCase ): _a = 'dandelin/vilt-b32-finetuned-vqa' _a = ( 'This is a tool that answers a question about an image. It takes an input named `image` which should be the ' 'image containing the information, as well as a `question` which should be the question in English. It ' 'returns a text that is the answer to the question.' ) _a = 'image_qa' _a = AutoProcessor _a = AutoModelForVisualQuestionAnswering _a = ['image', 'text'] _a = ['text'] def __init__( self : List[str] , *lowerCAmelCase : Dict , **lowerCAmelCase : List[str] ): requires_backends(self , ["""vision"""] ) super().__init__(*lowerCAmelCase , **lowerCAmelCase ) def __lowercase ( self : str , lowerCAmelCase : "Image" , lowerCAmelCase : str ): return self.pre_processor(lowerCAmelCase , lowerCAmelCase , return_tensors="""pt""" ) def __lowercase ( self : str , lowerCAmelCase : str ): with torch.no_grad(): return self.model(**lowerCAmelCase ).logits def __lowercase ( self : Union[str, Any] , lowerCAmelCase : int ): lowerCAmelCase = outputs.argmax(-1 ).item() return self.model.config.idalabel[idx]
155
"""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 a ( unittest.TestCase ): """simple docstring""" def __init__( self: Optional[Any] , UpperCamelCase: Any , UpperCamelCase: Optional[int]=7 , UpperCamelCase: str=3 , UpperCamelCase: int=30 , UpperCamelCase: int=4_00 , UpperCamelCase: Union[str, Any]=True , UpperCamelCase: Tuple=None , UpperCamelCase: Any=True , UpperCamelCase: int=[0.5, 0.5, 0.5] , UpperCamelCase: Any=[0.5, 0.5, 0.5] , UpperCamelCase: Optional[Any]=True , UpperCamelCase: List[Any]=1 / 2_55 , UpperCamelCase: Tuple=True , ): """simple docstring""" A__ = size if size is not None else {"""shortest_edge""": 18, """longest_edge""": 13_33} A__ = parent A__ = batch_size A__ = num_channels A__ = min_resolution A__ = max_resolution A__ = do_resize A__ = size A__ = do_normalize A__ = image_mean A__ = image_std A__ = do_rescale A__ = rescale_factor A__ = do_pad def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" 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 UpperCamelCase ( self: Any , UpperCamelCase: List[str] , UpperCamelCase: int=False ): """simple docstring""" if not batched: A__ = image_inputs[0] if isinstance(UpperCamelCase , Image.Image ): A__ , A__ = image.size else: A__ , A__ = image.shape[1], image.shape[2] if w < h: A__ = int(self.size["""shortest_edge"""] * h / w ) A__ = self.size["""shortest_edge"""] elif w > h: A__ = self.size["""shortest_edge"""] A__ = int(self.size["""shortest_edge"""] * w / h ) else: A__ = self.size["""shortest_edge"""] A__ = self.size["""shortest_edge"""] else: A__ = [] for image in image_inputs: A__ , A__ = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) A__ = max(UpperCamelCase , key=lambda UpperCamelCase : item[0] )[0] A__ = max(UpperCamelCase , key=lambda UpperCamelCase : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class a ( _lowerCamelCase, unittest.TestCase ): """simple docstring""" UpperCAmelCase = YolosImageProcessor if is_vision_available() else None def UpperCamelCase ( self: Optional[int] ): """simple docstring""" A__ = YolosImageProcessingTester(self ) @property def UpperCamelCase ( self: Optional[int] ): """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(UpperCamelCase , """image_mean""" ) ) self.assertTrue(hasattr(UpperCamelCase , """image_std""" ) ) self.assertTrue(hasattr(UpperCamelCase , """do_normalize""" ) ) self.assertTrue(hasattr(UpperCamelCase , """do_resize""" ) ) self.assertTrue(hasattr(UpperCamelCase , """size""" ) ) def UpperCamelCase ( self: Tuple ): """simple docstring""" A__ = 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 , UpperCamelCase ) A__ = self.image_processing_class.from_dict( self.image_processor_dict , size=42 , max_size=84 , pad_and_return_pixel_mask=UpperCamelCase ) self.assertEqual(image_processor.size , {"""shortest_edge""": 42, """longest_edge""": 84} ) self.assertEqual(image_processor.do_pad , UpperCamelCase ) def UpperCamelCase ( self: str ): """simple docstring""" pass def UpperCamelCase ( self: str ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) # create random PIL images A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , Image.Image ) # Test not batched input A__ = image_processing(image_inputs[0] , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase , batched=UpperCamelCase ) A__ = image_processing(UpperCamelCase , 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 UpperCamelCase ( self: Tuple ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase , numpify=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , np.ndarray ) # Test not batched input A__ = image_processing(image_inputs[0] , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched A__ = image_processing(UpperCamelCase , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase , batched=UpperCamelCase ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self: str ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase , torchify=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , torch.Tensor ) # Test not batched input A__ = image_processing(image_inputs[0] , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched A__ = image_processing(UpperCamelCase , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase , batched=UpperCamelCase ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self: str ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) A__ = self.image_processing_class(do_resize=UpperCamelCase , do_normalize=UpperCamelCase , do_rescale=UpperCamelCase ) # create random PyTorch tensors A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase , torchify=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , torch.Tensor ) # Test whether the method "pad" and calling the image processor return the same tensors A__ = image_processing_a.pad(UpperCamelCase , return_tensors="""pt""" ) A__ = image_processing_a(UpperCamelCase , return_tensors="""pt""" ) self.assertTrue( torch.allclose(encoded_images_with_method["""pixel_values"""] , encoded_images["""pixel_values"""] , atol=1e-4 ) ) @slow def UpperCamelCase ( self: str ): """simple docstring""" A__ = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) with open("""./tests/fixtures/tests_samples/COCO/coco_annotations.txt""" , """r""" ) as f: A__ = json.loads(f.read() ) A__ = {"""image_id""": 3_97_69, """annotations""": target} # encode them A__ = YolosImageProcessor.from_pretrained("""hustvl/yolos-small""" ) A__ = image_processing(images=UpperCamelCase , annotations=UpperCamelCase , return_tensors="""pt""" ) # verify pixel values A__ = torch.Size([1, 3, 8_00, 10_66] ) self.assertEqual(encoding["""pixel_values"""].shape , UpperCamelCase ) A__ = torch.tensor([0.2_796, 0.3_138, 0.3_481] ) self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3] , UpperCamelCase , atol=1e-4 ) ) # verify area A__ = torch.tensor([5_887.9_600, 11_250.2_061, 489_353.8_438, 837_122.7_500, 147_967.5_156, 165_732.3_438] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""] , UpperCamelCase ) ) # verify boxes A__ = torch.Size([6, 4] ) self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape , UpperCamelCase ) A__ = torch.tensor([0.5_503, 0.2_765, 0.0_604, 0.2_215] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0] , UpperCamelCase , atol=1e-3 ) ) # verify image_id A__ = torch.tensor([3_97_69] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""] , UpperCamelCase ) ) # verify is_crowd A__ = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""] , UpperCamelCase ) ) # verify class_labels A__ = torch.tensor([75, 75, 63, 65, 17, 17] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""] , UpperCamelCase ) ) # verify orig_size A__ = torch.tensor([4_80, 6_40] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""] , UpperCamelCase ) ) # verify size A__ = torch.tensor([8_00, 10_66] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""] , UpperCamelCase ) ) @slow def UpperCamelCase ( self: int ): """simple docstring""" A__ = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) with open("""./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt""" , """r""" ) as f: A__ = json.loads(f.read() ) A__ = {"""file_name""": """000000039769.png""", """image_id""": 3_97_69, """segments_info""": target} A__ = pathlib.Path("""./tests/fixtures/tests_samples/COCO/coco_panoptic""" ) # encode them A__ = YolosImageProcessor(format="""coco_panoptic""" ) A__ = image_processing(images=UpperCamelCase , annotations=UpperCamelCase , masks_path=UpperCamelCase , return_tensors="""pt""" ) # verify pixel values A__ = torch.Size([1, 3, 8_00, 10_66] ) self.assertEqual(encoding["""pixel_values"""].shape , UpperCamelCase ) A__ = torch.tensor([0.2_796, 0.3_138, 0.3_481] ) self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3] , UpperCamelCase , atol=1e-4 ) ) # verify area A__ = torch.tensor([147_979.6_875, 165_527.0_469, 484_638.5_938, 11_292.9_375, 5_879.6_562, 7_634.1_147] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""] , UpperCamelCase ) ) # verify boxes A__ = torch.Size([6, 4] ) self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape , UpperCamelCase ) A__ = torch.tensor([0.2_625, 0.5_437, 0.4_688, 0.8_625] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0] , UpperCamelCase , atol=1e-3 ) ) # verify image_id A__ = torch.tensor([3_97_69] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""] , UpperCamelCase ) ) # verify is_crowd A__ = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""] , UpperCamelCase ) ) # verify class_labels A__ = torch.tensor([17, 17, 63, 75, 75, 93] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""] , UpperCamelCase ) ) # verify masks A__ = 82_28_73 self.assertEqual(encoding["""labels"""][0]["""masks"""].sum().item() , UpperCamelCase ) # verify orig_size A__ = torch.tensor([4_80, 6_40] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""] , UpperCamelCase ) ) # verify size A__ = torch.tensor([8_00, 10_66] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""] , UpperCamelCase ) )
335
0
"""simple docstring""" import logging import os import sys from pathlib import Path from unittest.mock import patch from parameterized import parameterized from run_eval import run_generate from run_eval_search import run_search from transformers.testing_utils import CaptureStdout, TestCasePlus, slow from utils import ROUGE_KEYS logging.basicConfig(level=logging.DEBUG) __SCREAMING_SNAKE_CASE =logging.getLogger() def lowercase__( __SCREAMING_SNAKE_CASE : Path , __SCREAMING_SNAKE_CASE : list ): lowercase_ : List[str] = '\n'.join(UpperCAmelCase_ ) Path(UpperCAmelCase_ ).open('w' ).writelines(UpperCAmelCase_ ) __SCREAMING_SNAKE_CASE ='patrickvonplaten/t5-tiny-random' __SCREAMING_SNAKE_CASE ='sshleifer/bart-tiny-random' __SCREAMING_SNAKE_CASE ='sshleifer/tiny-mbart' __SCREAMING_SNAKE_CASE =logging.StreamHandler(sys.stdout) logger.addHandler(stream_handler) logging.disable(logging.CRITICAL) # remove noisy download output from tracebacks class UpperCamelCase ( _lowerCamelCase ): def _UpperCAmelCase ( self ,__UpperCamelCase ) -> int: '''simple docstring''' lowercase_ : Tuple = Path(self.get_auto_remove_tmp_dir() ) / 'utest_input.source' lowercase_ : List[str] = input_file_name.parent / 'utest_output.txt' assert not output_file_name.exists() lowercase_ : Optional[Any] = [' New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County.'] _dump_articles(__UpperCamelCase ,__UpperCamelCase ) lowercase_ : Optional[Any] = str(Path(self.get_auto_remove_tmp_dir() ) / 'scores.json' ) lowercase_ : Union[str, Any] = 'translation_en_to_de' if model == T5_TINY else 'summarization' lowercase_ : Optional[int] = f''' run_eval_search.py {model} {input_file_name} {output_file_name} --score_path {score_path} --task {task} --num_beams 2 --length_penalty 2.0 '''.split() with patch.object(__UpperCamelCase ,'argv' ,__UpperCamelCase ): run_generate() assert Path(__UpperCamelCase ).exists() # os.remove(Path(output_file_name)) def _UpperCAmelCase ( self ) -> Tuple: '''simple docstring''' self.run_eval_tester(__UpperCamelCase ) @parameterized.expand([BART_TINY, MBART_TINY] ) @slow def _UpperCAmelCase ( self ,__UpperCamelCase ) -> Tuple: '''simple docstring''' self.run_eval_tester(__UpperCamelCase ) @parameterized.expand([T5_TINY, MBART_TINY] ) @slow def _UpperCAmelCase ( self ,__UpperCamelCase ) -> Dict: '''simple docstring''' lowercase_ : Any = Path(self.get_auto_remove_tmp_dir() ) / 'utest_input.source' lowercase_ : str = input_file_name.parent / 'utest_output.txt' assert not output_file_name.exists() lowercase_ : Union[str, Any] = { 'en': ['Machine learning is great, isn\'t it?', 'I like to eat bananas', 'Tomorrow is another great day!'], 'de': [ 'Maschinelles Lernen ist großartig, oder?', 'Ich esse gerne Bananen', 'Morgen ist wieder ein toller Tag!', ], } lowercase_ : Any = Path(self.get_auto_remove_tmp_dir() ) lowercase_ : Tuple = str(tmp_dir / 'scores.json' ) lowercase_ : List[str] = str(tmp_dir / 'val.target' ) _dump_articles(__UpperCamelCase ,text['en'] ) _dump_articles(__UpperCamelCase ,text['de'] ) lowercase_ : Union[str, Any] = 'translation_en_to_de' if model == T5_TINY else 'summarization' lowercase_ : str = f''' run_eval_search.py {model} {str(__UpperCamelCase )} {str(__UpperCamelCase )} --score_path {score_path} --reference_path {reference_path} --task {task} '''.split() testargs.extend(['--search', 'num_beams=1:2 length_penalty=0.9:1.0'] ) with patch.object(__UpperCamelCase ,'argv' ,__UpperCamelCase ): with CaptureStdout() as cs: run_search() lowercase_ : int = [' num_beams | length_penalty', model, 'Best score args'] lowercase_ : int = ['Info'] if "translation" in task: expected_strings.append('bleu' ) else: expected_strings.extend(__UpperCamelCase ) for w in expected_strings: assert w in cs.out for w in un_expected_strings: assert w not in cs.out assert Path(__UpperCamelCase ).exists() os.remove(Path(__UpperCamelCase ) )
213
"""simple docstring""" def _snake_case ( UpperCAmelCase_ : Dict ): # noqa: E741 A__ = len(UpperCAmelCase_ ) A__ = 0 A__ = [0] * n A__ = [False] * n A__ = [False] * n def dfs(UpperCAmelCase_ : List[str] , UpperCAmelCase_ : int , UpperCAmelCase_ : Dict , UpperCAmelCase_ : List[Any] ): if parent == root: out_edge_count += 1 A__ = True A__ = at for to in l[at]: if to == parent: pass elif not visited[to]: A__ = dfs(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) A__ = min(low[at] , low[to] ) # AP found via bridge if at < low[to]: A__ = True # AP found via cycle if at == low[to]: A__ = True else: A__ = min(low[at] , UpperCAmelCase_ ) return out_edge_count for i in range(UpperCAmelCase_ ): if not visited[i]: A__ = 0 A__ = dfs(UpperCAmelCase_ , UpperCAmelCase_ , -1 , UpperCAmelCase_ ) A__ = out_edge_count > 1 for x in range(len(UpperCAmelCase_ ) ): if is_art[x] is True: print(UpperCAmelCase_ ) # Adjacency list of graph SCREAMING_SNAKE_CASE_ : Optional[int] = { 0: [1, 2], 1: [0, 2], 2: [0, 1, 3, 5], 3: [2, 4], 4: [3], 5: [2, 6, 8], 6: [5, 7], 7: [6, 8], 8: [5, 7], } compute_ap(data)
335
0
"""simple docstring""" from packaging import version from .import_utils import is_accelerate_available if is_accelerate_available(): import accelerate def lowerCamelCase__ ( _lowerCamelCase : Dict ) -> int: if not is_accelerate_available(): return method lowerCamelCase_ = version.parse(accelerate.__version__ ).base_version if version.parse(UpperCAmelCase_ ) < version.parse('0.17.0' ): return method def wrapper(self : int , *_lowerCamelCase : Tuple , **_lowerCamelCase : Dict ): if hasattr(self , '_hf_hook' ) and hasattr(self._hf_hook , 'pre_forward' ): self._hf_hook.pre_forward(self ) return method(self , *UpperCAmelCase_ , **UpperCAmelCase_ ) return wrapper
183
"""simple docstring""" import unittest import torch from torch import nn from diffusers.models.activations import get_activation class a ( unittest.TestCase ): """simple docstring""" def UpperCamelCase ( self: str ): """simple docstring""" A__ = get_activation("""swish""" ) self.assertIsInstance(UpperCamelCase , nn.SiLU ) self.assertEqual(act(torch.tensor(-1_00 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 ) def UpperCamelCase ( self: Any ): """simple docstring""" A__ = get_activation("""silu""" ) self.assertIsInstance(UpperCamelCase , nn.SiLU ) self.assertEqual(act(torch.tensor(-1_00 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 ) def UpperCamelCase ( self: Optional[int] ): """simple docstring""" A__ = get_activation("""mish""" ) self.assertIsInstance(UpperCamelCase , nn.Mish ) self.assertEqual(act(torch.tensor(-2_00 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 ) def UpperCamelCase ( self: Any ): """simple docstring""" A__ = get_activation("""gelu""" ) self.assertIsInstance(UpperCamelCase , nn.GELU ) self.assertEqual(act(torch.tensor(-1_00 , dtype=torch.floataa ) ).item() , 0 ) self.assertNotEqual(act(torch.tensor(-1 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(0 , dtype=torch.floataa ) ).item() , 0 ) self.assertEqual(act(torch.tensor(20 , dtype=torch.floataa ) ).item() , 20 )
335
0
from typing import List, Optional, Union import torch from transformers import ( XLMRobertaTokenizer, ) from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDIMScheduler, DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) from .text_encoder import MultilingualCLIP __A =logging.get_logger(__name__) # pylint: disable=invalid-name __A ='\n Examples:\n ```py\n >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline\n >>> import torch\n\n >>> pipe_prior = KandinskyPriorPipeline.from_pretrained("kandinsky-community/Kandinsky-2-1-prior")\n >>> pipe_prior.to("cuda")\n\n >>> prompt = "red cat, 4k photo"\n >>> out = pipe_prior(prompt)\n >>> image_emb = out.image_embeds\n >>> negative_image_emb = out.negative_image_embeds\n\n >>> pipe = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1")\n >>> pipe.to("cuda")\n\n >>> image = pipe(\n ... prompt,\n ... image_embeds=image_emb,\n ... negative_image_embeds=negative_image_emb,\n ... height=768,\n ... width=768,\n ... num_inference_steps=100,\n ... ).images\n\n >>> image[0].save("cat.png")\n ```\n' def a ( _UpperCAmelCase : Tuple , _UpperCAmelCase : List[Any] , _UpperCAmelCase : Optional[int]=8 ): '''simple docstring''' __UpperCAmelCase : List[Any] = h // scale_factor**2 if h % scale_factor**2 != 0: new_h += 1 __UpperCAmelCase : Union[str, Any] = w // scale_factor**2 if w % scale_factor**2 != 0: new_w += 1 return new_h * scale_factor, new_w * scale_factor class UpperCAmelCase__ ( _lowerCamelCase ): '''simple docstring''' def __init__( self : Any , a_ : MultilingualCLIP , a_ : XLMRobertaTokenizer , a_ : UNetaDConditionModel , a_ : Union[DDIMScheduler, DDPMScheduler] , a_ : VQModel , ): '''simple docstring''' super().__init__() self.register_modules( text_encoder=a_ , tokenizer=a_ , unet=a_ , scheduler=a_ , movq=a_ , ) __UpperCAmelCase : Optional[int] = 2 ** (len(self.movq.config.block_out_channels ) - 1) def snake_case__ ( self : Any , a_ : Optional[int] , a_ : str , a_ : Optional[Any] , a_ : List[str] , a_ : int , a_ : Optional[Any] ): '''simple docstring''' if latents is None: __UpperCAmelCase : Optional[int] = randn_tensor(a_ , generator=a_ , device=a_ , dtype=a_ ) else: if latents.shape != shape: raise ValueError(F'Unexpected latents shape, got {latents.shape}, expected {shape}' ) __UpperCAmelCase : int = latents.to(a_ ) __UpperCAmelCase : Union[str, Any] = latents * scheduler.init_noise_sigma return latents def snake_case__ ( self : Tuple , a_ : Union[str, Any] , a_ : List[str] , a_ : Optional[Any] , a_ : Any , a_ : List[str]=None , ): '''simple docstring''' __UpperCAmelCase : Union[str, Any] = len(a_ ) if isinstance(a_ , a_ ) else 1 # get prompt text embeddings __UpperCAmelCase : Dict = self.tokenizer( a_ , padding='''max_length''' , truncation=a_ , max_length=77 , return_attention_mask=a_ , add_special_tokens=a_ , return_tensors='''pt''' , ) __UpperCAmelCase : Dict = text_inputs.input_ids __UpperCAmelCase : Union[str, Any] = self.tokenizer(a_ , padding='''longest''' , return_tensors='''pt''' ).input_ids if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(a_ , a_ ): __UpperCAmelCase : Dict = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1] ) logger.warning( '''The following part of your input was truncated because CLIP can only handle sequences up to''' F' {self.tokenizer.model_max_length} tokens: {removed_text}' ) __UpperCAmelCase : str = text_input_ids.to(a_ ) __UpperCAmelCase : Optional[int] = text_inputs.attention_mask.to(a_ ) __UpperCAmelCase , __UpperCAmelCase : Optional[Any] = self.text_encoder( input_ids=a_ , attention_mask=a_ ) __UpperCAmelCase : Union[str, Any] = prompt_embeds.repeat_interleave(a_ , dim=0 ) __UpperCAmelCase : str = text_encoder_hidden_states.repeat_interleave(a_ , dim=0 ) __UpperCAmelCase : int = text_mask.repeat_interleave(a_ , dim=0 ) if do_classifier_free_guidance: __UpperCAmelCase : Optional[Any] = 42 if negative_prompt is None: __UpperCAmelCase : int = [''''''] * batch_size elif type(a_ ) is not type(a_ ): raise TypeError( F'`negative_prompt` should be the same type to `prompt`, but got {type(a_ )} !=' F' {type(a_ )}.' ) elif isinstance(a_ , a_ ): __UpperCAmelCase : int = [negative_prompt] elif batch_size != len(a_ ): raise ValueError( F'`negative_prompt`: {negative_prompt} has batch size {len(a_ )}, but `prompt`:' F' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches' ''' the batch size of `prompt`.''' ) else: __UpperCAmelCase : Dict = negative_prompt __UpperCAmelCase : int = self.tokenizer( a_ , padding='''max_length''' , max_length=77 , truncation=a_ , return_attention_mask=a_ , add_special_tokens=a_ , return_tensors='''pt''' , ) __UpperCAmelCase : List[str] = uncond_input.input_ids.to(a_ ) __UpperCAmelCase : Optional[int] = uncond_input.attention_mask.to(a_ ) __UpperCAmelCase , __UpperCAmelCase : int = self.text_encoder( input_ids=a_ , attention_mask=a_ ) # duplicate unconditional embeddings for each generation per prompt, using mps friendly method __UpperCAmelCase : Optional[int] = negative_prompt_embeds.shape[1] __UpperCAmelCase : Dict = negative_prompt_embeds.repeat(1 , a_ ) __UpperCAmelCase : Tuple = negative_prompt_embeds.view(batch_size * num_images_per_prompt , a_ ) __UpperCAmelCase : str = uncond_text_encoder_hidden_states.shape[1] __UpperCAmelCase : Union[str, Any] = uncond_text_encoder_hidden_states.repeat(1 , a_ , 1 ) __UpperCAmelCase : Tuple = uncond_text_encoder_hidden_states.view( batch_size * num_images_per_prompt , a_ , -1 ) __UpperCAmelCase : Optional[int] = uncond_text_mask.repeat_interleave(a_ , dim=0 ) # done duplicates # 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 __UpperCAmelCase : Tuple = torch.cat([negative_prompt_embeds, prompt_embeds] ) __UpperCAmelCase : str = torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states] ) __UpperCAmelCase : List[Any] = torch.cat([uncond_text_mask, text_mask] ) return prompt_embeds, text_encoder_hidden_states, text_mask def snake_case__ ( self : List[str] , a_ : Dict=0 ): '''simple docstring''' if is_accelerate_available(): from accelerate import cpu_offload else: raise ImportError('''Please install accelerate via `pip install accelerate`''' ) __UpperCAmelCase : List[Any] = torch.device(F'cuda:{gpu_id}' ) __UpperCAmelCase : int = [ self.unet, self.text_encoder, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(a_ , a_ ) def snake_case__ ( self : List[Any] , a_ : Union[str, Any]=0 ): '''simple docstring''' if is_accelerate_available() and is_accelerate_version('''>=''' , '''0.17.0.dev0''' ): from accelerate import cpu_offload_with_hook else: raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.''' ) __UpperCAmelCase : Tuple = torch.device(F'cuda:{gpu_id}' ) if self.device.type != "cpu": self.to('''cpu''' , silence_dtype_warnings=a_ ) torch.cuda.empty_cache() # otherwise we don't see the memory savings (but they probably exist) __UpperCAmelCase : int = None for cpu_offloaded_model in [self.text_encoder, self.unet, self.movq]: __UpperCAmelCase , __UpperCAmelCase : str = cpu_offload_with_hook(a_ , a_ , prev_module_hook=a_ ) if self.safety_checker is not None: __UpperCAmelCase , __UpperCAmelCase : Optional[Any] = cpu_offload_with_hook(self.safety_checker , a_ , prev_module_hook=a_ ) # We'll offload the last model manually. __UpperCAmelCase : List[Any] = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def snake_case__ ( self : Dict ): '''simple docstring''' if not hasattr(self.unet , '''_hf_hook''' ): return self.device for module in self.unet.modules(): if ( hasattr(a_ , '''_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() @replace_example_docstring(a_ ) def __call__( self : Optional[int] , a_ : Union[str, List[str]] , a_ : Union[torch.FloatTensor, List[torch.FloatTensor]] , a_ : Union[torch.FloatTensor, List[torch.FloatTensor]] , a_ : Optional[Union[str, List[str]]] = None , a_ : int = 5_12 , a_ : int = 5_12 , a_ : int = 1_00 , a_ : float = 4.0 , a_ : int = 1 , a_ : Optional[Union[torch.Generator, List[torch.Generator]]] = None , a_ : Optional[torch.FloatTensor] = None , a_ : Optional[str] = "pil" , a_ : bool = True , ): '''simple docstring''' if isinstance(a_ , a_ ): __UpperCAmelCase : int = 1 elif isinstance(a_ , a_ ): __UpperCAmelCase : Dict = len(a_ ) else: raise ValueError(F'`prompt` has to be of type `str` or `list` but is {type(a_ )}' ) __UpperCAmelCase : Optional[int] = self._execution_device __UpperCAmelCase : int = batch_size * num_images_per_prompt __UpperCAmelCase : Optional[int] = guidance_scale > 1.0 __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase : Tuple = self._encode_prompt( a_ , a_ , a_ , a_ , a_ ) if isinstance(a_ , a_ ): __UpperCAmelCase : Optional[Any] = torch.cat(a_ , dim=0 ) if isinstance(a_ , a_ ): __UpperCAmelCase : Any = torch.cat(a_ , dim=0 ) if do_classifier_free_guidance: __UpperCAmelCase : Optional[Any] = image_embeds.repeat_interleave(a_ , dim=0 ) __UpperCAmelCase : Dict = negative_image_embeds.repeat_interleave(a_ , dim=0 ) __UpperCAmelCase : int = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to( dtype=prompt_embeds.dtype , device=a_ ) self.scheduler.set_timesteps(a_ , device=a_ ) __UpperCAmelCase : Any = self.scheduler.timesteps __UpperCAmelCase : Dict = self.unet.config.in_channels __UpperCAmelCase , __UpperCAmelCase : Union[str, Any] = get_new_h_w(a_ , a_ , self.movq_scale_factor ) # create initial latent __UpperCAmelCase : Union[str, Any] = self.prepare_latents( (batch_size, num_channels_latents, height, width) , text_encoder_hidden_states.dtype , a_ , a_ , a_ , self.scheduler , ) for i, t in enumerate(self.progress_bar(a_ ) ): # expand the latents if we are doing classifier free guidance __UpperCAmelCase : str = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents __UpperCAmelCase : int = {'''text_embeds''': prompt_embeds, '''image_embeds''': image_embeds} __UpperCAmelCase : List[str] = self.unet( sample=a_ , timestep=a_ , encoder_hidden_states=a_ , added_cond_kwargs=a_ , return_dict=a_ , )[0] if do_classifier_free_guidance: __UpperCAmelCase , __UpperCAmelCase : Dict = noise_pred.split(latents.shape[1] , dim=1 ) __UpperCAmelCase , __UpperCAmelCase : Optional[int] = noise_pred.chunk(2 ) __UpperCAmelCase , __UpperCAmelCase : Any = variance_pred.chunk(2 ) __UpperCAmelCase : Any = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) __UpperCAmelCase : Optional[Any] = torch.cat([noise_pred, variance_pred_text] , dim=1 ) if not ( hasattr(self.scheduler.config , '''variance_type''' ) and self.scheduler.config.variance_type in ["learned", "learned_range"] ): __UpperCAmelCase , __UpperCAmelCase : int = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 __UpperCAmelCase : Tuple = self.scheduler.step( a_ , a_ , a_ , generator=a_ , ).prev_sample # post-processing __UpperCAmelCase : str = self.movq.decode(a_ , force_not_quantize=a_ )['''sample'''] if output_type not in ["pt", "np", "pil"]: raise ValueError(F'Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}' ) if output_type in ["np", "pil"]: __UpperCAmelCase : Union[str, Any] = image * 0.5 + 0.5 __UpperCAmelCase : Dict = image.clamp(0 , 1 ) __UpperCAmelCase : List[Any] = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": __UpperCAmelCase : Optional[Any] = self.numpy_to_pil(a_ ) if not return_dict: return (image,) return ImagePipelineOutput(images=a_ )
226
"""simple docstring""" from __future__ import absolute_import, division, print_function, unicode_literals from torch import nn from torch.nn import CrossEntropyLoss, MSELoss from transformers import RobertaConfig from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward from transformers.models.roberta.modeling_roberta import ( ROBERTA_INPUTS_DOCSTRING, ROBERTA_START_DOCSTRING, RobertaEmbeddings, ) from .modeling_highway_bert import BertPreTrainedModel, DeeBertModel, HighwayException, entropy @add_start_docstrings( "The RoBERTa Model transformer with early exiting (DeeRoBERTa). ", _lowerCamelCase, ) class a ( _lowerCamelCase ): """simple docstring""" UpperCAmelCase = RobertaConfig UpperCAmelCase = "roberta" def __init__( self: Union[str, Any] , UpperCamelCase: Any ): """simple docstring""" super().__init__(UpperCamelCase ) A__ = RobertaEmbeddings(UpperCamelCase ) self.init_weights() @add_start_docstrings( "RoBERTa Model (with early exiting - DeeRoBERTa) with a classifier on top,\n also takes care of multi-layer training. ", _lowerCamelCase, ) class a ( _lowerCamelCase ): """simple docstring""" UpperCAmelCase = RobertaConfig UpperCAmelCase = "roberta" def __init__( self: Optional[Any] , UpperCamelCase: int ): """simple docstring""" super().__init__(UpperCamelCase ) A__ = config.num_labels A__ = config.num_hidden_layers A__ = DeeRobertaModel(UpperCamelCase ) A__ = nn.Dropout(config.hidden_dropout_prob ) A__ = nn.Linear(config.hidden_size , self.config.num_labels ) @add_start_docstrings_to_model_forward(UpperCamelCase ) def UpperCamelCase ( self: Union[str, Any] , UpperCamelCase: Optional[int]=None , UpperCamelCase: str=None , UpperCamelCase: str=None , UpperCamelCase: List[str]=None , UpperCamelCase: Dict=None , UpperCamelCase: List[Any]=None , UpperCamelCase: Tuple=None , UpperCamelCase: Optional[int]=-1 , UpperCamelCase: Optional[Any]=False , ): """simple docstring""" A__ = self.num_layers try: A__ = self.roberta( UpperCamelCase , attention_mask=UpperCamelCase , token_type_ids=UpperCamelCase , position_ids=UpperCamelCase , head_mask=UpperCamelCase , inputs_embeds=UpperCamelCase , ) A__ = outputs[1] A__ = self.dropout(UpperCamelCase ) A__ = self.classifier(UpperCamelCase ) A__ = (logits,) + outputs[2:] # add hidden states and attention if they are here except HighwayException as e: A__ = e.message A__ = e.exit_layer A__ = outputs[0] if not self.training: A__ = entropy(UpperCamelCase ) A__ = [] A__ = [] if labels is not None: if self.num_labels == 1: # We are doing regression A__ = MSELoss() A__ = loss_fct(logits.view(-1 ) , labels.view(-1 ) ) else: A__ = CrossEntropyLoss() A__ = loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) # work with highway exits A__ = [] for highway_exit in outputs[-1]: A__ = highway_exit[0] if not self.training: highway_logits_all.append(UpperCamelCase ) highway_entropy.append(highway_exit[2] ) if self.num_labels == 1: # We are doing regression A__ = MSELoss() A__ = loss_fct(highway_logits.view(-1 ) , labels.view(-1 ) ) else: A__ = CrossEntropyLoss() A__ = loss_fct(highway_logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) highway_losses.append(UpperCamelCase ) if train_highway: A__ = (sum(highway_losses[:-1] ),) + outputs # exclude the final highway, of course else: A__ = (loss,) + outputs if not self.training: A__ = outputs + ((original_entropy, highway_entropy), exit_layer) if output_layer >= 0: A__ = ( (outputs[0],) + (highway_logits_all[output_layer],) + outputs[2:] ) # use the highway of the last layer return outputs # (loss), logits, (hidden_states), (attentions), entropy
335
0
from collections import defaultdict def UpperCAmelCase ( a_ , a_ ) -> Any: """simple docstring""" __A = first_str.lower().strip() __A = second_str.lower().strip() # Remove whitespace __A = first_str.replace(" " , "" ) __A = second_str.replace(" " , "" ) # Strings of different lengths are not anagrams if len(UpperCAmelCase_ ) != len(UpperCAmelCase_ ): return False # Default values for count should be 0 __A = defaultdict(UpperCAmelCase_ ) # For each character in input strings, # increment count in the corresponding for i in range(len(UpperCAmelCase_ ) ): count[first_str[i]] += 1 count[second_str[i]] -= 1 return all(_count == 0 for _count in count.values() ) if __name__ == "__main__": from doctest import testmod testmod() SCREAMING_SNAKE_CASE :Tuple = input('Enter the first string ').strip() SCREAMING_SNAKE_CASE :Tuple = input('Enter the second string ').strip() SCREAMING_SNAKE_CASE :List[Any] = check_anagrams(input_a, input_b) print(f'''{input_a} and {input_b} are {"" if status else "not "}anagrams.''')
15
"""simple docstring""" from collections import defaultdict from pathlib import Path import pandas as pd from rouge_cli import calculate_rouge_path from utils import calculate_rouge SCREAMING_SNAKE_CASE_ : int = [ 'Prosecutor: "No videos were used in the crash investigation" German papers say they saw a cell phone video of the' ' final seconds on board Flight 9525. The Germanwings co-pilot says he had a "previous episode of severe' ' depression\" German airline confirms it knew of Andreas Lubitz\'s depression years before he took control.', 'The Palestinian Authority officially becomes the 123rd member of the International Criminal Court. The formal' ' accession was marked with a ceremony at The Hague, in the Netherlands. The Palestinians signed the ICC\'s' ' founding Rome Statute in January. Israel and the United States opposed the Palestinians\' efforts to join the' ' body.', 'Amnesty International releases its annual report on the death penalty. The report catalogs the use of' ' state-sanctioned killing as a punitive measure across the globe. At least 607 people were executed around the' ' world in 2014, compared to 778 in 2013. The U.S. remains one of the worst offenders for imposing capital' ' punishment.', ] SCREAMING_SNAKE_CASE_ : List[Any] = [ 'Marseille prosecutor says "so far no videos were used in the crash investigation" despite media reports .' ' Journalists at Bild and Paris Match are "very confident" the video clip is real, an editor says . Andreas Lubitz' ' had informed his Lufthansa training school of an episode of severe depression, airline says .', 'Membership gives the ICC jurisdiction over alleged crimes committed in Palestinian territories since last June .' ' Israel and the United States opposed the move, which could open the door to war crimes investigations against' ' Israelis .', 'Amnesty\'s annual death penalty report catalogs encouraging signs, but setbacks in numbers of those sentenced to' ' death . Organization claims that governments around the world are using the threat of terrorism to advance' ' executions . The number of executions worldwide has gone down by almost 22% compared with 2013, but death' ' sentences up by 28% .', ] def _snake_case ( ): A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , bootstrap_aggregation=UpperCAmelCase_ , rouge_keys=["""rouge2""", """rougeL"""] ) assert isinstance(UpperCAmelCase_ , UpperCAmelCase_ ) A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , bootstrap_aggregation=UpperCAmelCase_ , rouge_keys=["""rouge2"""] ) assert ( pd.DataFrame(no_aggregation["""rouge2"""] ).fmeasure.mean() == pd.DataFrame(no_aggregation_just_ra["""rouge2"""] ).fmeasure.mean() ) def _snake_case ( ): A__ = """rougeLsum""" A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , newline_sep=UpperCAmelCase_ , rouge_keys=[k] )[k] A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , newline_sep=UpperCAmelCase_ , rouge_keys=[k] )[k] assert score > score_no_sep def _snake_case ( ): A__ = ["""rouge1""", """rouge2""", """rougeL"""] A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , newline_sep=UpperCAmelCase_ , rouge_keys=UpperCAmelCase_ ) A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , newline_sep=UpperCAmelCase_ , rouge_keys=UpperCAmelCase_ ) assert score_sep == score_no_sep def _snake_case ( ): A__ = [ """Her older sister, Margot Frank, died in 1945, a month earlier than previously thought.""", """Marseille prosecutor says \"so far no videos were used in the crash investigation\" despite media reports .""", ] A__ = [ """Margot Frank, died in 1945, a month earlier than previously thought.""", """Prosecutor: \"No videos were used in the crash investigation\" German papers say they saw a cell phone video of""" """ the final seconds on board Flight 9525.""", ] assert calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , newline_sep=UpperCAmelCase_ ) == calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , newline_sep=UpperCAmelCase_ ) def _snake_case ( ): A__ = [ """\" \"a person who has such a video needs to immediately give it to the investigators,\" prosecutor says .<n> \"it is a very disturbing scene,\" editor-in-chief of bild online tells \"erin burnett: outfront\" """ ] A__ = [ """ Marseille prosecutor says \"so far no videos were used in the crash investigation\" despite media reports . Journalists at Bild and Paris Match are \"very confident\" the video clip is real, an editor says . Andreas Lubitz had informed his Lufthansa training school of an episode of severe depression, airline says .""" ] A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , rouge_keys=["""rougeLsum"""] , newline_sep=UpperCAmelCase_ )["""rougeLsum"""] A__ = calculate_rouge(UpperCAmelCase_ , UpperCAmelCase_ , rouge_keys=["""rougeLsum"""] )["""rougeLsum"""] assert new_score > prev_score def _snake_case ( ): A__ = Path("""examples/seq2seq/test_data/wmt_en_ro""" ) A__ = calculate_rouge_path(data_dir.joinpath("""test.source""" ) , data_dir.joinpath("""test.target""" ) ) assert isinstance(UpperCAmelCase_ , UpperCAmelCase_ ) A__ = calculate_rouge_path( data_dir.joinpath("""test.source""" ) , data_dir.joinpath("""test.target""" ) , bootstrap_aggregation=UpperCAmelCase_ ) assert isinstance(UpperCAmelCase_ , UpperCAmelCase_ )
335
0
from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments def a( ) -> List[Any]: """simple docstring""" a = HfArgumentParser(UpperCAmelCase_ ) a = parser.parse_args_into_dataclasses()[0] a = TensorFlowBenchmark(args=UpperCAmelCase_ ) try: a = parser.parse_args_into_dataclasses()[0] except ValueError as e: a = "Arg --no_{0} is no longer used, please use --no-{0} instead." a = " ".join(str(UpperCAmelCase_ ).split(" " )[:-1] ) a = "" a = eval(str(UpperCAmelCase_ ).split(" " )[-1] ) a = [] for arg in depreciated_args: # arg[2:] removes '--' if arg[2:] in TensorFlowBenchmark.deprecated_args: # arg[5:] removes '--no_' full_error_msg += arg_error_msg.format(arg[5:] ) else: wrong_args.append(UpperCAmelCase_ ) if len(UpperCAmelCase_ ) > 0: a = full_error_msg + begin_error_msg + str(UpperCAmelCase_ ) raise ValueError(UpperCAmelCase_ ) benchmark.run() if __name__ == "__main__": main()
227
"""simple docstring""" from typing import Optional, Union import torch from torch import nn from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss from ...activations import ACTaFN from ...modeling_outputs import BaseModelOutputWithPoolingAndNoAttention, ImageClassifierOutputWithNoAttention from ...modeling_utils import PreTrainedModel from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging from .configuration_mobilenet_va import MobileNetVaConfig SCREAMING_SNAKE_CASE_ : Union[str, Any] = logging.get_logger(__name__) # General docstring SCREAMING_SNAKE_CASE_ : Union[str, Any] = 'MobileNetV1Config' # Base docstring SCREAMING_SNAKE_CASE_ : str = 'google/mobilenet_v1_1.0_224' SCREAMING_SNAKE_CASE_ : List[str] = [1, 1_0_2_4, 7, 7] # Image classification docstring SCREAMING_SNAKE_CASE_ : Optional[Any] = 'google/mobilenet_v1_1.0_224' SCREAMING_SNAKE_CASE_ : Tuple = 'tabby, tabby cat' SCREAMING_SNAKE_CASE_ : Union[str, Any] = [ 'google/mobilenet_v1_1.0_224', 'google/mobilenet_v1_0.75_192', # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1 ] def _snake_case ( UpperCAmelCase_ : int , UpperCAmelCase_ : List[str] , UpperCAmelCase_ : Dict=None ): A__ = {} if isinstance(UpperCAmelCase_ , UpperCAmelCase_ ): A__ = model.mobilenet_va else: A__ = model A__ = """MobilenetV1/Conv2d_0/""" A__ = backbone.conv_stem.convolution.weight A__ = backbone.conv_stem.normalization.bias A__ = backbone.conv_stem.normalization.weight A__ = backbone.conv_stem.normalization.running_mean A__ = backbone.conv_stem.normalization.running_var for i in range(13 ): A__ = i + 1 A__ = i * 2 A__ = backbone.layer[pt_index] A__ = F"""MobilenetV1/Conv2d_{tf_index}_depthwise/""" A__ = pointer.convolution.weight A__ = pointer.normalization.bias A__ = pointer.normalization.weight A__ = pointer.normalization.running_mean A__ = pointer.normalization.running_var A__ = backbone.layer[pt_index + 1] A__ = F"""MobilenetV1/Conv2d_{tf_index}_pointwise/""" A__ = pointer.convolution.weight A__ = pointer.normalization.bias A__ = pointer.normalization.weight A__ = pointer.normalization.running_mean A__ = pointer.normalization.running_var if isinstance(UpperCAmelCase_ , UpperCAmelCase_ ): A__ = """MobilenetV1/Logits/Conv2d_1c_1x1/""" A__ = model.classifier.weight A__ = model.classifier.bias return tf_to_pt_map def _snake_case ( UpperCAmelCase_ : Union[str, Any] , UpperCAmelCase_ : Union[str, Any] , UpperCAmelCase_ : List[Any] ): try: import numpy as np import tensorflow as tf except ImportError: logger.error( """Loading a TensorFlow models in PyTorch, requires TensorFlow to be installed. Please see """ """https://www.tensorflow.org/install/ for installation instructions.""" ) raise # Load weights from TF model A__ = tf.train.list_variables(UpperCAmelCase_ ) A__ = {} for name, shape in init_vars: logger.info(F"""Loading TF weight {name} with shape {shape}""" ) A__ = tf.train.load_variable(UpperCAmelCase_ , UpperCAmelCase_ ) A__ = array # Build TF to PyTorch weights loading map A__ = _build_tf_to_pytorch_map(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) for name, pointer in tf_to_pt_map.items(): logger.info(F"""Importing {name}""" ) if name not in tf_weights: logger.info(F"""{name} not in tf pre-trained weights, skipping""" ) continue A__ = tf_weights[name] if "depthwise_weights" in name: logger.info("""Transposing depthwise""" ) A__ = np.transpose(UpperCAmelCase_ , (2, 3, 0, 1) ) elif "weights" in name: logger.info("""Transposing""" ) if len(pointer.shape ) == 2: # copying into linear layer A__ = array.squeeze().transpose() else: A__ = np.transpose(UpperCAmelCase_ , (3, 2, 0, 1) ) if pointer.shape != array.shape: raise ValueError(F"""Pointer shape {pointer.shape} and array shape {array.shape} mismatched""" ) logger.info(F"""Initialize PyTorch weight {name} {array.shape}""" ) A__ = torch.from_numpy(UpperCAmelCase_ ) tf_weights.pop(UpperCAmelCase_ , UpperCAmelCase_ ) tf_weights.pop(name + """/RMSProp""" , UpperCAmelCase_ ) tf_weights.pop(name + """/RMSProp_1""" , UpperCAmelCase_ ) tf_weights.pop(name + """/ExponentialMovingAverage""" , UpperCAmelCase_ ) logger.info(F"""Weights not copied to PyTorch model: {', '.join(tf_weights.keys() )}""" ) return model def _snake_case ( UpperCAmelCase_ : torch.Tensor , UpperCAmelCase_ : nn.Convad ): A__ , A__ = features.shape[-2:] A__ , A__ = conv_layer.stride A__ , A__ = conv_layer.kernel_size if in_height % stride_height == 0: A__ = max(kernel_height - stride_height , 0 ) else: A__ = max(kernel_height - (in_height % stride_height) , 0 ) if in_width % stride_width == 0: A__ = max(kernel_width - stride_width , 0 ) else: A__ = max(kernel_width - (in_width % stride_width) , 0 ) A__ = pad_along_width // 2 A__ = pad_along_width - pad_left A__ = pad_along_height // 2 A__ = pad_along_height - pad_top A__ = (pad_left, pad_right, pad_top, pad_bottom) return nn.functional.pad(UpperCAmelCase_ , UpperCAmelCase_ , """constant""" , 0.0 ) class a ( nn.Module ): """simple docstring""" def __init__( self: Union[str, Any] , UpperCamelCase: MobileNetVaConfig , UpperCamelCase: int , UpperCamelCase: int , UpperCamelCase: int , UpperCamelCase: Optional[int] = 1 , UpperCamelCase: Optional[int] = 1 , UpperCamelCase: bool = False , UpperCamelCase: Optional[bool] = True , UpperCamelCase: Optional[bool or str] = True , ): """simple docstring""" super().__init__() A__ = config if in_channels % groups != 0: raise ValueError(f"""Input channels ({in_channels}) are not divisible by {groups} groups.""" ) if out_channels % groups != 0: raise ValueError(f"""Output channels ({out_channels}) are not divisible by {groups} groups.""" ) A__ = 0 if config.tf_padding else int((kernel_size - 1) / 2 ) A__ = nn.Convad( in_channels=UpperCamelCase , out_channels=UpperCamelCase , kernel_size=UpperCamelCase , stride=UpperCamelCase , padding=UpperCamelCase , groups=UpperCamelCase , bias=UpperCamelCase , padding_mode="""zeros""" , ) if use_normalization: A__ = nn.BatchNormad( num_features=UpperCamelCase , eps=config.layer_norm_eps , momentum=0.9_997 , affine=UpperCamelCase , track_running_stats=UpperCamelCase , ) else: A__ = None if use_activation: if isinstance(UpperCamelCase , UpperCamelCase ): A__ = ACTaFN[use_activation] elif isinstance(config.hidden_act , UpperCamelCase ): A__ = ACTaFN[config.hidden_act] else: A__ = config.hidden_act else: A__ = None def UpperCamelCase ( self: List[Any] , UpperCamelCase: torch.Tensor ): """simple docstring""" if self.config.tf_padding: A__ = apply_tf_padding(UpperCamelCase , self.convolution ) A__ = self.convolution(UpperCamelCase ) if self.normalization is not None: A__ = self.normalization(UpperCamelCase ) if self.activation is not None: A__ = self.activation(UpperCamelCase ) return features class a ( _lowerCamelCase ): """simple docstring""" UpperCAmelCase = MobileNetVaConfig UpperCAmelCase = load_tf_weights_in_mobilenet_va UpperCAmelCase = "mobilenet_v1" UpperCAmelCase = "pixel_values" UpperCAmelCase = False def UpperCamelCase ( self: Any , UpperCamelCase: Union[nn.Linear, nn.Convad] ): """simple docstring""" if isinstance(UpperCamelCase , (nn.Linear, nn.Convad) ): module.weight.data.normal_(mean=0.0 , std=self.config.initializer_range ) if module.bias is not None: module.bias.data.zero_() elif isinstance(UpperCamelCase , nn.BatchNormad ): module.bias.data.zero_() module.weight.data.fill_(1.0 ) SCREAMING_SNAKE_CASE_ : Optional[Any] = r'\n This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n behavior.\n\n Parameters:\n config ([`MobileNetV1Config`]): Model configuration class with all the parameters of the model.\n Initializing with a config file does not load the weights associated with the model, only the\n configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n' SCREAMING_SNAKE_CASE_ : Optional[Any] = r'\n Args:\n pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n [`MobileNetV1ImageProcessor.__call__`] for details.\n output_hidden_states (`bool`, *optional*):\n Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n more detail.\n return_dict (`bool`, *optional*):\n Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n' @add_start_docstrings( "The bare MobileNetV1 model outputting raw hidden-states without any specific head on top.", _lowerCamelCase, ) class a ( _lowerCamelCase ): """simple docstring""" def __init__( self: Any , UpperCamelCase: MobileNetVaConfig , UpperCamelCase: bool = True ): """simple docstring""" super().__init__(UpperCamelCase ) A__ = config A__ = 32 A__ = max(int(depth * config.depth_multiplier ) , config.min_depth ) A__ = MobileNetVaConvLayer( UpperCamelCase , in_channels=config.num_channels , out_channels=UpperCamelCase , kernel_size=3 , stride=2 , ) A__ = [1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 1, 2, 1] A__ = nn.ModuleList() for i in range(13 ): A__ = out_channels if strides[i] == 2 or i == 0: depth *= 2 A__ = max(int(depth * config.depth_multiplier ) , config.min_depth ) self.layer.append( MobileNetVaConvLayer( UpperCamelCase , in_channels=UpperCamelCase , out_channels=UpperCamelCase , kernel_size=3 , stride=strides[i] , groups=UpperCamelCase , ) ) self.layer.append( MobileNetVaConvLayer( UpperCamelCase , in_channels=UpperCamelCase , out_channels=UpperCamelCase , kernel_size=1 , ) ) A__ = nn.AdaptiveAvgPoolad((1, 1) ) if add_pooling_layer else None # Initialize weights and apply final processing self.post_init() def UpperCamelCase ( self: Dict , UpperCamelCase: Optional[Any] ): """simple docstring""" raise NotImplementedError @add_start_docstrings_to_model_forward(UpperCamelCase ) @add_code_sample_docstrings( checkpoint=_CHECKPOINT_FOR_DOC , output_type=UpperCamelCase , config_class=_CONFIG_FOR_DOC , modality="""vision""" , expected_output=_EXPECTED_OUTPUT_SHAPE , ) def UpperCamelCase ( self: Tuple , UpperCamelCase: Optional[torch.Tensor] = None , UpperCamelCase: Optional[bool] = None , UpperCamelCase: Optional[bool] = None , ): """simple docstring""" A__ = ( output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states ) A__ = return_dict if return_dict is not None else self.config.use_return_dict if pixel_values is None: raise ValueError("""You have to specify pixel_values""" ) A__ = self.conv_stem(UpperCamelCase ) A__ = () if output_hidden_states else None for i, layer_module in enumerate(self.layer ): A__ = layer_module(UpperCamelCase ) if output_hidden_states: A__ = all_hidden_states + (hidden_states,) A__ = hidden_states if self.pooler is not None: A__ = torch.flatten(self.pooler(UpperCamelCase ) , start_dim=1 ) else: A__ = None if not return_dict: return tuple(v for v in [last_hidden_state, pooled_output, all_hidden_states] if v is not None ) return BaseModelOutputWithPoolingAndNoAttention( last_hidden_state=UpperCamelCase , pooler_output=UpperCamelCase , hidden_states=UpperCamelCase , ) @add_start_docstrings( "\n MobileNetV1 model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n ImageNet.\n ", _lowerCamelCase, ) class a ( _lowerCamelCase ): """simple docstring""" def __init__( self: Union[str, Any] , UpperCamelCase: MobileNetVaConfig ): """simple docstring""" super().__init__(UpperCamelCase ) A__ = config.num_labels A__ = MobileNetVaModel(UpperCamelCase ) A__ = self.mobilenet_va.layer[-1].convolution.out_channels # Classifier head A__ = nn.Dropout(config.classifier_dropout_prob , inplace=UpperCamelCase ) A__ = nn.Linear(UpperCamelCase , config.num_labels ) if config.num_labels > 0 else nn.Identity() # Initialize weights and apply final processing self.post_init() @add_start_docstrings_to_model_forward(UpperCamelCase ) @add_code_sample_docstrings( checkpoint=_IMAGE_CLASS_CHECKPOINT , output_type=UpperCamelCase , config_class=_CONFIG_FOR_DOC , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT , ) def UpperCamelCase ( self: Union[str, Any] , UpperCamelCase: Optional[torch.Tensor] = None , UpperCamelCase: Optional[bool] = None , UpperCamelCase: Optional[torch.Tensor] = None , UpperCamelCase: Optional[bool] = None , ): """simple docstring""" A__ = return_dict if return_dict is not None else self.config.use_return_dict A__ = self.mobilenet_va(UpperCamelCase , output_hidden_states=UpperCamelCase , return_dict=UpperCamelCase ) A__ = outputs.pooler_output if return_dict else outputs[1] A__ = self.classifier(self.dropout(UpperCamelCase ) ) A__ = None if labels is not None: if self.config.problem_type is None: if self.num_labels == 1: A__ = """regression""" elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int): A__ = """single_label_classification""" else: A__ = """multi_label_classification""" if self.config.problem_type == "regression": A__ = MSELoss() if self.num_labels == 1: A__ = loss_fct(logits.squeeze() , labels.squeeze() ) else: A__ = loss_fct(UpperCamelCase , UpperCamelCase ) elif self.config.problem_type == "single_label_classification": A__ = CrossEntropyLoss() A__ = loss_fct(logits.view(-1 , self.num_labels ) , labels.view(-1 ) ) elif self.config.problem_type == "multi_label_classification": A__ = BCEWithLogitsLoss() A__ = loss_fct(UpperCamelCase , UpperCamelCase ) if not return_dict: A__ = (logits,) + outputs[2:] return ((loss,) + output) if loss is not None else output return ImageClassifierOutputWithNoAttention( loss=UpperCamelCase , logits=UpperCamelCase , hidden_states=outputs.hidden_states , )
335
0
from __future__ import annotations from pprint import pformat from typing import Generic, TypeVar __A = TypeVar("T") class __lowerCAmelCase ( Generic[T] ): """simple docstring""" def __init__( self , lowerCamelCase__ = True ) -> str: '''simple docstring''' __lowerCamelCase = {} # dictionary of lists __lowerCamelCase = directed def lowercase_ ( self , lowerCamelCase__ , lowerCamelCase__ ) -> int: '''simple docstring''' if not self.directed: # For undirected graphs # if both source vertex and destination vertex are both present in the # adjacency list, add destination vertex to source vertex list of adjacent # vertices and add source vertex to destination vertex list of adjacent # vertices. if source_vertex in self.adj_list and destination_vertex in self.adj_list: self.adj_list[source_vertex].append(lowerCamelCase__ ) self.adj_list[destination_vertex].append(lowerCamelCase__ ) # if only source vertex is present in adjacency list, add destination vertex # to source vertex list of adjacent vertices, then create a new vertex with # destination vertex as key and assign a list containing the source vertex # as it's first adjacent vertex. elif source_vertex in self.adj_list: self.adj_list[source_vertex].append(lowerCamelCase__ ) __lowerCamelCase = [source_vertex] # if only destination vertex is present in adjacency list, add source vertex # to destination vertex list of adjacent vertices, then create a new vertex # with source vertex as key and assign a list containing the source vertex # as it's first adjacent vertex. elif destination_vertex in self.adj_list: self.adj_list[destination_vertex].append(lowerCamelCase__ ) __lowerCamelCase = [destination_vertex] # if both source vertex and destination vertex are not present in adjacency # list, create a new vertex with source vertex as key and assign a list # containing the destination vertex as it's first adjacent vertex also # create a new vertex with destination vertex as key and assign a list # containing the source vertex as it's first adjacent vertex. else: __lowerCamelCase = [destination_vertex] __lowerCamelCase = [source_vertex] else: # For directed graphs # if both source vertex and destination vertex are present in adjacency # list, add destination vertex to source vertex list of adjacent vertices. if source_vertex in self.adj_list and destination_vertex in self.adj_list: self.adj_list[source_vertex].append(lowerCamelCase__ ) # if only source vertex is present in adjacency list, add destination # vertex to source vertex list of adjacent vertices and create a new vertex # with destination vertex as key, which has no adjacent vertex elif source_vertex in self.adj_list: self.adj_list[source_vertex].append(lowerCamelCase__ ) __lowerCamelCase = [] # if only destination vertex is present in adjacency list, create a new # vertex with source vertex as key and assign a list containing destination # vertex as first adjacent vertex elif destination_vertex in self.adj_list: __lowerCamelCase = [destination_vertex] # if both source vertex and destination vertex are not present in adjacency # list, create a new vertex with source vertex as key and a list containing # destination vertex as it's first adjacent vertex. Then create a new vertex # with destination vertex as key, which has no adjacent vertex else: __lowerCamelCase = [destination_vertex] __lowerCamelCase = [] return self def __repr__( self ) -> Union[str, Any]: '''simple docstring''' return pformat(self.adj_list )
90
"""simple docstring""" def _snake_case ( UpperCAmelCase_ : list[list[int]] , UpperCAmelCase_ : int , UpperCAmelCase_ : int , UpperCAmelCase_ : set ): A__ , A__ = len(UpperCAmelCase_ ), len(grid[0] ) if ( min(UpperCAmelCase_ , UpperCAmelCase_ ) < 0 or row == row_length or col == col_length or (row, col) in visit or grid[row][col] == 1 ): return 0 if row == row_length - 1 and col == col_length - 1: return 1 visit.add((row, col) ) A__ = 0 count += depth_first_search(UpperCAmelCase_ , row + 1 , UpperCAmelCase_ , UpperCAmelCase_ ) count += depth_first_search(UpperCAmelCase_ , row - 1 , UpperCAmelCase_ , UpperCAmelCase_ ) count += depth_first_search(UpperCAmelCase_ , UpperCAmelCase_ , col + 1 , UpperCAmelCase_ ) count += depth_first_search(UpperCAmelCase_ , UpperCAmelCase_ , col - 1 , UpperCAmelCase_ ) visit.remove((row, col) ) return count if __name__ == "__main__": import doctest doctest.testmod()
335
0
"""simple docstring""" import argparse import torch from transformers import BertForMaskedLM if __name__ == "__main__": lowercase__ = argparse.ArgumentParser( description=( """Extraction some layers of the full BertForMaskedLM or RObertaForMaskedLM for Transfer Learned""" """ Distillation""" ) ) parser.add_argument("""--model_type""", default="""bert""", choices=["""bert"""]) parser.add_argument("""--model_name""", default="""bert-base-uncased""", type=str) parser.add_argument("""--dump_checkpoint""", default="""serialization_dir/tf_bert-base-uncased_0247911.pth""", type=str) parser.add_argument("""--vocab_transform""", action="""store_true""") lowercase__ = parser.parse_args() if args.model_type == "bert": lowercase__ = BertForMaskedLM.from_pretrained(args.model_name) lowercase__ = 'bert' else: raise ValueError("""args.model_type should be \"bert\".""") lowercase__ = model.state_dict() lowercase__ = {} for w in ["word_embeddings", "position_embeddings"]: lowercase__ = state_dict[F"{prefix}.embeddings.{w}.weight"] for w in ["weight", "bias"]: lowercase__ = state_dict[F"{prefix}.embeddings.LayerNorm.{w}"] lowercase__ = 0 for teacher_idx in [0, 2, 4, 7, 9, 11]: for w in ["weight", "bias"]: lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.attention.self.query.{w}" ] lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.attention.self.key.{w}" ] lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.attention.self.value.{w}" ] lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.attention.output.dense.{w}" ] lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.attention.output.LayerNorm.{w}" ] lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.intermediate.dense.{w}" ] lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.output.dense.{w}" ] lowercase__ = state_dict[ F"{prefix}.encoder.layer.{teacher_idx}.output.LayerNorm.{w}" ] std_idx += 1 lowercase__ = state_dict['cls.predictions.decoder.weight'] lowercase__ = state_dict['cls.predictions.bias'] if args.vocab_transform: for w in ["weight", "bias"]: lowercase__ = state_dict[F"cls.predictions.transform.dense.{w}"] lowercase__ = state_dict[F"cls.predictions.transform.LayerNorm.{w}"] print(F"N layers selected for distillation: {std_idx}") print(F"Number of params transferred for distillation: {len(compressed_sd.keys())}") print(F"Save transferred checkpoint to {args.dump_checkpoint}.") torch.save(compressed_sd, args.dump_checkpoint)
96
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available SCREAMING_SNAKE_CASE_ : int = { 'configuration_megatron_bert': ['MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MegatronBertConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE_ : Tuple = [ 'MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'MegatronBertForCausalLM', 'MegatronBertForMaskedLM', 'MegatronBertForMultipleChoice', 'MegatronBertForNextSentencePrediction', 'MegatronBertForPreTraining', 'MegatronBertForQuestionAnswering', 'MegatronBertForSequenceClassification', 'MegatronBertForTokenClassification', 'MegatronBertModel', 'MegatronBertPreTrainedModel', ] if TYPE_CHECKING: from .configuration_megatron_bert import MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, MegatronBertConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_megatron_bert import ( MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST, MegatronBertForCausalLM, MegatronBertForMaskedLM, MegatronBertForMultipleChoice, MegatronBertForNextSentencePrediction, MegatronBertForPreTraining, MegatronBertForQuestionAnswering, MegatronBertForSequenceClassification, MegatronBertForTokenClassification, MegatronBertModel, MegatronBertPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE_ : str = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
335
0
"""simple docstring""" _lowerCamelCase : int = { 'a': 'AAAAA', 'b': 'AAAAB', 'c': 'AAABA', 'd': 'AAABB', 'e': 'AABAA', 'f': 'AABAB', 'g': 'AABBA', 'h': 'AABBB', 'i': 'ABAAA', 'j': 'BBBAA', 'k': 'ABAAB', 'l': 'ABABA', 'm': 'ABABB', 'n': 'ABBAA', 'o': 'ABBAB', 'p': 'ABBBA', 'q': 'ABBBB', 'r': 'BAAAA', 's': 'BAAAB', 't': 'BAABA', 'u': 'BAABB', 'v': 'BBBAB', 'w': 'BABAA', 'x': 'BABAB', 'y': 'BABBA', 'z': 'BABBB', ' ': ' ', } _lowerCamelCase : str = {value: key for key, value in encode_dict.items()} def lowercase_ ( _UpperCAmelCase ): """simple docstring""" A_ : Union[str, Any] = '''''' for letter in word.lower(): if letter.isalpha() or letter == " ": encoded += encode_dict[letter] else: raise Exception('''encode() accepts only letters of the alphabet and spaces''' ) return encoded def lowercase_ ( _UpperCAmelCase ): """simple docstring""" if set(UpperCAmelCase_ ) - {"A", "B", " "} != set(): raise Exception('''decode() accepts only \'A\', \'B\' and spaces''' ) A_ : int = '''''' for word in coded.split(): while len(UpperCAmelCase_ ) != 0: decoded += decode_dict[word[:5]] A_ : int = word[5:] decoded += " " return decoded.strip() if __name__ == "__main__": from doctest import testmod testmod()
167
"""simple docstring""" import pytest from datasets.utils.sharding import _distribute_shards, _number_of_shards_in_gen_kwargs, _split_gen_kwargs @pytest.mark.parametrize( """kwargs, expected""" , [ ({"""num_shards""": 0, """max_num_jobs""": 1}, []), ({"""num_shards""": 10, """max_num_jobs""": 1}, [range(10 )]), ({"""num_shards""": 10, """max_num_jobs""": 10}, [range(UpperCAmelCase_ , i + 1 ) for i in range(10 )]), ({"""num_shards""": 1, """max_num_jobs""": 10}, [range(1 )]), ({"""num_shards""": 10, """max_num_jobs""": 3}, [range(0 , 4 ), range(4 , 7 ), range(7 , 10 )]), ({"""num_shards""": 3, """max_num_jobs""": 10}, [range(0 , 1 ), range(1 , 2 ), range(2 , 3 )]), ] , ) def _snake_case ( UpperCAmelCase_ : List[str] , UpperCAmelCase_ : int ): A__ = _distribute_shards(**UpperCAmelCase_ ) assert out == expected @pytest.mark.parametrize( """gen_kwargs, max_num_jobs, expected""" , [ ({"""foo""": 0}, 10, [{"""foo""": 0}]), ({"""shards""": [0, 1, 2, 3]}, 1, [{"""shards""": [0, 1, 2, 3]}]), ({"""shards""": [0, 1, 2, 3]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}, {"""shards""": [2]}, {"""shards""": [3]}]), ({"""shards""": [0, 1]}, 4, [{"""shards""": [0]}, {"""shards""": [1]}]), ({"""shards""": [0, 1, 2, 3]}, 2, [{"""shards""": [0, 1]}, {"""shards""": [2, 3]}]), ] , ) def _snake_case ( UpperCAmelCase_ : str , UpperCAmelCase_ : Dict , UpperCAmelCase_ : List[Any] ): A__ = _split_gen_kwargs(UpperCAmelCase_ , UpperCAmelCase_ ) assert out == expected @pytest.mark.parametrize( """gen_kwargs, expected""" , [ ({"""foo""": 0}, 1), ({"""shards""": [0]}, 1), ({"""shards""": [0, 1, 2, 3]}, 4), ({"""shards""": [0, 1, 2, 3], """foo""": 0}, 4), ({"""shards""": [0, 1, 2, 3], """other""": (0, 1)}, 4), ({"""shards""": [0, 1, 2, 3], """shards2""": [0, 1]}, RuntimeError), ] , ) def _snake_case ( UpperCAmelCase_ : Optional[int] , UpperCAmelCase_ : Optional[int] ): if expected is RuntimeError: with pytest.raises(UpperCAmelCase_ ): _number_of_shards_in_gen_kwargs(UpperCAmelCase_ ) else: A__ = _number_of_shards_in_gen_kwargs(UpperCAmelCase_ ) assert out == expected
335
0
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tf_available, is_tokenizers_available, is_torch_available, ) _SCREAMING_SNAKE_CASE = { 'configuration_rembert': ['REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RemBertConfig', 'RemBertOnnxConfig'] } try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _SCREAMING_SNAKE_CASE = ['RemBertTokenizer'] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _SCREAMING_SNAKE_CASE = ['RemBertTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _SCREAMING_SNAKE_CASE = [ 'REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'RemBertForCausalLM', 'RemBertForMaskedLM', 'RemBertForMultipleChoice', 'RemBertForQuestionAnswering', 'RemBertForSequenceClassification', 'RemBertForTokenClassification', 'RemBertLayer', 'RemBertModel', 'RemBertPreTrainedModel', 'load_tf_weights_in_rembert', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _SCREAMING_SNAKE_CASE = [ 'TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFRemBertForCausalLM', 'TFRemBertForMaskedLM', 'TFRemBertForMultipleChoice', 'TFRemBertForQuestionAnswering', 'TFRemBertForSequenceClassification', 'TFRemBertForTokenClassification', 'TFRemBertLayer', 'TFRemBertModel', 'TFRemBertPreTrainedModel', ] if TYPE_CHECKING: from .configuration_rembert import REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RemBertConfig, RemBertOnnxConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_rembert import RemBertTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_rembert_fast import RemBertTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_rembert import ( REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST, RemBertForCausalLM, RemBertForMaskedLM, RemBertForMultipleChoice, RemBertForQuestionAnswering, RemBertForSequenceClassification, RemBertForTokenClassification, RemBertLayer, RemBertModel, RemBertPreTrainedModel, load_tf_weights_in_rembert, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_rembert import ( TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST, TFRemBertForCausalLM, TFRemBertForMaskedLM, TFRemBertForMultipleChoice, TFRemBertForQuestionAnswering, TFRemBertForSequenceClassification, TFRemBertForTokenClassification, TFRemBertLayer, TFRemBertModel, TFRemBertPreTrainedModel, ) else: import sys _SCREAMING_SNAKE_CASE = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
158
"""simple docstring""" import importlib.metadata from typing import Union from packaging.version import Version, parse from .constants import STR_OPERATION_TO_FUNC SCREAMING_SNAKE_CASE_ : str = parse(importlib.metadata.version('torch')) def _snake_case ( UpperCAmelCase_ : Union[str, Version] , UpperCAmelCase_ : str , UpperCAmelCase_ : str ): if operation not in STR_OPERATION_TO_FUNC.keys(): raise ValueError(F"""`operation` must be one of {list(STR_OPERATION_TO_FUNC.keys() )}, received {operation}""" ) A__ = STR_OPERATION_TO_FUNC[operation] if isinstance(UpperCAmelCase_ , UpperCAmelCase_ ): A__ = parse(importlib.metadata.version(UpperCAmelCase_ ) ) return operation(UpperCAmelCase_ , parse(UpperCAmelCase_ ) ) def _snake_case ( UpperCAmelCase_ : str , UpperCAmelCase_ : str ): return compare_versions(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ )
335
0
import collections import inspect import unittest from transformers import SwinvaConfig 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, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class UpperCamelCase__ : def __init__(self : Optional[int] , snake_case_ : Tuple , snake_case_ : Optional[int]=1_3 , snake_case_ : List[Any]=3_2 , snake_case_ : str=2 , snake_case_ : List[str]=3 , snake_case_ : Dict=1_6 , snake_case_ : Dict=[1, 2, 1] , snake_case_ : List[Any]=[2, 2, 4] , snake_case_ : Optional[int]=2 , snake_case_ : str=2.0 , snake_case_ : Tuple=True , snake_case_ : Union[str, Any]=0.0 , snake_case_ : List[str]=0.0 , snake_case_ : Optional[int]=0.1 , snake_case_ : int="gelu" , snake_case_ : Any=False , snake_case_ : str=True , snake_case_ : List[Any]=0.02 , snake_case_ : str=1E-5 , snake_case_ : Optional[int]=True , snake_case_ : Dict=None , snake_case_ : Dict=True , snake_case_ : Tuple=1_0 , snake_case_ : Any=8 , ): __a : str = parent __a : Union[str, Any] = batch_size __a : Tuple = image_size __a : List[Any] = patch_size __a : Optional[int] = num_channels __a : Tuple = embed_dim __a : Tuple = depths __a : Optional[int] = num_heads __a : Any = window_size __a : List[str] = mlp_ratio __a : Union[str, Any] = qkv_bias __a : Union[str, Any] = hidden_dropout_prob __a : str = attention_probs_dropout_prob __a : Tuple = drop_path_rate __a : int = hidden_act __a : Optional[int] = use_absolute_embeddings __a : str = patch_norm __a : int = layer_norm_eps __a : Dict = initializer_range __a : int = is_training __a : Union[str, Any] = scope __a : Optional[int] = use_labels __a : List[str] = type_sequence_label_size __a : str = encoder_stride def lowerCAmelCase (self : int ): __a : int = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) __a : List[Any] = None if self.use_labels: __a : Tuple = ids_tensor([self.batch_size] , self.type_sequence_label_size ) __a : Dict = self.get_config() return config, pixel_values, labels def lowerCAmelCase (self : Any ): return SwinvaConfig( 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 , ) def lowerCAmelCase (self : Any , snake_case_ : Any , snake_case_ : Union[str, Any] , snake_case_ : Optional[Any] ): __a : Dict = SwinvaModel(config=snake_case_ ) model.to(snake_case_ ) model.eval() __a : Optional[Any] = model(snake_case_ ) __a : Union[str, Any] = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1)) __a : Tuple = 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 : str , snake_case_ : Optional[Any] , snake_case_ : Any , snake_case_ : List[Any] ): __a : Dict = SwinvaForMaskedImageModeling(config=snake_case_ ) model.to(snake_case_ ) model.eval() __a : int = model(snake_case_ ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_channels, self.image_size, self.image_size) ) # test greyscale images __a : Dict = 1 __a : Any = SwinvaForMaskedImageModeling(snake_case_ ) model.to(snake_case_ ) model.eval() __a : int = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) __a : Any = model(snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, 1, self.image_size, self.image_size) ) def lowerCAmelCase (self : int , snake_case_ : Any , snake_case_ : List[str] , snake_case_ : Tuple ): __a : List[Any] = self.type_sequence_label_size __a : Dict = SwinvaForImageClassification(snake_case_ ) model.to(snake_case_ ) model.eval() __a : Union[str, Any] = model(snake_case_ , labels=snake_case_ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def lowerCAmelCase (self : str ): __a : Any = self.prepare_config_and_inputs() __a , __a , __a : str = config_and_inputs __a : Union[str, Any] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class UpperCamelCase__ ( _lowerCamelCase ,_lowerCamelCase ,unittest.TestCase ): _SCREAMING_SNAKE_CASE : List[Any] = ( (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else () ) _SCREAMING_SNAKE_CASE : Dict = ( {"feature-extraction": SwinvaModel, "image-classification": SwinvaForImageClassification} if is_torch_available() else {} ) _SCREAMING_SNAKE_CASE : Any = False _SCREAMING_SNAKE_CASE : Union[str, Any] = False _SCREAMING_SNAKE_CASE : List[Any] = False _SCREAMING_SNAKE_CASE : Tuple = False def lowerCAmelCase (self : Any ): __a : Optional[Any] = SwinvaModelTester(self ) __a : str = ConfigTester(self , config_class=snake_case_ , embed_dim=3_7 ) def lowerCAmelCase (self : List[str] ): 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 : str ): __a : Union[str, Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case_ ) @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.''' ) def lowerCAmelCase (self : int ): pass @unittest.skip(reason='''Swinv2 does not use inputs_embeds''' ) def lowerCAmelCase (self : Optional[int] ): pass def lowerCAmelCase (self : Any ): __a , __a : List[str] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __a : List[str] = model_class(snake_case_ ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) __a : Optional[Any] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(snake_case_ , nn.Linear ) ) def lowerCAmelCase (self : Union[str, Any] ): __a , __a : Optional[int] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: __a : Tuple = model_class(snake_case_ ) __a : Optional[Any] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic __a : List[Any] = [*signature.parameters.keys()] __a : Optional[int] = ['''pixel_values'''] self.assertListEqual(arg_names[:1] , snake_case_ ) def lowerCAmelCase (self : Optional[int] ): __a , __a : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() __a : Union[str, Any] = True for model_class in self.all_model_classes: __a : str = True __a : str = False __a : str = True __a : Optional[int] = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): __a : Optional[Any] = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) __a : Tuple = outputs.attentions __a : Any = len(self.model_tester.depths ) self.assertEqual(len(snake_case_ ) , snake_case_ ) # check that output_attentions also work using config del inputs_dict["output_attentions"] __a : str = True __a : Dict = config.window_size**2 __a : Union[str, Any] = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): __a : Optional[Any] = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) __a : List[Any] = outputs.attentions self.assertEqual(len(snake_case_ ) , snake_case_ ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_heads[0], window_size_squared, window_size_squared] , ) __a : str = len(snake_case_ ) # Check attention is always last and order is fine __a : Optional[Any] = True __a : List[str] = True __a : Optional[Any] = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): __a : Dict = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) if hasattr(self.model_tester , '''num_hidden_states_types''' ): __a : Union[str, Any] = self.model_tester.num_hidden_states_types else: # also another +1 for reshaped_hidden_states __a : Optional[Any] = 2 self.assertEqual(out_len + added_hidden_states , len(snake_case_ ) ) __a : List[str] = outputs.attentions self.assertEqual(len(snake_case_ ) , snake_case_ ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_heads[0], window_size_squared, window_size_squared] , ) def lowerCAmelCase (self : Optional[int] , snake_case_ : Tuple , snake_case_ : Union[str, Any] , snake_case_ : int , snake_case_ : str ): __a : int = model_class(snake_case_ ) model.to(snake_case_ ) model.eval() with torch.no_grad(): __a : Tuple = model(**self._prepare_for_class(snake_case_ , snake_case_ ) ) __a : Tuple = outputs.hidden_states __a : str = getattr( self.model_tester , '''expected_num_hidden_layers''' , len(self.model_tester.depths ) + 1 ) self.assertEqual(len(snake_case_ ) , snake_case_ ) # Swinv2 has a different seq_length __a : Optional[int] = ( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable ) else (config.patch_size, config.patch_size) ) __a : List[str] = (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] , ) __a : Tuple = outputs.reshaped_hidden_states self.assertEqual(len(snake_case_ ) , snake_case_ ) __a , __a , __a , __a : Optional[int] = reshaped_hidden_states[0].shape __a : Dict = ( reshaped_hidden_states[0].view(snake_case_ , snake_case_ , height * width ).permute(0 , 2 , 1 ) ) self.assertListEqual( list(reshaped_hidden_states.shape[-2:] ) , [num_patches, self.model_tester.embed_dim] , ) def lowerCAmelCase (self : str ): __a , __a : Any = self.model_tester.prepare_config_and_inputs_for_common() __a : List[str] = ( 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 : Optional[int] = True self.check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] __a : int = True self.check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ , snake_case_ ) def lowerCAmelCase (self : Optional[Any] ): __a , __a : Dict = self.model_tester.prepare_config_and_inputs_for_common() __a : str = 3 __a : Optional[Any] = ( 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 : List[Any] = ( config.patch_size if isinstance(config.patch_size , collections.abc.Iterable ) else (config.patch_size, config.patch_size) ) __a : str = 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 : int = True self.check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ , (padded_height, padded_width) ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] __a : int = True self.check_hidden_states_output(snake_case_ , snake_case_ , snake_case_ , (padded_height, padded_width) ) def lowerCAmelCase (self : List[str] ): __a : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_ ) def lowerCAmelCase (self : Optional[int] ): __a : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*snake_case_ ) @slow def lowerCAmelCase (self : Any ): for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __a : List[str] = SwinvaModel.from_pretrained(snake_case_ ) self.assertIsNotNone(snake_case_ ) def lowerCAmelCase (self : Tuple ): __a , __a : int = self.model_tester.prepare_config_and_inputs_for_common() __a : Optional[int] = _config_zero_init(snake_case_ ) for model_class in self.all_model_classes: __a : str = model_class(config=snake_case_ ) for name, param in model.named_parameters(): if "embeddings" not in name and "logit_scale" not in name and 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" , ) @require_vision @require_torch class UpperCamelCase__ ( unittest.TestCase ): @cached_property def lowerCAmelCase (self : Optional[int] ): return ( AutoImageProcessor.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256''' ) if is_vision_available() else None ) @slow def lowerCAmelCase (self : Optional[Any] ): __a : List[Any] = SwinvaForImageClassification.from_pretrained('''microsoft/swinv2-tiny-patch4-window8-256''' ).to( snake_case_ ) __a : List[Any] = self.default_image_processor __a : List[str] = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) __a : List[str] = image_processor(images=snake_case_ , return_tensors='''pt''' ).to(snake_case_ ) # forward pass with torch.no_grad(): __a : List[str] = model(**snake_case_ ) # verify the logits __a : str = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape , snake_case_ ) __a : List[Any] = torch.tensor([-0.3947, -0.4306, 0.0026] ).to(snake_case_ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , snake_case_ , atol=1E-4 ) )
216
"""simple docstring""" import sacrebleu as scb from packaging import version from sacrebleu import CHRF import datasets SCREAMING_SNAKE_CASE_ : Dict = '\\n@inproceedings{popovic-2015-chrf,\n title = "chr{F}: character n-gram {F}-score for automatic {MT} evaluation",\n author = "Popovi{\'c}, Maja",\n booktitle = "Proceedings of the Tenth Workshop on Statistical Machine Translation",\n month = sep,\n year = "2015",\n address = "Lisbon, Portugal",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/W15-3049",\n doi = "10.18653/v1/W15-3049",\n pages = "392--395",\n}\n@inproceedings{popovic-2017-chrf,\n title = "chr{F}++: words helping character n-grams",\n author = "Popovi{\'c}, Maja",\n booktitle = "Proceedings of the Second Conference on Machine Translation",\n month = sep,\n year = "2017",\n address = "Copenhagen, Denmark",\n publisher = "Association for Computational Linguistics",\n url = "https://aclanthology.org/W17-4770",\n doi = "10.18653/v1/W17-4770",\n pages = "612--618",\n}\n@inproceedings{post-2018-call,\n title = "A Call for Clarity in Reporting {BLEU} Scores",\n author = "Post, Matt",\n booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",\n month = oct,\n year = "2018",\n address = "Belgium, Brussels",\n publisher = "Association for Computational Linguistics",\n url = "https://www.aclweb.org/anthology/W18-6319",\n pages = "186--191",\n}\n' SCREAMING_SNAKE_CASE_ : str = '\\nChrF and ChrF++ are two MT evaluation metrics. They both use the F-score statistic for character n-gram matches,\nand ChrF++ adds word n-grams as well which correlates more strongly with direct assessment. We use the implementation\nthat is already present in sacrebleu.\n\nThe implementation here is slightly different from sacrebleu in terms of the required input format. The length of\nthe references and hypotheses lists need to be the same, so you may need to transpose your references compared to\nsacrebleu\'s required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534\n\nSee the README.md file at https://github.com/mjpost/sacreBLEU#chrf--chrf for more information.\n' SCREAMING_SNAKE_CASE_ : List[str] = '\nProduces ChrF(++) scores for hypotheses given reference translations.\n\nArgs:\n predictions (list of str): The predicted sentences.\n references (list of list of str): The references. There should be one reference sub-list for each prediction sentence.\n char_order (int): Character n-gram order. Defaults to `6`.\n word_order (int): Word n-gram order. If equals to `2`, the metric is referred to as chrF++. Defaults to `0`.\n beta (int): Determine the importance of recall w.r.t precision. Defaults to `2`.\n lowercase (bool): if `True`, enables case-insensitivity. Defaults to `False`.\n whitespace (bool): If `True`, include whitespaces when extracting character n-grams.\n eps_smoothing (bool): If `True`, applies epsilon smoothing similar\n to reference chrF++.py, NLTK and Moses implementations. If `False`,\n it takes into account effective match order similar to sacreBLEU < 2.0.0. Defaults to `False`.\n\nReturns:\n \'score\' (float): The chrF (chrF++) score,\n \'char_order\' (int): The character n-gram order,\n \'word_order\' (int): The word n-gram order. If equals to 2, the metric is referred to as chrF++,\n \'beta\' (int): Determine the importance of recall w.r.t precision\n\nExamples:\n Example 1--a simple example of calculating chrF:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = datasets.load_metric("chrf")\n >>> results = chrf.compute(predictions=prediction, references=reference)\n >>> print(results)\n {\'score\': 84.64214891738334, \'char_order\': 6, \'word_order\': 0, \'beta\': 2}\n\n Example 2--the same example, but with the argument word_order=2, to calculate chrF++ instead of chrF:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = datasets.load_metric("chrf")\n >>> results = chrf.compute(predictions=prediction,\n ... references=reference,\n ... word_order=2)\n >>> print(results)\n {\'score\': 82.87263732906315, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}\n\n Example 3--the same chrF++ example as above, but with `lowercase=True` to normalize all case:\n >>> prediction = ["The relationship between cats and dogs is not exactly friendly.", "a good bookshop is just a genteel black hole that knows how to read."]\n >>> reference = [["The relationship between dogs and cats is not exactly friendly."], ["A good bookshop is just a genteel Black Hole that knows how to read."]]\n >>> chrf = datasets.load_metric("chrf")\n >>> results = chrf.compute(predictions=prediction,\n ... references=reference,\n ... word_order=2,\n ... lowercase=True)\n >>> print(results)\n {\'score\': 92.12853119829202, \'char_order\': 6, \'word_order\': 2, \'beta\': 2}\n' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION ) class a ( datasets.Metric ): """simple docstring""" def UpperCamelCase ( self: List[str] ): """simple docstring""" if version.parse(scb.__version__ ) < version.parse("""1.4.12""" ): raise ImportWarning( """To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n""" """You can install it with `pip install \"sacrebleu>=1.4.12\"`.""" ) return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , homepage="""https://github.com/mjpost/sacreBLEU#chrf--chrf""" , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Value("""string""" , id="""sequence""" ), """references""": datasets.Sequence(datasets.Value("""string""" , id="""sequence""" ) , id="""references""" ), } ) , codebase_urls=["""https://github.com/mjpost/sacreBLEU#chrf--chrf"""] , reference_urls=[ """https://github.com/m-popovic/chrF""", ] , ) def UpperCamelCase ( self: List[Any] , UpperCamelCase: Union[str, Any] , UpperCamelCase: Optional[Any] , UpperCamelCase: int = CHRF.CHAR_ORDER , UpperCamelCase: int = CHRF.WORD_ORDER , UpperCamelCase: int = CHRF.BETA , UpperCamelCase: bool = False , UpperCamelCase: bool = False , UpperCamelCase: bool = False , ): """simple docstring""" A__ = len(references[0] ) if any(len(UpperCamelCase ) != references_per_prediction for refs in references ): raise ValueError("""Sacrebleu requires the same number of references for each prediction""" ) A__ = [[refs[i] for refs in references] for i in range(UpperCamelCase )] A__ = CHRF(UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase , UpperCamelCase ) A__ = sb_chrf.corpus_score(UpperCamelCase , UpperCamelCase ) return { "score": output.score, "char_order": output.char_order, "word_order": output.word_order, "beta": output.beta, }
335
0
"""simple docstring""" import json import os import tempfile import transformers import datasets from utils import generate_example_dataset, get_duration a = 5_0_0_0_0_0 a = os.path.split(__file__) a = os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json')) @get_duration def lowercase (snake_case__ : datasets.Dataset , **snake_case__ : str ) -> Union[str, Any]: '''simple docstring''' lowerCAmelCase = dataset.map(**UpperCAmelCase_ ) @get_duration def lowercase (snake_case__ : datasets.Dataset , **snake_case__ : Any ) -> List[str]: '''simple docstring''' lowerCAmelCase = dataset.filter(**UpperCAmelCase_ ) def lowercase () -> Dict: '''simple docstring''' lowerCAmelCase = {"""num examples""": SPEED_TEST_N_EXAMPLES} with tempfile.TemporaryDirectory() as tmp_dir: lowerCAmelCase = datasets.Features({"""text""": datasets.Value("""string""" ), """numbers""": datasets.Value("""float32""" )} ) lowerCAmelCase = generate_example_dataset( os.path.join(UpperCAmelCase_ , """dataset.arrow""" ) , UpperCAmelCase_ , num_examples=UpperCAmelCase_ ) lowerCAmelCase = transformers.AutoTokenizer.from_pretrained("""bert-base-cased""" , use_fast=UpperCAmelCase_ ) def tokenize(snake_case__ : Optional[int] ): return tokenizer(examples["""text"""] ) lowerCAmelCase = map(UpperCAmelCase_ ) lowerCAmelCase = map(UpperCAmelCase_ , batched=UpperCAmelCase_ ) lowerCAmelCase = map(UpperCAmelCase_ , function=lambda snake_case__ : None , batched=UpperCAmelCase_ ) with dataset.formatted_as(type="""numpy""" ): lowerCAmelCase = map(UpperCAmelCase_ , function=lambda snake_case__ : None , batched=UpperCAmelCase_ ) with dataset.formatted_as(type="""pandas""" ): lowerCAmelCase = map(UpperCAmelCase_ , function=lambda snake_case__ : None , batched=UpperCAmelCase_ ) with dataset.formatted_as(type="""torch""" , columns="""numbers""" ): lowerCAmelCase = map(UpperCAmelCase_ , function=lambda snake_case__ : None , batched=UpperCAmelCase_ ) with dataset.formatted_as(type="""tensorflow""" , columns="""numbers""" ): lowerCAmelCase = map(UpperCAmelCase_ , function=lambda snake_case__ : None , batched=UpperCAmelCase_ ) lowerCAmelCase = map(UpperCAmelCase_ , function=UpperCAmelCase_ , batched=UpperCAmelCase_ ) lowerCAmelCase = filter(UpperCAmelCase_ ) # Activate later when tokenizer support batched inputs # with dataset.formatted_as(type='numpy'): # times[func.__name__ + " fast-tokenizer batched numpy"] = func(dataset, function=tokenize, batched=True) with open(UpperCAmelCase_ , """wb""" ) as f: f.write(json.dumps(UpperCAmelCase_ ).encode("""utf-8""" ) ) if __name__ == "__main__": # useful to run the profiler benchmark_map_filter()
155
"""simple docstring""" 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 a ( _lowerCamelCase ): """simple docstring""" def __init__( self: Optional[int] , *UpperCamelCase: Optional[Any] , UpperCamelCase: Tuple=None , UpperCamelCase: Tuple=None , **UpperCamelCase: Dict ): """simple docstring""" super().__init__(*UpperCamelCase , **UpperCamelCase ) A__ = eval_examples A__ = post_process_function def UpperCamelCase ( self: Optional[Any] , UpperCamelCase: Optional[Dataset] = None , UpperCamelCase: List[Any]=None , UpperCamelCase: Optional[List[str]] = None , UpperCamelCase: str = "eval" , **UpperCamelCase: Optional[int] , ): """simple docstring""" A__ = gen_kwargs.copy() A__ = ( gen_kwargs["""max_length"""] if gen_kwargs.get("""max_length""" ) is not None else self.args.generation_max_length ) A__ = ( gen_kwargs["""num_beams"""] if gen_kwargs.get("""num_beams""" ) is not None else self.args.generation_num_beams ) A__ = gen_kwargs A__ = self.eval_dataset if eval_dataset is None else eval_dataset A__ = self.get_eval_dataloader(UpperCamelCase ) A__ = self.eval_examples if eval_examples is None else eval_examples # Temporarily disable metric computation, we will do it in the loop here. A__ = self.compute_metrics A__ = None A__ = time.time() A__ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: A__ = eval_loop( UpperCamelCase , description="""Evaluation""" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=UpperCamelCase , metric_key_prefix=UpperCamelCase , ) finally: A__ = compute_metrics A__ = 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( UpperCamelCase , UpperCamelCase , 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 A__ = self.post_process_function(UpperCamelCase , UpperCamelCase , UpperCamelCase ) A__ = self.compute_metrics(UpperCamelCase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f"""{metric_key_prefix}_""" ): A__ = metrics.pop(UpperCamelCase ) metrics.update(output.metrics ) else: A__ = output.metrics if self.args.should_log: # Only the main node log the results by default self.log(UpperCamelCase ) 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() ) A__ = self.callback_handler.on_evaluate(self.args , self.state , self.control , UpperCamelCase ) return metrics def UpperCamelCase ( self: List[Any] , UpperCamelCase: Dict , UpperCamelCase: List[str] , UpperCamelCase: Dict=None , UpperCamelCase: str = "test" , **UpperCamelCase: Optional[int] ): """simple docstring""" A__ = gen_kwargs.copy() A__ = self.get_test_dataloader(UpperCamelCase ) # Temporarily disable metric computation, we will do it in the loop here. A__ = self.compute_metrics A__ = None A__ = time.time() A__ = self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop try: A__ = eval_loop( UpperCamelCase , description="""Prediction""" , prediction_loss_only=True if compute_metrics is None else None , ignore_keys=UpperCamelCase , metric_key_prefix=UpperCamelCase , ) finally: A__ = compute_metrics A__ = 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( UpperCamelCase , UpperCamelCase , 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 A__ = self.post_process_function(UpperCamelCase , UpperCamelCase , UpperCamelCase , """predict""" ) A__ = self.compute_metrics(UpperCamelCase ) # Prefix all keys with metric_key_prefix + '_' for key in list(metrics.keys() ): if not key.startswith(f"""{metric_key_prefix}_""" ): A__ = metrics.pop(UpperCamelCase ) metrics.update(output.metrics ) return PredictionOutput(predictions=predictions.predictions , label_ids=predictions.label_ids , metrics=UpperCamelCase )
335
0
"""simple docstring""" import re def lowercase__( __SCREAMING_SNAKE_CASE : str ): lowercase_ : Dict = re.compile(R'^(\+91[\-\s]?)?[0]?(91)?[789]\d{9}$' ) if match := re.search(UpperCAmelCase_ , UpperCAmelCase_ ): return match.string == phone return False if __name__ == "__main__": print(indian_phone_validator("+918827897895"))
213
"""simple docstring""" class a : """simple docstring""" def __init__( self: Dict ): """simple docstring""" A__ = {} def UpperCamelCase ( self: List[str] ): """simple docstring""" print(self.vertex ) for i in self.vertex: print(UpperCamelCase , """ -> """ , """ -> """.join([str(UpperCamelCase ) for j in self.vertex[i]] ) ) def UpperCamelCase ( self: Any , UpperCamelCase: int , UpperCamelCase: int ): """simple docstring""" if from_vertex in self.vertex: self.vertex[from_vertex].append(UpperCamelCase ) else: # else make a new vertex A__ = [to_vertex] def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = [False] * len(self.vertex ) # call the recursive helper function for i in range(len(self.vertex ) ): if not visited[i]: self.dfs_recursive(UpperCamelCase , UpperCamelCase ) def UpperCamelCase ( self: str , UpperCamelCase: int , UpperCamelCase: list ): """simple docstring""" A__ = True print(UpperCamelCase , end=""" """ ) # Recur for all the vertices that are adjacent to this node for i in self.vertex: if not visited[i]: self.dfs_recursive(UpperCamelCase , UpperCamelCase ) if __name__ == "__main__": SCREAMING_SNAKE_CASE_ : Optional[int] = Graph() g.add_edge(0, 1) g.add_edge(0, 2) g.add_edge(1, 2) g.add_edge(2, 0) g.add_edge(2, 3) g.add_edge(3, 3) g.print_graph() print('DFS:') g.dfs() # OUTPUT: # 0 -> 1 -> 2 # 1 -> 2 # 2 -> 0 -> 3 # 3 -> 3 # DFS: # 0 1 2 3
335
0
"""simple docstring""" from collections import OrderedDict from typing import Mapping from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices _SCREAMING_SNAKE_CASE : List[str] = logging.get_logger(__name__) _SCREAMING_SNAKE_CASE : Optional[int] = { 'microsoft/swin-tiny-patch4-window7-224': ( 'https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json' ), # See all Swin models at https://huggingface.co/models?filter=swin } class a ( _lowerCamelCase , _lowerCamelCase ): SCREAMING_SNAKE_CASE : List[Any] = """swin""" SCREAMING_SNAKE_CASE : Dict = { """num_attention_heads""": """num_heads""", """num_hidden_layers""": """num_layers""", } def __init__( self : int , __SCREAMING_SNAKE_CASE : str=224 , __SCREAMING_SNAKE_CASE : Tuple=4 , __SCREAMING_SNAKE_CASE : Tuple=3 , __SCREAMING_SNAKE_CASE : Optional[Any]=96 , __SCREAMING_SNAKE_CASE : Optional[Any]=[2, 2, 6, 2] , __SCREAMING_SNAKE_CASE : Dict=[3, 6, 12, 24] , __SCREAMING_SNAKE_CASE : Dict=7 , __SCREAMING_SNAKE_CASE : Tuple=4.0 , __SCREAMING_SNAKE_CASE : Optional[Any]=True , __SCREAMING_SNAKE_CASE : Optional[Any]=0.0 , __SCREAMING_SNAKE_CASE : List[str]=0.0 , __SCREAMING_SNAKE_CASE : Optional[int]=0.1 , __SCREAMING_SNAKE_CASE : Optional[int]="gelu" , __SCREAMING_SNAKE_CASE : Dict=False , __SCREAMING_SNAKE_CASE : Tuple=0.02 , __SCREAMING_SNAKE_CASE : Dict=1e-5 , __SCREAMING_SNAKE_CASE : Dict=32 , __SCREAMING_SNAKE_CASE : List[str]=None , __SCREAMING_SNAKE_CASE : Union[str, Any]=None , **__SCREAMING_SNAKE_CASE : List[str] , ) -> List[Any]: super().__init__(**__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = image_size lowerCamelCase_ = patch_size lowerCamelCase_ = num_channels lowerCamelCase_ = embed_dim lowerCamelCase_ = depths lowerCamelCase_ = len(__SCREAMING_SNAKE_CASE ) lowerCamelCase_ = num_heads lowerCamelCase_ = window_size lowerCamelCase_ = mlp_ratio lowerCamelCase_ = qkv_bias lowerCamelCase_ = hidden_dropout_prob lowerCamelCase_ = attention_probs_dropout_prob lowerCamelCase_ = drop_path_rate lowerCamelCase_ = hidden_act lowerCamelCase_ = use_absolute_embeddings lowerCamelCase_ = layer_norm_eps lowerCamelCase_ = initializer_range lowerCamelCase_ = encoder_stride # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel # this indicates the channel dimension after the last stage of the model lowerCamelCase_ = int(embed_dim * 2 ** (len(__SCREAMING_SNAKE_CASE ) - 1) ) lowerCamelCase_ = ['stem'] + [F'''stage{idx}''' for idx in range(1 , len(__SCREAMING_SNAKE_CASE ) + 1 )] lowerCamelCase_ , lowerCamelCase_ = get_aligned_output_features_output_indices( out_features=__SCREAMING_SNAKE_CASE , out_indices=__SCREAMING_SNAKE_CASE , stage_names=self.stage_names ) class a ( _lowerCamelCase ): SCREAMING_SNAKE_CASE : Optional[Any] = version.parse("""1.11""" ) @property def UpperCamelCase ( self : str ) -> str: return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) @property def UpperCamelCase ( self : Union[str, Any] ) -> Optional[Any]: return 1e-4
183
"""simple docstring""" def _snake_case ( UpperCAmelCase_ : int = 10 ): if not isinstance(UpperCAmelCase_ , UpperCAmelCase_ ) or n < 0: raise ValueError("""Invalid input""" ) A__ = 10**n A__ = 2_8433 * (pow(2 , 783_0457 , UpperCAmelCase_ )) + 1 return str(number % modulus ) if __name__ == "__main__": from doctest import testmod testmod() print(f"""{solution(1_0) = }""")
335
0
import argparse import json import os import tensorstore as ts import torch from flax import serialization from flax.traverse_util import flatten_dict, unflatten_dict from tensorflow.io import gfile from transformers.modeling_utils import dtype_byte_size from transformers.models.switch_transformers.convert_switch_transformers_original_flax_checkpoint_to_pytorch import ( rename_keys, ) from transformers.utils import WEIGHTS_INDEX_NAME, WEIGHTS_NAME from transformers.utils.hub import convert_file_size_to_int def a ( _UpperCAmelCase : Dict , _UpperCAmelCase : Optional[Any] ): '''simple docstring''' if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 3: # expert layer __UpperCAmelCase : List[str] = flax_key_tuple[:-1] + ('''weight''',) __UpperCAmelCase : Union[str, Any] = torch.permute(UpperCAmelCase_ , (0, 2, 1) ) elif flax_key_tuple[-1] == "kernel" and ".".join(UpperCAmelCase_ ): # linear layer __UpperCAmelCase : Optional[int] = flax_key_tuple[:-1] + ('''weight''',) __UpperCAmelCase : str = flax_tensor.T elif flax_key_tuple[-1] in ["scale", "embedding"]: __UpperCAmelCase : int = flax_key_tuple[:-1] + ('''weight''',) return flax_key_tuple, flax_tensor def a ( _UpperCAmelCase : str , _UpperCAmelCase : List[str] , _UpperCAmelCase : List[str] ): '''simple docstring''' if "metadata" in layer: __UpperCAmelCase : Union[str, Any] = layer.split('''metadata''' ) __UpperCAmelCase : Tuple = ''''''.join(split_layer[0] )[:-1] __UpperCAmelCase : Optional[int] = [tuple(('''metadata''' + split_layer[1]).split('''/''' ) )] elif "kvstore" in layer: __UpperCAmelCase : Optional[int] = layer.split('''kvstore''' ) __UpperCAmelCase : Union[str, Any] = ''''''.join(split_layer[0] )[:-1] __UpperCAmelCase : Any = [tuple(('''kvstore''' + split_layer[1]).split('''/''' ) )] else: __UpperCAmelCase : Optional[Any] = layer.split('''/''' ) __UpperCAmelCase : Dict = '''/'''.join(split_layer[:-1] ) __UpperCAmelCase : List[Any] = (split_layer[-1],) if "kvstore/path" in layer: __UpperCAmelCase : int = f'{switch_checkpoint_path}/{checkpoint_info[layer]}' elif "kvstore/driver" in layer: __UpperCAmelCase : List[str] = '''file''' else: __UpperCAmelCase : List[str] = checkpoint_info[layer] return curr_real_layer_name, split_layer, content def a ( _UpperCAmelCase : Dict , _UpperCAmelCase : Optional[Any] ): '''simple docstring''' __UpperCAmelCase : int = rename_keys(UpperCAmelCase_ ) __UpperCAmelCase : Union[str, Any] = {} for k, v in current_block.items(): __UpperCAmelCase : Optional[Any] = v __UpperCAmelCase : List[str] = new_current_block torch.save(UpperCAmelCase_ , UpperCAmelCase_ ) def a ( _UpperCAmelCase : int , _UpperCAmelCase : Union[str, Any] , _UpperCAmelCase : Optional[int] , _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : str = WEIGHTS_NAME ): '''simple docstring''' __UpperCAmelCase : Tuple = convert_file_size_to_int(UpperCAmelCase_ ) __UpperCAmelCase : str = [] __UpperCAmelCase : int = {} __UpperCAmelCase : Any = 0 __UpperCAmelCase : List[Any] = 0 os.makedirs(UpperCAmelCase_ , exist_ok=UpperCAmelCase_ ) with gfile.GFile(switch_checkpoint_path + '''/checkpoint''' , '''rb''' ) as fp: __UpperCAmelCase : Union[str, Any] = serialization.msgpack_restore(fp.read() )['''optimizer''']['''target'''] __UpperCAmelCase : List[Any] = flatten_dict(UpperCAmelCase_ , sep='''/''' ) __UpperCAmelCase : Optional[Any] = {} for layer in checkpoint_info.keys(): __UpperCAmelCase , __UpperCAmelCase , __UpperCAmelCase : Any = get_key_and_tensorstore_dict( UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) if curr_real_layer_name in all_layers: __UpperCAmelCase : List[Any] = content else: __UpperCAmelCase : Any = {split_layer[-1]: content} for key in all_layers.keys(): # open tensorstore file __UpperCAmelCase : List[Any] = ts.open(unflatten_dict(all_layers[key] ) ).result().read().result() __UpperCAmelCase : str = torch.tensor(UpperCAmelCase_ ) __UpperCAmelCase : Any = raw_weights.numel() * dtype_byte_size(raw_weights.dtype ) # use the renaming pattern from the small conversion scripts __UpperCAmelCase , __UpperCAmelCase : List[str] = rename_base_flax_keys(tuple(key.split('''/''' ) ) , UpperCAmelCase_ ) __UpperCAmelCase : Dict = '''/'''.join(UpperCAmelCase_ ) # If this weight is going to tip up over the maximal size, we split. if current_block_size + weight_size > max_shard_size: __UpperCAmelCase : Optional[Any] = os.path.join( UpperCAmelCase_ , weights_name.replace('''.bin''' , f'-{len(UpperCAmelCase_ )+1:05d}-of-???.bin' ) ) rename_and_save_block(UpperCAmelCase_ , UpperCAmelCase_ ) sharded_state_dicts.append(current_block.keys() ) del current_block __UpperCAmelCase : Tuple = {} __UpperCAmelCase : str = 0 __UpperCAmelCase : List[str] = raw_weights.to(getattr(UpperCAmelCase_ , UpperCAmelCase_ ) ) current_block_size += weight_size total_size += weight_size # Add the last block __UpperCAmelCase : Dict = os.path.join(UpperCAmelCase_ , weights_name.replace('''.bin''' , f'-{len(UpperCAmelCase_ )+1:05d}-of-???.bin' ) ) rename_and_save_block(UpperCAmelCase_ , UpperCAmelCase_ ) sharded_state_dicts.append(current_block.keys() ) # If we only have one shard, we return it if len(UpperCAmelCase_ ) == 1: return {weights_name: sharded_state_dicts[0]}, None # Otherwise, let's build the index __UpperCAmelCase : Dict = {} __UpperCAmelCase : Optional[Any] = {} for idx, shard in enumerate(UpperCAmelCase_ ): __UpperCAmelCase : Optional[int] = weights_name.replace( '''.bin''' , f'-{idx+1:05d}-of-{len(UpperCAmelCase_ ):05d}.bin' ) # len(sharded_state_dicts):05d} __UpperCAmelCase : Union[str, Any] = os.path.join(UpperCAmelCase_ , weights_name.replace('''.bin''' , f'-{idx+1:05d}-of-???.bin' ) ) os.rename(UpperCAmelCase_ , os.path.join(UpperCAmelCase_ , UpperCAmelCase_ ) ) __UpperCAmelCase : Any = shard for key in shard: __UpperCAmelCase : Dict = shard_file # Add the metadata __UpperCAmelCase : List[Any] = {'''total_size''': total_size} __UpperCAmelCase : List[Any] = {'''metadata''': metadata, '''weight_map''': weight_map} with open(os.path.join(UpperCAmelCase_ , UpperCAmelCase_ ) , '''w''' , encoding='''utf-8''' ) as f: __UpperCAmelCase : Any = json.dumps(UpperCAmelCase_ , indent=2 , sort_keys=UpperCAmelCase_ ) + '''\n''' f.write(UpperCAmelCase_ ) return metadata, index if __name__ == "__main__": __A =argparse.ArgumentParser() # Required parameters parser.add_argument( "--switch_t5x_checkpoint_path", default="/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128/checkpoint_634600", type=str, required=False, help="Path to a directory containing a folder per layer. Follows the original Google format.", ) parser.add_argument("--max_shard_size", default="10GB", required=False, help="Max shard size") parser.add_argument("--dtype", default="bfloat16", type=str, required=False, help="dtype of the saved model") parser.add_argument( "--pytorch_dump_folder_path", default="/mnt/disks/disk_switch/original_checkpoints/switch-xxl-128-converted", type=str, required=False, help="Path to the output pytorch model.", ) __A =parser.parse_args() shard_on_the_fly( args.switch_tax_checkpoint_path, args.pytorch_dump_folder_path, args.max_shard_size, args.dtype, ) def a ( ): '''simple docstring''' from transformers import SwitchTransformersConfig, SwitchTransformersForConditionalGeneration, TaTokenizer __UpperCAmelCase : Any = SwitchTransformersConfig.from_pretrained('''google/switch-base-8''' ) config.save_pretrained('''/home/arthur_huggingface_co/transformers/switch_converted''' ) __UpperCAmelCase : Any = SwitchTransformersForConditionalGeneration.from_pretrained( '''/home/arthur_huggingface_co/transformers/switch_converted''' , device_map='''auto''' ) __UpperCAmelCase : str = TaTokenizer.from_pretrained('''t5-small''' ) __UpperCAmelCase : Tuple = '''A <extra_id_0> walks into a bar a orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.''' __UpperCAmelCase : List[str] = tokenizer(UpperCAmelCase_ , return_tensors='''pt''' ).input_ids __UpperCAmelCase : Tuple = model.generate(UpperCAmelCase_ , decoder_start_token_id=0 ) print(tokenizer.decode(out[0] ) )
226
"""simple docstring""" SCREAMING_SNAKE_CASE_ : Optional[int] = tuple[float, float, float] SCREAMING_SNAKE_CASE_ : Optional[int] = tuple[float, float, float] def _snake_case ( UpperCAmelCase_ : Pointad , UpperCAmelCase_ : Pointad ): A__ = end_pointa[0] - end_pointa[0] A__ = end_pointa[1] - end_pointa[1] A__ = end_pointa[2] - end_pointa[2] return (x, y, z) def _snake_case ( UpperCAmelCase_ : Vectorad , UpperCAmelCase_ : Vectorad ): A__ = ab[1] * ac[2] - ab[2] * ac[1] # *i A__ = (ab[0] * ac[2] - ab[2] * ac[0]) * -1 # *j A__ = ab[0] * ac[1] - ab[1] * ac[0] # *k return (x, y, z) def _snake_case ( UpperCAmelCase_ : Vectorad , UpperCAmelCase_ : int ): return tuple(round(UpperCAmelCase_ , UpperCAmelCase_ ) for x in vector ) == (0, 0, 0) def _snake_case ( UpperCAmelCase_ : Pointad , UpperCAmelCase_ : Pointad , UpperCAmelCase_ : Pointad , UpperCAmelCase_ : int = 10 ): A__ = create_vector(UpperCAmelCase_ , UpperCAmelCase_ ) A__ = create_vector(UpperCAmelCase_ , UpperCAmelCase_ ) return is_zero_vector(get_ad_vectors_cross(UpperCAmelCase_ , UpperCAmelCase_ ) , UpperCAmelCase_ )
335
0
import copy import os import cva import numpy as np from matplotlib import pyplot as plt class UpperCAmelCase : '''simple docstring''' def __init__( self : int ): __A = "" __A = "" __A = [] __A = 0 __A = 2_56 __A = 0 __A = 0 __A = 0 __A = 0 def UpperCamelCase_ ( self : List[Any] ,A : int ): __A = cva.imread(A ,0 ) __A = copy.deepcopy(self.img ) __A , __A , __A = plt.hist(self.img.ravel() ,2_56 ,[0, 2_56] ,label="x" ) __A = np.sum(A ) for i in range(len(A ) ): __A = x[i] / self.k self.sk += prk __A = (self.L - 1) * self.sk if self.rem != 0: __A = int(last % last ) __A = int(last + 1 if self.rem >= 0.5 else last ) self.last_list.append(A ) __A = int(np.ma.count(self.img ) / self.img[1].size ) __A = self.img[1].size for i in range(self.number_of_cols ): for j in range(self.number_of_rows ): __A = self.img[j][i] if num != self.last_list[num]: __A = self.last_list[num] cva.imwrite("output_data/output.jpg" ,self.img ) def UpperCamelCase_ ( self : Optional[Any] ): plt.hist(self.img.ravel() ,2_56 ,[0, 2_56] ) def UpperCamelCase_ ( self : Optional[Any] ): cva.imshow("Output-Image" ,self.img ) cva.imshow("Input-Image" ,self.original_image ) cva.waitKey(50_00 ) cva.destroyAllWindows() if __name__ == "__main__": SCREAMING_SNAKE_CASE :str = os.path.join(os.path.basename(__file__), 'image_data/input.jpg') SCREAMING_SNAKE_CASE :str = ConstantStretch() stretcher.stretch(file_path) stretcher.plot_histogram() stretcher.show_image()
15
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available SCREAMING_SNAKE_CASE_ : Optional[int] = { 'configuration_pegasus_x': ['PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP', 'PegasusXConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: SCREAMING_SNAKE_CASE_ : Any = [ 'PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST', 'PegasusXForConditionalGeneration', 'PegasusXModel', 'PegasusXPreTrainedModel', ] if TYPE_CHECKING: from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_pegasus_x import ( PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST, PegasusXForConditionalGeneration, PegasusXModel, PegasusXPreTrainedModel, ) else: import sys SCREAMING_SNAKE_CASE_ : str = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
335
0
import pytest from datasets.parallel import ParallelBackendConfig, parallel_backend from datasets.utils.py_utils import map_nested from .utils import require_dill_gt_0_3_2, require_joblibspark, require_not_windows def a( A : Optional[int] ) -> List[Any]: # picklable for multiprocessing """simple docstring""" return i + 1 @require_dill_gt_0_3_2 @require_joblibspark @require_not_windows def a( ) -> str: """simple docstring""" with parallel_backend("spark" ): assert ParallelBackendConfig.backend_name == "spark" a = [1, 2, 3] with pytest.raises(UpperCAmelCase_ ): with parallel_backend("unsupported backend" ): map_nested(UpperCAmelCase_ , UpperCAmelCase_ , num_proc=2 ) with pytest.raises(UpperCAmelCase_ ): with parallel_backend("unsupported backend" ): map_nested(UpperCAmelCase_ , UpperCAmelCase_ , num_proc=-1 ) @require_dill_gt_0_3_2 @require_joblibspark @require_not_windows @pytest.mark.parametrize("num_proc" , [2, -1] ) def a( A : List[str] ) -> int: """simple docstring""" a = [1, 2] a = {"a": 1, "b": 2} a = {"a": [1, 2], "b": [3, 4]} a = {"a": {"1": 1}, "b": 2} a = {"a": 1, "b": 2, "c": 3, "d": 4} a = [2, 3] a = {"a": 2, "b": 3} a = {"a": [2, 3], "b": [4, 5]} a = {"a": {"1": 2}, "b": 3} a = {"a": 2, "b": 3, "c": 4, "d": 5} with parallel_backend("spark" ): assert map_nested(UpperCAmelCase_ , UpperCAmelCase_ , num_proc=UpperCAmelCase_ ) == expected_map_nested_sa assert map_nested(UpperCAmelCase_ , UpperCAmelCase_ , num_proc=UpperCAmelCase_ ) == expected_map_nested_sa assert map_nested(UpperCAmelCase_ , UpperCAmelCase_ , num_proc=UpperCAmelCase_ ) == expected_map_nested_sa assert map_nested(UpperCAmelCase_ , UpperCAmelCase_ , num_proc=UpperCAmelCase_ ) == expected_map_nested_sa assert map_nested(UpperCAmelCase_ , UpperCAmelCase_ , num_proc=UpperCAmelCase_ ) == expected_map_nested_sa
227
"""simple docstring""" import math class a : """simple docstring""" def __init__( self: List[Any] , UpperCamelCase: List[str]=0 ): # a graph with Node 0,1,...,N-1 """simple docstring""" A__ = n A__ = [ [math.inf for j in range(0 , UpperCamelCase )] for i in range(0 , UpperCamelCase ) ] # adjacency matrix for weight A__ = [ [math.inf for j in range(0 , UpperCamelCase )] for i in range(0 , UpperCamelCase ) ] # dp[i][j] stores minimum distance from i to j def UpperCamelCase ( self: Union[str, Any] , UpperCamelCase: Optional[int] , UpperCamelCase: Union[str, Any] , UpperCamelCase: Tuple ): """simple docstring""" A__ = w def UpperCamelCase ( self: int ): """simple docstring""" for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): A__ = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def UpperCamelCase ( self: int , UpperCamelCase: List[str] , UpperCamelCase: Dict ): """simple docstring""" return self.dp[u][v] if __name__ == "__main__": SCREAMING_SNAKE_CASE_ : List[Any] = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 1_0) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 1_0) graph.add_edge(3, 1, 2) graph.add_edge(3, 2, 1) graph.add_edge(3, 4, 6) graph.add_edge(4, 1, 3) graph.add_edge(4, 2, 4) graph.add_edge(4, 3, 9) graph.floyd_warshall() graph.show_min(1, 4) graph.show_min(0, 3)
335
0
class __lowerCAmelCase : """simple docstring""" def __init__( self , lowerCamelCase__ ) -> int: '''simple docstring''' __lowerCamelCase = val __lowerCamelCase = None __lowerCamelCase = None def lowercase_ ( self , lowerCamelCase__ ) -> Optional[Any]: '''simple docstring''' if self.val: if val < self.val: if self.left is None: __lowerCamelCase = Node(lowerCamelCase__ ) else: self.left.insert(lowerCamelCase__ ) elif val > self.val: if self.right is None: __lowerCamelCase = Node(lowerCamelCase__ ) else: self.right.insert(lowerCamelCase__ ) else: __lowerCamelCase = val def lowerCamelCase_ ( UpperCamelCase__ : str , UpperCamelCase__ : Tuple ) -> List[Any]: """simple docstring""" if root: inorder(root.left , UpperCAmelCase_ ) res.append(root.val ) inorder(root.right , UpperCAmelCase_ ) def lowerCamelCase_ ( UpperCamelCase__ : Optional[Any] ) -> int: """simple docstring""" if len(UpperCAmelCase_ ) == 0: return arr __lowerCamelCase = Node(arr[0] ) for i in range(1 , len(UpperCAmelCase_ ) ): root.insert(arr[i] ) # Traverse BST in order. __lowerCamelCase = [] inorder(UpperCAmelCase_ , UpperCAmelCase_ ) return res if __name__ == "__main__": print(tree_sort([10, 1, 3, 2, 9, 14, 13]))
90
"""simple docstring""" import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import MgpstrTokenizer from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES from transformers.testing_utils import require_torch, require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_torch_available, is_vision_available if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import MgpstrProcessor, ViTImageProcessor @require_torch @require_vision class a ( unittest.TestCase ): """simple docstring""" UpperCAmelCase = ViTImageProcessor if is_vision_available() else None @property def UpperCamelCase ( self: str ): """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def UpperCamelCase ( self: List[Any] ): """simple docstring""" A__ = (3, 32, 1_28) A__ = tempfile.mkdtemp() # fmt: off A__ = ["""[GO]""", """[s]""", """0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9""", """a""", """b""", """c""", """d""", """e""", """f""", """g""", """h""", """i""", """j""", """k""", """l""", """m""", """n""", """o""", """p""", """q""", """r""", """s""", """t""", """u""", """v""", """w""", """x""", """y""", """z"""] # fmt: on A__ = dict(zip(UpperCamelCase , range(len(UpperCamelCase ) ) ) ) A__ = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as fp: fp.write(json.dumps(UpperCamelCase ) + """\n""" ) A__ = { """do_normalize""": False, """do_resize""": True, """image_processor_type""": """ViTImageProcessor""", """resample""": 3, """size""": {"""height""": 32, """width""": 1_28}, } A__ = os.path.join(self.tmpdirname , UpperCamelCase ) with open(self.image_processor_file , """w""" , encoding="""utf-8""" ) as fp: json.dump(UpperCamelCase , UpperCamelCase ) def UpperCamelCase ( self: List[str] , **UpperCamelCase: Union[str, Any] ): """simple docstring""" return MgpstrTokenizer.from_pretrained(self.tmpdirname , **UpperCamelCase ) def UpperCamelCase ( self: List[Any] , **UpperCamelCase: str ): """simple docstring""" return ViTImageProcessor.from_pretrained(self.tmpdirname , **UpperCamelCase ) def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" shutil.rmtree(self.tmpdirname ) def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta ) A__ = Image.fromarray(np.moveaxis(UpperCamelCase , 0 , -1 ) ) return image_input def UpperCamelCase ( self: Tuple ): """simple docstring""" A__ = self.get_tokenizer() A__ = self.get_image_processor() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) processor.save_pretrained(self.tmpdirname ) A__ = MgpstrProcessor.from_pretrained(self.tmpdirname , use_fast=UpperCamelCase ) self.assertEqual(processor.char_tokenizer.get_vocab() , tokenizer.get_vocab() ) self.assertIsInstance(processor.char_tokenizer , UpperCamelCase ) self.assertEqual(processor.image_processor.to_json_string() , image_processor.to_json_string() ) self.assertIsInstance(processor.image_processor , UpperCamelCase ) def UpperCamelCase ( self: Dict ): """simple docstring""" A__ = self.get_tokenizer() A__ = self.get_image_processor() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) processor.save_pretrained(self.tmpdirname ) A__ = self.get_tokenizer(bos_token="""(BOS)""" , eos_token="""(EOS)""" ) A__ = self.get_image_processor(do_normalize=UpperCamelCase , padding_value=1.0 ) A__ = MgpstrProcessor.from_pretrained( self.tmpdirname , bos_token="""(BOS)""" , eos_token="""(EOS)""" , do_normalize=UpperCamelCase , padding_value=1.0 ) self.assertEqual(processor.char_tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.char_tokenizer , UpperCamelCase ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , UpperCamelCase ) def UpperCamelCase ( self: List[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = self.prepare_image_inputs() A__ = image_processor(UpperCamelCase , return_tensors="""np""" ) A__ = processor(images=UpperCamelCase , return_tensors="""np""" ) for key in input_image_proc.keys(): self.assertAlmostEqual(input_image_proc[key].sum() , input_processor[key].sum() , delta=1e-2 ) def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = """test""" A__ = processor(text=UpperCamelCase ) A__ = tokenizer(UpperCamelCase ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = """test""" A__ = self.prepare_image_inputs() A__ = processor(text=UpperCamelCase , images=UpperCamelCase ) self.assertListEqual(list(inputs.keys() ) , ["""pixel_values""", """labels"""] ) # test if it raises when no input is passed with pytest.raises(UpperCamelCase ): processor() def UpperCamelCase ( self: List[str] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9], [3, 4, 3, 1, 1, 8, 9]] A__ = processor.char_decode(UpperCamelCase ) A__ = tokenizer.batch_decode(UpperCamelCase ) A__ = [seq.replace(""" """ , """""" ) for seq in decoded_tok] self.assertListEqual(UpperCamelCase , UpperCamelCase ) def UpperCamelCase ( self: List[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = None A__ = self.prepare_image_inputs() A__ = processor(text=UpperCamelCase , images=UpperCamelCase ) self.assertListEqual(list(inputs.keys() ) , processor.model_input_names ) def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = MgpstrProcessor(tokenizer=UpperCamelCase , image_processor=UpperCamelCase ) A__ = torch.randn(1 , 27 , 38 ) A__ = torch.randn(1 , 27 , 5_02_57 ) A__ = torch.randn(1 , 27 , 3_05_22 ) A__ = processor.batch_decode([char_input, bpe_input, wp_input] ) self.assertListEqual(list(results.keys() ) , ["""generated_text""", """scores""", """char_preds""", """bpe_preds""", """wp_preds"""] )
335
0
"""simple docstring""" from typing import List, Union import numpy as np from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, logging from .base import PIPELINE_INIT_ARGS, ArgumentHandler, ChunkPipeline lowercase__ = logging.get_logger(__name__) class lowerCAmelCase__ ( _lowerCamelCase ): '''simple docstring''' def A_ ( self , lowercase ): if isinstance(lowercase , lowercase ): _lowerCamelCase : List[str] = [label.strip() for label in labels.split(',' ) if label.strip()] return labels def __call__( self , lowercase , lowercase , lowercase ): if len(lowercase ) == 0 or len(lowercase ) == 0: raise ValueError('You must include at least one label and at least one sequence.' ) if hypothesis_template.format(labels[0] ) == hypothesis_template: raise ValueError( ( 'The provided hypothesis_template \"{}\" was not able to be formatted with the target labels. ' 'Make sure the passed template includes formatting syntax such as {{}} where the label should go.' ).format(lowercase ) ) if isinstance(lowercase , lowercase ): _lowerCamelCase : Optional[Any] = [sequences] _lowerCamelCase : Union[str, Any] = [] for sequence in sequences: sequence_pairs.extend([[sequence, hypothesis_template.format(lowercase )] for label in labels] ) return sequence_pairs, sequences @add_end_docstrings(_lowerCamelCase ) class lowerCAmelCase__ ( _lowerCamelCase ): '''simple docstring''' def __init__( self , lowercase=ZeroShotClassificationArgumentHandler() , *lowercase , **lowercase ): _lowerCamelCase : Union[str, Any] = args_parser super().__init__(*lowercase , **lowercase ) if self.entailment_id == -1: logger.warning( 'Failed to determine \'entailment\' label id from the label2id mapping in the model config. Setting to ' '-1. Define a descriptive label2id mapping in the model config to ensure correct outputs.' ) @property def A_ ( self ): for label, ind in self.model.config.labelaid.items(): if label.lower().startswith('entail' ): return ind return -1 def A_ ( self , lowercase , lowercase=True , lowercase=True , lowercase=TruncationStrategy.ONLY_FIRST , **lowercase ): _lowerCamelCase : Union[str, Any] = self.framework if self.tokenizer.pad_token is None: # Override for tokenizers not supporting padding logger.error( 'Tokenizer was not supporting padding necessary for zero-shot, attempting to use ' ' `pad_token=eos_token`' ) _lowerCamelCase : int = self.tokenizer.eos_token try: _lowerCamelCase : Any = self.tokenizer( lowercase , add_special_tokens=lowercase , return_tensors=lowercase , padding=lowercase , truncation=lowercase , ) except Exception as e: if "too short" in str(lowercase ): # tokenizers might yell that we want to truncate # to a value that is not even reached by the input. # In that case we don't want to truncate. # It seems there's not a really better way to catch that # exception. _lowerCamelCase : Optional[Any] = self.tokenizer( lowercase , add_special_tokens=lowercase , return_tensors=lowercase , padding=lowercase , truncation=TruncationStrategy.DO_NOT_TRUNCATE , ) else: raise e return inputs def A_ ( self , **lowercase ): if kwargs.get('multi_class' , lowercase ) is not None: _lowerCamelCase : Tuple = kwargs['multi_class'] logger.warning( 'The `multi_class` argument has been deprecated and renamed to `multi_label`. ' '`multi_class` will be removed in a future version of Transformers.' ) _lowerCamelCase : int = {} if "candidate_labels" in kwargs: _lowerCamelCase : List[str] = self._args_parser._parse_labels(kwargs['candidate_labels'] ) if "hypothesis_template" in kwargs: _lowerCamelCase : Optional[Any] = kwargs['hypothesis_template'] _lowerCamelCase : List[str] = {} if "multi_label" in kwargs: _lowerCamelCase : Optional[int] = kwargs['multi_label'] return preprocess_params, {}, postprocess_params def __call__( self , lowercase , *lowercase , **lowercase , ): if len(lowercase ) == 0: pass elif len(lowercase ) == 1 and "candidate_labels" not in kwargs: _lowerCamelCase : Union[str, Any] = args[0] else: raise ValueError(F'''Unable to understand extra arguments {args}''' ) return super().__call__(lowercase , **lowercase ) def A_ ( self , lowercase , lowercase=None , lowercase="This example is {}." ): _lowerCamelCase, _lowerCamelCase : List[Any] = self._args_parser(lowercase , lowercase , lowercase ) for i, (candidate_label, sequence_pair) in enumerate(zip(lowercase , lowercase ) ): _lowerCamelCase : Any = self._parse_and_tokenize([sequence_pair] ) yield { "candidate_label": candidate_label, "sequence": sequences[0], "is_last": i == len(lowercase ) - 1, **model_input, } def A_ ( self , lowercase ): _lowerCamelCase : Dict = inputs['candidate_label'] _lowerCamelCase : Dict = inputs['sequence'] _lowerCamelCase : Union[str, Any] = {k: inputs[k] for k in self.tokenizer.model_input_names} _lowerCamelCase : str = self.model(**lowercase ) _lowerCamelCase : int = { 'candidate_label': candidate_label, 'sequence': sequence, 'is_last': inputs['is_last'], **outputs, } return model_outputs def A_ ( self , lowercase , lowercase=False ): _lowerCamelCase : Optional[int] = [outputs['candidate_label'] for outputs in model_outputs] _lowerCamelCase : Tuple = [outputs['sequence'] for outputs in model_outputs] _lowerCamelCase : Dict = np.concatenate([output['logits'].numpy() for output in model_outputs] ) _lowerCamelCase : List[str] = logits.shape[0] _lowerCamelCase : Any = len(lowercase ) _lowerCamelCase : List[Any] = N // n _lowerCamelCase : int = logits.reshape((num_sequences, n, -1) ) if multi_label or len(lowercase ) == 1: # softmax over the entailment vs. contradiction dim for each label independently _lowerCamelCase : Optional[Any] = self.entailment_id _lowerCamelCase : Dict = -1 if entailment_id == 0 else 0 _lowerCamelCase : int = reshaped_outputs[..., [contradiction_id, entailment_id]] _lowerCamelCase : List[str] = np.exp(lowercase ) / np.exp(lowercase ).sum(-1 , keepdims=lowercase ) _lowerCamelCase : Any = scores[..., 1] else: # softmax the "entailment" logits over all candidate labels _lowerCamelCase : int = reshaped_outputs[..., self.entailment_id] _lowerCamelCase : Optional[int] = np.exp(lowercase ) / np.exp(lowercase ).sum(-1 , keepdims=lowercase ) _lowerCamelCase : int = list(reversed(scores[0].argsort() ) ) return { "sequence": sequences[0], "labels": [candidate_labels[i] for i in top_inds], "scores": scores[0, top_inds].tolist(), }
96
"""simple docstring""" import math def _snake_case ( UpperCAmelCase_ : float , UpperCAmelCase_ : float ): if initial_intensity < 0: raise ValueError("""The value of intensity cannot be negative""" ) # handling of negative values of initial intensity if angle < 0 or angle > 360: raise ValueError("""In Malus Law, the angle is in the range 0-360 degrees""" ) # handling of values out of allowed range return initial_intensity * (math.cos(math.radians(UpperCAmelCase_ ) ) ** 2) if __name__ == "__main__": import doctest doctest.testmod(name='malus_law')
335
0
"""simple docstring""" import argparse import os from . import ( ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BART_PRETRAINED_MODEL_ARCHIVE_LIST, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, BartConfig, BertConfig, CamembertConfig, CTRLConfig, DistilBertConfig, DPRConfig, ElectraConfig, FlaubertConfig, GPTaConfig, LayoutLMConfig, LxmertConfig, OpenAIGPTConfig, RobertaConfig, TaConfig, TFAlbertForPreTraining, TFBartForConditionalGeneration, TFBartForSequenceClassification, TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification, TFCamembertForMaskedLM, TFCTRLLMHeadModel, TFDistilBertForMaskedLM, TFDistilBertForQuestionAnswering, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, TFElectraForPreTraining, TFFlaubertWithLMHeadModel, TFGPTaLMHeadModel, TFLayoutLMForMaskedLM, TFLxmertForPreTraining, TFLxmertVisualFeatureEncoder, TFOpenAIGPTLMHeadModel, TFRobertaForCausalLM, TFRobertaForMaskedLM, TFRobertaForSequenceClassification, TFTaForConditionalGeneration, TFTransfoXLLMHeadModel, TFWavaVecaModel, TFXLMRobertaForMaskedLM, TFXLMWithLMHeadModel, TFXLNetLMHeadModel, TransfoXLConfig, WavaVecaConfig, WavaVecaModel, XLMConfig, XLMRobertaConfig, XLNetConfig, is_torch_available, load_pytorch_checkpoint_in_tfa_model, ) from .utils import CONFIG_NAME, WEIGHTS_NAME, cached_file, logging if is_torch_available(): import numpy as np import torch from . import ( AlbertForPreTraining, BartForConditionalGeneration, BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification, CamembertForMaskedLM, CTRLLMHeadModel, DistilBertForMaskedLM, DistilBertForQuestionAnswering, DPRContextEncoder, DPRQuestionEncoder, DPRReader, ElectraForPreTraining, FlaubertWithLMHeadModel, GPTaLMHeadModel, LayoutLMForMaskedLM, LxmertForPreTraining, LxmertVisualFeatureEncoder, OpenAIGPTLMHeadModel, RobertaForMaskedLM, RobertaForSequenceClassification, TaForConditionalGeneration, TransfoXLLMHeadModel, XLMRobertaForMaskedLM, XLMWithLMHeadModel, XLNetLMHeadModel, ) logging.set_verbosity_info() _lowerCamelCase : List[str] = { 'bart': ( BartConfig, TFBartForConditionalGeneration, TFBartForSequenceClassification, BartForConditionalGeneration, BART_PRETRAINED_MODEL_ARCHIVE_LIST, ), 'bert': ( BertConfig, TFBertForPreTraining, BertForPreTraining, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'bert-large-uncased-whole-word-masking-finetuned-squad': ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'bert-large-cased-whole-word-masking-finetuned-squad': ( BertConfig, TFBertForQuestionAnswering, BertForQuestionAnswering, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'bert-base-cased-finetuned-mrpc': ( BertConfig, TFBertForSequenceClassification, BertForSequenceClassification, BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'dpr': ( DPRConfig, TFDPRQuestionEncoder, TFDPRContextEncoder, TFDPRReader, DPRQuestionEncoder, DPRContextEncoder, DPRReader, DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, ), 'gpt2': ( GPTaConfig, TFGPTaLMHeadModel, GPTaLMHeadModel, GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'xlnet': ( XLNetConfig, TFXLNetLMHeadModel, XLNetLMHeadModel, XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'xlm': ( XLMConfig, TFXLMWithLMHeadModel, XLMWithLMHeadModel, XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'xlm-roberta': ( XLMRobertaConfig, TFXLMRobertaForMaskedLM, XLMRobertaForMaskedLM, XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'transfo-xl': ( TransfoXLConfig, TFTransfoXLLMHeadModel, TransfoXLLMHeadModel, TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'openai-gpt': ( OpenAIGPTConfig, TFOpenAIGPTLMHeadModel, OpenAIGPTLMHeadModel, OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'roberta': ( RobertaConfig, TFRobertaForCausalLM, TFRobertaForMaskedLM, RobertaForMaskedLM, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'layoutlm': ( LayoutLMConfig, TFLayoutLMForMaskedLM, LayoutLMForMaskedLM, LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST, ), 'roberta-large-mnli': ( RobertaConfig, TFRobertaForSequenceClassification, RobertaForSequenceClassification, ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'camembert': ( CamembertConfig, TFCamembertForMaskedLM, CamembertForMaskedLM, CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'flaubert': ( FlaubertConfig, TFFlaubertWithLMHeadModel, FlaubertWithLMHeadModel, FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'distilbert': ( DistilBertConfig, TFDistilBertForMaskedLM, DistilBertForMaskedLM, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'distilbert-base-distilled-squad': ( DistilBertConfig, TFDistilBertForQuestionAnswering, DistilBertForQuestionAnswering, DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'lxmert': ( LxmertConfig, TFLxmertForPreTraining, LxmertForPreTraining, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'lxmert-visual-feature-encoder': ( LxmertConfig, TFLxmertVisualFeatureEncoder, LxmertVisualFeatureEncoder, LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'ctrl': ( CTRLConfig, TFCTRLLMHeadModel, CTRLLMHeadModel, CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'albert': ( AlbertConfig, TFAlbertForPreTraining, AlbertForPreTraining, ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 't5': ( TaConfig, TFTaForConditionalGeneration, TaForConditionalGeneration, T5_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'electra': ( ElectraConfig, TFElectraForPreTraining, ElectraForPreTraining, ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ), 'wav2vec2': ( WavaVecaConfig, TFWavaVecaModel, WavaVecaModel, WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, ), } def lowercase_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=False , _UpperCAmelCase=True ): """simple docstring""" if model_type not in MODEL_CLASSES: raise ValueError(f"""Unrecognized model type, should be one of {list(MODEL_CLASSES.keys() )}.""" ) A_ , A_ , A_ , A_ : Dict = MODEL_CLASSES[model_type] # Initialise TF model if config_file in aws_config_map: A_ : Any = cached_file(UpperCAmelCase_ , UpperCAmelCase_ , force_download=not use_cached_models ) A_ : Optional[Any] = config_class.from_json_file(UpperCAmelCase_ ) A_ : int = True A_ : Dict = True print(f"""Building TensorFlow model from configuration: {config}""" ) A_ : Tuple = model_class(UpperCAmelCase_ ) # Load weights from tf checkpoint if pytorch_checkpoint_path in aws_config_map.keys(): A_ : int = cached_file( UpperCAmelCase_ , UpperCAmelCase_ , force_download=not use_cached_models ) # Load PyTorch checkpoint in tf2 model: A_ : Tuple = load_pytorch_checkpoint_in_tfa_model(UpperCAmelCase_ , UpperCAmelCase_ ) if compare_with_pt_model: A_ : Optional[Any] = tf_model(tf_model.dummy_inputs , training=UpperCAmelCase_ ) # build the network A_ : Any = torch.load(UpperCAmelCase_ , map_location='''cpu''' ) A_ : Dict = pt_model_class.from_pretrained( pretrained_model_name_or_path=UpperCAmelCase_ , config=UpperCAmelCase_ , state_dict=UpperCAmelCase_ ) with torch.no_grad(): A_ : Optional[int] = pt_model(**pt_model.dummy_inputs ) A_ : Optional[int] = pto[0].numpy() A_ : Dict = tfo[0].numpy() A_ : int = np.amax(np.abs(np_pt - np_tf ) ) print(f"""Max absolute difference between models outputs {diff}""" ) assert diff <= 2E-2, f"""Error, model absolute difference is >2e-2: {diff}""" # Save pytorch-model print(f"""Save TensorFlow model to {tf_dump_path}""" ) tf_model.save_weights(UpperCAmelCase_ , save_format='''h5''' ) def lowercase_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase=None , _UpperCAmelCase=None , _UpperCAmelCase=False , _UpperCAmelCase=False , _UpperCAmelCase=False , _UpperCAmelCase=False , ): """simple docstring""" if args_model_type is None: A_ : Tuple = list(MODEL_CLASSES.keys() ) else: A_ : Tuple = [args_model_type] for j, model_type in enumerate(UpperCAmelCase_ , start=1 ): print('''=''' * 100 ) print(f""" Converting model type {j}/{len(UpperCAmelCase_ )}: {model_type}""" ) print('''=''' * 100 ) if model_type not in MODEL_CLASSES: raise ValueError(f"""Unrecognized model type {model_type}, should be one of {list(MODEL_CLASSES.keys() )}.""" ) A_ , A_ , A_ , A_ , A_ : Optional[Any] = MODEL_CLASSES[model_type] if model_shortcut_names_or_path is None: A_ : List[str] = list(aws_model_maps.keys() ) if config_shortcut_names_or_path is None: A_ : Tuple = model_shortcut_names_or_path for i, (model_shortcut_name, config_shortcut_name) in enumerate( zip(UpperCAmelCase_ , UpperCAmelCase_ ) , start=1 ): print('''-''' * 100 ) if "-squad" in model_shortcut_name or "-mrpc" in model_shortcut_name or "-mnli" in model_shortcut_name: if not only_convert_finetuned_models: print(f""" Skipping finetuned checkpoint {model_shortcut_name}""" ) continue A_ : List[Any] = model_shortcut_name elif only_convert_finetuned_models: print(f""" Skipping not finetuned checkpoint {model_shortcut_name}""" ) continue print( f""" Converting checkpoint {i}/{len(UpperCAmelCase_ )}: {model_shortcut_name} - model_type {model_type}""" ) print('''-''' * 100 ) if config_shortcut_name in aws_config_map: A_ : Tuple = cached_file(UpperCAmelCase_ , UpperCAmelCase_ , force_download=not use_cached_models ) else: A_ : Dict = config_shortcut_name if model_shortcut_name in aws_model_maps: A_ : Union[str, Any] = cached_file(UpperCAmelCase_ , UpperCAmelCase_ , force_download=not use_cached_models ) else: A_ : Optional[Any] = model_shortcut_name if os.path.isfile(UpperCAmelCase_ ): A_ : Any = '''converted_model''' convert_pt_checkpoint_to_tf( model_type=UpperCAmelCase_ , pytorch_checkpoint_path=UpperCAmelCase_ , config_file=UpperCAmelCase_ , tf_dump_path=os.path.join(UpperCAmelCase_ , model_shortcut_name + '''-tf_model.h5''' ) , compare_with_pt_model=UpperCAmelCase_ , ) if remove_cached_files: os.remove(UpperCAmelCase_ ) os.remove(UpperCAmelCase_ ) if __name__ == "__main__": _lowerCamelCase : Any = argparse.ArgumentParser() # Required parameters parser.add_argument( '--tf_dump_path', default=None, type=str, required=True, help='Path to the output Tensorflow dump file.' ) parser.add_argument( '--model_type', default=None, type=str, help=( f'Model type selected in the list of {list(MODEL_CLASSES.keys())}. If not given, will download and ' 'convert all the models from AWS.' ), ) parser.add_argument( '--pytorch_checkpoint_path', default=None, type=str, help=( 'Path to the PyTorch checkpoint path or shortcut name to download from AWS. ' 'If not given, will download and convert all the checkpoints from AWS.' ), ) parser.add_argument( '--config_file', default=None, type=str, help=( 'The config json file corresponding to the pre-trained model. \n' 'This specifies the model architecture. If not given and ' '--pytorch_checkpoint_path is not given or is a shortcut name ' 'use the configuration associated to the shortcut name on the AWS' ), ) parser.add_argument( '--compare_with_pt_model', action='store_true', help='Compare Tensorflow and PyTorch model predictions.' ) parser.add_argument( '--use_cached_models', action='store_true', help='Use cached models if possible instead of updating to latest checkpoint versions.', ) parser.add_argument( '--remove_cached_files', action='store_true', help='Remove pytorch models after conversion (save memory when converting in batches).', ) parser.add_argument('--only_convert_finetuned_models', action='store_true', help='Only convert finetuned models.') _lowerCamelCase : List[str] = parser.parse_args() # if args.pytorch_checkpoint_path is not None: # convert_pt_checkpoint_to_tf(args.model_type.lower(), # args.pytorch_checkpoint_path, # args.config_file if args.config_file is not None else args.pytorch_checkpoint_path, # args.tf_dump_path, # compare_with_pt_model=args.compare_with_pt_model, # use_cached_models=args.use_cached_models) # else: convert_all_pt_checkpoints_to_tf( args.model_type.lower() if args.model_type is not None else None, args.tf_dump_path, model_shortcut_names_or_path=[args.pytorch_checkpoint_path] if args.pytorch_checkpoint_path is not None else None, config_shortcut_names_or_path=[args.config_file] if args.config_file is not None else None, compare_with_pt_model=args.compare_with_pt_model, use_cached_models=args.use_cached_models, remove_cached_files=args.remove_cached_files, only_convert_finetuned_models=args.only_convert_finetuned_models, )
167
"""simple docstring""" import gc import random import unittest import numpy as np import torch from transformers import XLMRobertaTokenizer from diffusers import ( AltDiffusionImgaImgPipeline, AutoencoderKL, PNDMScheduler, UNetaDConditionModel, ) from diffusers.image_processor import VaeImageProcessor from diffusers.pipelines.alt_diffusion.modeling_roberta_series import ( RobertaSeriesConfig, RobertaSeriesModelWithTransformation, ) from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu enable_full_determinism() class a ( unittest.TestCase ): """simple docstring""" def UpperCamelCase ( self: Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() @property def UpperCamelCase ( self: Dict ): """simple docstring""" A__ = 1 A__ = 3 A__ = (32, 32) A__ = floats_tensor((batch_size, num_channels) + sizes , rng=random.Random(0 ) ).to(UpperCamelCase ) return image @property def UpperCamelCase ( self: int ): """simple docstring""" torch.manual_seed(0 ) A__ = 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 , ) return model @property def UpperCamelCase ( self: Tuple ): """simple docstring""" torch.manual_seed(0 ) A__ = 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 , ) return model @property def UpperCamelCase ( self: List[Any] ): """simple docstring""" torch.manual_seed(0 ) A__ = RobertaSeriesConfig( hidden_size=32 , project_dim=32 , intermediate_size=37 , layer_norm_eps=1e-0_5 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=50_06 , ) return RobertaSeriesModelWithTransformation(UpperCamelCase ) @property def UpperCamelCase ( self: str ): """simple docstring""" def extract(*UpperCamelCase: List[str] , **UpperCamelCase: Any ): class a : """simple docstring""" def __init__( self: Any ): """simple docstring""" A__ = torch.ones([0] ) def UpperCamelCase ( self: Dict , UpperCamelCase: Optional[Any] ): """simple docstring""" self.pixel_values.to(UpperCamelCase ) return self return Out() return extract def UpperCamelCase ( self: str ): """simple docstring""" A__ = """cpu""" # ensure determinism for the device-dependent torch.Generator A__ = self.dummy_cond_unet A__ = PNDMScheduler(skip_prk_steps=UpperCamelCase ) A__ = self.dummy_vae A__ = self.dummy_text_encoder A__ = XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta""" ) A__ = 77 A__ = self.dummy_image.to(UpperCamelCase ) A__ = init_image / 2 + 0.5 # make sure here that pndm scheduler skips prk A__ = AltDiffusionImgaImgPipeline( unet=UpperCamelCase , scheduler=UpperCamelCase , vae=UpperCamelCase , text_encoder=UpperCamelCase , tokenizer=UpperCamelCase , safety_checker=UpperCamelCase , feature_extractor=self.dummy_extractor , ) A__ = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=UpperCamelCase ) A__ = alt_pipe.to(UpperCamelCase ) alt_pipe.set_progress_bar_config(disable=UpperCamelCase ) A__ = """A painting of a squirrel eating a burger""" A__ = torch.Generator(device=UpperCamelCase ).manual_seed(0 ) A__ = alt_pipe( [prompt] , generator=UpperCamelCase , guidance_scale=6.0 , num_inference_steps=2 , output_type="""np""" , image=UpperCamelCase , ) A__ = output.images A__ = torch.Generator(device=UpperCamelCase ).manual_seed(0 ) A__ = alt_pipe( [prompt] , generator=UpperCamelCase , guidance_scale=6.0 , num_inference_steps=2 , output_type="""np""" , image=UpperCamelCase , return_dict=UpperCamelCase , )[0] A__ = image[0, -3:, -3:, -1] A__ = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 32, 32, 3) A__ = np.array([0.4_427, 0.3_731, 0.4_249, 0.4_941, 0.4_546, 0.4_148, 0.4_193, 0.4_666, 0.4_499] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 5e-3 assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 5e-3 @unittest.skipIf(torch_device != """cuda""" , """This test requires a GPU""" ) def UpperCamelCase ( self: int ): """simple docstring""" A__ = self.dummy_cond_unet A__ = PNDMScheduler(skip_prk_steps=UpperCamelCase ) A__ = self.dummy_vae A__ = self.dummy_text_encoder A__ = XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta""" ) A__ = 77 A__ = self.dummy_image.to(UpperCamelCase ) # put models in fp16 A__ = unet.half() A__ = vae.half() A__ = bert.half() # make sure here that pndm scheduler skips prk A__ = AltDiffusionImgaImgPipeline( unet=UpperCamelCase , scheduler=UpperCamelCase , vae=UpperCamelCase , text_encoder=UpperCamelCase , tokenizer=UpperCamelCase , safety_checker=UpperCamelCase , feature_extractor=self.dummy_extractor , ) A__ = VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor , do_normalize=UpperCamelCase ) A__ = alt_pipe.to(UpperCamelCase ) alt_pipe.set_progress_bar_config(disable=UpperCamelCase ) A__ = """A painting of a squirrel eating a burger""" A__ = torch.manual_seed(0 ) A__ = alt_pipe( [prompt] , generator=UpperCamelCase , num_inference_steps=2 , output_type="""np""" , image=UpperCamelCase , ).images assert image.shape == (1, 32, 32, 3) @unittest.skipIf(torch_device != """cuda""" , """This test requires a GPU""" ) def UpperCamelCase ( self: str ): """simple docstring""" A__ = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/img2img/sketch-mountains-input.jpg""" ) # resize to resolution that is divisible by 8 but not 16 or 32 A__ = init_image.resize((7_60, 5_04) ) A__ = """BAAI/AltDiffusion""" A__ = AltDiffusionImgaImgPipeline.from_pretrained( UpperCamelCase , safety_checker=UpperCamelCase , ) pipe.to(UpperCamelCase ) pipe.set_progress_bar_config(disable=UpperCamelCase ) pipe.enable_attention_slicing() A__ = """A fantasy landscape, trending on artstation""" A__ = torch.manual_seed(0 ) A__ = pipe( prompt=UpperCamelCase , image=UpperCamelCase , strength=0.75 , guidance_scale=7.5 , generator=UpperCamelCase , output_type="""np""" , ) A__ = output.images[0] A__ = image[2_55:2_58, 3_83:3_86, -1] assert image.shape == (5_04, 7_60, 3) A__ = np.array([0.9_358, 0.9_397, 0.9_599, 0.9_901, 1.0_000, 1.0_000, 0.9_882, 1.0_000, 1.0_000] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2 @slow @require_torch_gpu class a ( unittest.TestCase ): """simple docstring""" def UpperCamelCase ( self: Any ): """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def UpperCamelCase ( self: List[str] ): """simple docstring""" A__ = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/img2img/sketch-mountains-input.jpg""" ) A__ = init_image.resize((7_68, 5_12) ) A__ = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy""" ) A__ = """BAAI/AltDiffusion""" A__ = AltDiffusionImgaImgPipeline.from_pretrained( UpperCamelCase , safety_checker=UpperCamelCase , ) pipe.to(UpperCamelCase ) pipe.set_progress_bar_config(disable=UpperCamelCase ) pipe.enable_attention_slicing() A__ = """A fantasy landscape, trending on artstation""" A__ = torch.manual_seed(0 ) A__ = pipe( prompt=UpperCamelCase , image=UpperCamelCase , strength=0.75 , guidance_scale=7.5 , generator=UpperCamelCase , output_type="""np""" , ) A__ = output.images[0] assert image.shape == (5_12, 7_68, 3) # img2img is flaky across GPUs even in fp32, so using MAE here assert np.abs(expected_image - image ).max() < 1e-2
335
0
'''simple docstring''' from math import pi def __a(SCREAMING_SNAKE_CASE_ : int , SCREAMING_SNAKE_CASE_ : int ): '''simple docstring''' return 2 * pi * radius * (angle / 360) if __name__ == "__main__": print(arc_length(90, 10))
158
"""simple docstring""" import os import time import pytest from datasets.utils.filelock import FileLock, Timeout def _snake_case ( UpperCAmelCase_ : List[Any] ): A__ = FileLock(str(tmpdir / """foo.lock""" ) ) A__ = FileLock(str(tmpdir / """foo.lock""" ) ) A__ = 0.01 with locka.acquire(): with pytest.raises(UpperCAmelCase_ ): A__ = time.time() locka.acquire(UpperCAmelCase_ ) assert time.time() - _start > timeout def _snake_case ( UpperCAmelCase_ : List[Any] ): A__ = """a""" * 1000 + """.lock""" A__ = FileLock(str(tmpdir / filename ) ) assert locka._lock_file.endswith(""".lock""" ) assert not locka._lock_file.endswith(UpperCAmelCase_ ) assert len(os.path.basename(locka._lock_file ) ) <= 255 A__ = FileLock(tmpdir / filename ) with locka.acquire(): with pytest.raises(UpperCAmelCase_ ): locka.acquire(0 )
335
0
lowercase__ =tuple[float, float, float] lowercase__ =tuple[float, float, float] def __UpperCamelCase ( lowerCAmelCase__ : Pointad , lowerCAmelCase__ : Pointad ): __a : Optional[int] = end_pointa[0] - end_pointa[0] __a : Optional[int] = end_pointa[1] - end_pointa[1] __a : Union[str, Any] = end_pointa[2] - end_pointa[2] return (x, y, z) def __UpperCamelCase ( lowerCAmelCase__ : Vectorad , lowerCAmelCase__ : Vectorad ): __a : str = ab[1] * ac[2] - ab[2] * ac[1] # *i __a : str = (ab[0] * ac[2] - ab[2] * ac[0]) * -1 # *j __a : Optional[int] = ab[0] * ac[1] - ab[1] * ac[0] # *k return (x, y, z) def __UpperCamelCase ( lowerCAmelCase__ : Vectorad , lowerCAmelCase__ : int ): return tuple(round(UpperCAmelCase_ , UpperCAmelCase_ ) for x in vector ) == (0, 0, 0) def __UpperCamelCase ( lowerCAmelCase__ : Pointad , lowerCAmelCase__ : Pointad , lowerCAmelCase__ : Pointad , lowerCAmelCase__ : int = 1_0 ): __a : Optional[int] = create_vector(UpperCAmelCase_ , UpperCAmelCase_ ) __a : Optional[int] = create_vector(UpperCAmelCase_ , UpperCAmelCase_ ) return is_zero_vector(get_ad_vectors_cross(UpperCAmelCase_ , UpperCAmelCase_ ) , UpperCAmelCase_ )
216
"""simple docstring""" # Copyright 2023 The HuggingFace Inc. team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import TYPE_CHECKING import torch from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor from ..utils import requires_backends from .base import PipelineTool if TYPE_CHECKING: from PIL import Image class a ( _lowerCamelCase ): """simple docstring""" UpperCAmelCase = "dandelin/vilt-b32-finetuned-vqa" UpperCAmelCase = ( "This is a tool that answers a question about an image. It takes an input named `image` which should be the " "image containing the information, as well as a `question` which should be the question in English. It " "returns a text that is the answer to the question." ) UpperCAmelCase = "image_qa" UpperCAmelCase = AutoProcessor UpperCAmelCase = AutoModelForVisualQuestionAnswering UpperCAmelCase = ["image", "text"] UpperCAmelCase = ["text"] def __init__( self: List[str] , *UpperCamelCase: Dict , **UpperCamelCase: List[str] ): """simple docstring""" requires_backends(self , ["""vision"""] ) super().__init__(*UpperCamelCase , **UpperCamelCase ) def UpperCamelCase ( self: str , UpperCamelCase: "Image" , UpperCamelCase: str ): """simple docstring""" return self.pre_processor(UpperCamelCase , UpperCamelCase , return_tensors="""pt""" ) def UpperCamelCase ( self: str , UpperCamelCase: str ): """simple docstring""" with torch.no_grad(): return self.model(**UpperCamelCase ).logits def UpperCamelCase ( self: Union[str, Any] , UpperCamelCase: int ): """simple docstring""" A__ = outputs.argmax(-1 ).item() return self.model.config.idalabel[idx]
335
0
"""simple docstring""" def lowercase (snake_case__ : int , snake_case__ : int ) -> Optional[Any]: '''simple docstring''' if number < 0 or shift_amount < 0: raise ValueError("""both inputs must be positive integers""" ) lowerCAmelCase = str(bin(UpperCAmelCase_ ) ) binary_number += "0" * shift_amount return binary_number def lowercase (snake_case__ : int , snake_case__ : int ) -> List[str]: '''simple docstring''' if number < 0 or shift_amount < 0: raise ValueError("""both inputs must be positive integers""" ) lowerCAmelCase = str(bin(UpperCAmelCase_ ) )[2:] if shift_amount >= len(UpperCAmelCase_ ): return "0b0" lowerCAmelCase = binary_number[: len(UpperCAmelCase_ ) - shift_amount] return "0b" + shifted_binary_number def lowercase (snake_case__ : int , snake_case__ : int ) -> List[Any]: '''simple docstring''' if number >= 0: # Get binary representation of positive number lowerCAmelCase = """0""" + str(bin(UpperCAmelCase_ ) ).strip("""-""" )[2:] else: # Get binary (2's complement) representation of negative number lowerCAmelCase = len(bin(UpperCAmelCase_ )[3:] ) # Find 2's complement of number lowerCAmelCase = bin(abs(UpperCAmelCase_ ) - (1 << binary_number_length) )[3:] lowerCAmelCase = ( """1""" + """0""" * (binary_number_length - len(UpperCAmelCase_ )) + binary_number ) if shift_amount >= len(UpperCAmelCase_ ): return "0b" + binary_number[0] * len(UpperCAmelCase_ ) return ( "0b" + binary_number[0] * shift_amount + binary_number[: len(UpperCAmelCase_ ) - shift_amount] ) if __name__ == "__main__": import doctest doctest.testmod()
155
"""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 a ( unittest.TestCase ): """simple docstring""" def __init__( self: Optional[Any] , UpperCamelCase: Any , UpperCamelCase: Optional[int]=7 , UpperCamelCase: str=3 , UpperCamelCase: int=30 , UpperCamelCase: int=4_00 , UpperCamelCase: Union[str, Any]=True , UpperCamelCase: Tuple=None , UpperCamelCase: Any=True , UpperCamelCase: int=[0.5, 0.5, 0.5] , UpperCamelCase: Any=[0.5, 0.5, 0.5] , UpperCamelCase: Optional[Any]=True , UpperCamelCase: List[Any]=1 / 2_55 , UpperCamelCase: Tuple=True , ): """simple docstring""" A__ = size if size is not None else {"""shortest_edge""": 18, """longest_edge""": 13_33} A__ = parent A__ = batch_size A__ = num_channels A__ = min_resolution A__ = max_resolution A__ = do_resize A__ = size A__ = do_normalize A__ = image_mean A__ = image_std A__ = do_rescale A__ = rescale_factor A__ = do_pad def UpperCamelCase ( self: Optional[Any] ): """simple docstring""" 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 UpperCamelCase ( self: Any , UpperCamelCase: List[str] , UpperCamelCase: int=False ): """simple docstring""" if not batched: A__ = image_inputs[0] if isinstance(UpperCamelCase , Image.Image ): A__ , A__ = image.size else: A__ , A__ = image.shape[1], image.shape[2] if w < h: A__ = int(self.size["""shortest_edge"""] * h / w ) A__ = self.size["""shortest_edge"""] elif w > h: A__ = self.size["""shortest_edge"""] A__ = int(self.size["""shortest_edge"""] * w / h ) else: A__ = self.size["""shortest_edge"""] A__ = self.size["""shortest_edge"""] else: A__ = [] for image in image_inputs: A__ , A__ = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) A__ = max(UpperCamelCase , key=lambda UpperCamelCase : item[0] )[0] A__ = max(UpperCamelCase , key=lambda UpperCamelCase : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class a ( _lowerCamelCase, unittest.TestCase ): """simple docstring""" UpperCAmelCase = YolosImageProcessor if is_vision_available() else None def UpperCamelCase ( self: Optional[int] ): """simple docstring""" A__ = YolosImageProcessingTester(self ) @property def UpperCamelCase ( self: Optional[int] ): """simple docstring""" return self.image_processor_tester.prepare_image_processor_dict() def UpperCamelCase ( self: Union[str, Any] ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(UpperCamelCase , """image_mean""" ) ) self.assertTrue(hasattr(UpperCamelCase , """image_std""" ) ) self.assertTrue(hasattr(UpperCamelCase , """do_normalize""" ) ) self.assertTrue(hasattr(UpperCamelCase , """do_resize""" ) ) self.assertTrue(hasattr(UpperCamelCase , """size""" ) ) def UpperCamelCase ( self: Tuple ): """simple docstring""" A__ = 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 , UpperCamelCase ) A__ = self.image_processing_class.from_dict( self.image_processor_dict , size=42 , max_size=84 , pad_and_return_pixel_mask=UpperCamelCase ) self.assertEqual(image_processor.size , {"""shortest_edge""": 42, """longest_edge""": 84} ) self.assertEqual(image_processor.do_pad , UpperCamelCase ) def UpperCamelCase ( self: str ): """simple docstring""" pass def UpperCamelCase ( self: str ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) # create random PIL images A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , Image.Image ) # Test not batched input A__ = image_processing(image_inputs[0] , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase , batched=UpperCamelCase ) A__ = image_processing(UpperCamelCase , 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 UpperCamelCase ( self: Tuple ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase , numpify=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , np.ndarray ) # Test not batched input A__ = image_processing(image_inputs[0] , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched A__ = image_processing(UpperCamelCase , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase , batched=UpperCamelCase ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self: str ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase , torchify=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , torch.Tensor ) # Test not batched input A__ = image_processing(image_inputs[0] , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched A__ = image_processing(UpperCamelCase , return_tensors="""pt""" ).pixel_values A__ , A__ = self.image_processor_tester.get_expected_values(UpperCamelCase , batched=UpperCamelCase ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def UpperCamelCase ( self: str ): """simple docstring""" A__ = self.image_processing_class(**self.image_processor_dict ) A__ = self.image_processing_class(do_resize=UpperCamelCase , do_normalize=UpperCamelCase , do_rescale=UpperCamelCase ) # create random PyTorch tensors A__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=UpperCamelCase , torchify=UpperCamelCase ) for image in image_inputs: self.assertIsInstance(UpperCamelCase , torch.Tensor ) # Test whether the method "pad" and calling the image processor return the same tensors A__ = image_processing_a.pad(UpperCamelCase , return_tensors="""pt""" ) A__ = image_processing_a(UpperCamelCase , return_tensors="""pt""" ) self.assertTrue( torch.allclose(encoded_images_with_method["""pixel_values"""] , encoded_images["""pixel_values"""] , atol=1e-4 ) ) @slow def UpperCamelCase ( self: str ): """simple docstring""" A__ = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) with open("""./tests/fixtures/tests_samples/COCO/coco_annotations.txt""" , """r""" ) as f: A__ = json.loads(f.read() ) A__ = {"""image_id""": 3_97_69, """annotations""": target} # encode them A__ = YolosImageProcessor.from_pretrained("""hustvl/yolos-small""" ) A__ = image_processing(images=UpperCamelCase , annotations=UpperCamelCase , return_tensors="""pt""" ) # verify pixel values A__ = torch.Size([1, 3, 8_00, 10_66] ) self.assertEqual(encoding["""pixel_values"""].shape , UpperCamelCase ) A__ = torch.tensor([0.2_796, 0.3_138, 0.3_481] ) self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3] , UpperCamelCase , atol=1e-4 ) ) # verify area A__ = torch.tensor([5_887.9_600, 11_250.2_061, 489_353.8_438, 837_122.7_500, 147_967.5_156, 165_732.3_438] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""] , UpperCamelCase ) ) # verify boxes A__ = torch.Size([6, 4] ) self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape , UpperCamelCase ) A__ = torch.tensor([0.5_503, 0.2_765, 0.0_604, 0.2_215] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0] , UpperCamelCase , atol=1e-3 ) ) # verify image_id A__ = torch.tensor([3_97_69] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""] , UpperCamelCase ) ) # verify is_crowd A__ = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""] , UpperCamelCase ) ) # verify class_labels A__ = torch.tensor([75, 75, 63, 65, 17, 17] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""] , UpperCamelCase ) ) # verify orig_size A__ = torch.tensor([4_80, 6_40] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""] , UpperCamelCase ) ) # verify size A__ = torch.tensor([8_00, 10_66] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""] , UpperCamelCase ) ) @slow def UpperCamelCase ( self: int ): """simple docstring""" A__ = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) with open("""./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt""" , """r""" ) as f: A__ = json.loads(f.read() ) A__ = {"""file_name""": """000000039769.png""", """image_id""": 3_97_69, """segments_info""": target} A__ = pathlib.Path("""./tests/fixtures/tests_samples/COCO/coco_panoptic""" ) # encode them A__ = YolosImageProcessor(format="""coco_panoptic""" ) A__ = image_processing(images=UpperCamelCase , annotations=UpperCamelCase , masks_path=UpperCamelCase , return_tensors="""pt""" ) # verify pixel values A__ = torch.Size([1, 3, 8_00, 10_66] ) self.assertEqual(encoding["""pixel_values"""].shape , UpperCamelCase ) A__ = torch.tensor([0.2_796, 0.3_138, 0.3_481] ) self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3] , UpperCamelCase , atol=1e-4 ) ) # verify area A__ = torch.tensor([147_979.6_875, 165_527.0_469, 484_638.5_938, 11_292.9_375, 5_879.6_562, 7_634.1_147] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""] , UpperCamelCase ) ) # verify boxes A__ = torch.Size([6, 4] ) self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape , UpperCamelCase ) A__ = torch.tensor([0.2_625, 0.5_437, 0.4_688, 0.8_625] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0] , UpperCamelCase , atol=1e-3 ) ) # verify image_id A__ = torch.tensor([3_97_69] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""] , UpperCamelCase ) ) # verify is_crowd A__ = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""] , UpperCamelCase ) ) # verify class_labels A__ = torch.tensor([17, 17, 63, 75, 75, 93] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""] , UpperCamelCase ) ) # verify masks A__ = 82_28_73 self.assertEqual(encoding["""labels"""][0]["""masks"""].sum().item() , UpperCamelCase ) # verify orig_size A__ = torch.tensor([4_80, 6_40] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""] , UpperCamelCase ) ) # verify size A__ = torch.tensor([8_00, 10_66] ) self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""] , UpperCamelCase ) )
335
0
"""simple docstring""" from ..utils import DummyObject, requires_backends class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) def lowercase__( *__SCREAMING_SNAKE_CASE : Optional[Any] , **__SCREAMING_SNAKE_CASE : int ): requires_backends(UpperCAmelCase_ , ['torch'] ) def lowercase__( *__SCREAMING_SNAKE_CASE : List[Any] , **__SCREAMING_SNAKE_CASE : Union[str, Any] ): requires_backends(UpperCAmelCase_ , ['torch'] ) def lowercase__( *__SCREAMING_SNAKE_CASE : Optional[int] , **__SCREAMING_SNAKE_CASE : int ): requires_backends(UpperCAmelCase_ , ['torch'] ) def lowercase__( *__SCREAMING_SNAKE_CASE : Optional[Any] , **__SCREAMING_SNAKE_CASE : int ): requires_backends(UpperCAmelCase_ , ['torch'] ) def lowercase__( *__SCREAMING_SNAKE_CASE : List[str] , **__SCREAMING_SNAKE_CASE : Tuple ): requires_backends(UpperCAmelCase_ , ['torch'] ) def lowercase__( *__SCREAMING_SNAKE_CASE : List[str] , **__SCREAMING_SNAKE_CASE : int ): requires_backends(UpperCAmelCase_ , ['torch'] ) def lowercase__( *__SCREAMING_SNAKE_CASE : List[Any] , **__SCREAMING_SNAKE_CASE : int ): requires_backends(UpperCAmelCase_ , ['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[str]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Union[str, Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Any: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> List[Any]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Optional[int]: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Dict: '''simple docstring''' requires_backends(cls ,['torch'] ) class UpperCamelCase ( metaclass=_lowerCamelCase ): lowercase = ['torch'] def __init__( self ,*__UpperCamelCase ,**__UpperCamelCase ) -> int: '''simple docstring''' requires_backends(self ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> str: '''simple docstring''' requires_backends(cls ,['torch'] ) @classmethod def _UpperCAmelCase ( cls ,*__UpperCamelCase ,**__UpperCamelCase ) -> Tuple: '''simple docstring''' requires_backends(cls ,['torch'] )
213
"""simple docstring""" def _snake_case ( UpperCAmelCase_ : Dict ): # noqa: E741 A__ = len(UpperCAmelCase_ ) A__ = 0 A__ = [0] * n A__ = [False] * n A__ = [False] * n def dfs(UpperCAmelCase_ : List[str] , UpperCAmelCase_ : int , UpperCAmelCase_ : Dict , UpperCAmelCase_ : List[Any] ): if parent == root: out_edge_count += 1 A__ = True A__ = at for to in l[at]: if to == parent: pass elif not visited[to]: A__ = dfs(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) A__ = min(low[at] , low[to] ) # AP found via bridge if at < low[to]: A__ = True # AP found via cycle if at == low[to]: A__ = True else: A__ = min(low[at] , UpperCAmelCase_ ) return out_edge_count for i in range(UpperCAmelCase_ ): if not visited[i]: A__ = 0 A__ = dfs(UpperCAmelCase_ , UpperCAmelCase_ , -1 , UpperCAmelCase_ ) A__ = out_edge_count > 1 for x in range(len(UpperCAmelCase_ ) ): if is_art[x] is True: print(UpperCAmelCase_ ) # Adjacency list of graph SCREAMING_SNAKE_CASE_ : Optional[int] = { 0: [1, 2], 1: [0, 2], 2: [0, 1, 3, 5], 3: [2, 4], 4: [3], 5: [2, 6, 8], 6: [5, 7], 7: [6, 8], 8: [5, 7], } compute_ap(data)
335
0
from ...configuration_utils import PretrainedConfig from ...utils import logging _lowerCamelCase : List[str] = logging.get_logger(__name__) _lowerCamelCase : int = { "SCUT-DLVCLab/lilt-roberta-en-base": ( "https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base/resolve/main/config.json" ), } class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """lilt""" def __init__( self : List[str], __A : Dict=3_0_5_2_2, __A : Tuple=7_6_8, __A : int=1_2, __A : Any=1_2, __A : Dict=3_0_7_2, __A : Tuple="gelu", __A : Optional[int]=0.1, __A : Tuple=0.1, __A : Any=5_1_2, __A : Any=2, __A : Optional[Any]=0.0_2, __A : Tuple=1E-12, __A : Optional[Any]=0, __A : Dict="absolute", __A : Any=None, __A : Union[str, Any]=4, __A : Dict=1_0_2_4, **__A : Tuple, ): super().__init__(pad_token_id=__A, **__A ) UpperCAmelCase : List[Any] = vocab_size UpperCAmelCase : List[Any] = hidden_size UpperCAmelCase : Union[str, Any] = num_hidden_layers UpperCAmelCase : Tuple = num_attention_heads UpperCAmelCase : Tuple = hidden_act UpperCAmelCase : Optional[Any] = intermediate_size UpperCAmelCase : Optional[int] = hidden_dropout_prob UpperCAmelCase : Dict = attention_probs_dropout_prob UpperCAmelCase : Optional[int] = max_position_embeddings UpperCAmelCase : List[str] = type_vocab_size UpperCAmelCase : int = initializer_range UpperCAmelCase : Dict = layer_norm_eps UpperCAmelCase : Any = position_embedding_type UpperCAmelCase : int = classifier_dropout UpperCAmelCase : Union[str, Any] = channel_shrink_ratio UpperCAmelCase : Union[str, Any] = max_ad_position_embeddings
336
import os import sys from contextlib import contextmanager # Windows only if os.name == "nt": import ctypes import msvcrt # noqa class __UpperCAmelCase ( ctypes.Structure ): # _fields is a specific attr expected by ctypes UpperCamelCase = [("""size""", ctypes.c_int), ("""visible""", ctypes.c_byte)] def a__ ( ) -> Dict: if os.name == "nt": UpperCAmelCase : List[str] = CursorInfo() UpperCAmelCase : List[Any] = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) UpperCAmelCase : Dict = False ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) elif os.name == "posix": sys.stdout.write('''\033[?25l''' ) sys.stdout.flush() def a__ ( ) -> Optional[int]: if os.name == "nt": UpperCAmelCase : int = CursorInfo() UpperCAmelCase : int = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) UpperCAmelCase : Any = True ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) elif os.name == "posix": sys.stdout.write('''\033[?25h''' ) sys.stdout.flush() @contextmanager def a__ ( ) -> Optional[Any]: try: hide_cursor() yield finally: show_cursor()
336
1
from __future__ import annotations import inspect import unittest import numpy as np from transformers import ResNetConfig from transformers.testing_utils import require_tf, require_vision, slow from transformers.utils import cached_property, is_tf_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFResNetForImageClassification, TFResNetModel from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class __UpperCAmelCase : def __init__( self : Tuple, __A : List[str], __A : Optional[int]=3, __A : Any=3_2, __A : Tuple=3, __A : List[Any]=1_0, __A : List[Any]=[1_0, 2_0, 3_0, 4_0], __A : Tuple=[1, 1, 2, 1], __A : Dict=True, __A : int=True, __A : Dict="relu", __A : List[str]=3, __A : Tuple=None, ): UpperCAmelCase : List[Any] = parent UpperCAmelCase : List[Any] = batch_size UpperCAmelCase : Dict = image_size UpperCAmelCase : Tuple = num_channels UpperCAmelCase : int = embeddings_size UpperCAmelCase : Tuple = hidden_sizes UpperCAmelCase : str = depths UpperCAmelCase : Optional[Any] = is_training UpperCAmelCase : Any = use_labels UpperCAmelCase : int = hidden_act UpperCAmelCase : Dict = num_labels UpperCAmelCase : int = scope UpperCAmelCase : Tuple = len(__A ) def __magic_name__ ( self : Dict ): UpperCAmelCase : Tuple = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : Tuple = None if self.use_labels: UpperCAmelCase : Dict = ids_tensor([self.batch_size], self.num_labels ) UpperCAmelCase : Optional[Any] = self.get_config() return config, pixel_values, labels def __magic_name__ ( self : Any ): return ResNetConfig( num_channels=self.num_channels, embeddings_size=self.embeddings_size, hidden_sizes=self.hidden_sizes, depths=self.depths, hidden_act=self.hidden_act, num_labels=self.num_labels, image_size=self.image_size, ) def __magic_name__ ( self : List[Any], __A : Any, __A : str, __A : Union[str, Any] ): UpperCAmelCase : List[Any] = TFResNetModel(config=__A ) UpperCAmelCase : List[str] = model(__A ) # expected last hidden states: B, C, H // 32, W // 32 self.parent.assertEqual( result.last_hidden_state.shape, (self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2), ) def __magic_name__ ( self : List[str], __A : Dict, __A : Any, __A : Any ): UpperCAmelCase : Any = self.num_labels UpperCAmelCase : Optional[Any] = TFResNetForImageClassification(__A ) UpperCAmelCase : Dict = model(__A, labels=__A ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels) ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : List[Any] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Any = config_and_inputs UpperCAmelCase : Tuple = {'''pixel_values''': pixel_values} return config, inputs_dict @require_tf class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else () UpperCamelCase = ( {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification} if is_tf_available() else {} ) UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : int ): UpperCAmelCase : List[str] = TFResNetModelTester(self ) UpperCAmelCase : Optional[int] = ConfigTester(self, config_class=__A, has_text_modality=__A ) def __magic_name__ ( self : int ): 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 __magic_name__ ( self : Union[str, Any] ): return @unittest.skip(reason='''ResNet does not use inputs_embeds''' ) def __magic_name__ ( self : List[str] ): pass @unittest.skip(reason='''ResNet does not support input and output embeddings''' ) def __magic_name__ ( self : List[Any] ): pass def __magic_name__ ( self : Tuple ): UpperCAmelCase , UpperCAmelCase : int = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) UpperCAmelCase : List[str] = inspect.signature(model.call ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : Optional[int] = [*signature.parameters.keys()] UpperCAmelCase : List[str] = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Optional[int] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : Dict ): def check_hidden_states_output(__A : Any, __A : Optional[int], __A : str ): UpperCAmelCase : List[Any] = model_class(__A ) UpperCAmelCase : int = model(**self._prepare_for_class(__A, __A ) ) 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(__A ), expected_num_stages + 1 ) # ResNet'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() UpperCAmelCase : Any = ['''basic''', '''bottleneck'''] for model_class in self.all_model_classes: for layer_type in layers_type: UpperCAmelCase : Tuple = layer_type UpperCAmelCase : List[Any] = True check_hidden_states_output(__A, __A, __A ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] UpperCAmelCase : Optional[Any] = True check_hidden_states_output(__A, __A, __A ) def __magic_name__ ( self : Tuple ): UpperCAmelCase : Dict = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__A ) @slow def __magic_name__ ( self : str ): for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase : int = TFResNetModel.from_pretrained(__A ) self.assertIsNotNone(__A ) def a__ ( ) -> Tuple: UpperCAmelCase : Any = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_tf @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : int ): return ( AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def __magic_name__ ( self : List[str] ): UpperCAmelCase : Any = TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) UpperCAmelCase : List[Any] = self.default_image_processor UpperCAmelCase : Optional[Any] = prepare_img() UpperCAmelCase : List[Any] = image_processor(images=__A, return_tensors='''tf''' ) # forward pass UpperCAmelCase : List[Any] = model(**__A ) # verify the logits UpperCAmelCase : List[Any] = tf.TensorShape((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : List[str] = tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7] ) self.assertTrue(np.allclose(outputs.logits[0, :3].numpy(), __A, atol=1E-4 ) )
336
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) _lowerCamelCase : Tuple = { "configuration_encodec": [ "ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP", "EncodecConfig", ], "feature_extraction_encodec": ["EncodecFeatureExtractor"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[Any] = [ "ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST", "EncodecModel", "EncodecPreTrainedModel", ] if TYPE_CHECKING: from .configuration_encodec import ( ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP, EncodecConfig, ) from .feature_extraction_encodec import EncodecFeatureExtractor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_encodec import ( ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST, EncodecModel, EncodecPreTrainedModel, ) else: import sys _lowerCamelCase : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) _lowerCamelCase : List[str] = {"configuration_vit_mae": ["VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP", "ViTMAEConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Tuple = [ "VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST", "ViTMAEForPreTraining", "ViTMAELayer", "ViTMAEModel", "ViTMAEPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : List[Any] = [ "TFViTMAEForPreTraining", "TFViTMAEModel", "TFViTMAEPreTrainedModel", ] if TYPE_CHECKING: from .configuration_vit_mae import VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTMAEConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vit_mae import ( VIT_MAE_PRETRAINED_MODEL_ARCHIVE_LIST, ViTMAEForPreTraining, ViTMAELayer, ViTMAEModel, ViTMAEPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vit_mae import TFViTMAEForPreTraining, TFViTMAEModel, TFViTMAEPreTrainedModel else: import sys _lowerCamelCase : Tuple = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
from __future__ import annotations def a__ ( UpperCAmelCase : int , UpperCAmelCase : int ) -> list[str]: if partitions <= 0: raise ValueError('''partitions must be a positive number!''' ) if partitions > number_of_bytes: raise ValueError('''partitions can not > number_of_bytes!''' ) UpperCAmelCase : str = number_of_bytes // partitions UpperCAmelCase : Dict = [] for i in range(UpperCAmelCase ): UpperCAmelCase : int = i * bytes_per_partition + 1 UpperCAmelCase : Optional[int] = ( number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition ) allocation_list.append(f'''{start_bytes}-{end_bytes}''' ) return allocation_list if __name__ == "__main__": import doctest doctest.testmod()
336
1
import math def a__ ( UpperCAmelCase : int ) -> bool: if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(UpperCAmelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True def a__ ( UpperCAmelCase : int = 10_001 ) -> int: try: UpperCAmelCase : Any = int(UpperCAmelCase ) except (TypeError, ValueError): raise TypeError('''Parameter nth must be int or castable to int.''' ) from None if nth <= 0: raise ValueError('''Parameter nth must be greater than or equal to one.''' ) UpperCAmelCase : list[int] = [] UpperCAmelCase : int = 2 while len(UpperCAmelCase ) < nth: if is_prime(UpperCAmelCase ): primes.append(UpperCAmelCase ) num += 1 else: num += 1 return primes[len(UpperCAmelCase ) - 1] if __name__ == "__main__": print(f"""{solution() = }""")
336
# Copyright 2022 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 import subprocess from packaging.version import Version, parse from accelerate.commands.config.config_args import default_config_file, load_config_from_file _lowerCamelCase : Union[str, Any] = "Run commands across TPU VMs for initial setup before running `accelerate launch`." def a__ ( UpperCAmelCase : Dict=None ) -> Optional[int]: if subparsers is not None: UpperCAmelCase : Tuple = subparsers.add_parser('''tpu-config''' , description=_description ) else: UpperCAmelCase : Dict = argparse.ArgumentParser('''Accelerate tpu-config command''' , description=_description ) # Core arguments UpperCAmelCase : Optional[int] = parser.add_argument_group( '''Config Arguments''' , '''Arguments that can be configured through `accelerate config`.''' ) config_args.add_argument( '''--config_file''' , type=UpperCAmelCase , default=UpperCAmelCase , help='''Path to the config file to use for accelerate.''' , ) config_args.add_argument( '''--tpu_name''' , default=UpperCAmelCase , help='''The name of the TPU to use. If not specified, will use the TPU specified in the config file.''' , ) config_args.add_argument( '''--tpu_zone''' , default=UpperCAmelCase , help='''The zone of the TPU to use. If not specified, will use the zone specified in the config file.''' , ) UpperCAmelCase : Union[str, Any] = parser.add_argument_group('''TPU Arguments''' , '''Arguments for options ran inside the TPU.''' ) pod_args.add_argument( '''--use_alpha''' , action='''store_true''' , help='''Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.''' , ) pod_args.add_argument( '''--command_file''' , default=UpperCAmelCase , help='''The path to the file containing the commands to run on the pod on startup.''' , ) pod_args.add_argument( '''--command''' , action='''append''' , nargs='''+''' , help='''A command to run on the pod. Can be passed multiple times.''' , ) pod_args.add_argument( '''--install_accelerate''' , action='''store_true''' , help='''Whether to install accelerate on the pod. Defaults to False.''' , ) pod_args.add_argument( '''--accelerate_version''' , default='''latest''' , help='''The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify \'dev\' to install from GitHub.''' , ) pod_args.add_argument( '''--debug''' , action='''store_true''' , help='''If set, will print the command that would be run instead of running it.''' ) if subparsers is not None: parser.set_defaults(func=UpperCAmelCase ) return parser def a__ ( UpperCAmelCase : Optional[int] ) -> Union[str, Any]: UpperCAmelCase : Union[str, Any] = None # Get the default from the config file if it exists. if args.config_file is not None or os.path.isfile(UpperCAmelCase ): UpperCAmelCase : Union[str, Any] = load_config_from_file(args.config_file ) if not args.command_file and defaults.command_file is not None and not args.command: UpperCAmelCase : List[Any] = defaults.command_file if not args.command and defaults.commands is not None: UpperCAmelCase : List[str] = defaults.commands if not args.tpu_name: UpperCAmelCase : Tuple = defaults.tpu_name if not args.tpu_zone: UpperCAmelCase : int = defaults.tpu_zone if args.accelerate_version == "dev": UpperCAmelCase : Tuple = '''git+https://github.com/huggingface/accelerate.git''' elif args.accelerate_version == "latest": UpperCAmelCase : Dict = '''accelerate -U''' elif isinstance(parse(args.accelerate_version ) , UpperCAmelCase ): UpperCAmelCase : Optional[int] = f'''accelerate=={args.accelerate_version}''' if not args.command_file and not args.command: raise ValueError('''You must specify either a command file or a command to run on the pod.''' ) if args.command_file: with open(args.command_file , '''r''' ) as f: UpperCAmelCase : int = [f.read().splitlines()] # To turn list of lists into list of strings if isinstance(args.command[0] , UpperCAmelCase ): UpperCAmelCase : int = [line for cmd in args.command for line in cmd] # Default to the shared folder and install accelerate UpperCAmelCase : Optional[int] = ['''cd /usr/share'''] if args.install_accelerate: new_cmd += [f'''pip install {args.accelerate_version}'''] new_cmd += args.command UpperCAmelCase : int = '''; '''.join(UpperCAmelCase ) # Then send it to gcloud # Eventually try to use google-api-core to do this instead of subprocess UpperCAmelCase : Any = ['''gcloud'''] if args.use_alpha: cmd += ["alpha"] cmd += [ "compute", "tpus", "tpu-vm", "ssh", args.tpu_name, "--zone", args.tpu_zone, "--command", args.command, "--worker", "all", ] if args.debug: print(f'''Running {" ".join(UpperCAmelCase )}''' ) return subprocess.run(UpperCAmelCase ) print('''Successfully setup pod.''' ) def a__ ( ) -> Any: UpperCAmelCase : Any = tpu_command_parser() UpperCAmelCase : Tuple = parser.parse_args() tpu_command_launcher(UpperCAmelCase )
336
1
from __future__ import annotations def a__ ( UpperCAmelCase : int , UpperCAmelCase : int ) -> list[str]: if partitions <= 0: raise ValueError('''partitions must be a positive number!''' ) if partitions > number_of_bytes: raise ValueError('''partitions can not > number_of_bytes!''' ) UpperCAmelCase : str = number_of_bytes // partitions UpperCAmelCase : Dict = [] for i in range(UpperCAmelCase ): UpperCAmelCase : int = i * bytes_per_partition + 1 UpperCAmelCase : Optional[int] = ( number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition ) allocation_list.append(f'''{start_bytes}-{end_bytes}''' ) return allocation_list if __name__ == "__main__": import doctest doctest.testmod()
336
import argparse import collections import json from pathlib import Path import requests import torch import yaml from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( MobileViTImageProcessor, MobileViTVaConfig, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, ) from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : Optional[int] = logging.get_logger(__name__) def a__ ( UpperCAmelCase : Union[str, Any] ) -> Optional[Any]: print('''Loading config file...''' ) def flatten_yaml_as_dict(UpperCAmelCase : Tuple , UpperCAmelCase : Any="" , UpperCAmelCase : Dict="." ): UpperCAmelCase : List[str] = [] for k, v in d.items(): UpperCAmelCase : List[Any] = parent_key + sep + k if parent_key else k if isinstance(UpperCAmelCase , collections.abc.MutableMapping ): items.extend(flatten_yaml_as_dict(UpperCAmelCase , UpperCAmelCase , sep=UpperCAmelCase ).items() ) else: items.append((new_key, v) ) return dict(UpperCAmelCase ) UpperCAmelCase : List[str] = argparse.Namespace() with open(UpperCAmelCase , '''r''' ) as yaml_file: try: UpperCAmelCase : List[str] = yaml.load(UpperCAmelCase , Loader=yaml.FullLoader ) UpperCAmelCase : Optional[int] = flatten_yaml_as_dict(UpperCAmelCase ) for k, v in flat_cfg.items(): setattr(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) except yaml.YAMLError as exc: logger.error('''Error while loading config file: {}. Error message: {}'''.format(UpperCAmelCase , str(UpperCAmelCase ) ) ) return config def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : int ) -> List[Any]: UpperCAmelCase : int = MobileViTVaConfig() UpperCAmelCase : str = False # dataset if task_name.startswith('''imagenet1k_''' ): UpperCAmelCase : Any = 1_000 if int(task_name.strip().split('''_''' )[-1] ) == 384: UpperCAmelCase : Any = 384 else: UpperCAmelCase : Tuple = 256 UpperCAmelCase : int = '''imagenet-1k-id2label.json''' elif task_name.startswith('''imagenet21k_to_1k_''' ): UpperCAmelCase : Optional[Any] = 21_000 if int(task_name.strip().split('''_''' )[-1] ) == 384: UpperCAmelCase : str = 384 else: UpperCAmelCase : Dict = 256 UpperCAmelCase : List[Any] = '''imagenet-22k-id2label.json''' elif task_name.startswith('''ade20k_''' ): UpperCAmelCase : Optional[Any] = 151 UpperCAmelCase : Tuple = 512 UpperCAmelCase : Tuple = '''ade20k-id2label.json''' UpperCAmelCase : Tuple = True elif task_name.startswith('''voc_''' ): UpperCAmelCase : Dict = 21 UpperCAmelCase : str = 512 UpperCAmelCase : Union[str, Any] = '''pascal-voc-id2label.json''' UpperCAmelCase : Dict = True # orig_config UpperCAmelCase : List[Any] = load_orig_config_file(UpperCAmelCase ) assert getattr(UpperCAmelCase , '''model.classification.name''' , -1 ) == "mobilevit_v2", "Invalid model" UpperCAmelCase : Tuple = getattr(UpperCAmelCase , '''model.classification.mitv2.width_multiplier''' , 1.0 ) assert ( getattr(UpperCAmelCase , '''model.classification.mitv2.attn_norm_layer''' , -1 ) == "layer_norm_2d" ), "Norm layers other than layer_norm_2d is not supported" UpperCAmelCase : int = getattr(UpperCAmelCase , '''model.classification.activation.name''' , '''swish''' ) # config.image_size == getattr(orig_config, 'sampler.bs.crop_size_width', 256) if is_segmentation_model: UpperCAmelCase : str = getattr(UpperCAmelCase , '''model.segmentation.output_stride''' , 16 ) if "_deeplabv3" in task_name: UpperCAmelCase : int = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_rates''' , [12, 24, 36] ) UpperCAmelCase : Any = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_out_channels''' , 512 ) UpperCAmelCase : Optional[Any] = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_dropout''' , 0.1 ) # id2label UpperCAmelCase : Union[str, Any] = '''huggingface/label-files''' UpperCAmelCase : List[Any] = json.load(open(hf_hub_download(UpperCAmelCase , UpperCAmelCase , repo_type='''dataset''' ) , '''r''' ) ) UpperCAmelCase : Any = {int(UpperCAmelCase ): v for k, v in idalabel.items()} UpperCAmelCase : int = idalabel UpperCAmelCase : Optional[int] = {v: k for k, v in idalabel.items()} return config def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : Optional[int] ) -> List[str]: UpperCAmelCase : Union[str, Any] = dct.pop(UpperCAmelCase ) UpperCAmelCase : List[str] = val def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : int=False ) -> Union[str, Any]: if base_model: UpperCAmelCase : Dict = '''''' else: UpperCAmelCase : Dict = '''mobilevitv2.''' UpperCAmelCase : Optional[int] = [] for k in state_dict.keys(): if k[:8] == "encoder.": UpperCAmelCase : List[str] = k[8:] else: UpperCAmelCase : Dict = k if ".block." in k: UpperCAmelCase : List[Any] = k_new.replace('''.block.''' , '''.''' ) if ".conv." in k: UpperCAmelCase : Optional[int] = k_new.replace('''.conv.''' , '''.convolution.''' ) if ".norm." in k: UpperCAmelCase : List[str] = k_new.replace('''.norm.''' , '''.normalization.''' ) if "conv_1." in k: UpperCAmelCase : Union[str, Any] = k_new.replace('''conv_1.''' , f'''{model_prefix}conv_stem.''' ) for i in [1, 2]: if f'''layer_{i}.''' in k: UpperCAmelCase : Union[str, Any] = k_new.replace(f'''layer_{i}.''' , f'''{model_prefix}encoder.layer.{i-1}.layer.''' ) if ".exp_1x1." in k: UpperCAmelCase : Optional[Any] = k_new.replace('''.exp_1x1.''' , '''.expand_1x1.''' ) if ".red_1x1." in k: UpperCAmelCase : int = k_new.replace('''.red_1x1.''' , '''.reduce_1x1.''' ) for i in [3, 4, 5]: if f'''layer_{i}.0.''' in k: UpperCAmelCase : Any = k_new.replace(f'''layer_{i}.0.''' , f'''{model_prefix}encoder.layer.{i-1}.downsampling_layer.''' ) if f'''layer_{i}.1.local_rep.0.''' in k: UpperCAmelCase : str = k_new.replace(f'''layer_{i}.1.local_rep.0.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_kxk.''' ) if f'''layer_{i}.1.local_rep.1.''' in k: UpperCAmelCase : int = k_new.replace(f'''layer_{i}.1.local_rep.1.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_1x1.''' ) for i in [3, 4, 5]: if i == 3: UpperCAmelCase : Dict = [0, 1] elif i == 4: UpperCAmelCase : Dict = [0, 1, 2, 3] elif i == 5: UpperCAmelCase : int = [0, 1, 2] for j in j_in: if f'''layer_{i}.1.global_rep.{j}.''' in k: UpperCAmelCase : Optional[Any] = k_new.replace( f'''layer_{i}.1.global_rep.{j}.''' , f'''{model_prefix}encoder.layer.{i-1}.transformer.layer.{j}.''' ) if f'''layer_{i}.1.global_rep.{j+1}.''' in k: UpperCAmelCase : Any = k_new.replace( f'''layer_{i}.1.global_rep.{j+1}.''' , f'''{model_prefix}encoder.layer.{i-1}.layernorm.''' ) if f'''layer_{i}.1.conv_proj.''' in k: UpperCAmelCase : Union[str, Any] = k_new.replace(f'''layer_{i}.1.conv_proj.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_projection.''' ) if "pre_norm_attn.0." in k: UpperCAmelCase : Optional[int] = k_new.replace('''pre_norm_attn.0.''' , '''layernorm_before.''' ) if "pre_norm_attn.1." in k: UpperCAmelCase : Optional[Any] = k_new.replace('''pre_norm_attn.1.''' , '''attention.''' ) if "pre_norm_ffn.0." in k: UpperCAmelCase : List[Any] = k_new.replace('''pre_norm_ffn.0.''' , '''layernorm_after.''' ) if "pre_norm_ffn.1." in k: UpperCAmelCase : List[Any] = k_new.replace('''pre_norm_ffn.1.''' , '''ffn.conv1.''' ) if "pre_norm_ffn.3." in k: UpperCAmelCase : Any = k_new.replace('''pre_norm_ffn.3.''' , '''ffn.conv2.''' ) if "classifier.1." in k: UpperCAmelCase : Optional[int] = k_new.replace('''classifier.1.''' , '''classifier.''' ) if "seg_head." in k: UpperCAmelCase : Union[str, Any] = k_new.replace('''seg_head.''' , '''segmentation_head.''' ) if ".aspp_layer." in k: UpperCAmelCase : Tuple = k_new.replace('''.aspp_layer.''' , '''.''' ) if ".aspp_pool." in k: UpperCAmelCase : Optional[int] = k_new.replace('''.aspp_pool.''' , '''.''' ) rename_keys.append((k, k_new) ) return rename_keys def a__ ( UpperCAmelCase : Union[str, Any] ) -> Any: UpperCAmelCase : str = [] for k in state_dict.keys(): if k.startswith('''seg_head.aux_head.''' ): keys_to_ignore.append(UpperCAmelCase ) for k in keys_to_ignore: state_dict.pop(UpperCAmelCase , UpperCAmelCase ) def a__ ( ) -> Union[str, Any]: UpperCAmelCase : int = '''http://images.cocodataset.org/val2017/000000039769.jpg''' # url = "https://cdn.britannica.com/86/141086-050-9D7C75EE/Gulfstream-G450-business-jet-passengers.jpg" UpperCAmelCase : List[str] = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ) return im @torch.no_grad() def a__ ( UpperCAmelCase : int , UpperCAmelCase : int , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : List[Any] ) -> Union[str, Any]: UpperCAmelCase : Union[str, Any] = get_mobilevitva_config(UpperCAmelCase , UpperCAmelCase ) # load original state_dict UpperCAmelCase : List[str] = torch.load(UpperCAmelCase , map_location='''cpu''' ) # load huggingface model if task_name.startswith('''ade20k_''' ) or task_name.startswith('''voc_''' ): UpperCAmelCase : str = MobileViTVaForSemanticSegmentation(UpperCAmelCase ).eval() UpperCAmelCase : str = False else: UpperCAmelCase : Union[str, Any] = MobileViTVaForImageClassification(UpperCAmelCase ).eval() UpperCAmelCase : Any = False # remove and rename some keys of load the original model UpperCAmelCase : Optional[Any] = checkpoint remove_unused_keys(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = create_rename_keys(UpperCAmelCase , base_model=UpperCAmelCase ) for rename_key_src, rename_key_dest in rename_keys: rename_key(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # load modified state_dict model.load_state_dict(UpperCAmelCase ) # Check outputs on an image, prepared by MobileViTImageProcessor UpperCAmelCase : Dict = MobileViTImageProcessor(crop_size=config.image_size , size=config.image_size + 32 ) UpperCAmelCase : Any = image_processor(images=prepare_img() , return_tensors='''pt''' ) UpperCAmelCase : Union[str, Any] = model(**UpperCAmelCase ) # verify classification model if task_name.startswith('''imagenet''' ): UpperCAmelCase : Optional[Any] = outputs.logits UpperCAmelCase : int = logits.argmax(-1 ).item() print('''Predicted class:''' , model.config.idalabel[predicted_class_idx] ) if task_name.startswith('''imagenet1k_256''' ) and config.width_multiplier == 1.0: # expected_logits for base variant UpperCAmelCase : str = torch.tensor([-1.6_336E00, -7.3_204E-02, -5.1_883E-01] ) assert torch.allclose(logits[0, :3] , UpperCAmelCase , atol=1E-4 ) Path(UpperCAmelCase ).mkdir(exist_ok=UpperCAmelCase ) print(f'''Saving model {task_name} to {pytorch_dump_folder_path}''' ) model.save_pretrained(UpperCAmelCase ) print(f'''Saving image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(UpperCAmelCase ) if __name__ == "__main__": _lowerCamelCase : str = argparse.ArgumentParser() # Required parameters parser.add_argument( "--task", default="imagenet1k_256", type=str, help=( "Name of the task for which the MobileViTV2 model you'd like to convert is trained on . " "\n Classification (ImageNet-1k)\n - MobileViTV2 (256x256) : imagenet1k_256\n - MobileViTV2 (Trained on 256x256 and Finetuned on 384x384) : imagenet1k_384\n - MobileViTV2 (Trained on ImageNet-21k and Finetuned on ImageNet-1k 256x256) :\n imagenet21k_to_1k_256\n - MobileViTV2 (Trained on ImageNet-21k, Finetuned on ImageNet-1k 256x256, and Finetuned on\n ImageNet-1k 384x384) : imagenet21k_to_1k_384\n Segmentation\n - ADE20K Dataset : ade20k_deeplabv3\n - Pascal VOC 2012 Dataset: voc_deeplabv3\n " ), choices=[ "imagenet1k_256", "imagenet1k_384", "imagenet21k_to_1k_256", "imagenet21k_to_1k_384", "ade20k_deeplabv3", "voc_deeplabv3", ], ) parser.add_argument( "--orig_checkpoint_path", required=True, type=str, help="Path to the original state dict (.pt file)." ) parser.add_argument("--orig_config_path", required=True, type=str, help="Path to the original config file.") parser.add_argument( "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory." ) _lowerCamelCase : Optional[int] = parser.parse_args() convert_mobilevitva_checkpoint( args.task, args.orig_checkpoint_path, args.orig_config_path, args.pytorch_dump_folder_path )
336
1
def a__ ( UpperCAmelCase : str , UpperCAmelCase : int ) -> list[str]: return [sentence[i : i + ngram_size] for i in range(len(UpperCAmelCase ) - ngram_size + 1 )] if __name__ == "__main__": from doctest import testmod testmod()
336
import inspect import tempfile from collections import OrderedDict, UserDict from collections.abc import MutableMapping from contextlib import ExitStack, contextmanager from dataclasses import fields from enum import Enum from typing import Any, ContextManager, List, Tuple import numpy as np from .import_utils import is_flax_available, is_tf_available, is_torch_available, is_torch_fx_proxy if is_flax_available(): import jax.numpy as jnp class __UpperCAmelCase ( lowerCamelCase__ ): def __get__( self : Tuple, __A : Optional[Any], __A : Optional[int]=None ): # See docs.python.org/3/howto/descriptor.html#properties if obj is None: return self if self.fget is None: raise AttributeError('''unreadable attribute''' ) UpperCAmelCase : str = '''__cached_''' + self.fget.__name__ UpperCAmelCase : int = getattr(__A, __A, __A ) if cached is None: UpperCAmelCase : Any = self.fget(__A ) setattr(__A, __A, __A ) return cached def a__ ( UpperCAmelCase : Optional[Any] ) -> Any: UpperCAmelCase : Any = val.lower() if val in {"y", "yes", "t", "true", "on", "1"}: return 1 if val in {"n", "no", "f", "false", "off", "0"}: return 0 raise ValueError(f'''invalid truth value {val!r}''' ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: if is_torch_fx_proxy(UpperCAmelCase ): return True if is_torch_available(): import torch if isinstance(UpperCAmelCase , torch.Tensor ): return True if is_tf_available(): import tensorflow as tf if isinstance(UpperCAmelCase , tf.Tensor ): return True if is_flax_available(): import jax.numpy as jnp from jax.core import Tracer if isinstance(UpperCAmelCase , (jnp.ndarray, Tracer) ): return True return isinstance(UpperCAmelCase , np.ndarray ) def a__ ( UpperCAmelCase : List[Any] ) -> Union[str, Any]: return isinstance(UpperCAmelCase , np.ndarray ) def a__ ( UpperCAmelCase : str ) -> Tuple: return _is_numpy(UpperCAmelCase ) def a__ ( UpperCAmelCase : str ) -> List[Any]: import torch return isinstance(UpperCAmelCase , torch.Tensor ) def a__ ( UpperCAmelCase : str ) -> List[Any]: return False if not is_torch_available() else _is_torch(UpperCAmelCase ) def a__ ( UpperCAmelCase : Tuple ) -> List[str]: import torch return isinstance(UpperCAmelCase , torch.device ) def a__ ( UpperCAmelCase : Any ) -> Any: return False if not is_torch_available() else _is_torch_device(UpperCAmelCase ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: import torch if isinstance(UpperCAmelCase , UpperCAmelCase ): if hasattr(UpperCAmelCase , UpperCAmelCase ): UpperCAmelCase : Union[str, Any] = getattr(UpperCAmelCase , UpperCAmelCase ) else: return False return isinstance(UpperCAmelCase , torch.dtype ) def a__ ( UpperCAmelCase : Optional[Any] ) -> Union[str, Any]: return False if not is_torch_available() else _is_torch_dtype(UpperCAmelCase ) def a__ ( UpperCAmelCase : Any ) -> str: import tensorflow as tf return isinstance(UpperCAmelCase , tf.Tensor ) def a__ ( UpperCAmelCase : int ) -> Union[str, Any]: return False if not is_tf_available() else _is_tensorflow(UpperCAmelCase ) def a__ ( UpperCAmelCase : List[str] ) -> Tuple: import tensorflow as tf # the `is_symbolic_tensor` predicate is only available starting with TF 2.14 if hasattr(UpperCAmelCase , '''is_symbolic_tensor''' ): return tf.is_symbolic_tensor(UpperCAmelCase ) return type(UpperCAmelCase ) == tf.Tensor def a__ ( UpperCAmelCase : int ) -> List[Any]: return False if not is_tf_available() else _is_tf_symbolic_tensor(UpperCAmelCase ) def a__ ( UpperCAmelCase : List[Any] ) -> Dict: import jax.numpy as jnp # noqa: F811 return isinstance(UpperCAmelCase , jnp.ndarray ) def a__ ( UpperCAmelCase : List[Any] ) -> Optional[int]: return False if not is_flax_available() else _is_jax(UpperCAmelCase ) def a__ ( UpperCAmelCase : int ) -> Tuple: if isinstance(UpperCAmelCase , (dict, UserDict) ): return {k: to_py_obj(UpperCAmelCase ) for k, v in obj.items()} elif isinstance(UpperCAmelCase , (list, tuple) ): return [to_py_obj(UpperCAmelCase ) for o in obj] elif is_tf_tensor(UpperCAmelCase ): return obj.numpy().tolist() elif is_torch_tensor(UpperCAmelCase ): return obj.detach().cpu().tolist() elif is_jax_tensor(UpperCAmelCase ): return np.asarray(UpperCAmelCase ).tolist() elif isinstance(UpperCAmelCase , (np.ndarray, np.number) ): # tolist also works on 0d np arrays return obj.tolist() else: return obj def a__ ( UpperCAmelCase : Any ) -> List[str]: if isinstance(UpperCAmelCase , (dict, UserDict) ): return {k: to_numpy(UpperCAmelCase ) for k, v in obj.items()} elif isinstance(UpperCAmelCase , (list, tuple) ): return np.array(UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): return obj.numpy() elif is_torch_tensor(UpperCAmelCase ): return obj.detach().cpu().numpy() elif is_jax_tensor(UpperCAmelCase ): return np.asarray(UpperCAmelCase ) else: return obj class __UpperCAmelCase ( lowerCamelCase__ ): def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Optional[Any] = fields(self ) # Safety and consistency checks if not len(__A ): raise ValueError(F'''{self.__class__.__name__} has no fields.''' ) if not all(field.default is None for field in class_fields[1:] ): raise ValueError(F'''{self.__class__.__name__} should not have more than one required field.''' ) UpperCAmelCase : int = getattr(self, class_fields[0].name ) UpperCAmelCase : str = all(getattr(self, field.name ) is None for field in class_fields[1:] ) if other_fields_are_none and not is_tensor(__A ): if isinstance(__A, __A ): UpperCAmelCase : Tuple = first_field.items() UpperCAmelCase : Any = True else: try: UpperCAmelCase : Optional[Any] = iter(__A ) UpperCAmelCase : Optional[Any] = True except TypeError: UpperCAmelCase : Optional[int] = False # if we provided an iterator as first field and the iterator is a (key, value) iterator # set the associated fields if first_field_iterator: for idx, element in enumerate(__A ): if ( not isinstance(__A, (list, tuple) ) or not len(__A ) == 2 or not isinstance(element[0], __A ) ): if idx == 0: # If we do not have an iterator of key/values, set it as attribute UpperCAmelCase : Any = first_field else: # If we have a mixed iterator, raise an error raise ValueError( F'''Cannot set key/value for {element}. It needs to be a tuple (key, value).''' ) break setattr(self, element[0], element[1] ) if element[1] is not None: UpperCAmelCase : Union[str, Any] = element[1] elif first_field is not None: UpperCAmelCase : Union[str, Any] = first_field else: for field in class_fields: UpperCAmelCase : Optional[Any] = getattr(self, field.name ) if v is not None: UpperCAmelCase : Optional[int] = v def __delitem__( self : Union[str, Any], *__A : str, **__A : Tuple ): raise Exception(F'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : List[str], *__A : Union[str, Any], **__A : Optional[Any] ): raise Exception(F'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : Any, *__A : Dict, **__A : str ): raise Exception(F'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : Dict, *__A : int, **__A : Dict ): raise Exception(F'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' ) def __getitem__( self : List[str], __A : List[str] ): if isinstance(__A, __A ): UpperCAmelCase : int = dict(self.items() ) return inner_dict[k] else: return self.to_tuple()[k] def __setattr__( self : Optional[Any], __A : Dict, __A : Union[str, Any] ): if name in self.keys() and value is not None: # Don't call self.__setitem__ to avoid recursion errors super().__setitem__(__A, __A ) super().__setattr__(__A, __A ) def __setitem__( self : Dict, __A : List[Any], __A : Union[str, Any] ): # Will raise a KeyException if needed super().__setitem__(__A, __A ) # Don't call self.__setattr__ to avoid recursion errors super().__setattr__(__A, __A ) def __magic_name__ ( self : List[str] ): return tuple(self[k] for k in self.keys() ) class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ ): @classmethod def __magic_name__ ( cls : List[Any], __A : Tuple ): raise ValueError( F'''{value} is not a valid {cls.__name__}, please select one of {list(cls._valueamember_map_.keys() )}''' ) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """longest""" UpperCamelCase = """max_length""" UpperCamelCase = """do_not_pad""" class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """pt""" UpperCamelCase = """tf""" UpperCamelCase = """np""" UpperCamelCase = """jax""" class __UpperCAmelCase : def __init__( self : Any, __A : List[ContextManager] ): UpperCAmelCase : Tuple = context_managers UpperCAmelCase : Tuple = ExitStack() def __enter__( self : Any ): for context_manager in self.context_managers: self.stack.enter_context(__A ) def __exit__( self : List[Any], *__A : Union[str, Any], **__A : Dict ): self.stack.__exit__(*__A, **__A ) def a__ ( UpperCAmelCase : Union[str, Any] ) -> str: UpperCAmelCase : int = infer_framework(UpperCAmelCase ) if framework == "tf": UpperCAmelCase : List[str] = inspect.signature(model_class.call ) # TensorFlow models elif framework == "pt": UpperCAmelCase : List[Any] = inspect.signature(model_class.forward ) # PyTorch models else: UpperCAmelCase : Tuple = inspect.signature(model_class.__call__ ) # Flax models for p in signature.parameters: if p == "return_loss" and signature.parameters[p].default is True: return True return False def a__ ( UpperCAmelCase : Dict ) -> Any: UpperCAmelCase : List[Any] = model_class.__name__ UpperCAmelCase : Union[str, Any] = infer_framework(UpperCAmelCase ) if framework == "tf": UpperCAmelCase : Tuple = inspect.signature(model_class.call ) # TensorFlow models elif framework == "pt": UpperCAmelCase : Dict = inspect.signature(model_class.forward ) # PyTorch models else: UpperCAmelCase : Dict = inspect.signature(model_class.__call__ ) # Flax models if "QuestionAnswering" in model_name: return [p for p in signature.parameters if "label" in p or p in ("start_positions", "end_positions")] else: return [p for p in signature.parameters if "label" in p] def a__ ( UpperCAmelCase : MutableMapping , UpperCAmelCase : str = "" , UpperCAmelCase : str = "." ) -> Union[str, Any]: def _flatten_dict(UpperCAmelCase : Optional[Any] , UpperCAmelCase : List[str]="" , UpperCAmelCase : Any="." ): for k, v in d.items(): UpperCAmelCase : List[str] = str(UpperCAmelCase ) + delimiter + str(UpperCAmelCase ) if parent_key else k if v and isinstance(UpperCAmelCase , UpperCAmelCase ): yield from flatten_dict(UpperCAmelCase , UpperCAmelCase , delimiter=UpperCAmelCase ).items() else: yield key, v return dict(_flatten_dict(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) ) @contextmanager def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : bool = False ) -> Optional[Any]: if use_temp_dir: with tempfile.TemporaryDirectory() as tmp_dir: yield tmp_dir else: yield working_dir def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : List[str]=None ) -> Optional[Any]: if is_numpy_array(UpperCAmelCase ): return np.transpose(UpperCAmelCase , axes=UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.T if axes is None else array.permute(*UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.transpose(UpperCAmelCase , perm=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.transpose(UpperCAmelCase , axes=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for transpose: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : Optional[int] ) -> List[str]: if is_numpy_array(UpperCAmelCase ): return np.reshape(UpperCAmelCase , UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.reshape(*UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.reshape(UpperCAmelCase , UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.reshape(UpperCAmelCase , UpperCAmelCase ) else: raise ValueError(f'''Type not supported for reshape: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : Tuple , UpperCAmelCase : Optional[int]=None ) -> Any: if is_numpy_array(UpperCAmelCase ): return np.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.squeeze() if axis is None else array.squeeze(dim=UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for squeeze: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : int ) -> str: if is_numpy_array(UpperCAmelCase ): return np.expand_dims(UpperCAmelCase , UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.unsqueeze(dim=UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.expand_dims(UpperCAmelCase , axis=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.expand_dims(UpperCAmelCase , axis=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for expand_dims: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: if is_numpy_array(UpperCAmelCase ): return np.size(UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.numel() elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.size(UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return array.size else: raise ValueError(f'''Type not supported for expand_dims: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : List[str] ) -> Dict: for key, value in auto_map.items(): if isinstance(UpperCAmelCase , (tuple, list) ): UpperCAmelCase : List[Any] = [f'''{repo_id}--{v}''' if (v is not None and '''--''' not in v) else v for v in value] elif value is not None and "--" not in value: UpperCAmelCase : List[Any] = f'''{repo_id}--{value}''' return auto_map def a__ ( UpperCAmelCase : Tuple ) -> Union[str, Any]: for base_class in inspect.getmro(UpperCAmelCase ): UpperCAmelCase : Any = base_class.__module__ UpperCAmelCase : Dict = base_class.__name__ if module.startswith('''tensorflow''' ) or module.startswith('''keras''' ) or name == "TFPreTrainedModel": return "tf" elif module.startswith('''torch''' ) or name == "PreTrainedModel": return "pt" elif module.startswith('''flax''' ) or module.startswith('''jax''' ) or name == "FlaxPreTrainedModel": return "flax" else: raise TypeError(f'''Could not infer framework from class {model_class}.''' )
336
1
import warnings from .generation import TFGenerationMixin class __UpperCAmelCase ( lowerCamelCase__ ): # warning at import time warnings.warn( """Importing `TFGenerationMixin` from `src/transformers/generation_tf_utils.py` is deprecated and will """ """be removed in Transformers v5. Import as `from transformers import TFGenerationMixin` instead.""" , lowerCamelCase__ , )
336
import os import unittest from transformers import LayoutLMTokenizer, LayoutLMTokenizerFast from transformers.models.layoutlm.tokenization_layoutlm import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class __UpperCAmelCase ( lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = LayoutLMTokenizer UpperCamelCase = LayoutLMTokenizerFast UpperCamelCase = True UpperCamelCase = True def __magic_name__ ( self : Any ): super().setUp() UpperCAmelCase : Dict = [ '''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''', ] UpperCAmelCase : int = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['''vocab_file'''] ) with open(self.vocab_file, '''w''', encoding='''utf-8''' ) as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens] ) ) def __magic_name__ ( self : Union[str, Any], **__A : List[str] ): return LayoutLMTokenizer.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Optional[int], __A : int ): UpperCAmelCase : Optional[Any] = '''UNwant\u00E9d,running''' UpperCAmelCase : Optional[int] = '''unwanted, running''' return input_text, output_text def __magic_name__ ( self : Any ): UpperCAmelCase : Union[str, Any] = self.tokenizer_class(self.vocab_file ) UpperCAmelCase : Optional[Any] = tokenizer.tokenize('''UNwant\u00E9d,running''' ) self.assertListEqual(__A, ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing'''] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__A ), [7, 4, 5, 1_0, 8, 9] ) def __magic_name__ ( self : Optional[int] ): pass
336
1
_lowerCamelCase : Any = "\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n" _lowerCamelCase : int = [{"type": "code", "content": INSTALL_CONTENT}] _lowerCamelCase : Optional[Any] = { "{processor_class}": "FakeProcessorClass", "{model_class}": "FakeModelClass", "{object_class}": "FakeObjectClass", }
336
from __future__ import annotations import copy import inspect import json import math import os import tempfile import unittest from importlib import import_module import numpy as np from transformers import ViTMAEConfig from transformers.file_utils import cached_property, is_tf_available, is_vision_available from transformers.testing_utils import require_tf, require_vision, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFViTMAEForPreTraining, TFViTMAEModel if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class __UpperCAmelCase : def __init__( self : Any, __A : str, __A : Dict=1_3, __A : int=3_0, __A : Tuple=2, __A : Union[str, Any]=3, __A : Any=True, __A : str=True, __A : Dict=3_2, __A : List[Any]=2, __A : Optional[Any]=4, __A : Union[str, Any]=3_7, __A : int="gelu", __A : int=0.1, __A : List[Any]=0.1, __A : Tuple=1_0, __A : Tuple=0.0_2, __A : Any=3, __A : List[str]=0.6, __A : Any=None, ): UpperCAmelCase : Union[str, Any] = parent UpperCAmelCase : Dict = batch_size UpperCAmelCase : List[str] = image_size UpperCAmelCase : Dict = patch_size UpperCAmelCase : int = num_channels UpperCAmelCase : Union[str, Any] = is_training UpperCAmelCase : Union[str, Any] = use_labels UpperCAmelCase : Union[str, Any] = hidden_size UpperCAmelCase : Optional[int] = num_hidden_layers UpperCAmelCase : Union[str, Any] = num_attention_heads UpperCAmelCase : List[str] = intermediate_size UpperCAmelCase : Optional[int] = hidden_act UpperCAmelCase : Tuple = hidden_dropout_prob UpperCAmelCase : List[Any] = attention_probs_dropout_prob UpperCAmelCase : Any = type_sequence_label_size UpperCAmelCase : Tuple = initializer_range UpperCAmelCase : Tuple = mask_ratio UpperCAmelCase : Any = scope # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above # (we add 1 for the [CLS] token) UpperCAmelCase : Tuple = (image_size // patch_size) ** 2 UpperCAmelCase : List[Any] = int(math.ceil((1 - mask_ratio) * (num_patches + 1) ) ) def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : int = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : Any = None if self.use_labels: UpperCAmelCase : Optional[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size ) UpperCAmelCase : str = self.get_config() return config, pixel_values, labels def __magic_name__ ( self : Optional[Any] ): 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, decoder_hidden_size=self.hidden_size, decoder_num_hidden_layers=self.num_hidden_layers, decoder_num_attention_heads=self.num_attention_heads, decoder_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 __magic_name__ ( self : str, __A : List[Any], __A : Any, __A : Any ): UpperCAmelCase : Optional[Any] = TFViTMAEModel(config=__A ) UpperCAmelCase : Tuple = model(__A, training=__A ) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__ ( self : Tuple, __A : str, __A : int, __A : str ): UpperCAmelCase : Dict = TFViTMAEForPreTraining(__A ) UpperCAmelCase : int = model(__A, training=__A ) # expected sequence length = num_patches UpperCAmelCase : int = (self.image_size // self.patch_size) ** 2 UpperCAmelCase : Optional[Any] = self.patch_size**2 * self.num_channels self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels) ) # test greyscale images UpperCAmelCase : Tuple = 1 UpperCAmelCase : List[Any] = TFViTMAEForPreTraining(__A ) UpperCAmelCase : Union[str, Any] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) UpperCAmelCase : List[Any] = model(__A, training=__A ) UpperCAmelCase : Union[str, Any] = self.patch_size**2 self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels) ) def __magic_name__ ( self : List[Any] ): UpperCAmelCase : Dict = self.prepare_config_and_inputs() ((UpperCAmelCase) , (UpperCAmelCase) , (UpperCAmelCase)) : Union[str, Any] = config_and_inputs UpperCAmelCase : Optional[Any] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_tf class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else () UpperCamelCase = {"""feature-extraction""": TFViTMAEModel} if is_tf_available() else {} UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = TFViTMAEModelTester(self ) UpperCAmelCase : int = ConfigTester(self, config_class=__A, has_text_modality=__A, hidden_size=3_7 ) def __magic_name__ ( self : List[str] ): self.config_tester.run_common_tests() @unittest.skip(reason='''ViTMAE does not use inputs_embeds''' ) def __magic_name__ ( self : List[Any] ): pass def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : List[str] = model_class(__A ) self.assertIsInstance(model.get_input_embeddings(), (tf.keras.layers.Layer) ) UpperCAmelCase : Union[str, Any] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__A, tf.keras.layers.Layer ) ) def __magic_name__ ( self : str ): UpperCAmelCase , UpperCAmelCase : str = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Any = model_class(__A ) UpperCAmelCase : Any = inspect.signature(model.call ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : int = [*signature.parameters.keys()] UpperCAmelCase : Tuple = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : str ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*__A ) def __magic_name__ ( self : int ): # make the mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Tuple = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : List[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : str = model_class(__A ) UpperCAmelCase : int = self._prepare_for_class(__A, __A ) UpperCAmelCase : Dict = model(__A, noise=__A ) UpperCAmelCase : Any = copy.deepcopy(self._prepare_for_class(__A, __A ) ) UpperCAmelCase : Union[str, Any] = model(**__A, noise=__A ) UpperCAmelCase : Dict = outputs_dict[0].numpy() UpperCAmelCase : Tuple = outputs_keywords[0].numpy() self.assertLess(np.sum(np.abs(output_dict - output_keywords ) ), 1E-6 ) def __magic_name__ ( self : Optional[Any] ): # make the mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Any = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : str = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Union[str, Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) def prepare_numpy_arrays(__A : Union[str, Any] ): UpperCAmelCase : str = {} for k, v in inputs_dict.items(): if tf.is_tensor(__A ): UpperCAmelCase : Tuple = v.numpy() else: UpperCAmelCase : str = np.array(__A ) return inputs_np_dict for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) UpperCAmelCase : Any = self._prepare_for_class(__A, __A ) UpperCAmelCase : Optional[int] = prepare_numpy_arrays(__A ) UpperCAmelCase : str = model(__A, noise=__A ) UpperCAmelCase : str = model(**__A, noise=__A ) self.assert_outputs_same(__A, __A ) def __magic_name__ ( self : int, __A : str, __A : Union[str, Any], __A : Optional[Any] ): # make masks reproducible np.random.seed(2 ) UpperCAmelCase : Any = int((tf_model.config.image_size // tf_model.config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) UpperCAmelCase : int = tf.constant(__A ) # Add `noise` argument. # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument UpperCAmelCase : List[Any] = tf_noise super().check_pt_tf_models(__A, __A, __A ) def __magic_name__ ( self : str ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Union[str, Any] = { module_member for model_class in self.all_model_classes for module in (import_module(model_class.__module__ ),) for module_member_name in dir(__A ) if module_member_name.endswith('''MainLayer''' ) # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`. and module_member_name[: -len('''MainLayer''' )] == model_class.__name__[: -len('''Model''' )] for module_member in (getattr(__A, __A ),) if isinstance(__A, __A ) and tf.keras.layers.Layer in module_member.__bases__ and getattr(__A, '''_keras_serializable''', __A ) } UpperCAmelCase : Union[str, Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Optional[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) UpperCAmelCase : str = tf.convert_to_tensor(__A ) inputs_dict.update({'''noise''': noise} ) for main_layer_class in tf_main_layer_classes: UpperCAmelCase : Tuple = main_layer_class(__A ) UpperCAmelCase : int = { name: tf.keras.Input(tensor.shape[1:], dtype=tensor.dtype ) for name, tensor in inputs_dict.items() } UpperCAmelCase : List[Any] = tf.keras.Model(__A, outputs=main_layer(__A ) ) UpperCAmelCase : List[Any] = model(__A ) with tempfile.TemporaryDirectory() as tmpdirname: UpperCAmelCase : Any = os.path.join(__A, '''keras_model.h5''' ) model.save(__A ) UpperCAmelCase : List[str] = tf.keras.models.load_model( __A, custom_objects={main_layer_class.__name__: main_layer_class} ) assert isinstance(__A, tf.keras.Model ) UpperCAmelCase : Tuple = model(__A ) self.assert_outputs_same(__A, __A ) @slow def __magic_name__ ( self : Dict ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Dict = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Optional[Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Optional[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : int = model_class(__A ) UpperCAmelCase : List[str] = self._prepare_for_class(__A, __A ) UpperCAmelCase : Union[str, Any] = model(__A, noise=__A ) if model_class.__name__ == "TFViTMAEModel": UpperCAmelCase : Optional[int] = outputs.last_hidden_state.numpy() UpperCAmelCase : Union[str, Any] = 0 else: UpperCAmelCase : Optional[int] = outputs.logits.numpy() UpperCAmelCase : int = 0 with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(__A, saved_model=__A ) UpperCAmelCase : Dict = model_class.from_pretrained(__A ) UpperCAmelCase : str = model(__A, noise=__A ) if model_class.__name__ == "TFViTMAEModel": UpperCAmelCase : int = after_outputs['''last_hidden_state'''].numpy() UpperCAmelCase : Dict = 0 else: UpperCAmelCase : Any = after_outputs['''logits'''].numpy() UpperCAmelCase : Dict = 0 UpperCAmelCase : Union[str, Any] = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(__A, 1E-5 ) def __magic_name__ ( self : Optional[Any] ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Dict = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : List[Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) UpperCAmelCase : int = self._prepare_for_class(__A, __A ) UpperCAmelCase : List[Any] = model(__A, noise=__A ) UpperCAmelCase : str = model.get_config() # make sure that returned config is jsonifiable, which is required by keras json.dumps(__A ) UpperCAmelCase : int = model_class.from_config(model.get_config() ) # make sure it also accepts a normal config UpperCAmelCase : str = model_class.from_config(model.config ) UpperCAmelCase : List[str] = new_model(__A ) # Build model new_model.set_weights(model.get_weights() ) UpperCAmelCase : Tuple = new_model(__A, noise=__A ) self.assert_outputs_same(__A, __A ) @unittest.skip( reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load to get deterministic results.''' ) def __magic_name__ ( self : Optional[int] ): pass @unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load''' ) def __magic_name__ ( self : Tuple ): pass @slow def __magic_name__ ( self : str ): UpperCAmelCase : Tuple = TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224''' ) self.assertIsNotNone(__A ) def a__ ( ) -> Dict: UpperCAmelCase : int = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_tf @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : List[str] ): return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base''' ) if is_vision_available() else None @slow def __magic_name__ ( self : str ): # make random mask reproducible across the PT and TF model np.random.seed(2 ) UpperCAmelCase : Tuple = TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base''' ) UpperCAmelCase : List[str] = self.default_image_processor UpperCAmelCase : Any = prepare_img() UpperCAmelCase : str = image_processor(images=__A, return_tensors='''tf''' ) # 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) UpperCAmelCase : Optional[int] = ViTMAEConfig() UpperCAmelCase : int = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(1, num_patches) ) # forward pass UpperCAmelCase : Optional[int] = model(**__A, noise=__A ) # verify the logits UpperCAmelCase : Union[str, Any] = tf.convert_to_tensor([1, 1_9_6, 7_6_8] ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : List[str] = tf.convert_to_tensor( [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]] ) tf.debugging.assert_near(outputs.logits[0, :3, :3], __A, atol=1E-4 )
336
1
import warnings from typing import List, Optional, Union from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy from ...utils import TensorType class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = ["""image_processor""", """tokenizer"""] UpperCamelCase = """LayoutLMv3ImageProcessor""" UpperCamelCase = ("""LayoutLMv3Tokenizer""", """LayoutLMv3TokenizerFast""") def __init__( self : Optional[Any], __A : Any=None, __A : Dict=None, **__A : Dict ): UpperCAmelCase : Tuple = None if "feature_extractor" in kwargs: warnings.warn( '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`''' ''' instead.''', __A, ) UpperCAmelCase : Optional[Any] = kwargs.pop('''feature_extractor''' ) UpperCAmelCase : Optional[Any] = image_processor if image_processor is not None else feature_extractor if image_processor is None: raise ValueError('''You need to specify an `image_processor`.''' ) if tokenizer is None: raise ValueError('''You need to specify a `tokenizer`.''' ) super().__init__(__A, __A ) def __call__( self : Optional[Any], __A : str, __A : Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None, __A : Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None, __A : Union[List[List[int]], List[List[List[int]]]] = None, __A : Optional[Union[List[int], List[List[int]]]] = None, __A : bool = True, __A : Union[bool, str, PaddingStrategy] = False, __A : Union[bool, str, TruncationStrategy] = None, __A : Optional[int] = None, __A : int = 0, __A : Optional[int] = None, __A : Optional[bool] = None, __A : Optional[bool] = None, __A : bool = False, __A : bool = False, __A : bool = False, __A : bool = False, __A : bool = True, __A : Optional[Union[str, TensorType]] = None, **__A : Tuple, ): # verify input if self.image_processor.apply_ocr and (boxes is not None): raise ValueError( '''You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True.''' ) if self.image_processor.apply_ocr and (word_labels is not None): raise ValueError( '''You cannot provide word labels if you initialized the image processor with apply_ocr set to True.''' ) # first, apply the image processor UpperCAmelCase : int = self.image_processor(images=__A, return_tensors=__A ) # second, apply the tokenizer if text is not None and self.image_processor.apply_ocr and text_pair is None: if isinstance(__A, __A ): UpperCAmelCase : Any = [text] # add batch dimension (as the image processor always adds a batch dimension) UpperCAmelCase : List[str] = features['''words'''] UpperCAmelCase : Union[str, Any] = self.tokenizer( text=text if text is not None else features['''words'''], text_pair=text_pair if text_pair is not None else None, boxes=boxes if boxes is not None else features['''boxes'''], word_labels=__A, add_special_tokens=__A, padding=__A, truncation=__A, max_length=__A, stride=__A, pad_to_multiple_of=__A, return_token_type_ids=__A, return_attention_mask=__A, return_overflowing_tokens=__A, return_special_tokens_mask=__A, return_offsets_mapping=__A, return_length=__A, verbose=__A, return_tensors=__A, **__A, ) # add pixel values UpperCAmelCase : List[Any] = features.pop('''pixel_values''' ) if return_overflowing_tokens is True: UpperCAmelCase : Tuple = self.get_overflowing_images(__A, encoded_inputs['''overflow_to_sample_mapping'''] ) UpperCAmelCase : int = images return encoded_inputs def __magic_name__ ( self : str, __A : List[Any], __A : Any ): # in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image UpperCAmelCase : Tuple = [] for sample_idx in overflow_to_sample_mapping: images_with_overflow.append(images[sample_idx] ) if len(__A ) != len(__A ): raise ValueError( '''Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got''' F''' {len(__A )} and {len(__A )}''' ) return images_with_overflow def __magic_name__ ( self : Any, *__A : List[Any], **__A : Tuple ): return self.tokenizer.batch_decode(*__A, **__A ) def __magic_name__ ( self : Any, *__A : Optional[int], **__A : int ): return self.tokenizer.decode(*__A, **__A ) @property def __magic_name__ ( self : List[Any] ): return ["input_ids", "bbox", "attention_mask", "pixel_values"] @property def __magic_name__ ( self : Optional[Any] ): warnings.warn( '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.''', __A, ) return self.image_processor_class @property def __magic_name__ ( self : str ): warnings.warn( '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.''', __A, ) return self.image_processor
336
def a__ ( UpperCAmelCase : int ) -> int: UpperCAmelCase : list[list[int]] = [[0 for _ in range(UpperCAmelCase )] for _ in range(m + 1 )] for i in range(m + 1 ): UpperCAmelCase : Optional[Any] = 1 for n in range(m + 1 ): for k in range(1 , UpperCAmelCase ): memo[n][k] += memo[n][k - 1] if n - k > 0: memo[n][k] += memo[n - k - 1][k] return memo[m][m - 1] if __name__ == "__main__": import sys if len(sys.argv) == 1: try: _lowerCamelCase : List[Any] = int(input("Enter a number: ").strip()) print(partition(n)) except ValueError: print("Please enter a number.") else: try: _lowerCamelCase : str = int(sys.argv[1]) print(partition(n)) except ValueError: print("Please pass a number.")
336
1
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 a__ ( UpperCAmelCase : int ) -> Any: return {key.lstrip('''-''' ): value for key, value in zip(unknown_args[::2] , unknown_args[1::2] )} def a__ ( ) -> Union[str, Any]: UpperCAmelCase : Optional[int] = ArgumentParser( '''HuggingFace Datasets CLI tool''' , usage='''datasets-cli <command> [<args>]''' , allow_abbrev=UpperCAmelCase ) UpperCAmelCase : Optional[Any] = parser.add_subparsers(help='''datasets-cli command helpers''' ) set_verbosity_info() # Register commands ConvertCommand.register_subcommand(UpperCAmelCase ) EnvironmentCommand.register_subcommand(UpperCAmelCase ) TestCommand.register_subcommand(UpperCAmelCase ) RunBeamCommand.register_subcommand(UpperCAmelCase ) DummyDataCommand.register_subcommand(UpperCAmelCase ) # Parse args UpperCAmelCase , UpperCAmelCase : Dict = parser.parse_known_args() if not hasattr(UpperCAmelCase , '''func''' ): parser.print_help() exit(1 ) UpperCAmelCase : str = parse_unknown_args(UpperCAmelCase ) # Run UpperCAmelCase : Dict = args.func(UpperCAmelCase , **UpperCAmelCase ) service.run() if __name__ == "__main__": main()
336
from __future__ import annotations def a__ ( UpperCAmelCase : list[list[int]] ) -> bool: UpperCAmelCase : Union[str, Any] = len(UpperCAmelCase ) # We need to create solution object to save path. UpperCAmelCase : int = [[0 for _ in range(UpperCAmelCase )] for _ in range(UpperCAmelCase )] UpperCAmelCase : Union[str, Any] = run_maze(UpperCAmelCase , 0 , 0 , UpperCAmelCase ) if solved: print('''\n'''.join(str(UpperCAmelCase ) for row in solutions ) ) else: print('''No solution exists!''' ) return solved def a__ ( UpperCAmelCase : list[list[int]] , UpperCAmelCase : int , UpperCAmelCase : int , UpperCAmelCase : list[list[int]] ) -> bool: UpperCAmelCase : Dict = len(UpperCAmelCase ) # Final check point. if i == j == (size - 1): UpperCAmelCase : Dict = 1 return True UpperCAmelCase : Union[str, Any] = (not i < 0) and (not j < 0) # Check lower bounds UpperCAmelCase : List[Any] = (i < size) and (j < size) # Check upper bounds if lower_flag and upper_flag: # check for already visited and block points. UpperCAmelCase : Any = (not solutions[i][j]) and (not maze[i][j]) if block_flag: # check visited UpperCAmelCase : str = 1 # check for directions if ( run_maze(UpperCAmelCase , i + 1 , UpperCAmelCase , UpperCAmelCase ) or run_maze(UpperCAmelCase , UpperCAmelCase , j + 1 , UpperCAmelCase ) or run_maze(UpperCAmelCase , i - 1 , UpperCAmelCase , UpperCAmelCase ) or run_maze(UpperCAmelCase , UpperCAmelCase , j - 1 , UpperCAmelCase ) ): return True UpperCAmelCase : Any = 0 return False return False if __name__ == "__main__": import doctest doctest.testmod()
336
1
from queue import Queue from typing import TYPE_CHECKING, Optional if TYPE_CHECKING: from ..models.auto import AutoTokenizer class __UpperCAmelCase : def __magic_name__ ( self : int, __A : Dict ): raise NotImplementedError() def __magic_name__ ( self : int ): raise NotImplementedError() class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : str, __A : "AutoTokenizer", __A : bool = False, **__A : str ): UpperCAmelCase : List[str] = tokenizer UpperCAmelCase : str = skip_prompt UpperCAmelCase : List[str] = decode_kwargs # variables used in the streaming process UpperCAmelCase : Dict = [] UpperCAmelCase : List[str] = 0 UpperCAmelCase : Union[str, Any] = True def __magic_name__ ( self : Dict, __A : Optional[int] ): if len(value.shape ) > 1 and value.shape[0] > 1: raise ValueError('''TextStreamer only supports batch size 1''' ) elif len(value.shape ) > 1: UpperCAmelCase : Union[str, Any] = value[0] if self.skip_prompt and self.next_tokens_are_prompt: UpperCAmelCase : Optional[int] = False return # Add the new token to the cache and decodes the entire thing. self.token_cache.extend(value.tolist() ) UpperCAmelCase : Any = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) # After the symbol for a new line, we flush the cache. if text.endswith('''\n''' ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] UpperCAmelCase : int = [] UpperCAmelCase : int = 0 # If the last token is a CJK character, we print the characters. elif len(__A ) > 0 and self._is_chinese_char(ord(text[-1] ) ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] self.print_len += len(__A ) # 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: UpperCAmelCase : Optional[Any] = text[self.print_len : text.rfind(''' ''' ) + 1] self.print_len += len(__A ) self.on_finalized_text(__A ) def __magic_name__ ( self : str ): # Flush the cache, if it exists if len(self.token_cache ) > 0: UpperCAmelCase : int = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) UpperCAmelCase : Dict = text[self.print_len :] UpperCAmelCase : List[Any] = [] UpperCAmelCase : List[Any] = 0 else: UpperCAmelCase : Dict = '''''' UpperCAmelCase : str = True self.on_finalized_text(__A, stream_end=__A ) def __magic_name__ ( self : List[str], __A : str, __A : bool = False ): print(__A, flush=__A, end='''''' if not stream_end else None ) def __magic_name__ ( self : List[Any], __A : Optional[int] ): # 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 >= 0X4E00 and cp <= 0X9FFF) or (cp >= 0X3400 and cp <= 0X4DBF) # or (cp >= 0X20000 and cp <= 0X2A6DF) # or (cp >= 0X2A700 and cp <= 0X2B73F) # or (cp >= 0X2B740 and cp <= 0X2B81F) # or (cp >= 0X2B820 and cp <= 0X2CEAF) # or (cp >= 0XF900 and cp <= 0XFAFF) or (cp >= 0X2F800 and cp <= 0X2FA1F) # ): # return True return False class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Dict, __A : "AutoTokenizer", __A : bool = False, __A : Optional[float] = None, **__A : str ): super().__init__(__A, __A, **__A ) UpperCAmelCase : Dict = Queue() UpperCAmelCase : Any = None UpperCAmelCase : Any = timeout def __magic_name__ ( self : Dict, __A : str, __A : bool = False ): self.text_queue.put(__A, timeout=self.timeout ) if stream_end: self.text_queue.put(self.stop_signal, timeout=self.timeout ) def __iter__( self : int ): return self def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : List[Any] = self.text_queue.get(timeout=self.timeout ) if value == self.stop_signal: raise StopIteration() else: return value
336
import inspect import unittest from transformers import ViTHybridConfig from transformers.testing_utils import require_accelerate, 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, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image class __UpperCAmelCase : def __init__( self : List[Any], __A : List[str], __A : List[str]=1_3, __A : Any=6_4, __A : Optional[Any]=2, __A : str=3, __A : str=True, __A : str=True, __A : Optional[Any]=3_2, __A : List[str]=5, __A : int=4, __A : str=3_7, __A : str="gelu", __A : Dict=0.1, __A : List[Any]=0.1, __A : Dict=1_0, __A : int=0.0_2, __A : Any=[1, 1_6, 4, 4], __A : Optional[int]=None, ): UpperCAmelCase : Union[str, Any] = parent UpperCAmelCase : Any = batch_size UpperCAmelCase : List[str] = image_size UpperCAmelCase : List[str] = patch_size UpperCAmelCase : Dict = num_channels UpperCAmelCase : List[Any] = is_training UpperCAmelCase : Dict = use_labels UpperCAmelCase : Optional[int] = hidden_size UpperCAmelCase : Union[str, Any] = num_hidden_layers UpperCAmelCase : Optional[Any] = num_attention_heads UpperCAmelCase : Any = intermediate_size UpperCAmelCase : Any = hidden_act UpperCAmelCase : Any = hidden_dropout_prob UpperCAmelCase : Optional[int] = attention_probs_dropout_prob UpperCAmelCase : str = type_sequence_label_size UpperCAmelCase : Any = initializer_range UpperCAmelCase : int = scope UpperCAmelCase : List[str] = backbone_featmap_shape # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token) # the number of patches is based on the feature map of the backbone, which by default uses an output stride # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size UpperCAmelCase : str = (self.image_size // 3_2) ** 2 UpperCAmelCase : List[str] = num_patches + 1 def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : str = None if self.use_labels: UpperCAmelCase : Any = ids_tensor([self.batch_size], self.type_sequence_label_size ) UpperCAmelCase : Optional[int] = self.get_config() return config, pixel_values, labels def __magic_name__ ( self : Any ): UpperCAmelCase : Dict = { '''global_padding''': '''same''', '''layer_type''': '''bottleneck''', '''depths''': [3, 4, 9], '''out_features''': ['''stage1''', '''stage2''', '''stage3'''], '''embedding_dynamic_padding''': True, '''hidden_sizes''': [4, 8, 1_6, 3_2], '''num_groups''': 2, } return ViTHybridConfig( 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, backbone_featmap_shape=self.backbone_featmap_shape, backbone_config=__A, ) def __magic_name__ ( self : Optional[int], __A : Optional[int], __A : int, __A : Tuple ): UpperCAmelCase : int = ViTHybridModel(config=__A ) model.to(__A ) model.eval() UpperCAmelCase : Tuple = model(__A ) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__ ( self : Tuple, __A : Dict, __A : str, __A : List[str] ): UpperCAmelCase : str = self.type_sequence_label_size UpperCAmelCase : List[Any] = ViTHybridForImageClassification(__A ) model.to(__A ) model.eval() UpperCAmelCase : Dict = model(__A, labels=__A ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.type_sequence_label_size) ) def __magic_name__ ( self : int ): UpperCAmelCase : Union[str, Any] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[str] = config_and_inputs UpperCAmelCase : int = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else () UpperCamelCase = ( {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification} if is_torch_available() else {} ) UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Any = ViTHybridModelTester(self ) UpperCAmelCase : List[Any] = ConfigTester(self, config_class=__A, has_text_modality=__A, hidden_size=3_7 ) def __magic_name__ ( self : int ): self.config_tester.run_common_tests() @unittest.skip(reason='''ViT does not use inputs_embeds''' ) def __magic_name__ ( self : List[Any] ): pass def __magic_name__ ( self : int ): UpperCAmelCase , UpperCAmelCase : List[str] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) self.assertIsInstance(model.get_input_embeddings(), (nn.Module) ) UpperCAmelCase : Optional[int] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__A, nn.Linear ) ) def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : List[Any] = model_class(__A ) UpperCAmelCase : Tuple = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : str = [*signature.parameters.keys()] UpperCAmelCase : Optional[Any] = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Dict = _config_zero_init(__A ) for model_class in self.all_model_classes: UpperCAmelCase : Optional[Any] = model_class(config=__A ) # Skip the check for the backbone for name, module in model.named_modules(): if module.__class__.__name__ == "ViTHybridPatchEmbeddings": UpperCAmelCase : Union[str, Any] = [F'''{name}.{key}''' for key in module.state_dict().keys()] break for name, param in model.named_parameters(): if param.requires_grad: if name in backbone_params: continue 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''', ) @slow def __magic_name__ ( self : List[str] ): for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase : Union[str, Any] = ViTHybridModel.from_pretrained(__A ) self.assertIsNotNone(__A ) def a__ ( ) -> Tuple: UpperCAmelCase : Any = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_torch @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : str ): return ( ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def __magic_name__ ( self : List[str] ): UpperCAmelCase : int = ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to( __A ) UpperCAmelCase : Tuple = self.default_image_processor UpperCAmelCase : int = prepare_img() UpperCAmelCase : Union[str, Any] = image_processor(images=__A, return_tensors='''pt''' ).to(__A ) # forward pass with torch.no_grad(): UpperCAmelCase : Optional[Any] = model(**__A ) # verify the logits UpperCAmelCase : str = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : Optional[Any] = torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9] ).to(__A ) self.assertTrue(torch.allclose(outputs.logits[0, :3], __A, atol=1E-4 ) ) @slow @require_accelerate def __magic_name__ ( self : Dict ): UpperCAmelCase : Union[str, Any] = ViTHybridImageProcessor.from_pretrained('''google/vit-hybrid-base-bit-384''' ) UpperCAmelCase : int = ViTHybridForImageClassification.from_pretrained('''google/vit-hybrid-base-bit-384''', device_map='''auto''' ) UpperCAmelCase : Tuple = prepare_img() UpperCAmelCase : Optional[int] = image_processor(images=__A, return_tensors='''pt''' ) UpperCAmelCase : Dict = model(**__A ) UpperCAmelCase : Any = outputs.logits # model predicts one of the 1000 ImageNet classes UpperCAmelCase : Dict = logits.argmax(-1 ).item() self.assertTrue(model.config.idalabel[predicted_class_idx], '''tabby, tabby cat''' )
336
1
from typing import Dict, List, Optional, Union import numpy as np from transformers.utils import is_vision_available from transformers.utils.generic import TensorType from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, is_valid_image, to_numpy_array, valid_images, ) from ...utils import logging if is_vision_available(): import PIL _lowerCamelCase : Optional[Any] = logging.get_logger(__name__) def a__ ( UpperCAmelCase : str ) -> List[List[ImageInput]]: if isinstance(UpperCAmelCase , (list, tuple) ) and isinstance(videos[0] , (list, tuple) ) and is_valid_image(videos[0][0] ): return videos elif isinstance(UpperCAmelCase , (list, tuple) ) and is_valid_image(videos[0] ): return [videos] elif is_valid_image(UpperCAmelCase ): return [[videos]] raise ValueError(f'''Could not make batched video from {videos}''' ) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = ["""pixel_values"""] def __init__( self : Optional[Any], __A : bool = True, __A : Dict[str, int] = None, __A : PILImageResampling = PILImageResampling.BILINEAR, __A : bool = True, __A : Dict[str, int] = None, __A : bool = True, __A : Union[int, float] = 1 / 2_5_5, __A : bool = True, __A : bool = True, __A : Optional[Union[float, List[float]]] = None, __A : Optional[Union[float, List[float]]] = None, **__A : Any, ): super().__init__(**__A ) UpperCAmelCase : Tuple = size if size is not None else {'''shortest_edge''': 2_5_6} UpperCAmelCase : Tuple = get_size_dict(__A, default_to_square=__A ) UpperCAmelCase : int = crop_size if crop_size is not None else {'''height''': 2_2_4, '''width''': 2_2_4} UpperCAmelCase : int = get_size_dict(__A, param_name='''crop_size''' ) UpperCAmelCase : Tuple = do_resize UpperCAmelCase : Any = size UpperCAmelCase : int = do_center_crop UpperCAmelCase : List[str] = crop_size UpperCAmelCase : List[str] = resample UpperCAmelCase : Optional[int] = do_rescale UpperCAmelCase : Optional[int] = rescale_factor UpperCAmelCase : int = offset UpperCAmelCase : Union[str, Any] = do_normalize UpperCAmelCase : Dict = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN UpperCAmelCase : str = image_std if image_std is not None else IMAGENET_STANDARD_STD def __magic_name__ ( self : int, __A : np.ndarray, __A : Dict[str, int], __A : PILImageResampling = PILImageResampling.BILINEAR, __A : Optional[Union[str, ChannelDimension]] = None, **__A : Union[str, Any], ): UpperCAmelCase : Tuple = get_size_dict(__A, default_to_square=__A ) if "shortest_edge" in size: UpperCAmelCase : Dict = get_resize_output_image_size(__A, size['''shortest_edge'''], default_to_square=__A ) elif "height" in size and "width" in size: UpperCAmelCase : List[Any] = (size['''height'''], size['''width''']) else: raise ValueError(F'''Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}''' ) return resize(__A, size=__A, resample=__A, data_format=__A, **__A ) def __magic_name__ ( self : List[str], __A : np.ndarray, __A : Dict[str, int], __A : Optional[Union[str, ChannelDimension]] = None, **__A : Optional[int], ): UpperCAmelCase : Optional[Any] = get_size_dict(__A ) if "height" not in size or "width" not in size: raise ValueError(F'''Size must have \'height\' and \'width\' as keys. Got {size.keys()}''' ) return center_crop(__A, size=(size['''height'''], size['''width''']), data_format=__A, **__A ) def __magic_name__ ( self : Optional[Any], __A : np.ndarray, __A : Union[int, float], __A : bool = True, __A : Optional[Union[str, ChannelDimension]] = None, **__A : Optional[Any], ): UpperCAmelCase : Dict = image.astype(np.floataa ) if offset: UpperCAmelCase : Union[str, Any] = image - (scale / 2) return rescale(__A, scale=__A, data_format=__A, **__A ) def __magic_name__ ( self : int, __A : np.ndarray, __A : Union[float, List[float]], __A : Union[float, List[float]], __A : Optional[Union[str, ChannelDimension]] = None, **__A : Dict, ): return normalize(__A, mean=__A, std=__A, data_format=__A, **__A ) def __magic_name__ ( self : int, __A : ImageInput, __A : bool = None, __A : Dict[str, int] = None, __A : PILImageResampling = None, __A : bool = None, __A : Dict[str, int] = None, __A : bool = None, __A : float = None, __A : bool = None, __A : bool = None, __A : Optional[Union[float, List[float]]] = None, __A : Optional[Union[float, List[float]]] = None, __A : Optional[ChannelDimension] = ChannelDimension.FIRST, ): if do_resize and size is None or resample is None: raise ValueError('''Size and resample must be specified if do_resize is True.''' ) if do_center_crop and crop_size is None: raise ValueError('''Crop size must be specified if do_center_crop is True.''' ) if do_rescale and rescale_factor is None: raise ValueError('''Rescale factor must be specified if do_rescale is True.''' ) if do_normalize and (image_mean is None or image_std is None): raise ValueError('''Image mean and std must be specified if do_normalize is True.''' ) if offset and not do_rescale: raise ValueError('''For offset, do_rescale must also be set to True.''' ) # All transformations expect numpy arrays. UpperCAmelCase : str = to_numpy_array(__A ) if do_resize: UpperCAmelCase : List[Any] = self.resize(image=__A, size=__A, resample=__A ) if do_center_crop: UpperCAmelCase : Optional[Any] = self.center_crop(__A, size=__A ) if do_rescale: UpperCAmelCase : List[str] = self.rescale(image=__A, scale=__A, offset=__A ) if do_normalize: UpperCAmelCase : Optional[int] = self.normalize(image=__A, mean=__A, std=__A ) UpperCAmelCase : int = to_channel_dimension_format(__A, __A ) return image def __magic_name__ ( self : Union[str, Any], __A : ImageInput, __A : bool = None, __A : Dict[str, int] = None, __A : PILImageResampling = None, __A : bool = None, __A : Dict[str, int] = None, __A : bool = None, __A : float = None, __A : bool = None, __A : bool = None, __A : Optional[Union[float, List[float]]] = None, __A : Optional[Union[float, List[float]]] = None, __A : Optional[Union[str, TensorType]] = None, __A : ChannelDimension = ChannelDimension.FIRST, **__A : int, ): UpperCAmelCase : List[Any] = do_resize if do_resize is not None else self.do_resize UpperCAmelCase : Union[str, Any] = resample if resample is not None else self.resample UpperCAmelCase : str = do_center_crop if do_center_crop is not None else self.do_center_crop UpperCAmelCase : Optional[Any] = do_rescale if do_rescale is not None else self.do_rescale UpperCAmelCase : List[str] = rescale_factor if rescale_factor is not None else self.rescale_factor UpperCAmelCase : str = offset if offset is not None else self.offset UpperCAmelCase : List[str] = do_normalize if do_normalize is not None else self.do_normalize UpperCAmelCase : Tuple = image_mean if image_mean is not None else self.image_mean UpperCAmelCase : Any = image_std if image_std is not None else self.image_std UpperCAmelCase : Union[str, Any] = size if size is not None else self.size UpperCAmelCase : Dict = get_size_dict(__A, default_to_square=__A ) UpperCAmelCase : str = crop_size if crop_size is not None else self.crop_size UpperCAmelCase : Any = get_size_dict(__A, param_name='''crop_size''' ) 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.''' ) UpperCAmelCase : Optional[Any] = make_batched(__A ) UpperCAmelCase : str = [ [ self._preprocess_image( image=__A, do_resize=__A, size=__A, resample=__A, do_center_crop=__A, crop_size=__A, do_rescale=__A, rescale_factor=__A, offset=__A, do_normalize=__A, image_mean=__A, image_std=__A, data_format=__A, ) for img in video ] for video in videos ] UpperCAmelCase : List[str] = {'''pixel_values''': videos} return BatchFeature(data=__A, tensor_type=__A )
336
from __future__ import annotations from itertools import permutations from random import randint from timeit import repeat def a__ ( ) -> tuple[list[int], int]: UpperCAmelCase : str = [randint(-1_000 , 1_000 ) for i in range(10 )] UpperCAmelCase : Any = randint(-5_000 , 5_000 ) return (arr, r) _lowerCamelCase : Any = make_dataset() def a__ ( UpperCAmelCase : list[int] , UpperCAmelCase : int ) -> tuple[int, ...]: for triplet in permutations(UpperCAmelCase , 3 ): if sum(UpperCAmelCase ) == target: return tuple(sorted(UpperCAmelCase ) ) return (0, 0, 0) def a__ ( UpperCAmelCase : list[int] , UpperCAmelCase : int ) -> tuple[int, int, int]: arr.sort() UpperCAmelCase : Tuple = len(UpperCAmelCase ) for i in range(n - 1 ): UpperCAmelCase , UpperCAmelCase : int = i + 1, n - 1 while left < right: if arr[i] + arr[left] + arr[right] == target: return (arr[i], arr[left], arr[right]) elif arr[i] + arr[left] + arr[right] < target: left += 1 elif arr[i] + arr[left] + arr[right] > target: right -= 1 return (0, 0, 0) def a__ ( ) -> tuple[float, float]: UpperCAmelCase : Union[str, Any] = ''' from __main__ import dataset, triplet_sum1, triplet_sum2 ''' UpperCAmelCase : Tuple = ''' triplet_sum1(*dataset) ''' UpperCAmelCase : List[str] = ''' triplet_sum2(*dataset) ''' UpperCAmelCase : Tuple = repeat(setup=UpperCAmelCase , stmt=UpperCAmelCase , repeat=5 , number=10_000 ) UpperCAmelCase : str = repeat(setup=UpperCAmelCase , stmt=UpperCAmelCase , repeat=5 , number=10_000 ) return (min(UpperCAmelCase ), min(UpperCAmelCase )) if __name__ == "__main__": from doctest import testmod testmod() _lowerCamelCase : int = solution_times() print(f"""The time for naive implementation is {times[0]}.""") print(f"""The time for optimized implementation is {times[1]}.""")
336
1
from __future__ import annotations import math def a__ ( UpperCAmelCase : int ) -> bool: if 1 < number < 4: # 2 and 3 are primes return True elif number < 2 or number % 2 == 0 or number % 3 == 0: # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes return False # All primes number are in format of 6k +/- 1 for i in range(5 , int(math.sqrt(UpperCAmelCase ) + 1 ) , 6 ): if number % i == 0 or number % (i + 2) == 0: return False return True _lowerCamelCase : int = [num for num in range(3, 1_0_0_0_0_1, 2) if not is_prime(num)] def a__ ( UpperCAmelCase : int ) -> list[int]: if not isinstance(UpperCAmelCase , UpperCAmelCase ): raise ValueError('''n must be an integer''' ) if n <= 0: raise ValueError('''n must be >= 0''' ) UpperCAmelCase : Dict = [] for num in range(len(UpperCAmelCase ) ): UpperCAmelCase : List[str] = 0 while 2 * i * i <= odd_composites[num]: UpperCAmelCase : int = odd_composites[num] - 2 * i * i if is_prime(UpperCAmelCase ): break i += 1 else: list_nums.append(odd_composites[num] ) if len(UpperCAmelCase ) == n: return list_nums return [] def a__ ( ) -> int: return compute_nums(1 )[0] if __name__ == "__main__": print(f"""{solution() = }""")
336
from queue import Queue from typing import TYPE_CHECKING, Optional if TYPE_CHECKING: from ..models.auto import AutoTokenizer class __UpperCAmelCase : def __magic_name__ ( self : int, __A : Dict ): raise NotImplementedError() def __magic_name__ ( self : int ): raise NotImplementedError() class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : str, __A : "AutoTokenizer", __A : bool = False, **__A : str ): UpperCAmelCase : List[str] = tokenizer UpperCAmelCase : str = skip_prompt UpperCAmelCase : List[str] = decode_kwargs # variables used in the streaming process UpperCAmelCase : Dict = [] UpperCAmelCase : List[str] = 0 UpperCAmelCase : Union[str, Any] = True def __magic_name__ ( self : Dict, __A : Optional[int] ): if len(value.shape ) > 1 and value.shape[0] > 1: raise ValueError('''TextStreamer only supports batch size 1''' ) elif len(value.shape ) > 1: UpperCAmelCase : Union[str, Any] = value[0] if self.skip_prompt and self.next_tokens_are_prompt: UpperCAmelCase : Optional[int] = False return # Add the new token to the cache and decodes the entire thing. self.token_cache.extend(value.tolist() ) UpperCAmelCase : Any = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) # After the symbol for a new line, we flush the cache. if text.endswith('''\n''' ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] UpperCAmelCase : int = [] UpperCAmelCase : int = 0 # If the last token is a CJK character, we print the characters. elif len(__A ) > 0 and self._is_chinese_char(ord(text[-1] ) ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] self.print_len += len(__A ) # 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: UpperCAmelCase : Optional[Any] = text[self.print_len : text.rfind(''' ''' ) + 1] self.print_len += len(__A ) self.on_finalized_text(__A ) def __magic_name__ ( self : str ): # Flush the cache, if it exists if len(self.token_cache ) > 0: UpperCAmelCase : int = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) UpperCAmelCase : Dict = text[self.print_len :] UpperCAmelCase : List[Any] = [] UpperCAmelCase : List[Any] = 0 else: UpperCAmelCase : Dict = '''''' UpperCAmelCase : str = True self.on_finalized_text(__A, stream_end=__A ) def __magic_name__ ( self : List[str], __A : str, __A : bool = False ): print(__A, flush=__A, end='''''' if not stream_end else None ) def __magic_name__ ( self : List[Any], __A : Optional[int] ): # 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 >= 0X4E00 and cp <= 0X9FFF) or (cp >= 0X3400 and cp <= 0X4DBF) # or (cp >= 0X20000 and cp <= 0X2A6DF) # or (cp >= 0X2A700 and cp <= 0X2B73F) # or (cp >= 0X2B740 and cp <= 0X2B81F) # or (cp >= 0X2B820 and cp <= 0X2CEAF) # or (cp >= 0XF900 and cp <= 0XFAFF) or (cp >= 0X2F800 and cp <= 0X2FA1F) # ): # return True return False class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Dict, __A : "AutoTokenizer", __A : bool = False, __A : Optional[float] = None, **__A : str ): super().__init__(__A, __A, **__A ) UpperCAmelCase : Dict = Queue() UpperCAmelCase : Any = None UpperCAmelCase : Any = timeout def __magic_name__ ( self : Dict, __A : str, __A : bool = False ): self.text_queue.put(__A, timeout=self.timeout ) if stream_end: self.text_queue.put(self.stop_signal, timeout=self.timeout ) def __iter__( self : int ): return self def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : List[Any] = self.text_queue.get(timeout=self.timeout ) if value == self.stop_signal: raise StopIteration() else: return value
336
1
import copy from typing import Any, Dict, List, Optional, Union import numpy as np from ...audio_utils import mel_filter_bank, spectrogram, window_function from ...feature_extraction_sequence_utils import SequenceFeatureExtractor from ...feature_extraction_utils import BatchFeature from ...utils import TensorType, logging _lowerCamelCase : Dict = logging.get_logger(__name__) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = ["""input_features"""] def __init__( self : List[str], __A : Union[str, Any]=8_0, __A : Optional[int]=1_6_0_0_0, __A : Optional[Any]=1_6_0, __A : Tuple=3_0, __A : Dict=4_0_0, __A : Any=0.0, __A : Any=False, **__A : Dict, ): super().__init__( feature_size=__A, sampling_rate=__A, padding_value=__A, return_attention_mask=__A, **__A, ) UpperCAmelCase : List[str] = n_fft UpperCAmelCase : Union[str, Any] = hop_length UpperCAmelCase : Tuple = chunk_length UpperCAmelCase : Union[str, Any] = chunk_length * sampling_rate UpperCAmelCase : List[Any] = self.n_samples // hop_length UpperCAmelCase : Union[str, Any] = sampling_rate UpperCAmelCase : str = mel_filter_bank( num_frequency_bins=1 + n_fft // 2, num_mel_filters=__A, min_frequency=0.0, max_frequency=8_0_0_0.0, sampling_rate=__A, norm='''slaney''', mel_scale='''slaney''', ) def __magic_name__ ( self : Dict, __A : np.array ): UpperCAmelCase : Tuple = spectrogram( __A, window_function(self.n_fft, '''hann''' ), frame_length=self.n_fft, hop_length=self.hop_length, power=2.0, mel_filters=self.mel_filters, log_mel='''log10''', ) UpperCAmelCase : Optional[Any] = log_spec[:, :-1] UpperCAmelCase : Union[str, Any] = np.maximum(__A, log_spec.max() - 8.0 ) UpperCAmelCase : Tuple = (log_spec + 4.0) / 4.0 return log_spec @staticmethod # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm def __magic_name__ ( __A : List[np.ndarray], __A : List[np.ndarray], __A : float = 0.0 ): if attention_mask is not None: UpperCAmelCase : Union[str, Any] = np.array(__A, np.intaa ) UpperCAmelCase : int = [] for vector, length in zip(__A, attention_mask.sum(-1 ) ): UpperCAmelCase : int = (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7 ) if length < normed_slice.shape[0]: UpperCAmelCase : int = padding_value normed_input_values.append(__A ) else: UpperCAmelCase : Any = [(x - x.mean()) / np.sqrt(x.var() + 1E-7 ) for x in input_values] return normed_input_values def __call__( self : Optional[Any], __A : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]], __A : bool = True, __A : Optional[int] = None, __A : Optional[Union[str, TensorType]] = None, __A : Optional[bool] = None, __A : Optional[str] = "max_length", __A : Optional[int] = None, __A : Optional[int] = None, __A : Optional[bool] = None, **__A : Union[str, Any], ): if sampling_rate is not None: if sampling_rate != self.sampling_rate: raise ValueError( F'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a''' F''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input''' F''' was sampled with {self.sampling_rate} and not {sampling_rate}.''' ) else: logger.warning( '''It is strongly recommended to pass the `sampling_rate` argument to this function. ''' '''Failing to do so can result in silent errors that might be hard to debug.''' ) UpperCAmelCase : List[str] = isinstance(__A, np.ndarray ) and len(raw_speech.shape ) > 1 if is_batched_numpy and len(raw_speech.shape ) > 2: raise ValueError(F'''Only mono-channel audio is supported for input to {self}''' ) UpperCAmelCase : List[str] = is_batched_numpy or ( isinstance(__A, (list, tuple) ) and (isinstance(raw_speech[0], (np.ndarray, tuple, list) )) ) if is_batched: UpperCAmelCase : Optional[int] = [np.asarray([speech], dtype=np.floataa ).T for speech in raw_speech] elif not is_batched and not isinstance(__A, np.ndarray ): UpperCAmelCase : Optional[Any] = np.asarray(__A, dtype=np.floataa ) elif isinstance(__A, np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ): UpperCAmelCase : str = raw_speech.astype(np.floataa ) # always return batch if not is_batched: UpperCAmelCase : List[Any] = [np.asarray([raw_speech] ).T] UpperCAmelCase : Any = BatchFeature({'''input_features''': raw_speech} ) # convert into correct format for padding UpperCAmelCase : Union[str, Any] = self.pad( __A, padding=__A, max_length=max_length if max_length else self.n_samples, truncation=__A, pad_to_multiple_of=__A, return_attention_mask=return_attention_mask or do_normalize, ) # zero-mean and unit-variance normalization if do_normalize: UpperCAmelCase : Any = self.zero_mean_unit_var_norm( padded_inputs['''input_features'''], attention_mask=padded_inputs['''attention_mask'''], padding_value=self.padding_value, ) UpperCAmelCase : Optional[Any] = np.stack(padded_inputs['''input_features'''], axis=0 ) # make sure list is in array format UpperCAmelCase : Optional[Any] = padded_inputs.get('''input_features''' ).transpose(2, 0, 1 ) UpperCAmelCase : Dict = [self._np_extract_fbank_features(__A ) for waveform in input_features[0]] if isinstance(input_features[0], __A ): UpperCAmelCase : Dict = [np.asarray(__A, dtype=np.floataa ) for feature in input_features] else: UpperCAmelCase : List[str] = input_features if return_attention_mask: # rescale from sample (48000) to feature (3000) UpperCAmelCase : int = padded_inputs['''attention_mask'''][:, :: self.hop_length] if return_tensors is not None: UpperCAmelCase : Optional[int] = padded_inputs.convert_to_tensors(__A ) return padded_inputs def __magic_name__ ( self : str ): UpperCAmelCase : Any = copy.deepcopy(self.__dict__ ) UpperCAmelCase : Optional[int] = self.__class__.__name__ if "mel_filters" in output: del output["mel_filters"] return output
336
import numpy # List of input, output pairs _lowerCamelCase : Dict = ( ((5, 2, 3), 1_5), ((6, 5, 9), 2_5), ((1_1, 1_2, 1_3), 4_1), ((1, 1, 1), 8), ((1_1, 1_2, 1_3), 4_1), ) _lowerCamelCase : str = (((5_1_5, 2_2, 1_3), 5_5_5), ((6_1, 3_5, 4_9), 1_5_0)) _lowerCamelCase : Dict = [2, 4, 1, 5] _lowerCamelCase : Dict = len(train_data) _lowerCamelCase : int = 0.0_0_9 def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : Optional[int]="train" ) -> Dict: return calculate_hypothesis_value(UpperCAmelCase , UpperCAmelCase ) - output( UpperCAmelCase , UpperCAmelCase ) def a__ ( UpperCAmelCase : int ) -> Any: UpperCAmelCase : str = 0 for i in range(len(UpperCAmelCase ) - 1 ): hyp_val += data_input_tuple[i] * parameter_vector[i + 1] hyp_val += parameter_vector[0] return hyp_val def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : Optional[Any] ) -> Optional[int]: if data_set == "train": return train_data[example_no][1] elif data_set == "test": return test_data[example_no][1] return None def a__ ( UpperCAmelCase : int , UpperCAmelCase : Optional[Any] ) -> 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 a__ ( UpperCAmelCase : Dict , UpperCAmelCase : str=m ) -> Dict: UpperCAmelCase : Optional[int] = 0 for i in range(UpperCAmelCase ): if index == -1: summation_value += _error(UpperCAmelCase ) else: summation_value += _error(UpperCAmelCase ) * train_data[i][0][index] return summation_value def a__ ( UpperCAmelCase : Dict ) -> Dict: UpperCAmelCase : Dict = summation_of_cost_derivative(UpperCAmelCase , UpperCAmelCase ) / m return cost_derivative_value def a__ ( ) -> List[Any]: global parameter_vector # Tune these values to set a tolerance value for predicted output UpperCAmelCase : List[str] = 0.000002 UpperCAmelCase : Any = 0 UpperCAmelCase : Dict = 0 while True: j += 1 UpperCAmelCase : List[Any] = [0, 0, 0, 0] for i in range(0 , len(UpperCAmelCase ) ): UpperCAmelCase : List[str] = get_cost_derivative(i - 1 ) UpperCAmelCase : Tuple = ( parameter_vector[i] - LEARNING_RATE * cost_derivative ) if numpy.allclose( UpperCAmelCase , UpperCAmelCase , atol=UpperCAmelCase , rtol=UpperCAmelCase , ): break UpperCAmelCase : int = temp_parameter_vector print(('''Number of iterations:''', j) ) def a__ ( ) -> List[Any]: for i in range(len(UpperCAmelCase ) ): print(('''Actual output value:''', output(UpperCAmelCase , '''test''' )) ) print(('''Hypothesis output:''', calculate_hypothesis_value(UpperCAmelCase , '''test''' )) ) if __name__ == "__main__": run_gradient_descent() print("\nTesting gradient descent for a linear hypothesis function.\n") test_gradient_descent()
336
1
import numpy as np import skfuzzy as fuzz if __name__ == "__main__": # Create universe of discourse in Python using linspace () _lowerCamelCase : Any = np.linspace(start=0, stop=7_5, num=7_5, endpoint=True, retstep=False) # Create two fuzzy sets by defining any membership function # (trapmf(), gbellmf(), gaussmf(), etc). _lowerCamelCase : Optional[int] = [0, 2_5, 5_0] _lowerCamelCase : Union[str, Any] = [2_5, 5_0, 7_5] _lowerCamelCase : Any = fuzz.membership.trimf(X, abca) _lowerCamelCase : Union[str, Any] = fuzz.membership.trimf(X, abca) # Compute the different operations using inbuilt functions. _lowerCamelCase : str = np.ones(7_5) _lowerCamelCase : str = np.zeros((7_5,)) # 1. Union = max(µA(x), µB(x)) _lowerCamelCase : Optional[int] = fuzz.fuzzy_or(X, young, X, middle_aged)[1] # 2. Intersection = min(µA(x), µB(x)) _lowerCamelCase : Optional[Any] = fuzz.fuzzy_and(X, young, X, middle_aged)[1] # 3. Complement (A) = (1- min(µA(x)) _lowerCamelCase : Any = fuzz.fuzzy_not(young) # 4. Difference (A/B) = min(µA(x),(1- µB(x))) _lowerCamelCase : List[str] = fuzz.fuzzy_and(X, young, X, fuzz.fuzzy_not(middle_aged)[1])[1] # 5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))] _lowerCamelCase : Union[str, Any] = young + middle_aged - (young * middle_aged) # 6. Algebraic Product = (µA(x) * µB(x)) _lowerCamelCase : Any = young * middle_aged # 7. Bounded Sum = min[1,(µA(x), µB(x))] _lowerCamelCase : Any = fuzz.fuzzy_and(X, one, X, young + middle_aged)[1] # 8. Bounded difference = min[0,(µA(x), µB(x))] _lowerCamelCase : Dict = fuzz.fuzzy_or(X, zero, X, young - middle_aged)[1] # max-min composition # max-product composition # Plot each set A, set B and each operation result using plot() and subplot(). from matplotlib import pyplot as plt plt.figure() plt.subplot(4, 3, 1) plt.plot(X, young) plt.title("Young") plt.grid(True) plt.subplot(4, 3, 2) plt.plot(X, middle_aged) plt.title("Middle aged") plt.grid(True) plt.subplot(4, 3, 3) plt.plot(X, union) plt.title("union") plt.grid(True) plt.subplot(4, 3, 4) plt.plot(X, intersection) plt.title("intersection") plt.grid(True) plt.subplot(4, 3, 5) plt.plot(X, complement_a) plt.title("complement_a") plt.grid(True) plt.subplot(4, 3, 6) plt.plot(X, difference) plt.title("difference a/b") plt.grid(True) plt.subplot(4, 3, 7) plt.plot(X, alg_sum) plt.title("alg_sum") plt.grid(True) plt.subplot(4, 3, 8) plt.plot(X, alg_product) plt.title("alg_product") plt.grid(True) plt.subplot(4, 3, 9) plt.plot(X, bdd_sum) plt.title("bdd_sum") plt.grid(True) plt.subplot(4, 3, 1_0) plt.plot(X, bdd_difference) plt.title("bdd_difference") plt.grid(True) plt.subplots_adjust(hspace=0.5) plt.show()
336
def a__ ( UpperCAmelCase : List[Any] , UpperCAmelCase : Optional[int] ) -> Optional[Any]: UpperCAmelCase : List[str] = 0 UpperCAmelCase : List[Any] = len(UpperCAmelCase ) - 1 while left <= right: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : Optional[int] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None UpperCAmelCase : Optional[Any] = sorted_collection[point] if current_item == item: return point else: if point < left: UpperCAmelCase : Any = left UpperCAmelCase : List[str] = point elif point > right: UpperCAmelCase : Any = right UpperCAmelCase : List[str] = point else: if item < current_item: UpperCAmelCase : Optional[int] = point - 1 else: UpperCAmelCase : str = point + 1 return None def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : int , UpperCAmelCase : str , UpperCAmelCase : Union[str, Any] ) -> Dict: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : List[str] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None if sorted_collection[point] == item: return point elif point < left: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) elif point > right: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) else: if sorted_collection[point] > item: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , point - 1 ) else: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , point + 1 , UpperCAmelCase ) def a__ ( UpperCAmelCase : Union[str, Any] ) -> int: if collection != sorted(UpperCAmelCase ): raise ValueError('''Collection must be ascending sorted''' ) return True if __name__ == "__main__": import sys _lowerCamelCase : Optional[int] = 0 if debug == 1: _lowerCamelCase : Dict = [1_0, 3_0, 4_0, 4_5, 5_0, 6_6, 7_7, 9_3] try: __assert_sorted(collection) except ValueError: sys.exit("Sequence must be ascending sorted to apply interpolation search") _lowerCamelCase : List[Any] = 6_7 _lowerCamelCase : Optional[Any] = interpolation_search(collection, target) if result is not None: print(f"""{target} found at positions: {result}""") else: print("Not found")
336
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available _lowerCamelCase : List[str] = { "configuration_luke": ["LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP", "LukeConfig"], "tokenization_luke": ["LukeTokenizer"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[int] = [ "LUKE_PRETRAINED_MODEL_ARCHIVE_LIST", "LukeForEntityClassification", "LukeForEntityPairClassification", "LukeForEntitySpanClassification", "LukeForMultipleChoice", "LukeForQuestionAnswering", "LukeForSequenceClassification", "LukeForTokenClassification", "LukeForMaskedLM", "LukeModel", "LukePreTrainedModel", ] if TYPE_CHECKING: from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig from .tokenization_luke import LukeTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_luke import ( LUKE_PRETRAINED_MODEL_ARCHIVE_LIST, LukeForEntityClassification, LukeForEntityPairClassification, LukeForEntitySpanClassification, LukeForMaskedLM, LukeForMultipleChoice, LukeForQuestionAnswering, LukeForSequenceClassification, LukeForTokenClassification, LukeModel, LukePreTrainedModel, ) else: import sys _lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
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 BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor from transformers.image_utils import PILImageResampling from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : Any = logging.get_logger(__name__) def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Optional[Any]=False , UpperCAmelCase : List[str]=False ) -> Any: UpperCAmelCase : Optional[int] = '''backbone.''' if is_semantic else '''''' UpperCAmelCase : Dict = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f'''{prefix}blocks.{i}.norm1.weight''', f'''beit.encoder.layer.{i}.layernorm_before.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm1.bias''', f'''beit.encoder.layer.{i}.layernorm_before.bias''') ) rename_keys.append( (f'''{prefix}blocks.{i}.attn.proj.weight''', f'''beit.encoder.layer.{i}.attention.output.dense.weight''') ) rename_keys.append( (f'''{prefix}blocks.{i}.attn.proj.bias''', f'''beit.encoder.layer.{i}.attention.output.dense.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm2.weight''', f'''beit.encoder.layer.{i}.layernorm_after.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm2.bias''', f'''beit.encoder.layer.{i}.layernorm_after.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc1.weight''', f'''beit.encoder.layer.{i}.intermediate.dense.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc1.bias''', f'''beit.encoder.layer.{i}.intermediate.dense.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc2.weight''', f'''beit.encoder.layer.{i}.output.dense.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc2.bias''', f'''beit.encoder.layer.{i}.output.dense.bias''') ) # projection layer + position embeddings rename_keys.extend( [ (f'''{prefix}cls_token''', '''beit.embeddings.cls_token'''), (f'''{prefix}patch_embed.proj.weight''', '''beit.embeddings.patch_embeddings.projection.weight'''), (f'''{prefix}patch_embed.proj.bias''', '''beit.embeddings.patch_embeddings.projection.bias'''), (f'''{prefix}pos_embed''', '''beit.embeddings.position_embeddings'''), ] ) if has_lm_head: # mask token + layernorm rename_keys.extend( [ ('''mask_token''', '''beit.embeddings.mask_token'''), ('''norm.weight''', '''layernorm.weight'''), ('''norm.bias''', '''layernorm.bias'''), ] ) else: # layernorm + classification head rename_keys.extend( [ ('''fc_norm.weight''', '''beit.pooler.layernorm.weight'''), ('''fc_norm.bias''', '''beit.pooler.layernorm.bias'''), ('''head.weight''', '''classifier.weight'''), ('''head.bias''', '''classifier.bias'''), ] ) return rename_keys def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : str , UpperCAmelCase : str=False , UpperCAmelCase : Dict=False ) -> Any: for i in range(config.num_hidden_layers ): UpperCAmelCase : Tuple = '''backbone.''' if is_semantic else '''''' # queries, keys and values UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.qkv.weight''' ) UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.q_bias''' ) UpperCAmelCase : List[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.v_bias''' ) UpperCAmelCase : Union[str, Any] = in_proj_weight[ : config.hidden_size, : ] UpperCAmelCase : str = q_bias UpperCAmelCase : List[str] = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] UpperCAmelCase : List[str] = in_proj_weight[ -config.hidden_size :, : ] UpperCAmelCase : int = v_bias # gamma_1 and gamma_2 # we call them lambda because otherwise they are renamed when using .from_pretrained UpperCAmelCase : int = state_dict.pop(f'''{prefix}blocks.{i}.gamma_1''' ) UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.gamma_2''' ) UpperCAmelCase : str = gamma_a UpperCAmelCase : Dict = gamma_a def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : List[Any] , UpperCAmelCase : Tuple ) -> Optional[Any]: UpperCAmelCase : Union[str, Any] = dct.pop(UpperCAmelCase ) UpperCAmelCase : str = val def a__ ( ) -> Optional[int]: UpperCAmelCase : List[Any] = '''http://images.cocodataset.org/val2017/000000039769.jpg''' UpperCAmelCase : Union[str, Any] = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ) return im @torch.no_grad() def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Tuple , UpperCAmelCase : List[Any]=False ) -> Union[str, Any]: UpperCAmelCase : Dict = False if '''rvlcdip''' in checkpoint_url else True UpperCAmelCase : Any = BeitConfig(use_absolute_position_embeddings=UpperCAmelCase , use_mask_token=UpperCAmelCase ) # size of the architecture if "large" in checkpoint_url or "dit-l" in checkpoint_url: UpperCAmelCase : List[Any] = 1_024 UpperCAmelCase : Optional[Any] = 4_096 UpperCAmelCase : Any = 24 UpperCAmelCase : Union[str, Any] = 16 # labels if "rvlcdip" in checkpoint_url: UpperCAmelCase : Optional[Any] = 16 UpperCAmelCase : List[Any] = '''huggingface/label-files''' UpperCAmelCase : Any = '''rvlcdip-id2label.json''' UpperCAmelCase : List[str] = json.load(open(hf_hub_download(UpperCAmelCase , UpperCAmelCase , repo_type='''dataset''' ) , '''r''' ) ) UpperCAmelCase : Dict = {int(UpperCAmelCase ): v for k, v in idalabel.items()} UpperCAmelCase : Union[str, Any] = idalabel UpperCAmelCase : Tuple = {v: k for k, v in idalabel.items()} # load state_dict of original model, remove and rename some keys UpperCAmelCase : Tuple = torch.hub.load_state_dict_from_url(UpperCAmelCase , map_location='''cpu''' )['''model'''] UpperCAmelCase : List[str] = create_rename_keys(UpperCAmelCase , has_lm_head=UpperCAmelCase ) for src, dest in rename_keys: rename_key(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) read_in_q_k_v(UpperCAmelCase , UpperCAmelCase , has_lm_head=UpperCAmelCase ) # load HuggingFace model UpperCAmelCase : Tuple = BeitForMaskedImageModeling(UpperCAmelCase ) if has_lm_head else BeitForImageClassification(UpperCAmelCase ) model.eval() model.load_state_dict(UpperCAmelCase ) # Check outputs on an image UpperCAmelCase : Dict = BeitImageProcessor( size=config.image_size , resample=PILImageResampling.BILINEAR , do_center_crop=UpperCAmelCase ) UpperCAmelCase : List[str] = prepare_img() UpperCAmelCase : Optional[Any] = image_processor(images=UpperCAmelCase , return_tensors='''pt''' ) UpperCAmelCase : str = encoding['''pixel_values'''] UpperCAmelCase : Any = model(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = outputs.logits # verify logits UpperCAmelCase : List[Any] = [1, 16] if '''rvlcdip''' in checkpoint_url else [1, 196, 8_192] assert logits.shape == torch.Size(UpperCAmelCase ), "Shape of logits not as expected" Path(UpperCAmelCase ).mkdir(exist_ok=UpperCAmelCase ) print(f'''Saving model to {pytorch_dump_folder_path}''' ) model.save_pretrained(UpperCAmelCase ) print(f'''Saving image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(UpperCAmelCase ) if push_to_hub: if has_lm_head: UpperCAmelCase : List[Any] = '''dit-base''' if '''base''' in checkpoint_url else '''dit-large''' else: UpperCAmelCase : Any = '''dit-base-finetuned-rvlcdip''' if '''dit-b''' in checkpoint_url else '''dit-large-finetuned-rvlcdip''' image_processor.push_to_hub( repo_path_or_name=Path(UpperCAmelCase , UpperCAmelCase ) , organization='''nielsr''' , commit_message='''Add image processor''' , use_temp_dir=UpperCAmelCase , ) model.push_to_hub( repo_path_or_name=Path(UpperCAmelCase , UpperCAmelCase ) , organization='''nielsr''' , commit_message='''Add model''' , use_temp_dir=UpperCAmelCase , ) if __name__ == "__main__": _lowerCamelCase : Tuple = argparse.ArgumentParser() parser.add_argument( "--checkpoint_url", default="https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth", type=str, help="URL to the original PyTorch checkpoint (.pth file).", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model." ) parser.add_argument( "--push_to_hub", action="store_true", ) _lowerCamelCase : Optional[int] = parser.parse_args() convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
336
1
import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import CLIPTokenizer, CLIPTokenizerFast from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import CLIPSegProcessor, ViTImageProcessor @require_vision class __UpperCAmelCase ( unittest.TestCase ): def __magic_name__ ( self : Dict ): UpperCAmelCase : Union[str, Any] = tempfile.mkdtemp() # fmt: off UpperCAmelCase : Optional[Any] = ['''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>'''] # fmt: on UpperCAmelCase : Any = dict(zip(__A, range(len(__A ) ) ) ) UpperCAmelCase : Optional[int] = ['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', ''''''] UpperCAmelCase : List[str] = {'''unk_token''': '''<unk>'''} UpperCAmelCase : str = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['''vocab_file'''] ) UpperCAmelCase : List[Any] = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['''merges_file'''] ) with open(self.vocab_file, '''w''', encoding='''utf-8''' ) as fp: fp.write(json.dumps(__A ) + '''\n''' ) with open(self.merges_file, '''w''', encoding='''utf-8''' ) as fp: fp.write('''\n'''.join(__A ) ) UpperCAmelCase : List[Any] = { '''do_resize''': True, '''size''': 2_0, '''do_center_crop''': True, '''crop_size''': 1_8, '''do_normalize''': True, '''image_mean''': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3], '''image_std''': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1], } UpperCAmelCase : str = os.path.join(self.tmpdirname, __A ) with open(self.image_processor_file, '''w''', encoding='''utf-8''' ) as fp: json.dump(__A, __A ) def __magic_name__ ( self : Optional[int], **__A : Optional[int] ): return CLIPTokenizer.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Optional[int], **__A : Optional[int] ): return CLIPTokenizerFast.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Optional[Any], **__A : List[Any] ): return ViTImageProcessor.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Union[str, Any] ): shutil.rmtree(self.tmpdirname ) def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Optional[Any] = [np.random.randint(2_5_5, size=(3, 3_0, 4_0_0), dtype=np.uinta )] UpperCAmelCase : Tuple = [Image.fromarray(np.moveaxis(__A, 0, -1 ) ) for x in image_inputs] return image_inputs def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : Optional[int] = self.get_tokenizer() UpperCAmelCase : Optional[Any] = self.get_rust_tokenizer() UpperCAmelCase : Any = self.get_image_processor() UpperCAmelCase : Union[str, Any] = CLIPSegProcessor(tokenizer=__A, image_processor=__A ) processor_slow.save_pretrained(self.tmpdirname ) UpperCAmelCase : Tuple = CLIPSegProcessor.from_pretrained(self.tmpdirname, use_fast=__A ) UpperCAmelCase : str = CLIPSegProcessor(tokenizer=__A, image_processor=__A ) processor_fast.save_pretrained(self.tmpdirname ) UpperCAmelCase : Any = CLIPSegProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor_slow.tokenizer.get_vocab(), tokenizer_slow.get_vocab() ) self.assertEqual(processor_fast.tokenizer.get_vocab(), tokenizer_fast.get_vocab() ) self.assertEqual(tokenizer_slow.get_vocab(), tokenizer_fast.get_vocab() ) self.assertIsInstance(processor_slow.tokenizer, __A ) self.assertIsInstance(processor_fast.tokenizer, __A ) self.assertEqual(processor_slow.image_processor.to_json_string(), image_processor.to_json_string() ) self.assertEqual(processor_fast.image_processor.to_json_string(), image_processor.to_json_string() ) self.assertIsInstance(processor_slow.image_processor, __A ) self.assertIsInstance(processor_fast.image_processor, __A ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Optional[int] = CLIPSegProcessor(tokenizer=self.get_tokenizer(), image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) UpperCAmelCase : str = self.get_tokenizer(bos_token='''(BOS)''', eos_token='''(EOS)''' ) UpperCAmelCase : Any = self.get_image_processor(do_normalize=__A, padding_value=1.0 ) UpperCAmelCase : Optional[int] = CLIPSegProcessor.from_pretrained( self.tmpdirname, bos_token='''(BOS)''', eos_token='''(EOS)''', do_normalize=__A, padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab(), tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer, __A ) self.assertEqual(processor.image_processor.to_json_string(), image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor, __A ) def __magic_name__ ( self : Tuple ): UpperCAmelCase : int = self.get_image_processor() UpperCAmelCase : Any = self.get_tokenizer() UpperCAmelCase : Any = CLIPSegProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : List[str] = self.prepare_image_inputs() UpperCAmelCase : Dict = image_processor(__A, return_tensors='''np''' ) UpperCAmelCase : List[str] = processor(images=__A, return_tensors='''np''' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum(), input_processor[key].sum(), delta=1E-2 ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : Dict = self.get_image_processor() UpperCAmelCase : int = self.get_tokenizer() UpperCAmelCase : Any = CLIPSegProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Optional[int] = '''lower newer''' UpperCAmelCase : List[str] = processor(text=__A ) UpperCAmelCase : Union[str, Any] = tokenizer(__A ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key], encoded_processor[key] ) def __magic_name__ ( self : Dict ): UpperCAmelCase : List[str] = self.get_image_processor() UpperCAmelCase : List[Any] = self.get_tokenizer() UpperCAmelCase : str = CLIPSegProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Optional[int] = '''lower newer''' UpperCAmelCase : str = self.prepare_image_inputs() UpperCAmelCase : List[Any] = processor(text=__A, images=__A ) self.assertListEqual(list(inputs.keys() ), ['''input_ids''', '''attention_mask''', '''pixel_values'''] ) # test if it raises when no input is passed with pytest.raises(__A ): processor() def __magic_name__ ( self : List[Any] ): UpperCAmelCase : List[str] = self.get_image_processor() UpperCAmelCase : Any = self.get_tokenizer() UpperCAmelCase : Optional[Any] = CLIPSegProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Dict = self.prepare_image_inputs() UpperCAmelCase : Optional[int] = self.prepare_image_inputs() UpperCAmelCase : List[Any] = processor(images=__A, visual_prompt=__A ) self.assertListEqual(list(inputs.keys() ), ['''pixel_values''', '''conditional_pixel_values'''] ) # test if it raises when no input is passed with pytest.raises(__A ): processor() def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : int = self.get_image_processor() UpperCAmelCase : int = self.get_tokenizer() UpperCAmelCase : Any = CLIPSegProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Optional[int] = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] UpperCAmelCase : List[Any] = processor.batch_decode(__A ) UpperCAmelCase : Optional[Any] = tokenizer.batch_decode(__A ) self.assertListEqual(__A, __A )
336
import unittest import numpy as np from transformers import RobertaConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_flax_available(): from transformers.models.roberta.modeling_flax_roberta import ( FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaModel, ) class __UpperCAmelCase ( unittest.TestCase ): def __init__( self : Optional[int], __A : Optional[int], __A : Any=1_3, __A : str=7, __A : Optional[int]=True, __A : Tuple=True, __A : Union[str, Any]=True, __A : Any=True, __A : Optional[int]=9_9, __A : Tuple=3_2, __A : str=5, __A : Union[str, Any]=4, __A : List[str]=3_7, __A : Tuple="gelu", __A : Optional[int]=0.1, __A : int=0.1, __A : Optional[Any]=5_1_2, __A : int=1_6, __A : Optional[Any]=2, __A : Union[str, Any]=0.0_2, __A : Optional[int]=4, ): UpperCAmelCase : Any = parent UpperCAmelCase : List[Any] = batch_size UpperCAmelCase : Any = seq_length UpperCAmelCase : Tuple = is_training UpperCAmelCase : str = use_attention_mask UpperCAmelCase : List[str] = use_token_type_ids UpperCAmelCase : int = use_labels UpperCAmelCase : List[Any] = vocab_size UpperCAmelCase : Optional[int] = hidden_size UpperCAmelCase : str = num_hidden_layers UpperCAmelCase : Dict = num_attention_heads UpperCAmelCase : Tuple = intermediate_size UpperCAmelCase : List[str] = hidden_act UpperCAmelCase : str = hidden_dropout_prob UpperCAmelCase : int = attention_probs_dropout_prob UpperCAmelCase : List[Any] = max_position_embeddings UpperCAmelCase : Optional[Any] = type_vocab_size UpperCAmelCase : Any = type_sequence_label_size UpperCAmelCase : Optional[Any] = initializer_range UpperCAmelCase : Any = num_choices def __magic_name__ ( self : str ): UpperCAmelCase : Any = ids_tensor([self.batch_size, self.seq_length], self.vocab_size ) UpperCAmelCase : List[Any] = None if self.use_attention_mask: UpperCAmelCase : Any = random_attention_mask([self.batch_size, self.seq_length] ) UpperCAmelCase : Any = None if self.use_token_type_ids: UpperCAmelCase : Any = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size ) UpperCAmelCase : Union[str, Any] = RobertaConfig( vocab_size=self.vocab_size, hidden_size=self.hidden_size, num_hidden_layers=self.num_hidden_layers, num_attention_heads=self.num_attention_heads, intermediate_size=self.intermediate_size, hidden_act=self.hidden_act, hidden_dropout_prob=self.hidden_dropout_prob, attention_probs_dropout_prob=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, type_vocab_size=self.type_vocab_size, is_decoder=__A, initializer_range=self.initializer_range, ) return config, input_ids, token_type_ids, attention_mask def __magic_name__ ( self : int ): UpperCAmelCase : Any = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[Any] = config_and_inputs UpperCAmelCase : Dict = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask} return config, inputs_dict def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Dict = config_and_inputs UpperCAmelCase : Any = True UpperCAmelCase : Union[str, Any] = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) UpperCAmelCase : List[Any] = ids_tensor([self.batch_size, self.seq_length], vocab_size=2 ) return ( config, input_ids, token_type_ids, encoder_hidden_states, encoder_attention_mask, ) @require_flax class __UpperCAmelCase ( lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRobertaModel, FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, ) if is_flax_available() else () ) def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : Dict = FlaxRobertaModelTester(self ) @slow def __magic_name__ ( self : Any ): for model_class_name in self.all_model_classes: UpperCAmelCase : Dict = model_class_name.from_pretrained('''roberta-base''', from_pt=__A ) UpperCAmelCase : List[str] = model(np.ones((1, 1) ) ) self.assertIsNotNone(__A )
336
1
import unittest from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin _lowerCamelCase : Optional[int] = get_tests_dir("fixtures/test_sentencepiece.model") @require_sentencepiece @require_tokenizers class __UpperCAmelCase ( lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = XLNetTokenizer UpperCamelCase = XLNetTokenizerFast UpperCamelCase = True UpperCamelCase = True def __magic_name__ ( self : Any ): super().setUp() # We have a SentencePiece fixture for testing UpperCAmelCase : Tuple = XLNetTokenizer(__A, keep_accents=__A ) tokenizer.sanitize_special_tokens() tokenizer.save_pretrained(self.tmpdirname ) def __magic_name__ ( self : Any ): UpperCAmelCase : List[Any] = '''<s>''' UpperCAmelCase : Union[str, Any] = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(__A ), __A ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(__A ), __A ) def __magic_name__ ( self : Dict ): UpperCAmelCase : Union[str, Any] = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0], '''<unk>''' ) self.assertEqual(vocab_keys[1], '''<s>''' ) self.assertEqual(vocab_keys[-1], '''<eod>''' ) self.assertEqual(len(__A ), 1_0_0_6 ) def __magic_name__ ( self : Optional[Any] ): self.assertEqual(self.get_tokenizer().vocab_size, 1_0_0_0 ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : Any = XLNetTokenizer(__A, keep_accents=__A ) UpperCAmelCase : Union[str, Any] = tokenizer.tokenize('''This is a test''' ) self.assertListEqual(__A, ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est'''] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__A ), [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2] ) UpperCAmelCase : Tuple = 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''', '''é''', '''.''', ], ) UpperCAmelCase : Any = tokenizer.convert_tokens_to_ids(__A ) self.assertListEqual(__A, [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 0, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 0, 4] ) UpperCAmelCase : List[Any] = 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>''', '''.''', ], ) def __magic_name__ ( self : Any ): UpperCAmelCase : int = XLNetTokenizer(__A, do_lower_case=__A ) UpperCAmelCase : int = 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''', '''se''', '''.''', ], ) self.assertListEqual(tokenizer.tokenize('''H\u00E9llo''' ), ['''▁he''', '''ll''', '''o'''] ) def __magic_name__ ( self : Any ): UpperCAmelCase : List[str] = XLNetTokenizer(__A, do_lower_case=__A ) UpperCAmelCase : Dict = 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''', '''se''', '''.''', ], ) @slow def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Optional[int] = XLNetTokenizer.from_pretrained('''xlnet-base-cased''' ) UpperCAmelCase : Tuple = tokenizer.encode('''sequence builders''', add_special_tokens=__A ) UpperCAmelCase : Any = tokenizer.encode('''multi-sequence build''', add_special_tokens=__A ) UpperCAmelCase : str = tokenizer.build_inputs_with_special_tokens(__A ) UpperCAmelCase : Tuple = tokenizer.build_inputs_with_special_tokens(__A, __A ) assert encoded_sentence == text + [4, 3] assert encoded_pair == text + [4] + text_a + [4, 3] @slow def __magic_name__ ( self : str ): # fmt: off UpperCAmelCase : Optional[Any] = {'''input_ids''': [[1_7, 2_1_4_4_2, 2_7_0, 1_7, 1_0, 1_4_6_4_5, 3_1_8, 3_4, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 7_7_5_2, 2_2_0_1_8, 2_3, 2_1, 1_7, 4_5_4_6, 3_1_4_5, 7_8_7, 1_3, 3_3_5_2, 1_4_4_3_1, 1_3, 5_5_0_0, 1_1, 1_1_7_6, 5_8_0, 1_3, 1_6_8_1_9, 4_7_9_7, 2_3, 1_7, 1_0, 1_7_1_3_5, 6_5_8, 1_9, 4_5_7, 7_9_3_2, 1_3, 1_8_4, 1_9, 3_1_5_4, 1_7_1_3_5, 6_4_6_8, 1_9, 1_4_0_4, 1_2_2_6_9, 1_9, 4_2_2_9, 5_3_5_6, 1_6_2_6_4, 4_6, 1_9, 1_7, 2_0_5_4_5, 1_0_3_9_5, 9, 9, 9, 1_1, 2_8, 6_4_2_1, 9_5_3_1, 2_0_7_2_9, 1_7, 1_0, 3_5_3, 1_7_0_2_2, 1_1, 2_1, 6_4_2_1, 9_5_3_1, 1_6_9_4_9, 1_7, 1_0, 1_1_5_0_9, 7_5_3, 1_1, 3_3, 9_5, 2_4_2_1, 7_3_8_5, 9_5_6, 1_4_4_3_1, 2_6_2_6, 2_5, 8_4_2, 7_3_8_5, 4_8_3_6, 2_1, 1_4_2_9, 2_2_7_2, 9_8_5_5, 3_1_2_0, 1_6_1, 2_4_7_3_8, 1_9, 1_3_2_0_3, 6_5_8, 2_1_8, 7_8_7, 2_1, 4_3_0, 1_8_4_8_2, 8_4_7, 2_6_3_7, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2_2, 2_2_1_7_8, 2_7, 1_0_6_4, 2_2, 9_5_6, 1_3, 1_1_1_0_1, 1_4_2_9, 5_8_5_4, 2_4_3_1_3, 1_8_9_5_3, 4_0, 4_2_2, 2_4_3_6_6, 6_8, 1_7_5_8, 3_7, 1_0_4_8_3, 1_4_2_5_7, 3_1, 2_0_7, 2_6_3, 2_1, 2_0_3, 3_7_7_3, 2_5, 7_1, 9_7_3_5, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_2, 2_0_4_9, 3_4_4_2, 1_7, 1_3_8_9_4, 3_3_8_0, 2_3, 9_5, 1_8, 1_7_6_3_4, 2_2_8_8, 9, 4, 3]], '''token_type_ids''': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], '''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], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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, 0, 0, 0, 0, 0, 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]]} # noqa: E501 # fmt: on self.tokenizer_integration_test_util( expected_encoding=__A, model_name='''xlnet-base-cased''', revision='''c841166438c31ec7ca9a106dee7bb312b73ae511''', )
336
import os from typing import List, Optional, Union from ...tokenization_utils import PreTrainedTokenizer from ...tokenization_utils_base import AddedToken from ...utils import logging _lowerCamelCase : Optional[Any] = logging.get_logger(__name__) _lowerCamelCase : Dict = {"vocab_file": "vocab.txt"} _lowerCamelCase : List[str] = { "vocab_file": { "facebook/esm2_t6_8M_UR50D": "https://huggingface.co/facebook/esm2_t6_8M_UR50D/resolve/main/vocab.txt", "facebook/esm2_t12_35M_UR50D": "https://huggingface.co/facebook/esm2_t12_35M_UR50D/resolve/main/vocab.txt", }, } _lowerCamelCase : List[Any] = { "facebook/esm2_t6_8M_UR50D": 1_0_2_4, "facebook/esm2_t12_35M_UR50D": 1_0_2_4, } def a__ ( UpperCAmelCase : List[str] ) -> Any: with open(UpperCAmelCase , '''r''' ) as f: UpperCAmelCase : Dict = f.read().splitlines() return [l.strip() for l in lines] class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = VOCAB_FILES_NAMES UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase = ["""input_ids""", """attention_mask"""] def __init__( self : Any, __A : Dict, __A : List[Any]="<unk>", __A : List[str]="<cls>", __A : Any="<pad>", __A : Union[str, Any]="<mask>", __A : int="<eos>", **__A : Tuple, ): super().__init__(**__A ) UpperCAmelCase : Tuple = load_vocab_file(__A ) UpperCAmelCase : List[Any] = dict(enumerate(self.all_tokens ) ) UpperCAmelCase : str = {tok: ind for ind, tok in enumerate(self.all_tokens )} UpperCAmelCase : Union[str, Any] = unk_token UpperCAmelCase : Optional[Any] = cls_token UpperCAmelCase : Optional[int] = pad_token UpperCAmelCase : Optional[int] = mask_token UpperCAmelCase : List[str] = eos_token UpperCAmelCase : Optional[Any] = self.all_tokens self._create_trie(self.unique_no_split_tokens ) def __magic_name__ ( self : Tuple, __A : int ): return self._id_to_token.get(__A, self.unk_token ) def __magic_name__ ( self : List[Any], __A : str ): return self._token_to_id.get(__A, self._token_to_id.get(self.unk_token ) ) def __magic_name__ ( self : Any, __A : Optional[Any], **__A : Union[str, Any] ): return text.split() def __magic_name__ ( self : Optional[int], __A : Dict=False ): return len(self._id_to_token ) def __magic_name__ ( self : int ): return {token: i for i, token in enumerate(self.all_tokens )} def __magic_name__ ( self : Tuple, __A : str ): return self._token_to_id.get(__A, self._token_to_id.get(self.unk_token ) ) def __magic_name__ ( self : Any, __A : int ): return self._id_to_token.get(__A, self.unk_token ) def __magic_name__ ( self : Union[str, Any], __A : List[int], __A : Optional[List[int]] = None ): UpperCAmelCase : Optional[int] = [self.cls_token_id] UpperCAmelCase : Optional[int] = [self.eos_token_id] # No sep token in ESM vocabulary if token_ids_a is None: if self.eos_token_id is None: return cls + token_ids_a else: return cls + token_ids_a + sep elif self.eos_token_id is None: raise ValueError('''Cannot tokenize multiple sequences when EOS token is not set!''' ) return cls + token_ids_a + sep + token_ids_a + sep # Multiple inputs always have an EOS token def __magic_name__ ( self : Any, __A : List, __A : Optional[List] = None, __A : bool = False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( '''You should not supply a second sequence if the provided sequence of ''' '''ids is already formatted with special tokens for the model.''' ) return [1 if token in self.all_special_ids else 0 for token in token_ids_a] UpperCAmelCase : Dict = [1] + ([0] * len(__A )) + [1] if token_ids_a is not None: mask += [0] * len(__A ) + [1] return mask def __magic_name__ ( self : Optional[int], __A : List[Any], __A : Dict ): UpperCAmelCase : Union[str, Any] = os.path.join(__A, (filename_prefix + '''-''' if filename_prefix else '''''') + '''vocab.txt''' ) with open(__A, '''w''' ) as f: f.write('''\n'''.join(self.all_tokens ) ) return (vocab_file,) @property def __magic_name__ ( self : Dict ): return self.get_vocab_size(with_added_tokens=__A ) def __magic_name__ ( self : Optional[int], __A : Union[List[str], List[AddedToken]], __A : bool = False ): return super()._add_tokens(__A, special_tokens=__A )
336
1
from copy import deepcopy import torch import torch.nn.functional as F from torch.optim import AdamW from torch.optim.lr_scheduler import LambdaLR from torch.utils.data import DataLoader from accelerate.accelerator import Accelerator from accelerate.state import GradientState from accelerate.test_utils import RegressionDataset, RegressionModel from accelerate.utils import DistributedType, is_torch_version, set_seed def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : List[Any] , UpperCAmelCase : List[str] , UpperCAmelCase : Any ) -> Any: for param, grad_param in zip(model_a.parameters() , model_b.parameters() ): if not param.requires_grad: continue if not did_step: # Grads should not be in sync assert ( torch.allclose(param.grad , grad_param.grad ) is False ), f'''Gradients in sync when they should not be at iteration {iteration}:\nmodel_a grad ({param.grad}) == model_b grad ({grad_param.grad})''' else: # Grads should be in sync assert ( torch.allclose(param.grad , grad_param.grad ) is True ), f'''Gradients not in sync when they should be at iteration {iteration}:\nmodel_a grad ({param.grad}) != model_b grad ({grad_param.grad})''' def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : Optional[int] , UpperCAmelCase : int , UpperCAmelCase : int , UpperCAmelCase : str=True ) -> Dict: model.train() UpperCAmelCase : Optional[int] = model(UpperCAmelCase ) UpperCAmelCase : Dict = F.mse_loss(UpperCAmelCase , target.to(output.device ) ) if not do_backward: loss /= accelerator.gradient_accumulation_steps loss.backward() else: accelerator.backward(UpperCAmelCase ) def a__ ( UpperCAmelCase : int , UpperCAmelCase : List[str]=False ) -> Optional[int]: set_seed(42 ) UpperCAmelCase : Optional[Any] = RegressionModel() UpperCAmelCase : Any = deepcopy(UpperCAmelCase ) UpperCAmelCase : List[Any] = RegressionDataset(length=80 ) UpperCAmelCase : Union[str, Any] = DataLoader(UpperCAmelCase , batch_size=16 ) model.to(accelerator.device ) if sched: UpperCAmelCase : Optional[int] = AdamW(params=model.parameters() , lr=1E-3 ) UpperCAmelCase : Optional[int] = AdamW(params=ddp_model.parameters() , lr=1E-3 ) UpperCAmelCase : str = LambdaLR(UpperCAmelCase , lr_lambda=lambda UpperCAmelCase : epoch**0.65 ) UpperCAmelCase : Any = LambdaLR(UpperCAmelCase , lr_lambda=lambda UpperCAmelCase : epoch**0.65 ) # Make a copy of `model` if sched: UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[str] = accelerator.prepare(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) else: UpperCAmelCase , UpperCAmelCase : List[str] = accelerator.prepare(UpperCAmelCase , UpperCAmelCase ) if sched: return (model, opt, sched, dataloader, ddp_model, ddp_opt, ddp_sched) return model, ddp_model, dataloader def a__ ( UpperCAmelCase : Any ) -> Any: # Test when on a single CPU or GPU that the context manager does nothing UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Tuple = get_training_setup(UpperCAmelCase ) # Use a single batch UpperCAmelCase , UpperCAmelCase : Union[str, Any] = next(iter(UpperCAmelCase ) ).values() for iteration in range(3 ): # Gather the distributed inputs and targs for the base model UpperCAmelCase , UpperCAmelCase : Any = accelerator.gather((ddp_input, ddp_target) ) UpperCAmelCase , UpperCAmelCase : str = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # Do "gradient accumulation" (noop) if iteration % 2 == 0: # Accumulate grads locally with accelerator.no_sync(UpperCAmelCase ): step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) else: # Sync grads step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # Since `no_sync` is a noop, `ddp_model` and `model` grads should always be in sync check_model_parameters(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) for param, ddp_param in zip(model.parameters() , ddp_model.parameters() ): if not param.requires_grad: continue assert torch.allclose( param.grad , ddp_param.grad ), f'''Gradients not in sync when they should be:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})''' # Shuffle ddp_input on each iteration torch.manual_seed(1_337 + iteration ) UpperCAmelCase : List[Any] = ddp_input[torch.randperm(len(UpperCAmelCase ) )] def a__ ( UpperCAmelCase : int ) -> str: # Test on distributed setup that context manager behaves properly UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Any = get_training_setup(UpperCAmelCase ) # Use a single batch UpperCAmelCase , UpperCAmelCase : Optional[int] = next(iter(UpperCAmelCase ) ).values() for iteration in range(3 ): # Gather the distributed inputs and targs for the base model UpperCAmelCase , UpperCAmelCase : Optional[int] = accelerator.gather((ddp_input, ddp_target) ) UpperCAmelCase , UpperCAmelCase : str = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # Do "gradient accumulation" (noop) if iteration % 2 == 0: # Accumulate grads locally with accelerator.no_sync(UpperCAmelCase ): step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) else: # Sync grads step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # DDP model and model should only be in sync when not (iteration % 2 == 0) for param, ddp_param in zip(model.parameters() , ddp_model.parameters() ): if not param.requires_grad: continue if iteration % 2 == 0: # Grads should not be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is False ), f'''Gradients in sync when they should not be:\nModel grad ({param.grad}) == DDP grad ({ddp_param.grad})''' else: # Grads should be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is True ), f'''Gradients not in sync when they should be:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})''' # Shuffle ddp_input on each iteration torch.manual_seed(1_337 + iteration ) UpperCAmelCase : int = ddp_input[torch.randperm(len(UpperCAmelCase ) )] def a__ ( UpperCAmelCase : Optional[Any]=False , UpperCAmelCase : Tuple=False ) -> Optional[Any]: UpperCAmelCase : Tuple = Accelerator( split_batches=UpperCAmelCase , dispatch_batches=UpperCAmelCase , gradient_accumulation_steps=2 ) # Test that context manager behaves properly UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Optional[int] = get_training_setup(UpperCAmelCase ) for iteration, batch in enumerate(UpperCAmelCase ): UpperCAmelCase , UpperCAmelCase : Union[str, Any] = batch.values() # Gather the distributed inputs and targs for the base model UpperCAmelCase , UpperCAmelCase : Tuple = accelerator.gather((ddp_input, ddp_target) ) UpperCAmelCase , UpperCAmelCase : Optional[int] = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # Do "gradient accumulation" (noop) with accelerator.accumulate(UpperCAmelCase ): step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # DDP model and model should only be in sync when not (iteration % 2 == 0) for param, ddp_param in zip(model.parameters() , ddp_model.parameters() ): if not param.requires_grad: continue if ((iteration + 1) % 2 == 0) or (iteration == len(UpperCAmelCase ) - 1): # Grads should be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is True ), f'''Gradients not in sync when they should be at iteration {iteration}:\nModel grad ({param.grad}) != DDP grad ({ddp_param.grad})''' else: # Grads should not be in sync assert ( torch.allclose(param.grad , ddp_param.grad ) is False ), f'''Gradients in sync when they should not be at iteration {iteration}:\nModel grad ({param.grad}) == DDP grad ({ddp_param.grad})''' # Shuffle ddp_input on each iteration torch.manual_seed(1_337 + iteration ) UpperCAmelCase : Any = ddp_input[torch.randperm(len(UpperCAmelCase ) )] GradientState._reset_state() def a__ ( UpperCAmelCase : List[str]=False , UpperCAmelCase : List[Any]=False ) -> str: UpperCAmelCase : List[str] = Accelerator( split_batches=UpperCAmelCase , dispatch_batches=UpperCAmelCase , gradient_accumulation_steps=2 ) # Test that context manager behaves properly UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : int = get_training_setup(UpperCAmelCase , UpperCAmelCase ) for iteration, batch in enumerate(UpperCAmelCase ): UpperCAmelCase , UpperCAmelCase : Dict = batch.values() # Gather the distributed inputs and targs for the base model UpperCAmelCase , UpperCAmelCase : List[str] = accelerator.gather((ddp_input, ddp_target) ) UpperCAmelCase , UpperCAmelCase : Dict = input.to(accelerator.device ), target.to(accelerator.device ) # Perform our initial ground truth step in non "DDP" model.train() ddp_model.train() step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) opt.step() if ((iteration + 1) % 2 == 0) or ((iteration + 1) == len(UpperCAmelCase )): if split_batches: sched.step() else: for _ in range(accelerator.num_processes ): sched.step() opt.zero_grad() # Perform gradient accumulation under wrapper with accelerator.accumulate(UpperCAmelCase ): step_model(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) ddp_opt.step() ddp_sched.step() ddp_opt.zero_grad() # Learning rates should be the same assert ( opt.param_groups[0]["lr"] == ddp_opt.param_groups[0]["lr"] ), f'''Learning rates found in each optimizer did not align\nopt: {opt.param_groups[0]["lr"]}\nDDP opt: {ddp_opt.param_groups[0]["lr"]}\n''' UpperCAmelCase : Any = (((iteration + 1) % 2) == 0) or ((iteration + 1) == len(UpperCAmelCase )) if accelerator.num_processes > 1: check_model_parameters(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # Shuffle ddp_input on each iteration torch.manual_seed(1_337 + iteration ) GradientState._reset_state() def a__ ( ) -> Dict: UpperCAmelCase : Union[str, Any] = Accelerator() UpperCAmelCase : Optional[Any] = RegressionDataset(length=80 ) UpperCAmelCase : Any = DataLoader(UpperCAmelCase , batch_size=16 ) UpperCAmelCase : List[str] = RegressionDataset(length=96 ) UpperCAmelCase : List[Any] = DataLoader(UpperCAmelCase , batch_size=16 ) UpperCAmelCase , UpperCAmelCase : str = accelerator.prepare(UpperCAmelCase , UpperCAmelCase ) assert accelerator.gradient_state.active_dataloader is None for iteration, _ in enumerate(UpperCAmelCase ): assert id(accelerator.gradient_state.active_dataloader ) == id(UpperCAmelCase ) if iteration < len(UpperCAmelCase ) - 1: assert not accelerator.gradient_state.end_of_dataloader if iteration == 1: for batch_num, _ in enumerate(UpperCAmelCase ): assert id(accelerator.gradient_state.active_dataloader ) == id(UpperCAmelCase ) if batch_num < len(UpperCAmelCase ) - 1: assert not accelerator.gradient_state.end_of_dataloader else: assert accelerator.gradient_state.end_of_dataloader else: assert accelerator.gradient_state.end_of_dataloader assert accelerator.gradient_state.active_dataloader is None def a__ ( ) -> List[str]: UpperCAmelCase : Optional[Any] = Accelerator() UpperCAmelCase : Optional[Any] = accelerator.state if state.local_process_index == 0: print('''**Test `accumulate` gradient accumulation with dataloader break**''' ) test_dataloader_break() if state.distributed_type == DistributedType.NO: if state.local_process_index == 0: print('''**Test NOOP `no_sync` context manager**''' ) test_noop_sync(UpperCAmelCase ) if state.distributed_type in (DistributedType.MULTI_GPU, DistributedType.MULTI_CPU): if state.local_process_index == 0: print('''**Test Distributed `no_sync` context manager**''' ) test_distributed_sync(UpperCAmelCase ) if state.distributed_type == DistributedType.MULTI_GPU: for split_batch in [True, False]: for dispatch_batches in [True, False]: if state.local_process_index == 0: print( '''**Test `accumulate` gradient accumulation, ''' , f'''`split_batches={split_batch}` and `dispatch_batches={dispatch_batches}`**''' , ) test_gradient_accumulation(UpperCAmelCase , UpperCAmelCase ) # Currently will break on torch 2.0 +, need to investigate why if is_torch_version('''<''' , '''2.0''' ) or state.distributed_type == DistributedType.NO: if state.local_process_index == 0: print( '''**Test `accumulate` gradient accumulation with optimizer and scheduler, ''' , '''`split_batches=False`, `dispatch_batches=False`**''' , ) test_gradient_accumulation_with_opt_and_scheduler() if state.distributed_type == DistributedType.MULTI_GPU: for split_batch in [True, False]: for dispatch_batches in [True, False]: if not split_batch and not dispatch_batches: continue if state.local_process_index == 0: print( '''**Test `accumulate` gradient accumulation with optimizer and scheduler, ''' , f'''`split_batches={split_batch}` and `dispatch_batches={dispatch_batches}`**''' , ) test_gradient_accumulation_with_opt_and_scheduler(UpperCAmelCase , UpperCAmelCase ) def a__ ( UpperCAmelCase : Any ) -> List[Any]: # For xla_spawn (TPUs) main() if __name__ == "__main__": main()
336
import inspect import unittest from transformers import MobileNetVaConfig 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 transformers import MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation, MobileNetVaModel from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import MobileNetVaImageProcessor class __UpperCAmelCase ( lowerCamelCase__ ): def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : str = self.config_class(**self.inputs_dict ) self.parent.assertTrue(hasattr(__A, '''tf_padding''' ) ) self.parent.assertTrue(hasattr(__A, '''depth_multiplier''' ) ) class __UpperCAmelCase : def __init__( self : int, __A : List[Any], __A : str=1_3, __A : Dict=3, __A : int=3_2, __A : int=0.2_5, __A : List[str]=8, __A : int=8, __A : Dict=6, __A : str=3_2, __A : Any=True, __A : str=True, __A : int=True, __A : Union[str, Any]="relu6", __A : Any=1_2_8_0, __A : List[Any]=0.1, __A : Optional[Any]=0.0_2, __A : Tuple=True, __A : List[Any]=True, __A : str=1_0, __A : Optional[Any]=None, ): UpperCAmelCase : Optional[int] = parent UpperCAmelCase : List[str] = batch_size UpperCAmelCase : List[str] = num_channels UpperCAmelCase : str = image_size UpperCAmelCase : Optional[int] = depth_multiplier UpperCAmelCase : Union[str, Any] = depth_divisible_by UpperCAmelCase : Optional[Any] = min_depth UpperCAmelCase : List[str] = expand_ratio UpperCAmelCase : Dict = tf_padding UpperCAmelCase : str = output_stride UpperCAmelCase : Union[str, Any] = first_layer_is_expansion UpperCAmelCase : List[Any] = finegrained_output UpperCAmelCase : Optional[Any] = hidden_act UpperCAmelCase : str = last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier ) UpperCAmelCase : Optional[Any] = classifier_dropout_prob UpperCAmelCase : Dict = use_labels UpperCAmelCase : List[str] = is_training UpperCAmelCase : Tuple = num_labels UpperCAmelCase : Union[str, Any] = initializer_range UpperCAmelCase : Any = scope def __magic_name__ ( self : List[Any] ): UpperCAmelCase : List[str] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : Dict = None UpperCAmelCase : Any = None if self.use_labels: UpperCAmelCase : Dict = ids_tensor([self.batch_size], self.num_labels ) UpperCAmelCase : Optional[int] = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels ) UpperCAmelCase : Optional[Any] = self.get_config() return config, pixel_values, labels, pixel_labels def __magic_name__ ( self : Any ): return MobileNetVaConfig( num_channels=self.num_channels, image_size=self.image_size, depth_multiplier=self.depth_multiplier, depth_divisible_by=self.depth_divisible_by, min_depth=self.min_depth, expand_ratio=self.expand_ratio, output_stride=self.output_stride, first_layer_is_expansion=self.first_layer_is_expansion, finegrained_output=self.finegrained_output, hidden_act=self.hidden_act, tf_padding=self.tf_padding, classifier_dropout_prob=self.classifier_dropout_prob, initializer_range=self.initializer_range, ) def __magic_name__ ( self : List[Any], __A : Dict, __A : Optional[Any], __A : Optional[int], __A : Union[str, Any] ): UpperCAmelCase : Any = MobileNetVaModel(config=__A ) model.to(__A ) model.eval() UpperCAmelCase : Optional[Any] = model(__A ) self.parent.assertEqual( result.last_hidden_state.shape, ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) self.parent.assertEqual( result.pooler_output.shape, (self.batch_size, self.last_hidden_size), ) def __magic_name__ ( self : str, __A : Union[str, Any], __A : Dict, __A : Optional[Any], __A : str ): UpperCAmelCase : Optional[int] = self.num_labels UpperCAmelCase : Any = MobileNetVaForImageClassification(__A ) model.to(__A ) model.eval() UpperCAmelCase : Optional[int] = model(__A, labels=__A ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels) ) def __magic_name__ ( self : List[Any], __A : Optional[Any], __A : List[str], __A : Dict, __A : Dict ): UpperCAmelCase : Tuple = self.num_labels UpperCAmelCase : Dict = MobileNetVaForSemanticSegmentation(__A ) model.to(__A ) model.eval() UpperCAmelCase : Dict = model(__A ) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) UpperCAmelCase : Optional[Any] = model(__A, labels=__A ) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def __magic_name__ ( self : Tuple ): UpperCAmelCase : List[str] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : int = config_and_inputs UpperCAmelCase : Optional[int] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = ( (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation) if is_torch_available() else () ) UpperCamelCase = ( { """feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification, """image-segmentation""": MobileNetVaForSemanticSegmentation, } if is_torch_available() else {} ) UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : List[Any] = MobileNetVaModelTester(self ) UpperCAmelCase : List[Any] = MobileNetVaConfigTester(self, config_class=__A, has_text_modality=__A ) def __magic_name__ ( self : Tuple ): self.config_tester.run_common_tests() @unittest.skip(reason='''MobileNetV2 does not use inputs_embeds''' ) def __magic_name__ ( self : Optional[int] ): pass @unittest.skip(reason='''MobileNetV2 does not support input and output embeddings''' ) def __magic_name__ ( self : Tuple ): pass @unittest.skip(reason='''MobileNetV2 does not output attentions''' ) def __magic_name__ ( self : Any ): pass def __magic_name__ ( self : Optional[int] ): UpperCAmelCase , UpperCAmelCase : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Optional[Any] = model_class(__A ) UpperCAmelCase : Optional[int] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : Union[str, Any] = [*signature.parameters.keys()] UpperCAmelCase : Any = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : List[Any] ): UpperCAmelCase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : int ): def check_hidden_states_output(__A : Any, __A : Optional[Any], __A : str ): UpperCAmelCase : Union[str, Any] = model_class(__A ) model.to(__A ) model.eval() with torch.no_grad(): UpperCAmelCase : Dict = model(**self._prepare_for_class(__A, __A ) ) UpperCAmelCase : Optional[Any] = outputs.hidden_states UpperCAmelCase : List[Any] = 1_6 self.assertEqual(len(__A ), __A ) UpperCAmelCase , UpperCAmelCase : int = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Tuple = True check_hidden_states_output(__A, __A, __A ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] UpperCAmelCase : Tuple = True check_hidden_states_output(__A, __A, __A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__A ) def __magic_name__ ( self : int ): UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__A ) @slow def __magic_name__ ( self : Dict ): for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase : Optional[Any] = MobileNetVaModel.from_pretrained(__A ) self.assertIsNotNone(__A ) def a__ ( ) -> int: UpperCAmelCase : Dict = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_torch @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : List[Any] ): return ( MobileNetVaImageProcessor.from_pretrained('''google/mobilenet_v2_1.0_224''' ) if is_vision_available() else None ) @slow def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : List[Any] = MobileNetVaForImageClassification.from_pretrained('''google/mobilenet_v2_1.0_224''' ).to(__A ) UpperCAmelCase : Optional[int] = self.default_image_processor UpperCAmelCase : Optional[Any] = prepare_img() UpperCAmelCase : Dict = image_processor(images=__A, return_tensors='''pt''' ).to(__A ) # forward pass with torch.no_grad(): UpperCAmelCase : str = model(**__A ) # verify the logits UpperCAmelCase : int = torch.Size((1, 1_0_0_1) ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : Tuple = torch.tensor([0.2_4_4_5, -1.1_9_9_3, 0.1_9_0_5] ).to(__A ) self.assertTrue(torch.allclose(outputs.logits[0, :3], __A, atol=1E-4 ) ) @slow def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Tuple = MobileNetVaForSemanticSegmentation.from_pretrained('''google/deeplabv3_mobilenet_v2_1.0_513''' ) UpperCAmelCase : List[Any] = model.to(__A ) UpperCAmelCase : Tuple = MobileNetVaImageProcessor.from_pretrained('''google/deeplabv3_mobilenet_v2_1.0_513''' ) UpperCAmelCase : List[Any] = prepare_img() UpperCAmelCase : int = image_processor(images=__A, return_tensors='''pt''' ).to(__A ) # forward pass with torch.no_grad(): UpperCAmelCase : Union[str, Any] = model(**__A ) UpperCAmelCase : Optional[Any] = outputs.logits # verify the logits UpperCAmelCase : Tuple = torch.Size((1, 2_1, 6_5, 6_5) ) self.assertEqual(logits.shape, __A ) UpperCAmelCase : Tuple = torch.tensor( [ [[1_7.5_7_9_0, 1_7.7_5_8_1, 1_8.3_3_5_5], [1_8.3_2_5_7, 1_8.4_2_3_0, 1_8.8_9_7_3], [1_8.6_1_6_9, 1_8.8_6_5_0, 1_9.2_1_8_7]], [[-2.1_5_9_5, -2.0_9_7_7, -2.3_7_4_1], [-2.4_2_2_6, -2.3_0_2_8, -2.6_8_3_5], [-2.7_8_1_9, -2.5_9_9_1, -2.7_7_0_6]], [[4.2_0_5_8, 4.8_3_1_7, 4.7_6_3_8], [4.4_1_3_6, 5.0_3_6_1, 4.9_3_8_3], [4.5_0_2_8, 4.9_6_4_4, 4.8_7_3_4]], ], device=__A, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], __A, atol=1E-4 ) )
336
1
from collections import defaultdict def a__ ( UpperCAmelCase : int ) -> int: UpperCAmelCase : Any = 1 UpperCAmelCase : Dict = True for v in tree[start]: if v not in visited: ret += dfs(UpperCAmelCase ) if ret % 2 == 0: cuts.append(UpperCAmelCase ) return ret def a__ ( ) -> Tuple: dfs(1 ) if __name__ == "__main__": _lowerCamelCase , _lowerCamelCase : Dict = 1_0, 9 _lowerCamelCase : Union[str, Any] = defaultdict(list) _lowerCamelCase : dict[int, bool] = {} _lowerCamelCase : list[int] = [] _lowerCamelCase : Dict = 0 _lowerCamelCase : Dict = [(2, 1), (3, 1), (4, 3), (5, 2), (6, 1), (7, 2), (8, 6), (9, 8), (1_0, 8)] for u, v in edges: tree[u].append(v) tree[v].append(u) even_tree() print(len(cuts) - 1)
336
from collections import OrderedDict from typing import Any, List, Mapping, Optional from ... import PreTrainedTokenizer, TensorType, is_torch_available from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfigWithPast, PatchingSpec from ...utils import logging _lowerCamelCase : str = logging.get_logger(__name__) _lowerCamelCase : Optional[int] = { "Salesforce/codegen-350M-nl": "https://huggingface.co/Salesforce/codegen-350M-nl/resolve/main/config.json", "Salesforce/codegen-350M-multi": "https://huggingface.co/Salesforce/codegen-350M-multi/resolve/main/config.json", "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/config.json", "Salesforce/codegen-2B-nl": "https://huggingface.co/Salesforce/codegen-2B-nl/resolve/main/config.json", "Salesforce/codegen-2B-multi": "https://huggingface.co/Salesforce/codegen-2B-multi/resolve/main/config.json", "Salesforce/codegen-2B-mono": "https://huggingface.co/Salesforce/codegen-2B-mono/resolve/main/config.json", "Salesforce/codegen-6B-nl": "https://huggingface.co/Salesforce/codegen-6B-nl/resolve/main/config.json", "Salesforce/codegen-6B-multi": "https://huggingface.co/Salesforce/codegen-6B-multi/resolve/main/config.json", "Salesforce/codegen-6B-mono": "https://huggingface.co/Salesforce/codegen-6B-mono/resolve/main/config.json", "Salesforce/codegen-16B-nl": "https://huggingface.co/Salesforce/codegen-16B-nl/resolve/main/config.json", "Salesforce/codegen-16B-multi": "https://huggingface.co/Salesforce/codegen-16B-multi/resolve/main/config.json", "Salesforce/codegen-16B-mono": "https://huggingface.co/Salesforce/codegen-16B-mono/resolve/main/config.json", } class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """codegen""" UpperCamelCase = { """max_position_embeddings""": """n_positions""", """hidden_size""": """n_embd""", """num_attention_heads""": """n_head""", """num_hidden_layers""": """n_layer""", } def __init__( self : Any, __A : Optional[int]=5_0_4_0_0, __A : Tuple=2_0_4_8, __A : Optional[int]=2_0_4_8, __A : List[str]=4_0_9_6, __A : List[str]=2_8, __A : Union[str, Any]=1_6, __A : Tuple=6_4, __A : Union[str, Any]=None, __A : Union[str, Any]="gelu_new", __A : Any=0.0, __A : Dict=0.0, __A : str=0.0, __A : Optional[int]=1E-5, __A : Any=0.0_2, __A : Any=True, __A : Union[str, Any]=5_0_2_5_6, __A : List[str]=5_0_2_5_6, __A : int=False, **__A : List[Any], ): UpperCAmelCase : int = vocab_size UpperCAmelCase : Tuple = n_ctx UpperCAmelCase : Tuple = n_positions UpperCAmelCase : Optional[int] = n_embd UpperCAmelCase : Union[str, Any] = n_layer UpperCAmelCase : List[str] = n_head UpperCAmelCase : Tuple = n_inner UpperCAmelCase : int = rotary_dim UpperCAmelCase : List[Any] = activation_function UpperCAmelCase : List[str] = resid_pdrop UpperCAmelCase : Optional[Any] = embd_pdrop UpperCAmelCase : str = attn_pdrop UpperCAmelCase : Tuple = layer_norm_epsilon UpperCAmelCase : Dict = initializer_range UpperCAmelCase : Union[str, Any] = use_cache UpperCAmelCase : Any = bos_token_id UpperCAmelCase : List[str] = eos_token_id super().__init__( bos_token_id=__A, eos_token_id=__A, tie_word_embeddings=__A, **__A ) class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Any, __A : PretrainedConfig, __A : str = "default", __A : List[PatchingSpec] = None, __A : bool = False, ): super().__init__(__A, task=__A, patching_specs=__A, use_past=__A ) if not getattr(self._config, '''pad_token_id''', __A ): # TODO: how to do that better? UpperCAmelCase : Union[str, Any] = 0 @property def __magic_name__ ( self : str ): UpperCAmelCase : Union[str, Any] = OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}} ) if self.use_past: self.fill_with_past_key_values_(__A, direction='''inputs''' ) UpperCAmelCase : int = {0: '''batch''', 1: '''past_sequence + sequence'''} else: UpperCAmelCase : List[Any] = {0: '''batch''', 1: '''sequence'''} return common_inputs @property def __magic_name__ ( self : Dict ): return self._config.n_layer @property def __magic_name__ ( self : List[str] ): return self._config.n_head def __magic_name__ ( self : str, __A : PreTrainedTokenizer, __A : int = -1, __A : int = -1, __A : bool = False, __A : Optional[TensorType] = None, ): UpperCAmelCase : Union[str, Any] = super(__A, self ).generate_dummy_inputs( __A, batch_size=__A, seq_length=__A, is_pair=__A, framework=__A ) # We need to order the input in the way they appears in the forward() UpperCAmelCase : Union[str, Any] = OrderedDict({'''input_ids''': common_inputs['''input_ids''']} ) # Need to add the past_keys if self.use_past: if not is_torch_available(): raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.''' ) else: import torch UpperCAmelCase , UpperCAmelCase : str = common_inputs['''input_ids'''].shape # Not using the same length for past_key_values UpperCAmelCase : str = seqlen + 2 UpperCAmelCase : Optional[int] = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) UpperCAmelCase : Optional[int] = [ (torch.zeros(__A ), torch.zeros(__A )) for _ in range(self.num_layers ) ] UpperCAmelCase : Union[str, Any] = common_inputs['''attention_mask'''] if self.use_past: UpperCAmelCase : Optional[Any] = ordered_inputs['''attention_mask'''].dtype UpperCAmelCase : Dict = torch.cat( [ordered_inputs['''attention_mask'''], torch.ones(__A, __A, dtype=__A )], dim=1 ) return ordered_inputs @property def __magic_name__ ( self : Tuple ): return 1_3
336
1
import unittest from pathlib import Path from tempfile import TemporaryDirectory from transformers import AutoConfig, TFAutoModel, is_tensorflow_text_available, is_tf_available from transformers.models.bert.tokenization_bert import BertTokenizer from transformers.testing_utils import require_tensorflow_text, require_tf, slow if is_tf_available(): import tensorflow as tf if is_tensorflow_text_available(): from transformers.models.bert import TFBertTokenizer _lowerCamelCase : List[Any] = ["bert-base-uncased", "bert-base-cased"] _lowerCamelCase : int = "hf-internal-testing/tiny-bert-tf-only" if is_tf_available(): class __UpperCAmelCase ( tf.keras.Model ): def __init__( self : List[Any], __A : Dict ): super().__init__() UpperCAmelCase : Optional[Any] = tokenizer UpperCAmelCase : Any = AutoConfig.from_pretrained(__A ) UpperCAmelCase : str = TFAutoModel.from_config(__A ) def __magic_name__ ( self : Union[str, Any], __A : Tuple ): UpperCAmelCase : List[Any] = self.tokenizer(__A ) UpperCAmelCase : Tuple = self.bert(**__A ) return out["pooler_output"] @require_tf @require_tensorflow_text class __UpperCAmelCase ( unittest.TestCase ): def __magic_name__ ( self : Optional[Any] ): super().setUp() UpperCAmelCase : List[Any] = [ BertTokenizer.from_pretrained(__A ) for checkpoint in (TOKENIZER_CHECKPOINTS * 2) ] # repeat for when fast_bert_tokenizer=false UpperCAmelCase : List[str] = [TFBertTokenizer.from_pretrained(__A ) for checkpoint in TOKENIZER_CHECKPOINTS] + [ TFBertTokenizer.from_pretrained(__A, use_fast_bert_tokenizer=__A ) for checkpoint in TOKENIZER_CHECKPOINTS ] assert len(self.tokenizers ) == len(self.tf_tokenizers ) UpperCAmelCase : Any = [ '''This is a straightforward English test sentence.''', '''This one has some weird characters\rto\nsee\r\nif those\u00E9break things.''', '''Now we\'re going to add some Chinese: 一 二 三 一二三''', '''And some much more rare Chinese: 齉 堃 齉堃''', '''Je vais aussi écrire en français pour tester les accents''', '''Classical Irish also has some unusual characters, so in they go: Gaelaċ, ꝼ''', ] UpperCAmelCase : Tuple = list(zip(self.test_sentences, self.test_sentences[::-1] ) ) def __magic_name__ ( self : List[str] ): for tokenizer, tf_tokenizer in zip(self.tokenizers, self.tf_tokenizers ): for test_inputs in (self.test_sentences, self.paired_sentences): UpperCAmelCase : Optional[Any] = tokenizer(__A, return_tensors='''tf''', padding='''longest''' ) UpperCAmelCase : List[str] = tf_tokenizer(__A ) for key in python_outputs.keys(): self.assertTrue(tf.reduce_all(python_outputs[key].shape == tf_outputs[key].shape ) ) self.assertTrue(tf.reduce_all(tf.cast(python_outputs[key], tf.intaa ) == tf_outputs[key] ) ) @slow def __magic_name__ ( self : Optional[int] ): for tf_tokenizer in self.tf_tokenizers: UpperCAmelCase : Dict = tf_tokenizer(self.paired_sentences ) UpperCAmelCase : List[Any] = tf_tokenizer( text=[sentence[0] for sentence in self.paired_sentences], text_pair=[sentence[1] for sentence in self.paired_sentences], ) for key in merged_outputs.keys(): self.assertTrue(tf.reduce_all(tf.cast(merged_outputs[key], tf.intaa ) == separated_outputs[key] ) ) @slow def __magic_name__ ( self : Any ): for tf_tokenizer in self.tf_tokenizers: UpperCAmelCase : List[str] = tf.function(__A ) for test_inputs in (self.test_sentences, self.paired_sentences): UpperCAmelCase : int = tf.constant(__A ) UpperCAmelCase : List[str] = compiled_tokenizer(__A ) UpperCAmelCase : Optional[int] = tf_tokenizer(__A ) for key in eager_outputs.keys(): self.assertTrue(tf.reduce_all(eager_outputs[key] == compiled_outputs[key] ) ) @slow def __magic_name__ ( self : Any ): for tf_tokenizer in self.tf_tokenizers: UpperCAmelCase : List[str] = ModelToSave(tokenizer=__A ) UpperCAmelCase : Optional[Any] = tf.convert_to_tensor(self.test_sentences ) UpperCAmelCase : Any = model(__A ) # Build model with some sample inputs with TemporaryDirectory() as tempdir: UpperCAmelCase : Dict = Path(__A ) / '''saved.model''' model.save(__A ) UpperCAmelCase : Tuple = tf.keras.models.load_model(__A ) UpperCAmelCase : Optional[Any] = loaded_model(__A ) # We may see small differences because the loaded model is compiled, so we need an epsilon for the test self.assertLessEqual(tf.reduce_max(tf.abs(out - loaded_output ) ), 1E-5 )
336
# limitations under the License. # NOTE: This file is deprecated and will be removed in a future version. # It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works from .pipelines import DiffusionPipeline, ImagePipelineOutput # noqa: F401 from .utils import deprecate deprecate( "pipelines_utils", "0.22.0", "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.", standard_warn=False, stacklevel=3, )
336
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available, is_vision_available, ) _lowerCamelCase : Tuple = {"configuration_deit": ["DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DeiTConfig", "DeiTOnnxConfig"]} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : str = ["DeiTFeatureExtractor"] _lowerCamelCase : List[Any] = ["DeiTImageProcessor"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[int] = [ "DEIT_PRETRAINED_MODEL_ARCHIVE_LIST", "DeiTForImageClassification", "DeiTForImageClassificationWithTeacher", "DeiTForMaskedImageModeling", "DeiTModel", "DeiTPreTrainedModel", ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Any = [ "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 _lowerCamelCase : List[str] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
from dataclasses import dataclass from typing import Optional, Tuple, Union import flax import jax.numpy as jnp from jax import random from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput from .scheduling_utils_flax import FlaxSchedulerMixin @flax.struct.dataclass class __UpperCAmelCase : # setable values UpperCamelCase = None UpperCamelCase = None UpperCamelCase = None # sigma(t_i) @classmethod def __magic_name__ ( cls : Any ): return cls() @dataclass class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 42 class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ ): @property def __magic_name__ ( self : Optional[int] ): return True @register_to_config def __init__( self : Optional[int], __A : float = 0.0_2, __A : float = 1_0_0, __A : float = 1.0_0_7, __A : float = 8_0, __A : float = 0.0_5, __A : float = 5_0, ): pass def __magic_name__ ( self : Optional[Any] ): return KarrasVeSchedulerState.create() def __magic_name__ ( self : int, __A : KarrasVeSchedulerState, __A : int, __A : Tuple = () ): UpperCAmelCase : Optional[Any] = jnp.arange(0, __A )[::-1].copy() UpperCAmelCase : Union[str, Any] = [ ( self.config.sigma_max**2 * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1)) ) for i in timesteps ] return state.replace( num_inference_steps=__A, schedule=jnp.array(__A, dtype=jnp.floataa ), timesteps=__A, ) def __magic_name__ ( self : List[Any], __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : random.KeyArray, ): if self.config.s_min <= sigma <= self.config.s_max: UpperCAmelCase : int = min(self.config.s_churn / state.num_inference_steps, 2**0.5 - 1 ) else: UpperCAmelCase : Optional[int] = 0 # sample eps ~ N(0, S_noise^2 * I) UpperCAmelCase : Union[str, Any] = random.split(__A, num=1 ) UpperCAmelCase : List[str] = self.config.s_noise * random.normal(key=__A, shape=sample.shape ) UpperCAmelCase : Tuple = sigma + gamma * sigma UpperCAmelCase : List[str] = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps) return sample_hat, sigma_hat def __magic_name__ ( self : Tuple, __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : float, __A : jnp.ndarray, __A : bool = True, ): UpperCAmelCase : int = sample_hat + sigma_hat * model_output UpperCAmelCase : Dict = (sample_hat - pred_original_sample) / sigma_hat UpperCAmelCase : int = sample_hat + (sigma_prev - sigma_hat) * derivative if not return_dict: return (sample_prev, derivative, state) return FlaxKarrasVeOutput(prev_sample=__A, derivative=__A, state=__A ) def __magic_name__ ( self : Tuple, __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : float, __A : jnp.ndarray, __A : jnp.ndarray, __A : jnp.ndarray, __A : bool = True, ): UpperCAmelCase : Tuple = sample_prev + sigma_prev * model_output UpperCAmelCase : List[str] = (sample_prev - pred_original_sample) / sigma_prev UpperCAmelCase : Union[str, Any] = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr) if not return_dict: return (sample_prev, derivative, state) return FlaxKarrasVeOutput(prev_sample=__A, derivative=__A, state=__A ) def __magic_name__ ( self : Optional[Any], __A : KarrasVeSchedulerState, __A : Optional[int], __A : int, __A : Union[str, Any] ): raise NotImplementedError()
336
1
import json import os import shutil import tempfile import unittest import numpy as np import pytest from transformers import CLIPTokenizer, CLIPTokenizerFast from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES from transformers.testing_utils import require_vision from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available if is_vision_available(): from PIL import Image from transformers import CLIPImageProcessor, CLIPProcessor @require_vision class __UpperCAmelCase ( unittest.TestCase ): def __magic_name__ ( self : Dict ): UpperCAmelCase : Any = tempfile.mkdtemp() # fmt: off UpperCAmelCase : Tuple = ['''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>'''] # fmt: on UpperCAmelCase : Optional[int] = dict(zip(__A, range(len(__A ) ) ) ) UpperCAmelCase : List[str] = ['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', ''''''] UpperCAmelCase : int = {'''unk_token''': '''<unk>'''} UpperCAmelCase : List[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: fp.write(json.dumps(__A ) + '''\n''' ) with open(self.merges_file, '''w''', encoding='''utf-8''' ) as fp: fp.write('''\n'''.join(__A ) ) UpperCAmelCase : List[Any] = { '''do_resize''': True, '''size''': 2_0, '''do_center_crop''': True, '''crop_size''': 1_8, '''do_normalize''': True, '''image_mean''': [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3], '''image_std''': [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1], } UpperCAmelCase : str = os.path.join(self.tmpdirname, __A ) with open(self.image_processor_file, '''w''', encoding='''utf-8''' ) as fp: json.dump(__A, __A ) def __magic_name__ ( self : Any, **__A : Any ): return CLIPTokenizer.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : List[Any], **__A : Union[str, Any] ): return CLIPTokenizerFast.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Tuple, **__A : Dict ): return CLIPImageProcessor.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Tuple ): shutil.rmtree(self.tmpdirname ) def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : Optional[Any] = [np.random.randint(2_5_5, size=(3, 3_0, 4_0_0), dtype=np.uinta )] UpperCAmelCase : List[Any] = [Image.fromarray(np.moveaxis(__A, 0, -1 ) ) for x in image_inputs] return image_inputs def __magic_name__ ( self : Tuple ): UpperCAmelCase : Tuple = self.get_tokenizer() UpperCAmelCase : Any = self.get_rust_tokenizer() UpperCAmelCase : Any = self.get_image_processor() UpperCAmelCase : str = CLIPProcessor(tokenizer=__A, image_processor=__A ) processor_slow.save_pretrained(self.tmpdirname ) UpperCAmelCase : int = CLIPProcessor.from_pretrained(self.tmpdirname, use_fast=__A ) UpperCAmelCase : Union[str, Any] = CLIPProcessor(tokenizer=__A, image_processor=__A ) processor_fast.save_pretrained(self.tmpdirname ) UpperCAmelCase : Any = CLIPProcessor.from_pretrained(self.tmpdirname ) self.assertEqual(processor_slow.tokenizer.get_vocab(), tokenizer_slow.get_vocab() ) self.assertEqual(processor_fast.tokenizer.get_vocab(), tokenizer_fast.get_vocab() ) self.assertEqual(tokenizer_slow.get_vocab(), tokenizer_fast.get_vocab() ) self.assertIsInstance(processor_slow.tokenizer, __A ) self.assertIsInstance(processor_fast.tokenizer, __A ) self.assertEqual(processor_slow.image_processor.to_json_string(), image_processor.to_json_string() ) self.assertEqual(processor_fast.image_processor.to_json_string(), image_processor.to_json_string() ) self.assertIsInstance(processor_slow.image_processor, __A ) self.assertIsInstance(processor_fast.image_processor, __A ) def __magic_name__ ( self : str ): UpperCAmelCase : List[str] = CLIPProcessor(tokenizer=self.get_tokenizer(), image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) UpperCAmelCase : Union[str, Any] = self.get_tokenizer(bos_token='''(BOS)''', eos_token='''(EOS)''' ) UpperCAmelCase : Optional[int] = self.get_image_processor(do_normalize=__A, padding_value=1.0 ) UpperCAmelCase : List[str] = CLIPProcessor.from_pretrained( self.tmpdirname, bos_token='''(BOS)''', eos_token='''(EOS)''', do_normalize=__A, padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab(), tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer, __A ) self.assertEqual(processor.image_processor.to_json_string(), image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor, __A ) def __magic_name__ ( self : Tuple ): UpperCAmelCase : Any = self.get_image_processor() UpperCAmelCase : Union[str, Any] = self.get_tokenizer() UpperCAmelCase : Tuple = CLIPProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : List[str] = self.prepare_image_inputs() UpperCAmelCase : List[str] = image_processor(__A, return_tensors='''np''' ) UpperCAmelCase : Dict = processor(images=__A, return_tensors='''np''' ) for key in input_image_proc.keys(): self.assertAlmostEqual(input_image_proc[key].sum(), input_processor[key].sum(), delta=1E-2 ) def __magic_name__ ( self : int ): UpperCAmelCase : Tuple = self.get_image_processor() UpperCAmelCase : Any = self.get_tokenizer() UpperCAmelCase : str = CLIPProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : List[Any] = '''lower newer''' UpperCAmelCase : Optional[int] = processor(text=__A ) UpperCAmelCase : Optional[int] = tokenizer(__A ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key], encoded_processor[key] ) def __magic_name__ ( self : List[Any] ): UpperCAmelCase : str = self.get_image_processor() UpperCAmelCase : Union[str, Any] = self.get_tokenizer() UpperCAmelCase : List[str] = CLIPProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Optional[int] = '''lower newer''' UpperCAmelCase : List[str] = self.prepare_image_inputs() UpperCAmelCase : str = processor(text=__A, images=__A ) self.assertListEqual(list(inputs.keys() ), ['''input_ids''', '''attention_mask''', '''pixel_values'''] ) # test if it raises when no input is passed with pytest.raises(__A ): processor() def __magic_name__ ( self : Dict ): UpperCAmelCase : List[Any] = self.get_image_processor() UpperCAmelCase : Optional[Any] = self.get_tokenizer() UpperCAmelCase : Union[str, Any] = CLIPProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : str = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] UpperCAmelCase : Optional[int] = processor.batch_decode(__A ) UpperCAmelCase : Dict = tokenizer.batch_decode(__A ) self.assertListEqual(__A, __A ) def __magic_name__ ( self : int ): UpperCAmelCase : Optional[Any] = self.get_image_processor() UpperCAmelCase : Dict = self.get_tokenizer() UpperCAmelCase : List[str] = CLIPProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : List[Any] = '''lower newer''' UpperCAmelCase : Union[str, Any] = self.prepare_image_inputs() UpperCAmelCase : List[str] = processor(text=__A, images=__A ) self.assertListEqual(list(inputs.keys() ), processor.model_input_names )
336
import os import sys from contextlib import contextmanager # Windows only if os.name == "nt": import ctypes import msvcrt # noqa class __UpperCAmelCase ( ctypes.Structure ): # _fields is a specific attr expected by ctypes UpperCamelCase = [("""size""", ctypes.c_int), ("""visible""", ctypes.c_byte)] def a__ ( ) -> Dict: if os.name == "nt": UpperCAmelCase : List[str] = CursorInfo() UpperCAmelCase : List[Any] = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) UpperCAmelCase : Dict = False ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) elif os.name == "posix": sys.stdout.write('''\033[?25l''' ) sys.stdout.flush() def a__ ( ) -> Optional[int]: if os.name == "nt": UpperCAmelCase : int = CursorInfo() UpperCAmelCase : int = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) UpperCAmelCase : Any = True ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) elif os.name == "posix": sys.stdout.write('''\033[?25h''' ) sys.stdout.flush() @contextmanager def a__ ( ) -> Optional[Any]: try: hide_cursor() yield finally: show_cursor()
336
1
import argparse import os import torch from transformers import FlavaImageCodebook, FlavaImageCodebookConfig def a__ ( UpperCAmelCase : int , UpperCAmelCase : str , UpperCAmelCase : List[Any] , UpperCAmelCase : Optional[Any] ) -> str: UpperCAmelCase : Tuple = s.rsplit(UpperCAmelCase , UpperCAmelCase ) return new.join(UpperCAmelCase ) def a__ ( UpperCAmelCase : str ) -> int: # 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__ ( UpperCAmelCase : List[str] ) -> List[Any]: UpperCAmelCase : Dict = {} UpperCAmelCase : int = ['''group_1''', '''group_2''', '''group_3''', '''group_4'''] for key, value in state_dict.items(): for group_key in group_keys: if group_key in key: UpperCAmelCase : Optional[Any] = key.replace(f'''{group_key}.''' , f'''{group_key}.group.''' ) if "res_path" in key: UpperCAmelCase : Dict = key.replace('''res_path.''' , '''res_path.path.''' ) if key.endswith('''.w''' ): UpperCAmelCase : List[Any] = rreplace(UpperCAmelCase , '''.w''' , '''.weight''' , 1 ) if key.endswith('''.b''' ): UpperCAmelCase : int = rreplace(UpperCAmelCase , '''.b''' , '''.bias''' , 1 ) UpperCAmelCase : Any = value.float() return upgrade @torch.no_grad() def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : Dict , UpperCAmelCase : Optional[int]=None , UpperCAmelCase : int=True ) -> Any: from dall_e import Encoder UpperCAmelCase : Optional[int] = Encoder() if os.path.exists(UpperCAmelCase ): UpperCAmelCase : int = torch.load(UpperCAmelCase ) else: UpperCAmelCase : Optional[int] = torch.hub.load_state_dict_from_url(UpperCAmelCase ) if isinstance(UpperCAmelCase , UpperCAmelCase ): UpperCAmelCase : Any = ckpt.state_dict() encoder.load_state_dict(UpperCAmelCase ) if config_path is not None: UpperCAmelCase : str = FlavaImageCodebookConfig.from_pretrained(UpperCAmelCase ) else: UpperCAmelCase : str = FlavaImageCodebookConfig() UpperCAmelCase : Dict = FlavaImageCodebook(UpperCAmelCase ).eval() UpperCAmelCase : Tuple = encoder.state_dict() UpperCAmelCase : Union[str, Any] = upgrade_state_dict(UpperCAmelCase ) hf_model.load_state_dict(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = hf_model.state_dict() UpperCAmelCase : Optional[int] = count_parameters(UpperCAmelCase ) UpperCAmelCase : Tuple = count_parameters(UpperCAmelCase ) assert torch.allclose(UpperCAmelCase , UpperCAmelCase , atol=1E-3 ) if save_checkpoint: hf_model.save_pretrained(UpperCAmelCase ) else: return hf_state_dict if __name__ == "__main__": _lowerCamelCase : 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("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") _lowerCamelCase : List[Any] = parser.parse_args() convert_dalle_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
336
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) _lowerCamelCase : Tuple = { "configuration_encodec": [ "ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP", "EncodecConfig", ], "feature_extraction_encodec": ["EncodecFeatureExtractor"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[Any] = [ "ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST", "EncodecModel", "EncodecPreTrainedModel", ] if TYPE_CHECKING: from .configuration_encodec import ( ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP, EncodecConfig, ) from .feature_extraction_encodec import EncodecFeatureExtractor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_encodec import ( ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST, EncodecModel, EncodecPreTrainedModel, ) else: import sys _lowerCamelCase : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
1
import glob import os import random from string import ascii_lowercase, digits import cva _lowerCamelCase : Dict = "" _lowerCamelCase : Optional[int] = "" _lowerCamelCase : Any = "" _lowerCamelCase : Optional[int] = 1 # (0 is vertical, 1 is horizontal) def a__ ( ) -> None: UpperCAmelCase , UpperCAmelCase : str = get_dataset(UpperCAmelCase , UpperCAmelCase ) print('''Processing...''' ) UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[Any] = update_image_and_anno(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) for index, image in enumerate(UpperCAmelCase ): # Get random string code: '7b7ad245cdff75241935e4dd860f3bad' UpperCAmelCase : int = random_chars(32 ) UpperCAmelCase : int = paths[index].split(os.sep )[-1].rsplit('''.''' , 1 )[0] UpperCAmelCase : List[str] = f'''{OUTPUT_DIR}/{file_name}_FLIP_{letter_code}''' cva.imwrite(f'''/{file_root}.jpg''' , UpperCAmelCase , [cva.IMWRITE_JPEG_QUALITY, 85] ) print(f'''Success {index+1}/{len(UpperCAmelCase )} with {file_name}''' ) UpperCAmelCase : List[str] = [] for anno in new_annos[index]: UpperCAmelCase : str = f'''{anno[0]} {anno[1]} {anno[2]} {anno[3]} {anno[4]}''' annos_list.append(UpperCAmelCase ) with open(f'''/{file_root}.txt''' , '''w''' ) as outfile: outfile.write('''\n'''.join(line for line in annos_list ) ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : str ) -> tuple[list, list]: UpperCAmelCase : Tuple = [] UpperCAmelCase : Union[str, Any] = [] for label_file in glob.glob(os.path.join(UpperCAmelCase , '''*.txt''' ) ): UpperCAmelCase : Optional[Any] = label_file.split(os.sep )[-1].rsplit('''.''' , 1 )[0] with open(UpperCAmelCase ) as in_file: UpperCAmelCase : Any = in_file.readlines() UpperCAmelCase : int = os.path.join(UpperCAmelCase , f'''{label_name}.jpg''' ) UpperCAmelCase : str = [] for obj_list in obj_lists: UpperCAmelCase : str = obj_list.rstrip('''\n''' ).split(''' ''' ) boxes.append( [ int(obj[0] ), float(obj[1] ), float(obj[2] ), float(obj[3] ), float(obj[4] ), ] ) if not boxes: continue img_paths.append(UpperCAmelCase ) labels.append(UpperCAmelCase ) return img_paths, labels def a__ ( UpperCAmelCase : list , UpperCAmelCase : list , UpperCAmelCase : int = 1 ) -> tuple[list, list, list]: UpperCAmelCase : Union[str, Any] = [] UpperCAmelCase : List[str] = [] UpperCAmelCase : Optional[Any] = [] for idx in range(len(UpperCAmelCase ) ): UpperCAmelCase : Dict = [] UpperCAmelCase : int = img_list[idx] path_list.append(UpperCAmelCase ) UpperCAmelCase : int = anno_list[idx] UpperCAmelCase : Any = cva.imread(UpperCAmelCase ) if flip_type == 1: UpperCAmelCase : Any = cva.flip(UpperCAmelCase , UpperCAmelCase ) for bbox in img_annos: UpperCAmelCase : Any = 1 - bbox[1] new_annos.append([bbox[0], x_center_new, bbox[2], bbox[3], bbox[4]] ) elif flip_type == 0: UpperCAmelCase : int = cva.flip(UpperCAmelCase , UpperCAmelCase ) for bbox in img_annos: UpperCAmelCase : str = 1 - bbox[2] new_annos.append([bbox[0], bbox[1], y_center_new, bbox[3], bbox[4]] ) new_annos_lists.append(UpperCAmelCase ) new_imgs_list.append(UpperCAmelCase ) return new_imgs_list, new_annos_lists, path_list def a__ ( UpperCAmelCase : int = 32 ) -> str: assert number_char > 1, "The number of character should greater than 1" UpperCAmelCase : Dict = ascii_lowercase + digits return "".join(random.choice(UpperCAmelCase ) for _ in range(UpperCAmelCase ) ) if __name__ == "__main__": main() print("DONE ✅")
336
from __future__ import annotations def a__ ( UpperCAmelCase : int , UpperCAmelCase : int ) -> list[str]: if partitions <= 0: raise ValueError('''partitions must be a positive number!''' ) if partitions > number_of_bytes: raise ValueError('''partitions can not > number_of_bytes!''' ) UpperCAmelCase : str = number_of_bytes // partitions UpperCAmelCase : Dict = [] for i in range(UpperCAmelCase ): UpperCAmelCase : int = i * bytes_per_partition + 1 UpperCAmelCase : Optional[int] = ( number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition ) allocation_list.append(f'''{start_bytes}-{end_bytes}''' ) return allocation_list if __name__ == "__main__": import doctest doctest.testmod()
336
1
import pprint import requests _lowerCamelCase : Union[str, Any] = "https://zenquotes.io/api" def a__ ( ) -> list: return requests.get(API_ENDPOINT_URL + '''/today''' ).json() def a__ ( ) -> list: return requests.get(API_ENDPOINT_URL + '''/random''' ).json() if __name__ == "__main__": _lowerCamelCase : List[Any] = random_quotes() pprint.pprint(response)
336
# Copyright 2022 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 import subprocess from packaging.version import Version, parse from accelerate.commands.config.config_args import default_config_file, load_config_from_file _lowerCamelCase : Union[str, Any] = "Run commands across TPU VMs for initial setup before running `accelerate launch`." def a__ ( UpperCAmelCase : Dict=None ) -> Optional[int]: if subparsers is not None: UpperCAmelCase : Tuple = subparsers.add_parser('''tpu-config''' , description=_description ) else: UpperCAmelCase : Dict = argparse.ArgumentParser('''Accelerate tpu-config command''' , description=_description ) # Core arguments UpperCAmelCase : Optional[int] = parser.add_argument_group( '''Config Arguments''' , '''Arguments that can be configured through `accelerate config`.''' ) config_args.add_argument( '''--config_file''' , type=UpperCAmelCase , default=UpperCAmelCase , help='''Path to the config file to use for accelerate.''' , ) config_args.add_argument( '''--tpu_name''' , default=UpperCAmelCase , help='''The name of the TPU to use. If not specified, will use the TPU specified in the config file.''' , ) config_args.add_argument( '''--tpu_zone''' , default=UpperCAmelCase , help='''The zone of the TPU to use. If not specified, will use the zone specified in the config file.''' , ) UpperCAmelCase : Union[str, Any] = parser.add_argument_group('''TPU Arguments''' , '''Arguments for options ran inside the TPU.''' ) pod_args.add_argument( '''--use_alpha''' , action='''store_true''' , help='''Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.''' , ) pod_args.add_argument( '''--command_file''' , default=UpperCAmelCase , help='''The path to the file containing the commands to run on the pod on startup.''' , ) pod_args.add_argument( '''--command''' , action='''append''' , nargs='''+''' , help='''A command to run on the pod. Can be passed multiple times.''' , ) pod_args.add_argument( '''--install_accelerate''' , action='''store_true''' , help='''Whether to install accelerate on the pod. Defaults to False.''' , ) pod_args.add_argument( '''--accelerate_version''' , default='''latest''' , help='''The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify \'dev\' to install from GitHub.''' , ) pod_args.add_argument( '''--debug''' , action='''store_true''' , help='''If set, will print the command that would be run instead of running it.''' ) if subparsers is not None: parser.set_defaults(func=UpperCAmelCase ) return parser def a__ ( UpperCAmelCase : Optional[int] ) -> Union[str, Any]: UpperCAmelCase : Union[str, Any] = None # Get the default from the config file if it exists. if args.config_file is not None or os.path.isfile(UpperCAmelCase ): UpperCAmelCase : Union[str, Any] = load_config_from_file(args.config_file ) if not args.command_file and defaults.command_file is not None and not args.command: UpperCAmelCase : List[Any] = defaults.command_file if not args.command and defaults.commands is not None: UpperCAmelCase : List[str] = defaults.commands if not args.tpu_name: UpperCAmelCase : Tuple = defaults.tpu_name if not args.tpu_zone: UpperCAmelCase : int = defaults.tpu_zone if args.accelerate_version == "dev": UpperCAmelCase : Tuple = '''git+https://github.com/huggingface/accelerate.git''' elif args.accelerate_version == "latest": UpperCAmelCase : Dict = '''accelerate -U''' elif isinstance(parse(args.accelerate_version ) , UpperCAmelCase ): UpperCAmelCase : Optional[int] = f'''accelerate=={args.accelerate_version}''' if not args.command_file and not args.command: raise ValueError('''You must specify either a command file or a command to run on the pod.''' ) if args.command_file: with open(args.command_file , '''r''' ) as f: UpperCAmelCase : int = [f.read().splitlines()] # To turn list of lists into list of strings if isinstance(args.command[0] , UpperCAmelCase ): UpperCAmelCase : int = [line for cmd in args.command for line in cmd] # Default to the shared folder and install accelerate UpperCAmelCase : Optional[int] = ['''cd /usr/share'''] if args.install_accelerate: new_cmd += [f'''pip install {args.accelerate_version}'''] new_cmd += args.command UpperCAmelCase : int = '''; '''.join(UpperCAmelCase ) # Then send it to gcloud # Eventually try to use google-api-core to do this instead of subprocess UpperCAmelCase : Any = ['''gcloud'''] if args.use_alpha: cmd += ["alpha"] cmd += [ "compute", "tpus", "tpu-vm", "ssh", args.tpu_name, "--zone", args.tpu_zone, "--command", args.command, "--worker", "all", ] if args.debug: print(f'''Running {" ".join(UpperCAmelCase )}''' ) return subprocess.run(UpperCAmelCase ) print('''Successfully setup pod.''' ) def a__ ( ) -> Any: UpperCAmelCase : Any = tpu_command_parser() UpperCAmelCase : Tuple = parser.parse_args() tpu_command_launcher(UpperCAmelCase )
336
1
def a__ ( ) -> int: return [ a * b * (1_000 - a - b) for a in range(1 , 999 ) for b in range(UpperCAmelCase , 999 ) if (a * a + b * b == (1_000 - a - b) ** 2) ][0] if __name__ == "__main__": print(f"""{solution() = }""")
336
import argparse import collections import json from pathlib import Path import requests import torch import yaml from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( MobileViTImageProcessor, MobileViTVaConfig, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, ) from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : Optional[int] = logging.get_logger(__name__) def a__ ( UpperCAmelCase : Union[str, Any] ) -> Optional[Any]: print('''Loading config file...''' ) def flatten_yaml_as_dict(UpperCAmelCase : Tuple , UpperCAmelCase : Any="" , UpperCAmelCase : Dict="." ): UpperCAmelCase : List[str] = [] for k, v in d.items(): UpperCAmelCase : List[Any] = parent_key + sep + k if parent_key else k if isinstance(UpperCAmelCase , collections.abc.MutableMapping ): items.extend(flatten_yaml_as_dict(UpperCAmelCase , UpperCAmelCase , sep=UpperCAmelCase ).items() ) else: items.append((new_key, v) ) return dict(UpperCAmelCase ) UpperCAmelCase : List[str] = argparse.Namespace() with open(UpperCAmelCase , '''r''' ) as yaml_file: try: UpperCAmelCase : List[str] = yaml.load(UpperCAmelCase , Loader=yaml.FullLoader ) UpperCAmelCase : Optional[int] = flatten_yaml_as_dict(UpperCAmelCase ) for k, v in flat_cfg.items(): setattr(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) except yaml.YAMLError as exc: logger.error('''Error while loading config file: {}. Error message: {}'''.format(UpperCAmelCase , str(UpperCAmelCase ) ) ) return config def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : int ) -> List[Any]: UpperCAmelCase : int = MobileViTVaConfig() UpperCAmelCase : str = False # dataset if task_name.startswith('''imagenet1k_''' ): UpperCAmelCase : Any = 1_000 if int(task_name.strip().split('''_''' )[-1] ) == 384: UpperCAmelCase : Any = 384 else: UpperCAmelCase : Tuple = 256 UpperCAmelCase : int = '''imagenet-1k-id2label.json''' elif task_name.startswith('''imagenet21k_to_1k_''' ): UpperCAmelCase : Optional[Any] = 21_000 if int(task_name.strip().split('''_''' )[-1] ) == 384: UpperCAmelCase : str = 384 else: UpperCAmelCase : Dict = 256 UpperCAmelCase : List[Any] = '''imagenet-22k-id2label.json''' elif task_name.startswith('''ade20k_''' ): UpperCAmelCase : Optional[Any] = 151 UpperCAmelCase : Tuple = 512 UpperCAmelCase : Tuple = '''ade20k-id2label.json''' UpperCAmelCase : Tuple = True elif task_name.startswith('''voc_''' ): UpperCAmelCase : Dict = 21 UpperCAmelCase : str = 512 UpperCAmelCase : Union[str, Any] = '''pascal-voc-id2label.json''' UpperCAmelCase : Dict = True # orig_config UpperCAmelCase : List[Any] = load_orig_config_file(UpperCAmelCase ) assert getattr(UpperCAmelCase , '''model.classification.name''' , -1 ) == "mobilevit_v2", "Invalid model" UpperCAmelCase : Tuple = getattr(UpperCAmelCase , '''model.classification.mitv2.width_multiplier''' , 1.0 ) assert ( getattr(UpperCAmelCase , '''model.classification.mitv2.attn_norm_layer''' , -1 ) == "layer_norm_2d" ), "Norm layers other than layer_norm_2d is not supported" UpperCAmelCase : int = getattr(UpperCAmelCase , '''model.classification.activation.name''' , '''swish''' ) # config.image_size == getattr(orig_config, 'sampler.bs.crop_size_width', 256) if is_segmentation_model: UpperCAmelCase : str = getattr(UpperCAmelCase , '''model.segmentation.output_stride''' , 16 ) if "_deeplabv3" in task_name: UpperCAmelCase : int = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_rates''' , [12, 24, 36] ) UpperCAmelCase : Any = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_out_channels''' , 512 ) UpperCAmelCase : Optional[Any] = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_dropout''' , 0.1 ) # id2label UpperCAmelCase : Union[str, Any] = '''huggingface/label-files''' UpperCAmelCase : List[Any] = json.load(open(hf_hub_download(UpperCAmelCase , UpperCAmelCase , repo_type='''dataset''' ) , '''r''' ) ) UpperCAmelCase : Any = {int(UpperCAmelCase ): v for k, v in idalabel.items()} UpperCAmelCase : int = idalabel UpperCAmelCase : Optional[int] = {v: k for k, v in idalabel.items()} return config def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : Optional[int] ) -> List[str]: UpperCAmelCase : Union[str, Any] = dct.pop(UpperCAmelCase ) UpperCAmelCase : List[str] = val def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : int=False ) -> Union[str, Any]: if base_model: UpperCAmelCase : Dict = '''''' else: UpperCAmelCase : Dict = '''mobilevitv2.''' UpperCAmelCase : Optional[int] = [] for k in state_dict.keys(): if k[:8] == "encoder.": UpperCAmelCase : List[str] = k[8:] else: UpperCAmelCase : Dict = k if ".block." in k: UpperCAmelCase : List[Any] = k_new.replace('''.block.''' , '''.''' ) if ".conv." in k: UpperCAmelCase : Optional[int] = k_new.replace('''.conv.''' , '''.convolution.''' ) if ".norm." in k: UpperCAmelCase : List[str] = k_new.replace('''.norm.''' , '''.normalization.''' ) if "conv_1." in k: UpperCAmelCase : Union[str, Any] = k_new.replace('''conv_1.''' , f'''{model_prefix}conv_stem.''' ) for i in [1, 2]: if f'''layer_{i}.''' in k: UpperCAmelCase : Union[str, Any] = k_new.replace(f'''layer_{i}.''' , f'''{model_prefix}encoder.layer.{i-1}.layer.''' ) if ".exp_1x1." in k: UpperCAmelCase : Optional[Any] = k_new.replace('''.exp_1x1.''' , '''.expand_1x1.''' ) if ".red_1x1." in k: UpperCAmelCase : int = k_new.replace('''.red_1x1.''' , '''.reduce_1x1.''' ) for i in [3, 4, 5]: if f'''layer_{i}.0.''' in k: UpperCAmelCase : Any = k_new.replace(f'''layer_{i}.0.''' , f'''{model_prefix}encoder.layer.{i-1}.downsampling_layer.''' ) if f'''layer_{i}.1.local_rep.0.''' in k: UpperCAmelCase : str = k_new.replace(f'''layer_{i}.1.local_rep.0.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_kxk.''' ) if f'''layer_{i}.1.local_rep.1.''' in k: UpperCAmelCase : int = k_new.replace(f'''layer_{i}.1.local_rep.1.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_1x1.''' ) for i in [3, 4, 5]: if i == 3: UpperCAmelCase : Dict = [0, 1] elif i == 4: UpperCAmelCase : Dict = [0, 1, 2, 3] elif i == 5: UpperCAmelCase : int = [0, 1, 2] for j in j_in: if f'''layer_{i}.1.global_rep.{j}.''' in k: UpperCAmelCase : Optional[Any] = k_new.replace( f'''layer_{i}.1.global_rep.{j}.''' , f'''{model_prefix}encoder.layer.{i-1}.transformer.layer.{j}.''' ) if f'''layer_{i}.1.global_rep.{j+1}.''' in k: UpperCAmelCase : Any = k_new.replace( f'''layer_{i}.1.global_rep.{j+1}.''' , f'''{model_prefix}encoder.layer.{i-1}.layernorm.''' ) if f'''layer_{i}.1.conv_proj.''' in k: UpperCAmelCase : Union[str, Any] = k_new.replace(f'''layer_{i}.1.conv_proj.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_projection.''' ) if "pre_norm_attn.0." in k: UpperCAmelCase : Optional[int] = k_new.replace('''pre_norm_attn.0.''' , '''layernorm_before.''' ) if "pre_norm_attn.1." in k: UpperCAmelCase : Optional[Any] = k_new.replace('''pre_norm_attn.1.''' , '''attention.''' ) if "pre_norm_ffn.0." in k: UpperCAmelCase : List[Any] = k_new.replace('''pre_norm_ffn.0.''' , '''layernorm_after.''' ) if "pre_norm_ffn.1." in k: UpperCAmelCase : List[Any] = k_new.replace('''pre_norm_ffn.1.''' , '''ffn.conv1.''' ) if "pre_norm_ffn.3." in k: UpperCAmelCase : Any = k_new.replace('''pre_norm_ffn.3.''' , '''ffn.conv2.''' ) if "classifier.1." in k: UpperCAmelCase : Optional[int] = k_new.replace('''classifier.1.''' , '''classifier.''' ) if "seg_head." in k: UpperCAmelCase : Union[str, Any] = k_new.replace('''seg_head.''' , '''segmentation_head.''' ) if ".aspp_layer." in k: UpperCAmelCase : Tuple = k_new.replace('''.aspp_layer.''' , '''.''' ) if ".aspp_pool." in k: UpperCAmelCase : Optional[int] = k_new.replace('''.aspp_pool.''' , '''.''' ) rename_keys.append((k, k_new) ) return rename_keys def a__ ( UpperCAmelCase : Union[str, Any] ) -> Any: UpperCAmelCase : str = [] for k in state_dict.keys(): if k.startswith('''seg_head.aux_head.''' ): keys_to_ignore.append(UpperCAmelCase ) for k in keys_to_ignore: state_dict.pop(UpperCAmelCase , UpperCAmelCase ) def a__ ( ) -> Union[str, Any]: UpperCAmelCase : int = '''http://images.cocodataset.org/val2017/000000039769.jpg''' # url = "https://cdn.britannica.com/86/141086-050-9D7C75EE/Gulfstream-G450-business-jet-passengers.jpg" UpperCAmelCase : List[str] = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ) return im @torch.no_grad() def a__ ( UpperCAmelCase : int , UpperCAmelCase : int , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : List[Any] ) -> Union[str, Any]: UpperCAmelCase : Union[str, Any] = get_mobilevitva_config(UpperCAmelCase , UpperCAmelCase ) # load original state_dict UpperCAmelCase : List[str] = torch.load(UpperCAmelCase , map_location='''cpu''' ) # load huggingface model if task_name.startswith('''ade20k_''' ) or task_name.startswith('''voc_''' ): UpperCAmelCase : str = MobileViTVaForSemanticSegmentation(UpperCAmelCase ).eval() UpperCAmelCase : str = False else: UpperCAmelCase : Union[str, Any] = MobileViTVaForImageClassification(UpperCAmelCase ).eval() UpperCAmelCase : Any = False # remove and rename some keys of load the original model UpperCAmelCase : Optional[Any] = checkpoint remove_unused_keys(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = create_rename_keys(UpperCAmelCase , base_model=UpperCAmelCase ) for rename_key_src, rename_key_dest in rename_keys: rename_key(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # load modified state_dict model.load_state_dict(UpperCAmelCase ) # Check outputs on an image, prepared by MobileViTImageProcessor UpperCAmelCase : Dict = MobileViTImageProcessor(crop_size=config.image_size , size=config.image_size + 32 ) UpperCAmelCase : Any = image_processor(images=prepare_img() , return_tensors='''pt''' ) UpperCAmelCase : Union[str, Any] = model(**UpperCAmelCase ) # verify classification model if task_name.startswith('''imagenet''' ): UpperCAmelCase : Optional[Any] = outputs.logits UpperCAmelCase : int = logits.argmax(-1 ).item() print('''Predicted class:''' , model.config.idalabel[predicted_class_idx] ) if task_name.startswith('''imagenet1k_256''' ) and config.width_multiplier == 1.0: # expected_logits for base variant UpperCAmelCase : str = torch.tensor([-1.6_336E00, -7.3_204E-02, -5.1_883E-01] ) assert torch.allclose(logits[0, :3] , UpperCAmelCase , atol=1E-4 ) Path(UpperCAmelCase ).mkdir(exist_ok=UpperCAmelCase ) print(f'''Saving model {task_name} to {pytorch_dump_folder_path}''' ) model.save_pretrained(UpperCAmelCase ) print(f'''Saving image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(UpperCAmelCase ) if __name__ == "__main__": _lowerCamelCase : str = argparse.ArgumentParser() # Required parameters parser.add_argument( "--task", default="imagenet1k_256", type=str, help=( "Name of the task for which the MobileViTV2 model you'd like to convert is trained on . " "\n Classification (ImageNet-1k)\n - MobileViTV2 (256x256) : imagenet1k_256\n - MobileViTV2 (Trained on 256x256 and Finetuned on 384x384) : imagenet1k_384\n - MobileViTV2 (Trained on ImageNet-21k and Finetuned on ImageNet-1k 256x256) :\n imagenet21k_to_1k_256\n - MobileViTV2 (Trained on ImageNet-21k, Finetuned on ImageNet-1k 256x256, and Finetuned on\n ImageNet-1k 384x384) : imagenet21k_to_1k_384\n Segmentation\n - ADE20K Dataset : ade20k_deeplabv3\n - Pascal VOC 2012 Dataset: voc_deeplabv3\n " ), choices=[ "imagenet1k_256", "imagenet1k_384", "imagenet21k_to_1k_256", "imagenet21k_to_1k_384", "ade20k_deeplabv3", "voc_deeplabv3", ], ) parser.add_argument( "--orig_checkpoint_path", required=True, type=str, help="Path to the original state dict (.pt file)." ) parser.add_argument("--orig_config_path", required=True, type=str, help="Path to the original config file.") parser.add_argument( "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory." ) _lowerCamelCase : Optional[int] = parser.parse_args() convert_mobilevitva_checkpoint( args.task, args.orig_checkpoint_path, args.orig_config_path, args.pytorch_dump_folder_path )
336
1
from dataclasses import dataclass from typing import Optional, Tuple, Union import flax import jax.numpy as jnp from jax import random from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput from .scheduling_utils_flax import FlaxSchedulerMixin @flax.struct.dataclass class __UpperCAmelCase : # setable values UpperCamelCase = None UpperCamelCase = None UpperCamelCase = None # sigma(t_i) @classmethod def __magic_name__ ( cls : Any ): return cls() @dataclass class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 42 class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ ): @property def __magic_name__ ( self : Optional[int] ): return True @register_to_config def __init__( self : Optional[int], __A : float = 0.0_2, __A : float = 1_0_0, __A : float = 1.0_0_7, __A : float = 8_0, __A : float = 0.0_5, __A : float = 5_0, ): pass def __magic_name__ ( self : Optional[Any] ): return KarrasVeSchedulerState.create() def __magic_name__ ( self : int, __A : KarrasVeSchedulerState, __A : int, __A : Tuple = () ): UpperCAmelCase : Optional[Any] = jnp.arange(0, __A )[::-1].copy() UpperCAmelCase : Union[str, Any] = [ ( self.config.sigma_max**2 * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1)) ) for i in timesteps ] return state.replace( num_inference_steps=__A, schedule=jnp.array(__A, dtype=jnp.floataa ), timesteps=__A, ) def __magic_name__ ( self : List[Any], __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : random.KeyArray, ): if self.config.s_min <= sigma <= self.config.s_max: UpperCAmelCase : int = min(self.config.s_churn / state.num_inference_steps, 2**0.5 - 1 ) else: UpperCAmelCase : Optional[int] = 0 # sample eps ~ N(0, S_noise^2 * I) UpperCAmelCase : Union[str, Any] = random.split(__A, num=1 ) UpperCAmelCase : List[str] = self.config.s_noise * random.normal(key=__A, shape=sample.shape ) UpperCAmelCase : Tuple = sigma + gamma * sigma UpperCAmelCase : List[str] = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps) return sample_hat, sigma_hat def __magic_name__ ( self : Tuple, __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : float, __A : jnp.ndarray, __A : bool = True, ): UpperCAmelCase : int = sample_hat + sigma_hat * model_output UpperCAmelCase : Dict = (sample_hat - pred_original_sample) / sigma_hat UpperCAmelCase : int = sample_hat + (sigma_prev - sigma_hat) * derivative if not return_dict: return (sample_prev, derivative, state) return FlaxKarrasVeOutput(prev_sample=__A, derivative=__A, state=__A ) def __magic_name__ ( self : Tuple, __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : float, __A : jnp.ndarray, __A : jnp.ndarray, __A : jnp.ndarray, __A : bool = True, ): UpperCAmelCase : Tuple = sample_prev + sigma_prev * model_output UpperCAmelCase : List[str] = (sample_prev - pred_original_sample) / sigma_prev UpperCAmelCase : Union[str, Any] = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr) if not return_dict: return (sample_prev, derivative, state) return FlaxKarrasVeOutput(prev_sample=__A, derivative=__A, state=__A ) def __magic_name__ ( self : Optional[Any], __A : KarrasVeSchedulerState, __A : Optional[int], __A : int, __A : Union[str, Any] ): raise NotImplementedError()
336
import inspect import tempfile from collections import OrderedDict, UserDict from collections.abc import MutableMapping from contextlib import ExitStack, contextmanager from dataclasses import fields from enum import Enum from typing import Any, ContextManager, List, Tuple import numpy as np from .import_utils import is_flax_available, is_tf_available, is_torch_available, is_torch_fx_proxy if is_flax_available(): import jax.numpy as jnp class __UpperCAmelCase ( lowerCamelCase__ ): def __get__( self : Tuple, __A : Optional[Any], __A : Optional[int]=None ): # See docs.python.org/3/howto/descriptor.html#properties if obj is None: return self if self.fget is None: raise AttributeError('''unreadable attribute''' ) UpperCAmelCase : str = '''__cached_''' + self.fget.__name__ UpperCAmelCase : int = getattr(__A, __A, __A ) if cached is None: UpperCAmelCase : Any = self.fget(__A ) setattr(__A, __A, __A ) return cached def a__ ( UpperCAmelCase : Optional[Any] ) -> Any: UpperCAmelCase : Any = val.lower() if val in {"y", "yes", "t", "true", "on", "1"}: return 1 if val in {"n", "no", "f", "false", "off", "0"}: return 0 raise ValueError(f'''invalid truth value {val!r}''' ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: if is_torch_fx_proxy(UpperCAmelCase ): return True if is_torch_available(): import torch if isinstance(UpperCAmelCase , torch.Tensor ): return True if is_tf_available(): import tensorflow as tf if isinstance(UpperCAmelCase , tf.Tensor ): return True if is_flax_available(): import jax.numpy as jnp from jax.core import Tracer if isinstance(UpperCAmelCase , (jnp.ndarray, Tracer) ): return True return isinstance(UpperCAmelCase , np.ndarray ) def a__ ( UpperCAmelCase : List[Any] ) -> Union[str, Any]: return isinstance(UpperCAmelCase , np.ndarray ) def a__ ( UpperCAmelCase : str ) -> Tuple: return _is_numpy(UpperCAmelCase ) def a__ ( UpperCAmelCase : str ) -> List[Any]: import torch return isinstance(UpperCAmelCase , torch.Tensor ) def a__ ( UpperCAmelCase : str ) -> List[Any]: return False if not is_torch_available() else _is_torch(UpperCAmelCase ) def a__ ( UpperCAmelCase : Tuple ) -> List[str]: import torch return isinstance(UpperCAmelCase , torch.device ) def a__ ( UpperCAmelCase : Any ) -> Any: return False if not is_torch_available() else _is_torch_device(UpperCAmelCase ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: import torch if isinstance(UpperCAmelCase , UpperCAmelCase ): if hasattr(UpperCAmelCase , UpperCAmelCase ): UpperCAmelCase : Union[str, Any] = getattr(UpperCAmelCase , UpperCAmelCase ) else: return False return isinstance(UpperCAmelCase , torch.dtype ) def a__ ( UpperCAmelCase : Optional[Any] ) -> Union[str, Any]: return False if not is_torch_available() else _is_torch_dtype(UpperCAmelCase ) def a__ ( UpperCAmelCase : Any ) -> str: import tensorflow as tf return isinstance(UpperCAmelCase , tf.Tensor ) def a__ ( UpperCAmelCase : int ) -> Union[str, Any]: return False if not is_tf_available() else _is_tensorflow(UpperCAmelCase ) def a__ ( UpperCAmelCase : List[str] ) -> Tuple: import tensorflow as tf # the `is_symbolic_tensor` predicate is only available starting with TF 2.14 if hasattr(UpperCAmelCase , '''is_symbolic_tensor''' ): return tf.is_symbolic_tensor(UpperCAmelCase ) return type(UpperCAmelCase ) == tf.Tensor def a__ ( UpperCAmelCase : int ) -> List[Any]: return False if not is_tf_available() else _is_tf_symbolic_tensor(UpperCAmelCase ) def a__ ( UpperCAmelCase : List[Any] ) -> Dict: import jax.numpy as jnp # noqa: F811 return isinstance(UpperCAmelCase , jnp.ndarray ) def a__ ( UpperCAmelCase : List[Any] ) -> Optional[int]: return False if not is_flax_available() else _is_jax(UpperCAmelCase ) def a__ ( UpperCAmelCase : int ) -> Tuple: if isinstance(UpperCAmelCase , (dict, UserDict) ): return {k: to_py_obj(UpperCAmelCase ) for k, v in obj.items()} elif isinstance(UpperCAmelCase , (list, tuple) ): return [to_py_obj(UpperCAmelCase ) for o in obj] elif is_tf_tensor(UpperCAmelCase ): return obj.numpy().tolist() elif is_torch_tensor(UpperCAmelCase ): return obj.detach().cpu().tolist() elif is_jax_tensor(UpperCAmelCase ): return np.asarray(UpperCAmelCase ).tolist() elif isinstance(UpperCAmelCase , (np.ndarray, np.number) ): # tolist also works on 0d np arrays return obj.tolist() else: return obj def a__ ( UpperCAmelCase : Any ) -> List[str]: if isinstance(UpperCAmelCase , (dict, UserDict) ): return {k: to_numpy(UpperCAmelCase ) for k, v in obj.items()} elif isinstance(UpperCAmelCase , (list, tuple) ): return np.array(UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): return obj.numpy() elif is_torch_tensor(UpperCAmelCase ): return obj.detach().cpu().numpy() elif is_jax_tensor(UpperCAmelCase ): return np.asarray(UpperCAmelCase ) else: return obj class __UpperCAmelCase ( lowerCamelCase__ ): def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Optional[Any] = fields(self ) # Safety and consistency checks if not len(__A ): raise ValueError(F'''{self.__class__.__name__} has no fields.''' ) if not all(field.default is None for field in class_fields[1:] ): raise ValueError(F'''{self.__class__.__name__} should not have more than one required field.''' ) UpperCAmelCase : int = getattr(self, class_fields[0].name ) UpperCAmelCase : str = all(getattr(self, field.name ) is None for field in class_fields[1:] ) if other_fields_are_none and not is_tensor(__A ): if isinstance(__A, __A ): UpperCAmelCase : Tuple = first_field.items() UpperCAmelCase : Any = True else: try: UpperCAmelCase : Optional[Any] = iter(__A ) UpperCAmelCase : Optional[Any] = True except TypeError: UpperCAmelCase : Optional[int] = False # if we provided an iterator as first field and the iterator is a (key, value) iterator # set the associated fields if first_field_iterator: for idx, element in enumerate(__A ): if ( not isinstance(__A, (list, tuple) ) or not len(__A ) == 2 or not isinstance(element[0], __A ) ): if idx == 0: # If we do not have an iterator of key/values, set it as attribute UpperCAmelCase : Any = first_field else: # If we have a mixed iterator, raise an error raise ValueError( F'''Cannot set key/value for {element}. It needs to be a tuple (key, value).''' ) break setattr(self, element[0], element[1] ) if element[1] is not None: UpperCAmelCase : Union[str, Any] = element[1] elif first_field is not None: UpperCAmelCase : Union[str, Any] = first_field else: for field in class_fields: UpperCAmelCase : Optional[Any] = getattr(self, field.name ) if v is not None: UpperCAmelCase : Optional[int] = v def __delitem__( self : Union[str, Any], *__A : str, **__A : Tuple ): raise Exception(F'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : List[str], *__A : Union[str, Any], **__A : Optional[Any] ): raise Exception(F'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : Any, *__A : Dict, **__A : str ): raise Exception(F'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : Dict, *__A : int, **__A : Dict ): raise Exception(F'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' ) def __getitem__( self : List[str], __A : List[str] ): if isinstance(__A, __A ): UpperCAmelCase : int = dict(self.items() ) return inner_dict[k] else: return self.to_tuple()[k] def __setattr__( self : Optional[Any], __A : Dict, __A : Union[str, Any] ): if name in self.keys() and value is not None: # Don't call self.__setitem__ to avoid recursion errors super().__setitem__(__A, __A ) super().__setattr__(__A, __A ) def __setitem__( self : Dict, __A : List[Any], __A : Union[str, Any] ): # Will raise a KeyException if needed super().__setitem__(__A, __A ) # Don't call self.__setattr__ to avoid recursion errors super().__setattr__(__A, __A ) def __magic_name__ ( self : List[str] ): return tuple(self[k] for k in self.keys() ) class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ ): @classmethod def __magic_name__ ( cls : List[Any], __A : Tuple ): raise ValueError( F'''{value} is not a valid {cls.__name__}, please select one of {list(cls._valueamember_map_.keys() )}''' ) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """longest""" UpperCamelCase = """max_length""" UpperCamelCase = """do_not_pad""" class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """pt""" UpperCamelCase = """tf""" UpperCamelCase = """np""" UpperCamelCase = """jax""" class __UpperCAmelCase : def __init__( self : Any, __A : List[ContextManager] ): UpperCAmelCase : Tuple = context_managers UpperCAmelCase : Tuple = ExitStack() def __enter__( self : Any ): for context_manager in self.context_managers: self.stack.enter_context(__A ) def __exit__( self : List[Any], *__A : Union[str, Any], **__A : Dict ): self.stack.__exit__(*__A, **__A ) def a__ ( UpperCAmelCase : Union[str, Any] ) -> str: UpperCAmelCase : int = infer_framework(UpperCAmelCase ) if framework == "tf": UpperCAmelCase : List[str] = inspect.signature(model_class.call ) # TensorFlow models elif framework == "pt": UpperCAmelCase : List[Any] = inspect.signature(model_class.forward ) # PyTorch models else: UpperCAmelCase : Tuple = inspect.signature(model_class.__call__ ) # Flax models for p in signature.parameters: if p == "return_loss" and signature.parameters[p].default is True: return True return False def a__ ( UpperCAmelCase : Dict ) -> Any: UpperCAmelCase : List[Any] = model_class.__name__ UpperCAmelCase : Union[str, Any] = infer_framework(UpperCAmelCase ) if framework == "tf": UpperCAmelCase : Tuple = inspect.signature(model_class.call ) # TensorFlow models elif framework == "pt": UpperCAmelCase : Dict = inspect.signature(model_class.forward ) # PyTorch models else: UpperCAmelCase : Dict = inspect.signature(model_class.__call__ ) # Flax models if "QuestionAnswering" in model_name: return [p for p in signature.parameters if "label" in p or p in ("start_positions", "end_positions")] else: return [p for p in signature.parameters if "label" in p] def a__ ( UpperCAmelCase : MutableMapping , UpperCAmelCase : str = "" , UpperCAmelCase : str = "." ) -> Union[str, Any]: def _flatten_dict(UpperCAmelCase : Optional[Any] , UpperCAmelCase : List[str]="" , UpperCAmelCase : Any="." ): for k, v in d.items(): UpperCAmelCase : List[str] = str(UpperCAmelCase ) + delimiter + str(UpperCAmelCase ) if parent_key else k if v and isinstance(UpperCAmelCase , UpperCAmelCase ): yield from flatten_dict(UpperCAmelCase , UpperCAmelCase , delimiter=UpperCAmelCase ).items() else: yield key, v return dict(_flatten_dict(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) ) @contextmanager def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : bool = False ) -> Optional[Any]: if use_temp_dir: with tempfile.TemporaryDirectory() as tmp_dir: yield tmp_dir else: yield working_dir def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : List[str]=None ) -> Optional[Any]: if is_numpy_array(UpperCAmelCase ): return np.transpose(UpperCAmelCase , axes=UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.T if axes is None else array.permute(*UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.transpose(UpperCAmelCase , perm=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.transpose(UpperCAmelCase , axes=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for transpose: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : Optional[int] ) -> List[str]: if is_numpy_array(UpperCAmelCase ): return np.reshape(UpperCAmelCase , UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.reshape(*UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.reshape(UpperCAmelCase , UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.reshape(UpperCAmelCase , UpperCAmelCase ) else: raise ValueError(f'''Type not supported for reshape: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : Tuple , UpperCAmelCase : Optional[int]=None ) -> Any: if is_numpy_array(UpperCAmelCase ): return np.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.squeeze() if axis is None else array.squeeze(dim=UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for squeeze: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : int ) -> str: if is_numpy_array(UpperCAmelCase ): return np.expand_dims(UpperCAmelCase , UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.unsqueeze(dim=UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.expand_dims(UpperCAmelCase , axis=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.expand_dims(UpperCAmelCase , axis=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for expand_dims: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: if is_numpy_array(UpperCAmelCase ): return np.size(UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.numel() elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.size(UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return array.size else: raise ValueError(f'''Type not supported for expand_dims: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : List[str] ) -> Dict: for key, value in auto_map.items(): if isinstance(UpperCAmelCase , (tuple, list) ): UpperCAmelCase : List[Any] = [f'''{repo_id}--{v}''' if (v is not None and '''--''' not in v) else v for v in value] elif value is not None and "--" not in value: UpperCAmelCase : List[Any] = f'''{repo_id}--{value}''' return auto_map def a__ ( UpperCAmelCase : Tuple ) -> Union[str, Any]: for base_class in inspect.getmro(UpperCAmelCase ): UpperCAmelCase : Any = base_class.__module__ UpperCAmelCase : Dict = base_class.__name__ if module.startswith('''tensorflow''' ) or module.startswith('''keras''' ) or name == "TFPreTrainedModel": return "tf" elif module.startswith('''torch''' ) or name == "PreTrainedModel": return "pt" elif module.startswith('''flax''' ) or module.startswith('''jax''' ) or name == "FlaxPreTrainedModel": return "flax" else: raise TypeError(f'''Could not infer framework from class {model_class}.''' )
336
1
_lowerCamelCase : Union[str, Any] = "\n# Transformers installation\n! pip install transformers datasets\n# To install from source instead of the last release, comment the command above and uncomment the following one.\n# ! pip install git+https://github.com/huggingface/transformers.git\n" _lowerCamelCase : Tuple = [{"type": "code", "content": INSTALL_CONTENT}] _lowerCamelCase : List[Any] = { "{processor_class}": "FakeProcessorClass", "{model_class}": "FakeModelClass", "{object_class}": "FakeObjectClass", }
336
import os import unittest from transformers import LayoutLMTokenizer, LayoutLMTokenizerFast from transformers.models.layoutlm.tokenization_layoutlm import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class __UpperCAmelCase ( lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = LayoutLMTokenizer UpperCamelCase = LayoutLMTokenizerFast UpperCamelCase = True UpperCamelCase = True def __magic_name__ ( self : Any ): super().setUp() UpperCAmelCase : Dict = [ '''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''', ] UpperCAmelCase : int = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['''vocab_file'''] ) with open(self.vocab_file, '''w''', encoding='''utf-8''' ) as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens] ) ) def __magic_name__ ( self : Union[str, Any], **__A : List[str] ): return LayoutLMTokenizer.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Optional[int], __A : int ): UpperCAmelCase : Optional[Any] = '''UNwant\u00E9d,running''' UpperCAmelCase : Optional[int] = '''unwanted, running''' return input_text, output_text def __magic_name__ ( self : Any ): UpperCAmelCase : Union[str, Any] = self.tokenizer_class(self.vocab_file ) UpperCAmelCase : Optional[Any] = tokenizer.tokenize('''UNwant\u00E9d,running''' ) self.assertListEqual(__A, ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing'''] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__A ), [7, 4, 5, 1_0, 8, 9] ) def __magic_name__ ( self : Optional[int] ): pass
336
1
import argparse import os import torch from transformers.utils import WEIGHTS_NAME _lowerCamelCase : Optional[Any] = ["small", "medium", "large"] _lowerCamelCase : int = "lm_head.decoder.weight" _lowerCamelCase : Tuple = "lm_head.weight" def a__ ( UpperCAmelCase : str , UpperCAmelCase : str ) -> List[Any]: UpperCAmelCase : Optional[Any] = torch.load(UpperCAmelCase ) UpperCAmelCase : int = d.pop(UpperCAmelCase ) os.makedirs(UpperCAmelCase , exist_ok=UpperCAmelCase ) torch.save(UpperCAmelCase , os.path.join(UpperCAmelCase , UpperCAmelCase ) ) if __name__ == "__main__": _lowerCamelCase : Union[str, Any] = argparse.ArgumentParser() parser.add_argument("--dialogpt_path", default=".", type=str) _lowerCamelCase : Union[str, Any] = parser.parse_args() for MODEL in DIALOGPT_MODELS: _lowerCamelCase : List[str] = os.path.join(args.dialogpt_path, f"""{MODEL}_ft.pkl""") _lowerCamelCase : Union[str, Any] = f"""./DialoGPT-{MODEL}""" convert_dialogpt_checkpoint( checkpoint_path, pytorch_dump_folder_path, )
336
from __future__ import annotations import copy import inspect import json import math import os import tempfile import unittest from importlib import import_module import numpy as np from transformers import ViTMAEConfig from transformers.file_utils import cached_property, is_tf_available, is_vision_available from transformers.testing_utils import require_tf, require_vision, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFViTMAEForPreTraining, TFViTMAEModel if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class __UpperCAmelCase : def __init__( self : Any, __A : str, __A : Dict=1_3, __A : int=3_0, __A : Tuple=2, __A : Union[str, Any]=3, __A : Any=True, __A : str=True, __A : Dict=3_2, __A : List[Any]=2, __A : Optional[Any]=4, __A : Union[str, Any]=3_7, __A : int="gelu", __A : int=0.1, __A : List[Any]=0.1, __A : Tuple=1_0, __A : Tuple=0.0_2, __A : Any=3, __A : List[str]=0.6, __A : Any=None, ): UpperCAmelCase : Union[str, Any] = parent UpperCAmelCase : Dict = batch_size UpperCAmelCase : List[str] = image_size UpperCAmelCase : Dict = patch_size UpperCAmelCase : int = num_channels UpperCAmelCase : Union[str, Any] = is_training UpperCAmelCase : Union[str, Any] = use_labels UpperCAmelCase : Union[str, Any] = hidden_size UpperCAmelCase : Optional[int] = num_hidden_layers UpperCAmelCase : Union[str, Any] = num_attention_heads UpperCAmelCase : List[str] = intermediate_size UpperCAmelCase : Optional[int] = hidden_act UpperCAmelCase : Tuple = hidden_dropout_prob UpperCAmelCase : List[Any] = attention_probs_dropout_prob UpperCAmelCase : Any = type_sequence_label_size UpperCAmelCase : Tuple = initializer_range UpperCAmelCase : Tuple = mask_ratio UpperCAmelCase : Any = scope # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above # (we add 1 for the [CLS] token) UpperCAmelCase : Tuple = (image_size // patch_size) ** 2 UpperCAmelCase : List[Any] = int(math.ceil((1 - mask_ratio) * (num_patches + 1) ) ) def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : int = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : Any = None if self.use_labels: UpperCAmelCase : Optional[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size ) UpperCAmelCase : str = self.get_config() return config, pixel_values, labels def __magic_name__ ( self : Optional[Any] ): 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, decoder_hidden_size=self.hidden_size, decoder_num_hidden_layers=self.num_hidden_layers, decoder_num_attention_heads=self.num_attention_heads, decoder_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 __magic_name__ ( self : str, __A : List[Any], __A : Any, __A : Any ): UpperCAmelCase : Optional[Any] = TFViTMAEModel(config=__A ) UpperCAmelCase : Tuple = model(__A, training=__A ) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__ ( self : Tuple, __A : str, __A : int, __A : str ): UpperCAmelCase : Dict = TFViTMAEForPreTraining(__A ) UpperCAmelCase : int = model(__A, training=__A ) # expected sequence length = num_patches UpperCAmelCase : int = (self.image_size // self.patch_size) ** 2 UpperCAmelCase : Optional[Any] = self.patch_size**2 * self.num_channels self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels) ) # test greyscale images UpperCAmelCase : Tuple = 1 UpperCAmelCase : List[Any] = TFViTMAEForPreTraining(__A ) UpperCAmelCase : Union[str, Any] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) UpperCAmelCase : List[Any] = model(__A, training=__A ) UpperCAmelCase : Union[str, Any] = self.patch_size**2 self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels) ) def __magic_name__ ( self : List[Any] ): UpperCAmelCase : Dict = self.prepare_config_and_inputs() ((UpperCAmelCase) , (UpperCAmelCase) , (UpperCAmelCase)) : Union[str, Any] = config_and_inputs UpperCAmelCase : Optional[Any] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_tf class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else () UpperCamelCase = {"""feature-extraction""": TFViTMAEModel} if is_tf_available() else {} UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = TFViTMAEModelTester(self ) UpperCAmelCase : int = ConfigTester(self, config_class=__A, has_text_modality=__A, hidden_size=3_7 ) def __magic_name__ ( self : List[str] ): self.config_tester.run_common_tests() @unittest.skip(reason='''ViTMAE does not use inputs_embeds''' ) def __magic_name__ ( self : List[Any] ): pass def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : List[str] = model_class(__A ) self.assertIsInstance(model.get_input_embeddings(), (tf.keras.layers.Layer) ) UpperCAmelCase : Union[str, Any] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__A, tf.keras.layers.Layer ) ) def __magic_name__ ( self : str ): UpperCAmelCase , UpperCAmelCase : str = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Any = model_class(__A ) UpperCAmelCase : Any = inspect.signature(model.call ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : int = [*signature.parameters.keys()] UpperCAmelCase : Tuple = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : str ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*__A ) def __magic_name__ ( self : int ): # make the mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Tuple = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : List[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : str = model_class(__A ) UpperCAmelCase : int = self._prepare_for_class(__A, __A ) UpperCAmelCase : Dict = model(__A, noise=__A ) UpperCAmelCase : Any = copy.deepcopy(self._prepare_for_class(__A, __A ) ) UpperCAmelCase : Union[str, Any] = model(**__A, noise=__A ) UpperCAmelCase : Dict = outputs_dict[0].numpy() UpperCAmelCase : Tuple = outputs_keywords[0].numpy() self.assertLess(np.sum(np.abs(output_dict - output_keywords ) ), 1E-6 ) def __magic_name__ ( self : Optional[Any] ): # make the mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Any = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : str = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Union[str, Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) def prepare_numpy_arrays(__A : Union[str, Any] ): UpperCAmelCase : str = {} for k, v in inputs_dict.items(): if tf.is_tensor(__A ): UpperCAmelCase : Tuple = v.numpy() else: UpperCAmelCase : str = np.array(__A ) return inputs_np_dict for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) UpperCAmelCase : Any = self._prepare_for_class(__A, __A ) UpperCAmelCase : Optional[int] = prepare_numpy_arrays(__A ) UpperCAmelCase : str = model(__A, noise=__A ) UpperCAmelCase : str = model(**__A, noise=__A ) self.assert_outputs_same(__A, __A ) def __magic_name__ ( self : int, __A : str, __A : Union[str, Any], __A : Optional[Any] ): # make masks reproducible np.random.seed(2 ) UpperCAmelCase : Any = int((tf_model.config.image_size // tf_model.config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) UpperCAmelCase : int = tf.constant(__A ) # Add `noise` argument. # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument UpperCAmelCase : List[Any] = tf_noise super().check_pt_tf_models(__A, __A, __A ) def __magic_name__ ( self : str ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Union[str, Any] = { module_member for model_class in self.all_model_classes for module in (import_module(model_class.__module__ ),) for module_member_name in dir(__A ) if module_member_name.endswith('''MainLayer''' ) # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`. and module_member_name[: -len('''MainLayer''' )] == model_class.__name__[: -len('''Model''' )] for module_member in (getattr(__A, __A ),) if isinstance(__A, __A ) and tf.keras.layers.Layer in module_member.__bases__ and getattr(__A, '''_keras_serializable''', __A ) } UpperCAmelCase : Union[str, Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Optional[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) UpperCAmelCase : str = tf.convert_to_tensor(__A ) inputs_dict.update({'''noise''': noise} ) for main_layer_class in tf_main_layer_classes: UpperCAmelCase : Tuple = main_layer_class(__A ) UpperCAmelCase : int = { name: tf.keras.Input(tensor.shape[1:], dtype=tensor.dtype ) for name, tensor in inputs_dict.items() } UpperCAmelCase : List[Any] = tf.keras.Model(__A, outputs=main_layer(__A ) ) UpperCAmelCase : List[Any] = model(__A ) with tempfile.TemporaryDirectory() as tmpdirname: UpperCAmelCase : Any = os.path.join(__A, '''keras_model.h5''' ) model.save(__A ) UpperCAmelCase : List[str] = tf.keras.models.load_model( __A, custom_objects={main_layer_class.__name__: main_layer_class} ) assert isinstance(__A, tf.keras.Model ) UpperCAmelCase : Tuple = model(__A ) self.assert_outputs_same(__A, __A ) @slow def __magic_name__ ( self : Dict ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Dict = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Optional[Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Optional[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : int = model_class(__A ) UpperCAmelCase : List[str] = self._prepare_for_class(__A, __A ) UpperCAmelCase : Union[str, Any] = model(__A, noise=__A ) if model_class.__name__ == "TFViTMAEModel": UpperCAmelCase : Optional[int] = outputs.last_hidden_state.numpy() UpperCAmelCase : Union[str, Any] = 0 else: UpperCAmelCase : Optional[int] = outputs.logits.numpy() UpperCAmelCase : int = 0 with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(__A, saved_model=__A ) UpperCAmelCase : Dict = model_class.from_pretrained(__A ) UpperCAmelCase : str = model(__A, noise=__A ) if model_class.__name__ == "TFViTMAEModel": UpperCAmelCase : int = after_outputs['''last_hidden_state'''].numpy() UpperCAmelCase : Dict = 0 else: UpperCAmelCase : Any = after_outputs['''logits'''].numpy() UpperCAmelCase : Dict = 0 UpperCAmelCase : Union[str, Any] = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(__A, 1E-5 ) def __magic_name__ ( self : Optional[Any] ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Dict = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : List[Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) UpperCAmelCase : int = self._prepare_for_class(__A, __A ) UpperCAmelCase : List[Any] = model(__A, noise=__A ) UpperCAmelCase : str = model.get_config() # make sure that returned config is jsonifiable, which is required by keras json.dumps(__A ) UpperCAmelCase : int = model_class.from_config(model.get_config() ) # make sure it also accepts a normal config UpperCAmelCase : str = model_class.from_config(model.config ) UpperCAmelCase : List[str] = new_model(__A ) # Build model new_model.set_weights(model.get_weights() ) UpperCAmelCase : Tuple = new_model(__A, noise=__A ) self.assert_outputs_same(__A, __A ) @unittest.skip( reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load to get deterministic results.''' ) def __magic_name__ ( self : Optional[int] ): pass @unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load''' ) def __magic_name__ ( self : Tuple ): pass @slow def __magic_name__ ( self : str ): UpperCAmelCase : Tuple = TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224''' ) self.assertIsNotNone(__A ) def a__ ( ) -> Dict: UpperCAmelCase : int = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_tf @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : List[str] ): return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base''' ) if is_vision_available() else None @slow def __magic_name__ ( self : str ): # make random mask reproducible across the PT and TF model np.random.seed(2 ) UpperCAmelCase : Tuple = TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base''' ) UpperCAmelCase : List[str] = self.default_image_processor UpperCAmelCase : Any = prepare_img() UpperCAmelCase : str = image_processor(images=__A, return_tensors='''tf''' ) # 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) UpperCAmelCase : Optional[int] = ViTMAEConfig() UpperCAmelCase : int = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(1, num_patches) ) # forward pass UpperCAmelCase : Optional[int] = model(**__A, noise=__A ) # verify the logits UpperCAmelCase : Union[str, Any] = tf.convert_to_tensor([1, 1_9_6, 7_6_8] ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : List[str] = tf.convert_to_tensor( [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]] ) tf.debugging.assert_near(outputs.logits[0, :3, :3], __A, atol=1E-4 )
336
1
import copy from dataclasses import dataclass, field from typing import ClassVar, Dict from ..features import Audio, Features, Value from .base import TaskTemplate @dataclass(frozen=lowerCamelCase__ ) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = field(default="""automatic-speech-recognition""" , metadata={"""include_in_asdict_even_if_is_default""": True} ) UpperCamelCase = Features({"""audio""": Audio()} ) UpperCamelCase = Features({"""transcription""": Value("""string""" )} ) UpperCamelCase = "audio" UpperCamelCase = "transcription" def __magic_name__ ( self : Union[str, Any], __A : str ): if self.audio_column not in features: raise ValueError(F'''Column {self.audio_column} is not present in features.''' ) if not isinstance(features[self.audio_column], __A ): raise ValueError(F'''Column {self.audio_column} is not an Audio type.''' ) UpperCAmelCase : List[Any] = copy.deepcopy(self ) UpperCAmelCase : str = self.input_schema.copy() UpperCAmelCase : Tuple = features[self.audio_column] UpperCAmelCase : List[str] = input_schema return task_template @property def __magic_name__ ( self : List[Any] ): return {self.audio_column: "audio", self.transcription_column: "transcription"}
336
def a__ ( UpperCAmelCase : int ) -> int: UpperCAmelCase : list[list[int]] = [[0 for _ in range(UpperCAmelCase )] for _ in range(m + 1 )] for i in range(m + 1 ): UpperCAmelCase : Optional[Any] = 1 for n in range(m + 1 ): for k in range(1 , UpperCAmelCase ): memo[n][k] += memo[n][k - 1] if n - k > 0: memo[n][k] += memo[n - k - 1][k] return memo[m][m - 1] if __name__ == "__main__": import sys if len(sys.argv) == 1: try: _lowerCamelCase : List[Any] = int(input("Enter a number: ").strip()) print(partition(n)) except ValueError: print("Please enter a number.") else: try: _lowerCamelCase : str = int(sys.argv[1]) print(partition(n)) except ValueError: print("Please pass a number.")
336
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, is_vision_available, ) _lowerCamelCase : List[str] = {"processing_layoutxlm": ["LayoutXLMProcessor"]} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[int] = ["LayoutXLMTokenizer"] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Any = ["LayoutXLMTokenizerFast"] if TYPE_CHECKING: from .processing_layoutxlm import LayoutXLMProcessor try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_layoutxlm import LayoutXLMTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_layoutxlm_fast import LayoutXLMTokenizerFast else: import sys _lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
from __future__ import annotations def a__ ( UpperCAmelCase : list[list[int]] ) -> bool: UpperCAmelCase : Union[str, Any] = len(UpperCAmelCase ) # We need to create solution object to save path. UpperCAmelCase : int = [[0 for _ in range(UpperCAmelCase )] for _ in range(UpperCAmelCase )] UpperCAmelCase : Union[str, Any] = run_maze(UpperCAmelCase , 0 , 0 , UpperCAmelCase ) if solved: print('''\n'''.join(str(UpperCAmelCase ) for row in solutions ) ) else: print('''No solution exists!''' ) return solved def a__ ( UpperCAmelCase : list[list[int]] , UpperCAmelCase : int , UpperCAmelCase : int , UpperCAmelCase : list[list[int]] ) -> bool: UpperCAmelCase : Dict = len(UpperCAmelCase ) # Final check point. if i == j == (size - 1): UpperCAmelCase : Dict = 1 return True UpperCAmelCase : Union[str, Any] = (not i < 0) and (not j < 0) # Check lower bounds UpperCAmelCase : List[Any] = (i < size) and (j < size) # Check upper bounds if lower_flag and upper_flag: # check for already visited and block points. UpperCAmelCase : Any = (not solutions[i][j]) and (not maze[i][j]) if block_flag: # check visited UpperCAmelCase : str = 1 # check for directions if ( run_maze(UpperCAmelCase , i + 1 , UpperCAmelCase , UpperCAmelCase ) or run_maze(UpperCAmelCase , UpperCAmelCase , j + 1 , UpperCAmelCase ) or run_maze(UpperCAmelCase , i - 1 , UpperCAmelCase , UpperCAmelCase ) or run_maze(UpperCAmelCase , UpperCAmelCase , j - 1 , UpperCAmelCase ) ): return True UpperCAmelCase : Any = 0 return False return False if __name__ == "__main__": import doctest doctest.testmod()
336
1
from manim import * class __UpperCAmelCase ( lowerCamelCase__ ): def __magic_name__ ( self : int ): UpperCAmelCase : List[Any] = Rectangle(height=0.5, width=0.5 ) UpperCAmelCase : Tuple = Rectangle(height=0.4_6, width=0.4_6 ).set_stroke(width=0 ) UpperCAmelCase : Optional[Any] = [mem.copy() for i in range(6 )] UpperCAmelCase : Any = [mem.copy() for i in range(6 )] UpperCAmelCase : Any = VGroup(*__A ).arrange(__A, buff=0 ) UpperCAmelCase : List[str] = VGroup(*__A ).arrange(__A, buff=0 ) UpperCAmelCase : Optional[int] = VGroup(__A, __A ).arrange(__A, buff=0 ) UpperCAmelCase : Union[str, Any] = Text('''CPU''', font_size=2_4 ) UpperCAmelCase : int = Group(__A, __A ).arrange(__A, buff=0.5, aligned_edge=__A ) cpu.move_to([-2.5, -0.5, 0] ) self.add(__A ) UpperCAmelCase : Dict = [mem.copy() for i in range(1 )] UpperCAmelCase : Optional[int] = VGroup(*__A ).arrange(__A, buff=0 ) UpperCAmelCase : Dict = Text('''GPU''', font_size=2_4 ) UpperCAmelCase : List[str] = Group(__A, __A ).arrange(__A, buff=0.5, aligned_edge=__A ) gpu.align_to(__A, __A ) gpu.set_x(gpu.get_x() - 1 ) self.add(__A ) UpperCAmelCase : Optional[int] = [mem.copy() for i in range(6 )] UpperCAmelCase : List[Any] = VGroup(*__A ).arrange(__A, buff=0 ) UpperCAmelCase : Any = Text('''Model''', font_size=2_4 ) UpperCAmelCase : Union[str, Any] = Group(__A, __A ).arrange(__A, buff=0.5, aligned_edge=__A ) model.move_to([3, -1.0, 0] ) self.play( Create(__A, run_time=1 ), Create(__A, run_time=1 ), Create(__A, run_time=1 ), ) UpperCAmelCase : Optional[int] = MarkupText( F'''First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.''', font_size=2_4, ) UpperCAmelCase : str = Square(side_length=2.2 ) key.move_to([-5, 2, 0] ) UpperCAmelCase : Optional[int] = MarkupText( F'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model''', font_size=1_8, ) key_text.move_to([-5, 2.4, 0] ) step_a.move_to([2, 2, 0] ) self.play(Write(__A, run_time=2.5 ), Write(__A ), Write(__A ) ) self.add(__A ) UpperCAmelCase : Tuple = [] UpperCAmelCase : Optional[int] = [] UpperCAmelCase : str = [] for i, rect in enumerate(__A ): UpperCAmelCase : Optional[int] = Rectangle(height=0.4_6, width=0.4_6 ).set_stroke(width=0.0 ).set_fill(__A, opacity=0.7 ) cpu_target.move_to(__A ) cpu_target.generate_target() UpperCAmelCase : Optional[Any] = 0.4_6 / 4 UpperCAmelCase : Optional[int] = 0.4_6 / 3 if i == 0: cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT ), buff=0.0_2, direction=__A ) cpu_target.target.set_x(cpu_target.target.get_x() + 0.1 ) elif i == 3: cpu_target.target.next_to(cpu_targs[0].target, direction=__A, buff=0.0 ) else: cpu_target.target.next_to(cpu_targs[i - 1].target, direction=__A, buff=0.0 ) cpu_targs.append(__A ) first_animations.append(rect.animate(run_time=0.5 ).set_stroke(__A ) ) second_animations.append(MoveToTarget(__A, run_time=1.5 ) ) self.play(*__A ) self.play(*__A ) self.wait()
336
import inspect import unittest from transformers import ViTHybridConfig from transformers.testing_utils import require_accelerate, 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, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image class __UpperCAmelCase : def __init__( self : List[Any], __A : List[str], __A : List[str]=1_3, __A : Any=6_4, __A : Optional[Any]=2, __A : str=3, __A : str=True, __A : str=True, __A : Optional[Any]=3_2, __A : List[str]=5, __A : int=4, __A : str=3_7, __A : str="gelu", __A : Dict=0.1, __A : List[Any]=0.1, __A : Dict=1_0, __A : int=0.0_2, __A : Any=[1, 1_6, 4, 4], __A : Optional[int]=None, ): UpperCAmelCase : Union[str, Any] = parent UpperCAmelCase : Any = batch_size UpperCAmelCase : List[str] = image_size UpperCAmelCase : List[str] = patch_size UpperCAmelCase : Dict = num_channels UpperCAmelCase : List[Any] = is_training UpperCAmelCase : Dict = use_labels UpperCAmelCase : Optional[int] = hidden_size UpperCAmelCase : Union[str, Any] = num_hidden_layers UpperCAmelCase : Optional[Any] = num_attention_heads UpperCAmelCase : Any = intermediate_size UpperCAmelCase : Any = hidden_act UpperCAmelCase : Any = hidden_dropout_prob UpperCAmelCase : Optional[int] = attention_probs_dropout_prob UpperCAmelCase : str = type_sequence_label_size UpperCAmelCase : Any = initializer_range UpperCAmelCase : int = scope UpperCAmelCase : List[str] = backbone_featmap_shape # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token) # the number of patches is based on the feature map of the backbone, which by default uses an output stride # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size UpperCAmelCase : str = (self.image_size // 3_2) ** 2 UpperCAmelCase : List[str] = num_patches + 1 def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : str = None if self.use_labels: UpperCAmelCase : Any = ids_tensor([self.batch_size], self.type_sequence_label_size ) UpperCAmelCase : Optional[int] = self.get_config() return config, pixel_values, labels def __magic_name__ ( self : Any ): UpperCAmelCase : Dict = { '''global_padding''': '''same''', '''layer_type''': '''bottleneck''', '''depths''': [3, 4, 9], '''out_features''': ['''stage1''', '''stage2''', '''stage3'''], '''embedding_dynamic_padding''': True, '''hidden_sizes''': [4, 8, 1_6, 3_2], '''num_groups''': 2, } return ViTHybridConfig( 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, backbone_featmap_shape=self.backbone_featmap_shape, backbone_config=__A, ) def __magic_name__ ( self : Optional[int], __A : Optional[int], __A : int, __A : Tuple ): UpperCAmelCase : int = ViTHybridModel(config=__A ) model.to(__A ) model.eval() UpperCAmelCase : Tuple = model(__A ) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__ ( self : Tuple, __A : Dict, __A : str, __A : List[str] ): UpperCAmelCase : str = self.type_sequence_label_size UpperCAmelCase : List[Any] = ViTHybridForImageClassification(__A ) model.to(__A ) model.eval() UpperCAmelCase : Dict = model(__A, labels=__A ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.type_sequence_label_size) ) def __magic_name__ ( self : int ): UpperCAmelCase : Union[str, Any] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[str] = config_and_inputs UpperCAmelCase : int = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else () UpperCamelCase = ( {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification} if is_torch_available() else {} ) UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Any = ViTHybridModelTester(self ) UpperCAmelCase : List[Any] = ConfigTester(self, config_class=__A, has_text_modality=__A, hidden_size=3_7 ) def __magic_name__ ( self : int ): self.config_tester.run_common_tests() @unittest.skip(reason='''ViT does not use inputs_embeds''' ) def __magic_name__ ( self : List[Any] ): pass def __magic_name__ ( self : int ): UpperCAmelCase , UpperCAmelCase : List[str] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) self.assertIsInstance(model.get_input_embeddings(), (nn.Module) ) UpperCAmelCase : Optional[int] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__A, nn.Linear ) ) def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : List[Any] = model_class(__A ) UpperCAmelCase : Tuple = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : str = [*signature.parameters.keys()] UpperCAmelCase : Optional[Any] = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Dict = _config_zero_init(__A ) for model_class in self.all_model_classes: UpperCAmelCase : Optional[Any] = model_class(config=__A ) # Skip the check for the backbone for name, module in model.named_modules(): if module.__class__.__name__ == "ViTHybridPatchEmbeddings": UpperCAmelCase : Union[str, Any] = [F'''{name}.{key}''' for key in module.state_dict().keys()] break for name, param in model.named_parameters(): if param.requires_grad: if name in backbone_params: continue 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''', ) @slow def __magic_name__ ( self : List[str] ): for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase : Union[str, Any] = ViTHybridModel.from_pretrained(__A ) self.assertIsNotNone(__A ) def a__ ( ) -> Tuple: UpperCAmelCase : Any = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_torch @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : str ): return ( ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def __magic_name__ ( self : List[str] ): UpperCAmelCase : int = ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to( __A ) UpperCAmelCase : Tuple = self.default_image_processor UpperCAmelCase : int = prepare_img() UpperCAmelCase : Union[str, Any] = image_processor(images=__A, return_tensors='''pt''' ).to(__A ) # forward pass with torch.no_grad(): UpperCAmelCase : Optional[Any] = model(**__A ) # verify the logits UpperCAmelCase : str = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : Optional[Any] = torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9] ).to(__A ) self.assertTrue(torch.allclose(outputs.logits[0, :3], __A, atol=1E-4 ) ) @slow @require_accelerate def __magic_name__ ( self : Dict ): UpperCAmelCase : Union[str, Any] = ViTHybridImageProcessor.from_pretrained('''google/vit-hybrid-base-bit-384''' ) UpperCAmelCase : int = ViTHybridForImageClassification.from_pretrained('''google/vit-hybrid-base-bit-384''', device_map='''auto''' ) UpperCAmelCase : Tuple = prepare_img() UpperCAmelCase : Optional[int] = image_processor(images=__A, return_tensors='''pt''' ) UpperCAmelCase : Dict = model(**__A ) UpperCAmelCase : Any = outputs.logits # model predicts one of the 1000 ImageNet classes UpperCAmelCase : Dict = logits.argmax(-1 ).item() self.assertTrue(model.config.idalabel[predicted_class_idx], '''tabby, tabby cat''' )
336
1
import inspect import re from hashlib import shaaaa from typing import Dict, List from .arrow import arrow from .audiofolder import audiofolder from .csv import csv from .imagefolder import imagefolder from .json import json from .pandas import pandas from .parquet import parquet from .sql import sql # noqa F401 from .text import text def a__ ( UpperCAmelCase : List[str] ) -> str: UpperCAmelCase : str = [] for line in lines: UpperCAmelCase : Dict = re.sub(r'''#.*''' , '''''' , UpperCAmelCase ) # remove comments if line: filtered_lines.append(UpperCAmelCase ) UpperCAmelCase : List[Any] = '''\n'''.join(UpperCAmelCase ) # Make a hash from all this code UpperCAmelCase : Dict = full_str.encode('''utf-8''' ) return shaaaa(UpperCAmelCase ).hexdigest() # get importable module names and hash for caching _lowerCamelCase : str = { "csv": (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())), "json": (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())), "pandas": (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())), "parquet": (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())), "arrow": (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())), "text": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())), "imagefolder": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())), "audiofolder": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())), } # Used to infer the module to use based on the data files extensions _lowerCamelCase : Optional[Any] = { ".csv": ("csv", {}), ".tsv": ("csv", {"sep": "\t"}), ".json": ("json", {}), ".jsonl": ("json", {}), ".parquet": ("parquet", {}), ".arrow": ("arrow", {}), ".txt": ("text", {}), } _EXTENSION_TO_MODULE.update({ext: ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext.upper(): ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext: ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS}) _EXTENSION_TO_MODULE.update({ext.upper(): ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS}) _lowerCamelCase : Dict = {"imagefolder", "audiofolder"} # Used to filter data files based on extensions given a module name _lowerCamelCase : Dict[str, List[str]] = {} for _ext, (_module, _) in _EXTENSION_TO_MODULE.items(): _MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext) _MODULE_TO_EXTENSIONS["imagefolder"].append(".zip") _MODULE_TO_EXTENSIONS["audiofolder"].append(".zip")
336
from __future__ import annotations from itertools import permutations from random import randint from timeit import repeat def a__ ( ) -> tuple[list[int], int]: UpperCAmelCase : str = [randint(-1_000 , 1_000 ) for i in range(10 )] UpperCAmelCase : Any = randint(-5_000 , 5_000 ) return (arr, r) _lowerCamelCase : Any = make_dataset() def a__ ( UpperCAmelCase : list[int] , UpperCAmelCase : int ) -> tuple[int, ...]: for triplet in permutations(UpperCAmelCase , 3 ): if sum(UpperCAmelCase ) == target: return tuple(sorted(UpperCAmelCase ) ) return (0, 0, 0) def a__ ( UpperCAmelCase : list[int] , UpperCAmelCase : int ) -> tuple[int, int, int]: arr.sort() UpperCAmelCase : Tuple = len(UpperCAmelCase ) for i in range(n - 1 ): UpperCAmelCase , UpperCAmelCase : int = i + 1, n - 1 while left < right: if arr[i] + arr[left] + arr[right] == target: return (arr[i], arr[left], arr[right]) elif arr[i] + arr[left] + arr[right] < target: left += 1 elif arr[i] + arr[left] + arr[right] > target: right -= 1 return (0, 0, 0) def a__ ( ) -> tuple[float, float]: UpperCAmelCase : Union[str, Any] = ''' from __main__ import dataset, triplet_sum1, triplet_sum2 ''' UpperCAmelCase : Tuple = ''' triplet_sum1(*dataset) ''' UpperCAmelCase : List[str] = ''' triplet_sum2(*dataset) ''' UpperCAmelCase : Tuple = repeat(setup=UpperCAmelCase , stmt=UpperCAmelCase , repeat=5 , number=10_000 ) UpperCAmelCase : str = repeat(setup=UpperCAmelCase , stmt=UpperCAmelCase , repeat=5 , number=10_000 ) return (min(UpperCAmelCase ), min(UpperCAmelCase )) if __name__ == "__main__": from doctest import testmod testmod() _lowerCamelCase : int = solution_times() print(f"""The time for naive implementation is {times[0]}.""") print(f"""The time for optimized implementation is {times[1]}.""")
336
1
from __future__ import annotations def a__ ( UpperCAmelCase : float , UpperCAmelCase : float , UpperCAmelCase : float , ) -> tuple[str, float]: if (stress, tangential_force, area).count(0 ) != 1: raise ValueError('''You cannot supply more or less than 2 values''' ) elif stress < 0: raise ValueError('''Stress cannot be negative''' ) elif tangential_force < 0: raise ValueError('''Tangential Force cannot be negative''' ) elif area < 0: raise ValueError('''Area cannot be negative''' ) elif stress == 0: return ( "stress", tangential_force / area, ) elif tangential_force == 0: return ( "tangential_force", stress * area, ) else: return ( "area", tangential_force / stress, ) if __name__ == "__main__": import doctest doctest.testmod()
336
from queue import Queue from typing import TYPE_CHECKING, Optional if TYPE_CHECKING: from ..models.auto import AutoTokenizer class __UpperCAmelCase : def __magic_name__ ( self : int, __A : Dict ): raise NotImplementedError() def __magic_name__ ( self : int ): raise NotImplementedError() class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : str, __A : "AutoTokenizer", __A : bool = False, **__A : str ): UpperCAmelCase : List[str] = tokenizer UpperCAmelCase : str = skip_prompt UpperCAmelCase : List[str] = decode_kwargs # variables used in the streaming process UpperCAmelCase : Dict = [] UpperCAmelCase : List[str] = 0 UpperCAmelCase : Union[str, Any] = True def __magic_name__ ( self : Dict, __A : Optional[int] ): if len(value.shape ) > 1 and value.shape[0] > 1: raise ValueError('''TextStreamer only supports batch size 1''' ) elif len(value.shape ) > 1: UpperCAmelCase : Union[str, Any] = value[0] if self.skip_prompt and self.next_tokens_are_prompt: UpperCAmelCase : Optional[int] = False return # Add the new token to the cache and decodes the entire thing. self.token_cache.extend(value.tolist() ) UpperCAmelCase : Any = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) # After the symbol for a new line, we flush the cache. if text.endswith('''\n''' ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] UpperCAmelCase : int = [] UpperCAmelCase : int = 0 # If the last token is a CJK character, we print the characters. elif len(__A ) > 0 and self._is_chinese_char(ord(text[-1] ) ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] self.print_len += len(__A ) # 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: UpperCAmelCase : Optional[Any] = text[self.print_len : text.rfind(''' ''' ) + 1] self.print_len += len(__A ) self.on_finalized_text(__A ) def __magic_name__ ( self : str ): # Flush the cache, if it exists if len(self.token_cache ) > 0: UpperCAmelCase : int = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) UpperCAmelCase : Dict = text[self.print_len :] UpperCAmelCase : List[Any] = [] UpperCAmelCase : List[Any] = 0 else: UpperCAmelCase : Dict = '''''' UpperCAmelCase : str = True self.on_finalized_text(__A, stream_end=__A ) def __magic_name__ ( self : List[str], __A : str, __A : bool = False ): print(__A, flush=__A, end='''''' if not stream_end else None ) def __magic_name__ ( self : List[Any], __A : Optional[int] ): # 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 >= 0X4E00 and cp <= 0X9FFF) or (cp >= 0X3400 and cp <= 0X4DBF) # or (cp >= 0X20000 and cp <= 0X2A6DF) # or (cp >= 0X2A700 and cp <= 0X2B73F) # or (cp >= 0X2B740 and cp <= 0X2B81F) # or (cp >= 0X2B820 and cp <= 0X2CEAF) # or (cp >= 0XF900 and cp <= 0XFAFF) or (cp >= 0X2F800 and cp <= 0X2FA1F) # ): # return True return False class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Dict, __A : "AutoTokenizer", __A : bool = False, __A : Optional[float] = None, **__A : str ): super().__init__(__A, __A, **__A ) UpperCAmelCase : Dict = Queue() UpperCAmelCase : Any = None UpperCAmelCase : Any = timeout def __magic_name__ ( self : Dict, __A : str, __A : bool = False ): self.text_queue.put(__A, timeout=self.timeout ) if stream_end: self.text_queue.put(self.stop_signal, timeout=self.timeout ) def __iter__( self : int ): return self def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : List[Any] = self.text_queue.get(timeout=self.timeout ) if value == self.stop_signal: raise StopIteration() else: return value
336
1
_lowerCamelCase : Union[str, Any] = { "A": ["B", "C", "E"], "B": ["A", "D", "E"], "C": ["A", "F", "G"], "D": ["B"], "E": ["A", "B", "D"], "F": ["C"], "G": ["C"], } def a__ ( UpperCAmelCase : dict , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : Optional[int] ) -> list[str]: UpperCAmelCase : Dict = set() # keep track of all the paths to be checked UpperCAmelCase : List[Any] = [[start]] # return path if start is goal if start == goal: return [start] # keeps looping until all possible paths have been checked while queue: # pop the first path from the queue UpperCAmelCase : int = queue.pop(0 ) # get the last node from the path UpperCAmelCase : Optional[Any] = path[-1] if node not in explored: UpperCAmelCase : Tuple = graph[node] # go through all neighbour nodes, construct a new path and # push it into the queue for neighbour in neighbours: UpperCAmelCase : int = list(UpperCAmelCase ) new_path.append(UpperCAmelCase ) queue.append(UpperCAmelCase ) # return path if neighbour is goal if neighbour == goal: return new_path # mark node as explored explored.add(UpperCAmelCase ) # in case there's no path between the 2 nodes return [] def a__ ( UpperCAmelCase : dict , UpperCAmelCase : List[str] , UpperCAmelCase : List[Any] ) -> int: if not graph or start not in graph or target not in graph: return -1 if start == target: return 0 UpperCAmelCase : List[Any] = [start] UpperCAmelCase : str = set(UpperCAmelCase ) # Keep tab on distances from `start` node. UpperCAmelCase : List[str] = {start: 0, target: -1} while queue: UpperCAmelCase : Tuple = queue.pop(0 ) if node == target: UpperCAmelCase : List[str] = ( dist[node] if dist[target] == -1 else min(dist[target] , dist[node] ) ) for adjacent in graph[node]: if adjacent not in visited: visited.add(UpperCAmelCase ) queue.append(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = dist[node] + 1 return dist[target] if __name__ == "__main__": print(bfs_shortest_path(demo_graph, "G", "D")) # returns ['G', 'C', 'A', 'B', 'D'] print(bfs_shortest_path_distance(demo_graph, "G", "D")) # returns 4
336
import numpy # List of input, output pairs _lowerCamelCase : Dict = ( ((5, 2, 3), 1_5), ((6, 5, 9), 2_5), ((1_1, 1_2, 1_3), 4_1), ((1, 1, 1), 8), ((1_1, 1_2, 1_3), 4_1), ) _lowerCamelCase : str = (((5_1_5, 2_2, 1_3), 5_5_5), ((6_1, 3_5, 4_9), 1_5_0)) _lowerCamelCase : Dict = [2, 4, 1, 5] _lowerCamelCase : Dict = len(train_data) _lowerCamelCase : int = 0.0_0_9 def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : Optional[int]="train" ) -> Dict: return calculate_hypothesis_value(UpperCAmelCase , UpperCAmelCase ) - output( UpperCAmelCase , UpperCAmelCase ) def a__ ( UpperCAmelCase : int ) -> Any: UpperCAmelCase : str = 0 for i in range(len(UpperCAmelCase ) - 1 ): hyp_val += data_input_tuple[i] * parameter_vector[i + 1] hyp_val += parameter_vector[0] return hyp_val def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : Optional[Any] ) -> Optional[int]: if data_set == "train": return train_data[example_no][1] elif data_set == "test": return test_data[example_no][1] return None def a__ ( UpperCAmelCase : int , UpperCAmelCase : Optional[Any] ) -> 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 a__ ( UpperCAmelCase : Dict , UpperCAmelCase : str=m ) -> Dict: UpperCAmelCase : Optional[int] = 0 for i in range(UpperCAmelCase ): if index == -1: summation_value += _error(UpperCAmelCase ) else: summation_value += _error(UpperCAmelCase ) * train_data[i][0][index] return summation_value def a__ ( UpperCAmelCase : Dict ) -> Dict: UpperCAmelCase : Dict = summation_of_cost_derivative(UpperCAmelCase , UpperCAmelCase ) / m return cost_derivative_value def a__ ( ) -> List[Any]: global parameter_vector # Tune these values to set a tolerance value for predicted output UpperCAmelCase : List[str] = 0.000002 UpperCAmelCase : Any = 0 UpperCAmelCase : Dict = 0 while True: j += 1 UpperCAmelCase : List[Any] = [0, 0, 0, 0] for i in range(0 , len(UpperCAmelCase ) ): UpperCAmelCase : List[str] = get_cost_derivative(i - 1 ) UpperCAmelCase : Tuple = ( parameter_vector[i] - LEARNING_RATE * cost_derivative ) if numpy.allclose( UpperCAmelCase , UpperCAmelCase , atol=UpperCAmelCase , rtol=UpperCAmelCase , ): break UpperCAmelCase : int = temp_parameter_vector print(('''Number of iterations:''', j) ) def a__ ( ) -> List[Any]: for i in range(len(UpperCAmelCase ) ): print(('''Actual output value:''', output(UpperCAmelCase , '''test''' )) ) print(('''Hypothesis output:''', calculate_hypothesis_value(UpperCAmelCase , '''test''' )) ) if __name__ == "__main__": run_gradient_descent() print("\nTesting gradient descent for a linear hypothesis function.\n") test_gradient_descent()
336
1
import shutil import tempfile import unittest import numpy as np import pytest from transformers.testing_utils import require_vision from transformers.utils import is_vision_available if is_vision_available(): from PIL import Image from transformers import AutoProcessor, BertTokenizer, BlipImageProcessor, BlipProcessor, PreTrainedTokenizerFast @require_vision class __UpperCAmelCase ( unittest.TestCase ): def __magic_name__ ( self : List[Any] ): UpperCAmelCase : Optional[Any] = tempfile.mkdtemp() UpperCAmelCase : List[Any] = BlipImageProcessor() UpperCAmelCase : Union[str, Any] = BertTokenizer.from_pretrained('''hf-internal-testing/tiny-random-BertModel''' ) UpperCAmelCase : Optional[int] = BlipProcessor(__A, __A ) processor.save_pretrained(self.tmpdirname ) def __magic_name__ ( self : str, **__A : str ): return AutoProcessor.from_pretrained(self.tmpdirname, **__A ).tokenizer def __magic_name__ ( self : List[Any], **__A : str ): return AutoProcessor.from_pretrained(self.tmpdirname, **__A ).image_processor def __magic_name__ ( self : Tuple ): shutil.rmtree(self.tmpdirname ) def __magic_name__ ( self : str ): UpperCAmelCase : Union[str, Any] = [np.random.randint(2_5_5, size=(3, 3_0, 4_0_0), dtype=np.uinta )] UpperCAmelCase : str = [Image.fromarray(np.moveaxis(__A, 0, -1 ) ) for x in image_inputs] return image_inputs def __magic_name__ ( self : str ): UpperCAmelCase : List[str] = BlipProcessor(tokenizer=self.get_tokenizer(), image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) UpperCAmelCase : List[str] = self.get_tokenizer(bos_token='''(BOS)''', eos_token='''(EOS)''' ) UpperCAmelCase : Tuple = self.get_image_processor(do_normalize=__A, padding_value=1.0 ) UpperCAmelCase : Union[str, Any] = BlipProcessor.from_pretrained( self.tmpdirname, bos_token='''(BOS)''', eos_token='''(EOS)''', do_normalize=__A, padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab(), tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer, __A ) self.assertEqual(processor.image_processor.to_json_string(), image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor, __A ) def __magic_name__ ( self : str ): UpperCAmelCase : int = self.get_image_processor() UpperCAmelCase : Dict = self.get_tokenizer() UpperCAmelCase : Union[str, Any] = BlipProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : List[str] = self.prepare_image_inputs() UpperCAmelCase : Optional[Any] = image_processor(__A, return_tensors='''np''' ) UpperCAmelCase : Tuple = processor(images=__A, return_tensors='''np''' ) for key in input_feat_extract.keys(): self.assertAlmostEqual(input_feat_extract[key].sum(), input_processor[key].sum(), delta=1E-2 ) def __magic_name__ ( self : Tuple ): UpperCAmelCase : Optional[int] = self.get_image_processor() UpperCAmelCase : Any = self.get_tokenizer() UpperCAmelCase : int = BlipProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Optional[int] = '''lower newer''' UpperCAmelCase : Any = processor(text=__A ) UpperCAmelCase : Optional[int] = tokenizer(__A, return_token_type_ids=__A ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key], encoded_processor[key] ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = self.get_image_processor() UpperCAmelCase : Union[str, Any] = self.get_tokenizer() UpperCAmelCase : int = BlipProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Any = '''lower newer''' UpperCAmelCase : Optional[int] = self.prepare_image_inputs() UpperCAmelCase : Tuple = processor(text=__A, images=__A ) self.assertListEqual(list(inputs.keys() ), ['''pixel_values''', '''input_ids''', '''attention_mask'''] ) # test if it raises when no input is passed with pytest.raises(__A ): processor() def __magic_name__ ( self : Tuple ): UpperCAmelCase : Dict = self.get_image_processor() UpperCAmelCase : Any = self.get_tokenizer() UpperCAmelCase : Dict = BlipProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Optional[Any] = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] UpperCAmelCase : List[str] = processor.batch_decode(__A ) UpperCAmelCase : int = tokenizer.batch_decode(__A ) self.assertListEqual(__A, __A ) def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Any = self.get_image_processor() UpperCAmelCase : Tuple = self.get_tokenizer() UpperCAmelCase : str = BlipProcessor(tokenizer=__A, image_processor=__A ) UpperCAmelCase : Dict = '''lower newer''' UpperCAmelCase : Optional[int] = self.prepare_image_inputs() UpperCAmelCase : Optional[Any] = processor(text=__A, images=__A ) # For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask'] self.assertListEqual(list(inputs.keys() ), ['''pixel_values''', '''input_ids''', '''attention_mask'''] )
336
def a__ ( UpperCAmelCase : List[Any] , UpperCAmelCase : Optional[int] ) -> Optional[Any]: UpperCAmelCase : List[str] = 0 UpperCAmelCase : List[Any] = len(UpperCAmelCase ) - 1 while left <= right: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : Optional[int] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None UpperCAmelCase : Optional[Any] = sorted_collection[point] if current_item == item: return point else: if point < left: UpperCAmelCase : Any = left UpperCAmelCase : List[str] = point elif point > right: UpperCAmelCase : Any = right UpperCAmelCase : List[str] = point else: if item < current_item: UpperCAmelCase : Optional[int] = point - 1 else: UpperCAmelCase : str = point + 1 return None def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : int , UpperCAmelCase : str , UpperCAmelCase : Union[str, Any] ) -> Dict: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : List[str] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None if sorted_collection[point] == item: return point elif point < left: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) elif point > right: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) else: if sorted_collection[point] > item: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , point - 1 ) else: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , point + 1 , UpperCAmelCase ) def a__ ( UpperCAmelCase : Union[str, Any] ) -> int: if collection != sorted(UpperCAmelCase ): raise ValueError('''Collection must be ascending sorted''' ) return True if __name__ == "__main__": import sys _lowerCamelCase : Optional[int] = 0 if debug == 1: _lowerCamelCase : Dict = [1_0, 3_0, 4_0, 4_5, 5_0, 6_6, 7_7, 9_3] try: __assert_sorted(collection) except ValueError: sys.exit("Sequence must be ascending sorted to apply interpolation search") _lowerCamelCase : List[Any] = 6_7 _lowerCamelCase : Optional[Any] = interpolation_search(collection, target) if result is not None: print(f"""{target} found at positions: {result}""") else: print("Not found")
336
1
import importlib import shutil import threading import warnings from typing import List import fsspec import fsspec.asyn from . import compression from .hffilesystem import HfFileSystem _lowerCamelCase : List[Any] = importlib.util.find_spec("s3fs") is not None if _has_safs: from .safilesystem import SaFileSystem # noqa: F401 _lowerCamelCase : List[compression.BaseCompressedFileFileSystem] = [ 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 a__ ( UpperCAmelCase : str ) -> str: if "://" in dataset_path: UpperCAmelCase : Optional[Any] = dataset_path.split('''://''' )[1] return dataset_path def a__ ( UpperCAmelCase : fsspec.AbstractFileSystem ) -> bool: if fs is not None and fs.protocol != "file": return True else: return False def a__ ( UpperCAmelCase : fsspec.AbstractFileSystem , UpperCAmelCase : str , UpperCAmelCase : str ) -> List[str]: UpperCAmelCase : Any = not is_remote_filesystem(UpperCAmelCase ) if is_local: # LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory shutil.move(fs._strip_protocol(UpperCAmelCase ) , fs._strip_protocol(UpperCAmelCase ) ) else: fs.mv(UpperCAmelCase , UpperCAmelCase , recursive=UpperCAmelCase ) def a__ ( ) -> None: if hasattr(fsspec.asyn , '''reset_lock''' ): # for future fsspec>2022.05.0 fsspec.asyn.reset_lock() else: UpperCAmelCase : Tuple = None UpperCAmelCase : str = None UpperCAmelCase : Tuple = threading.Lock()
336
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 BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor from transformers.image_utils import PILImageResampling from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : Any = logging.get_logger(__name__) def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Optional[Any]=False , UpperCAmelCase : List[str]=False ) -> Any: UpperCAmelCase : Optional[int] = '''backbone.''' if is_semantic else '''''' UpperCAmelCase : Dict = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f'''{prefix}blocks.{i}.norm1.weight''', f'''beit.encoder.layer.{i}.layernorm_before.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm1.bias''', f'''beit.encoder.layer.{i}.layernorm_before.bias''') ) rename_keys.append( (f'''{prefix}blocks.{i}.attn.proj.weight''', f'''beit.encoder.layer.{i}.attention.output.dense.weight''') ) rename_keys.append( (f'''{prefix}blocks.{i}.attn.proj.bias''', f'''beit.encoder.layer.{i}.attention.output.dense.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm2.weight''', f'''beit.encoder.layer.{i}.layernorm_after.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm2.bias''', f'''beit.encoder.layer.{i}.layernorm_after.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc1.weight''', f'''beit.encoder.layer.{i}.intermediate.dense.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc1.bias''', f'''beit.encoder.layer.{i}.intermediate.dense.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc2.weight''', f'''beit.encoder.layer.{i}.output.dense.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc2.bias''', f'''beit.encoder.layer.{i}.output.dense.bias''') ) # projection layer + position embeddings rename_keys.extend( [ (f'''{prefix}cls_token''', '''beit.embeddings.cls_token'''), (f'''{prefix}patch_embed.proj.weight''', '''beit.embeddings.patch_embeddings.projection.weight'''), (f'''{prefix}patch_embed.proj.bias''', '''beit.embeddings.patch_embeddings.projection.bias'''), (f'''{prefix}pos_embed''', '''beit.embeddings.position_embeddings'''), ] ) if has_lm_head: # mask token + layernorm rename_keys.extend( [ ('''mask_token''', '''beit.embeddings.mask_token'''), ('''norm.weight''', '''layernorm.weight'''), ('''norm.bias''', '''layernorm.bias'''), ] ) else: # layernorm + classification head rename_keys.extend( [ ('''fc_norm.weight''', '''beit.pooler.layernorm.weight'''), ('''fc_norm.bias''', '''beit.pooler.layernorm.bias'''), ('''head.weight''', '''classifier.weight'''), ('''head.bias''', '''classifier.bias'''), ] ) return rename_keys def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : str , UpperCAmelCase : str=False , UpperCAmelCase : Dict=False ) -> Any: for i in range(config.num_hidden_layers ): UpperCAmelCase : Tuple = '''backbone.''' if is_semantic else '''''' # queries, keys and values UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.qkv.weight''' ) UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.q_bias''' ) UpperCAmelCase : List[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.v_bias''' ) UpperCAmelCase : Union[str, Any] = in_proj_weight[ : config.hidden_size, : ] UpperCAmelCase : str = q_bias UpperCAmelCase : List[str] = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] UpperCAmelCase : List[str] = in_proj_weight[ -config.hidden_size :, : ] UpperCAmelCase : int = v_bias # gamma_1 and gamma_2 # we call them lambda because otherwise they are renamed when using .from_pretrained UpperCAmelCase : int = state_dict.pop(f'''{prefix}blocks.{i}.gamma_1''' ) UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.gamma_2''' ) UpperCAmelCase : str = gamma_a UpperCAmelCase : Dict = gamma_a def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : List[Any] , UpperCAmelCase : Tuple ) -> Optional[Any]: UpperCAmelCase : Union[str, Any] = dct.pop(UpperCAmelCase ) UpperCAmelCase : str = val def a__ ( ) -> Optional[int]: UpperCAmelCase : List[Any] = '''http://images.cocodataset.org/val2017/000000039769.jpg''' UpperCAmelCase : Union[str, Any] = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ) return im @torch.no_grad() def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Tuple , UpperCAmelCase : List[Any]=False ) -> Union[str, Any]: UpperCAmelCase : Dict = False if '''rvlcdip''' in checkpoint_url else True UpperCAmelCase : Any = BeitConfig(use_absolute_position_embeddings=UpperCAmelCase , use_mask_token=UpperCAmelCase ) # size of the architecture if "large" in checkpoint_url or "dit-l" in checkpoint_url: UpperCAmelCase : List[Any] = 1_024 UpperCAmelCase : Optional[Any] = 4_096 UpperCAmelCase : Any = 24 UpperCAmelCase : Union[str, Any] = 16 # labels if "rvlcdip" in checkpoint_url: UpperCAmelCase : Optional[Any] = 16 UpperCAmelCase : List[Any] = '''huggingface/label-files''' UpperCAmelCase : Any = '''rvlcdip-id2label.json''' UpperCAmelCase : List[str] = json.load(open(hf_hub_download(UpperCAmelCase , UpperCAmelCase , repo_type='''dataset''' ) , '''r''' ) ) UpperCAmelCase : Dict = {int(UpperCAmelCase ): v for k, v in idalabel.items()} UpperCAmelCase : Union[str, Any] = idalabel UpperCAmelCase : Tuple = {v: k for k, v in idalabel.items()} # load state_dict of original model, remove and rename some keys UpperCAmelCase : Tuple = torch.hub.load_state_dict_from_url(UpperCAmelCase , map_location='''cpu''' )['''model'''] UpperCAmelCase : List[str] = create_rename_keys(UpperCAmelCase , has_lm_head=UpperCAmelCase ) for src, dest in rename_keys: rename_key(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) read_in_q_k_v(UpperCAmelCase , UpperCAmelCase , has_lm_head=UpperCAmelCase ) # load HuggingFace model UpperCAmelCase : Tuple = BeitForMaskedImageModeling(UpperCAmelCase ) if has_lm_head else BeitForImageClassification(UpperCAmelCase ) model.eval() model.load_state_dict(UpperCAmelCase ) # Check outputs on an image UpperCAmelCase : Dict = BeitImageProcessor( size=config.image_size , resample=PILImageResampling.BILINEAR , do_center_crop=UpperCAmelCase ) UpperCAmelCase : List[str] = prepare_img() UpperCAmelCase : Optional[Any] = image_processor(images=UpperCAmelCase , return_tensors='''pt''' ) UpperCAmelCase : str = encoding['''pixel_values'''] UpperCAmelCase : Any = model(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = outputs.logits # verify logits UpperCAmelCase : List[Any] = [1, 16] if '''rvlcdip''' in checkpoint_url else [1, 196, 8_192] assert logits.shape == torch.Size(UpperCAmelCase ), "Shape of logits not as expected" Path(UpperCAmelCase ).mkdir(exist_ok=UpperCAmelCase ) print(f'''Saving model to {pytorch_dump_folder_path}''' ) model.save_pretrained(UpperCAmelCase ) print(f'''Saving image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(UpperCAmelCase ) if push_to_hub: if has_lm_head: UpperCAmelCase : List[Any] = '''dit-base''' if '''base''' in checkpoint_url else '''dit-large''' else: UpperCAmelCase : Any = '''dit-base-finetuned-rvlcdip''' if '''dit-b''' in checkpoint_url else '''dit-large-finetuned-rvlcdip''' image_processor.push_to_hub( repo_path_or_name=Path(UpperCAmelCase , UpperCAmelCase ) , organization='''nielsr''' , commit_message='''Add image processor''' , use_temp_dir=UpperCAmelCase , ) model.push_to_hub( repo_path_or_name=Path(UpperCAmelCase , UpperCAmelCase ) , organization='''nielsr''' , commit_message='''Add model''' , use_temp_dir=UpperCAmelCase , ) if __name__ == "__main__": _lowerCamelCase : Tuple = argparse.ArgumentParser() parser.add_argument( "--checkpoint_url", default="https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth", type=str, help="URL to the original PyTorch checkpoint (.pth file).", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model." ) parser.add_argument( "--push_to_hub", action="store_true", ) _lowerCamelCase : Optional[int] = parser.parse_args() convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
336
1
import os from typing import List, Optional, Union from ...tokenization_utils import PreTrainedTokenizer from ...tokenization_utils_base import AddedToken from ...utils import logging _lowerCamelCase : Optional[Any] = logging.get_logger(__name__) _lowerCamelCase : Dict = {"vocab_file": "vocab.txt"} _lowerCamelCase : List[str] = { "vocab_file": { "facebook/esm2_t6_8M_UR50D": "https://huggingface.co/facebook/esm2_t6_8M_UR50D/resolve/main/vocab.txt", "facebook/esm2_t12_35M_UR50D": "https://huggingface.co/facebook/esm2_t12_35M_UR50D/resolve/main/vocab.txt", }, } _lowerCamelCase : List[Any] = { "facebook/esm2_t6_8M_UR50D": 1_0_2_4, "facebook/esm2_t12_35M_UR50D": 1_0_2_4, } def a__ ( UpperCAmelCase : List[str] ) -> Any: with open(UpperCAmelCase , '''r''' ) as f: UpperCAmelCase : Dict = f.read().splitlines() return [l.strip() for l in lines] class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = VOCAB_FILES_NAMES UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase = ["""input_ids""", """attention_mask"""] def __init__( self : Any, __A : Dict, __A : List[Any]="<unk>", __A : List[str]="<cls>", __A : Any="<pad>", __A : Union[str, Any]="<mask>", __A : int="<eos>", **__A : Tuple, ): super().__init__(**__A ) UpperCAmelCase : Tuple = load_vocab_file(__A ) UpperCAmelCase : List[Any] = dict(enumerate(self.all_tokens ) ) UpperCAmelCase : str = {tok: ind for ind, tok in enumerate(self.all_tokens )} UpperCAmelCase : Union[str, Any] = unk_token UpperCAmelCase : Optional[Any] = cls_token UpperCAmelCase : Optional[int] = pad_token UpperCAmelCase : Optional[int] = mask_token UpperCAmelCase : List[str] = eos_token UpperCAmelCase : Optional[Any] = self.all_tokens self._create_trie(self.unique_no_split_tokens ) def __magic_name__ ( self : Tuple, __A : int ): return self._id_to_token.get(__A, self.unk_token ) def __magic_name__ ( self : List[Any], __A : str ): return self._token_to_id.get(__A, self._token_to_id.get(self.unk_token ) ) def __magic_name__ ( self : Any, __A : Optional[Any], **__A : Union[str, Any] ): return text.split() def __magic_name__ ( self : Optional[int], __A : Dict=False ): return len(self._id_to_token ) def __magic_name__ ( self : int ): return {token: i for i, token in enumerate(self.all_tokens )} def __magic_name__ ( self : Tuple, __A : str ): return self._token_to_id.get(__A, self._token_to_id.get(self.unk_token ) ) def __magic_name__ ( self : Any, __A : int ): return self._id_to_token.get(__A, self.unk_token ) def __magic_name__ ( self : Union[str, Any], __A : List[int], __A : Optional[List[int]] = None ): UpperCAmelCase : Optional[int] = [self.cls_token_id] UpperCAmelCase : Optional[int] = [self.eos_token_id] # No sep token in ESM vocabulary if token_ids_a is None: if self.eos_token_id is None: return cls + token_ids_a else: return cls + token_ids_a + sep elif self.eos_token_id is None: raise ValueError('''Cannot tokenize multiple sequences when EOS token is not set!''' ) return cls + token_ids_a + sep + token_ids_a + sep # Multiple inputs always have an EOS token def __magic_name__ ( self : Any, __A : List, __A : Optional[List] = None, __A : bool = False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( '''You should not supply a second sequence if the provided sequence of ''' '''ids is already formatted with special tokens for the model.''' ) return [1 if token in self.all_special_ids else 0 for token in token_ids_a] UpperCAmelCase : Dict = [1] + ([0] * len(__A )) + [1] if token_ids_a is not None: mask += [0] * len(__A ) + [1] return mask def __magic_name__ ( self : Optional[int], __A : List[Any], __A : Dict ): UpperCAmelCase : Union[str, Any] = os.path.join(__A, (filename_prefix + '''-''' if filename_prefix else '''''') + '''vocab.txt''' ) with open(__A, '''w''' ) as f: f.write('''\n'''.join(self.all_tokens ) ) return (vocab_file,) @property def __magic_name__ ( self : Dict ): return self.get_vocab_size(with_added_tokens=__A ) def __magic_name__ ( self : Optional[int], __A : Union[List[str], List[AddedToken]], __A : bool = False ): return super()._add_tokens(__A, special_tokens=__A )
336
import unittest import numpy as np from transformers import RobertaConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_flax_available(): from transformers.models.roberta.modeling_flax_roberta import ( FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaModel, ) class __UpperCAmelCase ( unittest.TestCase ): def __init__( self : Optional[int], __A : Optional[int], __A : Any=1_3, __A : str=7, __A : Optional[int]=True, __A : Tuple=True, __A : Union[str, Any]=True, __A : Any=True, __A : Optional[int]=9_9, __A : Tuple=3_2, __A : str=5, __A : Union[str, Any]=4, __A : List[str]=3_7, __A : Tuple="gelu", __A : Optional[int]=0.1, __A : int=0.1, __A : Optional[Any]=5_1_2, __A : int=1_6, __A : Optional[Any]=2, __A : Union[str, Any]=0.0_2, __A : Optional[int]=4, ): UpperCAmelCase : Any = parent UpperCAmelCase : List[Any] = batch_size UpperCAmelCase : Any = seq_length UpperCAmelCase : Tuple = is_training UpperCAmelCase : str = use_attention_mask UpperCAmelCase : List[str] = use_token_type_ids UpperCAmelCase : int = use_labels UpperCAmelCase : List[Any] = vocab_size UpperCAmelCase : Optional[int] = hidden_size UpperCAmelCase : str = num_hidden_layers UpperCAmelCase : Dict = num_attention_heads UpperCAmelCase : Tuple = intermediate_size UpperCAmelCase : List[str] = hidden_act UpperCAmelCase : str = hidden_dropout_prob UpperCAmelCase : int = attention_probs_dropout_prob UpperCAmelCase : List[Any] = max_position_embeddings UpperCAmelCase : Optional[Any] = type_vocab_size UpperCAmelCase : Any = type_sequence_label_size UpperCAmelCase : Optional[Any] = initializer_range UpperCAmelCase : Any = num_choices def __magic_name__ ( self : str ): UpperCAmelCase : Any = ids_tensor([self.batch_size, self.seq_length], self.vocab_size ) UpperCAmelCase : List[Any] = None if self.use_attention_mask: UpperCAmelCase : Any = random_attention_mask([self.batch_size, self.seq_length] ) UpperCAmelCase : Any = None if self.use_token_type_ids: UpperCAmelCase : Any = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size ) UpperCAmelCase : Union[str, Any] = RobertaConfig( vocab_size=self.vocab_size, hidden_size=self.hidden_size, num_hidden_layers=self.num_hidden_layers, num_attention_heads=self.num_attention_heads, intermediate_size=self.intermediate_size, hidden_act=self.hidden_act, hidden_dropout_prob=self.hidden_dropout_prob, attention_probs_dropout_prob=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, type_vocab_size=self.type_vocab_size, is_decoder=__A, initializer_range=self.initializer_range, ) return config, input_ids, token_type_ids, attention_mask def __magic_name__ ( self : int ): UpperCAmelCase : Any = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[Any] = config_and_inputs UpperCAmelCase : Dict = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask} return config, inputs_dict def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Dict = config_and_inputs UpperCAmelCase : Any = True UpperCAmelCase : Union[str, Any] = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) UpperCAmelCase : List[Any] = ids_tensor([self.batch_size, self.seq_length], vocab_size=2 ) return ( config, input_ids, token_type_ids, encoder_hidden_states, encoder_attention_mask, ) @require_flax class __UpperCAmelCase ( lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRobertaModel, FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, ) if is_flax_available() else () ) def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : Dict = FlaxRobertaModelTester(self ) @slow def __magic_name__ ( self : Any ): for model_class_name in self.all_model_classes: UpperCAmelCase : Dict = model_class_name.from_pretrained('''roberta-base''', from_pt=__A ) UpperCAmelCase : List[str] = model(np.ones((1, 1) ) ) self.assertIsNotNone(__A )
336
1
import re import string from collections import Counter import sacrebleu import sacremoses from packaging import version import datasets _lowerCamelCase : int = "\n@inproceedings{xu-etal-2016-optimizing,\n title = {Optimizing Statistical Machine Translation for Text Simplification},\n authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},\n journal = {Transactions of the Association for Computational Linguistics},\n volume = {4},\n year={2016},\n url = {https://www.aclweb.org/anthology/Q16-1029},\n pages = {401--415\n},\n@inproceedings{post-2018-call,\n title = \"A Call for Clarity in Reporting {BLEU} Scores\",\n author = \"Post, Matt\",\n booktitle = \"Proceedings of the Third Conference on Machine Translation: Research Papers\",\n month = oct,\n year = \"2018\",\n address = \"Belgium, Brussels\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://www.aclweb.org/anthology/W18-6319\",\n pages = \"186--191\",\n}\n" _lowerCamelCase : List[str] = "\\nWIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU\nIt can be used to evaluate the quality of machine-generated texts.\n" _lowerCamelCase : Optional[Any] = "\nCalculates sari score (between 0 and 100) given a list of source and predicted\nsentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.\nArgs:\n sources: list of source sentences where each sentence should be a string.\n predictions: list of predicted sentences where each sentence should be a string.\n references: list of lists of reference sentences where each sentence should be a string.\nReturns:\n sari: sari score\n sacrebleu: sacrebleu score\n exact: exact score\n\nExamples:\n >>> sources=[\"About 95 species are currently accepted .\"]\n >>> predictions=[\"About 95 you now get in .\"]\n >>> references=[[\"About 95 species are currently known .\"]]\n >>> wiki_split = datasets.load_metric(\"wiki_split\")\n >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)\n >>> print(results)\n {'sari': 21.805555555555557, 'sacrebleu': 14.535768424205482, 'exact': 0.0}\n" def a__ ( UpperCAmelCase : List[str] ) -> Tuple: def remove_articles(UpperCAmelCase : Dict ): UpperCAmelCase : List[str] = re.compile(r'''\b(a|an|the)\b''' , re.UNICODE ) return re.sub(UpperCAmelCase , ''' ''' , UpperCAmelCase ) def white_space_fix(UpperCAmelCase : List[str] ): return " ".join(text.split() ) def remove_punc(UpperCAmelCase : str ): UpperCAmelCase : Tuple = set(string.punctuation ) return "".join(ch for ch in text if ch not in exclude ) def lower(UpperCAmelCase : Optional[int] ): return text.lower() return white_space_fix(remove_articles(remove_punc(lower(UpperCAmelCase ) ) ) ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : str ) -> int: return int(normalize_answer(UpperCAmelCase ) == normalize_answer(UpperCAmelCase ) ) def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : Union[str, Any] ) -> List[Any]: UpperCAmelCase : Tuple = [any(compute_exact(UpperCAmelCase , UpperCAmelCase ) for ref in refs ) for pred, refs in zip(UpperCAmelCase , UpperCAmelCase )] return (sum(UpperCAmelCase ) / len(UpperCAmelCase )) * 100 def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Any , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : Optional[int] ) -> List[str]: UpperCAmelCase : Union[str, Any] = [rgram for rgrams in rgramslist for rgram in rgrams] UpperCAmelCase : int = Counter(UpperCAmelCase ) UpperCAmelCase : List[str] = Counter(UpperCAmelCase ) UpperCAmelCase : str = Counter() for sgram, scount in sgramcounter.items(): UpperCAmelCase : Union[str, Any] = scount * numref UpperCAmelCase : Optional[int] = Counter(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = Counter() for cgram, ccount in cgramcounter.items(): UpperCAmelCase : int = ccount * numref # KEEP UpperCAmelCase : str = sgramcounter_rep & cgramcounter_rep UpperCAmelCase : str = keepgramcounter_rep & rgramcounter UpperCAmelCase : Tuple = sgramcounter_rep & rgramcounter UpperCAmelCase : Optional[Any] = 0 UpperCAmelCase : Dict = 0 for keepgram in keepgramcountergood_rep: keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram] # Fix an alleged bug [2] in the keep score computation. # keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram] keeptmpscorea += keepgramcountergood_rep[keepgram] # Define 0/0=1 instead of 0 to give higher scores for predictions that match # a target exactly. UpperCAmelCase : Union[str, Any] = 1 UpperCAmelCase : str = 1 if len(UpperCAmelCase ) > 0: UpperCAmelCase : int = keeptmpscorea / len(UpperCAmelCase ) if len(UpperCAmelCase ) > 0: # Fix an alleged bug [2] in the keep score computation. # keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep) UpperCAmelCase : Union[str, Any] = keeptmpscorea / sum(keepgramcounterall_rep.values() ) UpperCAmelCase : List[Any] = 0 if keepscore_precision > 0 or keepscore_recall > 0: UpperCAmelCase : List[str] = 2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall) # DELETION UpperCAmelCase : int = sgramcounter_rep - cgramcounter_rep UpperCAmelCase : str = delgramcounter_rep - rgramcounter UpperCAmelCase : Tuple = sgramcounter_rep - rgramcounter UpperCAmelCase : Any = 0 UpperCAmelCase : Optional[Any] = 0 for delgram in delgramcountergood_rep: deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram] deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram] # Define 0/0=1 instead of 0 to give higher scores for predictions that match # a target exactly. UpperCAmelCase : Any = 1 if len(UpperCAmelCase ) > 0: UpperCAmelCase : List[str] = deltmpscorea / len(UpperCAmelCase ) # ADDITION UpperCAmelCase : Tuple = set(UpperCAmelCase ) - set(UpperCAmelCase ) UpperCAmelCase : Any = set(UpperCAmelCase ) & set(UpperCAmelCase ) UpperCAmelCase : str = set(UpperCAmelCase ) - set(UpperCAmelCase ) UpperCAmelCase : Tuple = 0 for addgram in addgramcountergood: addtmpscore += 1 # Define 0/0=1 instead of 0 to give higher scores for predictions that match # a target exactly. UpperCAmelCase : Tuple = 1 UpperCAmelCase : Optional[Any] = 1 if len(UpperCAmelCase ) > 0: UpperCAmelCase : Any = addtmpscore / len(UpperCAmelCase ) if len(UpperCAmelCase ) > 0: UpperCAmelCase : List[str] = addtmpscore / len(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = 0 if addscore_precision > 0 or addscore_recall > 0: UpperCAmelCase : List[str] = 2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall) return (keepscore, delscore_precision, addscore) def a__ ( UpperCAmelCase : str , UpperCAmelCase : List[str] , UpperCAmelCase : Optional[Any] ) -> Dict: UpperCAmelCase : Optional[Any] = len(UpperCAmelCase ) UpperCAmelCase : Union[str, Any] = ssent.split(''' ''' ) UpperCAmelCase : Optional[int] = csent.split(''' ''' ) UpperCAmelCase : Tuple = [] UpperCAmelCase : Optional[int] = [] UpperCAmelCase : Optional[Any] = [] UpperCAmelCase : Optional[int] = [] UpperCAmelCase : str = [] UpperCAmelCase : List[str] = [] UpperCAmelCase : str = [] UpperCAmelCase : Dict = [] UpperCAmelCase : Dict = [] UpperCAmelCase : str = [] for rsent in rsents: UpperCAmelCase : List[str] = rsent.split(''' ''' ) UpperCAmelCase : List[str] = [] UpperCAmelCase : List[str] = [] UpperCAmelCase : Optional[Any] = [] ragramslist.append(UpperCAmelCase ) for i in range(0 , len(UpperCAmelCase ) - 1 ): if i < len(UpperCAmelCase ) - 1: UpperCAmelCase : Dict = ragrams[i] + ''' ''' + ragrams[i + 1] ragrams.append(UpperCAmelCase ) if i < len(UpperCAmelCase ) - 2: UpperCAmelCase : Optional[Any] = ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2] ragrams.append(UpperCAmelCase ) if i < len(UpperCAmelCase ) - 3: UpperCAmelCase : Union[str, Any] = ragrams[i] + ''' ''' + ragrams[i + 1] + ''' ''' + ragrams[i + 2] + ''' ''' + ragrams[i + 3] ragrams.append(UpperCAmelCase ) ragramslist.append(UpperCAmelCase ) ragramslist.append(UpperCAmelCase ) ragramslist.append(UpperCAmelCase ) for i in range(0 , len(UpperCAmelCase ) - 1 ): if i < len(UpperCAmelCase ) - 1: UpperCAmelCase : Optional[int] = sagrams[i] + ''' ''' + sagrams[i + 1] sagrams.append(UpperCAmelCase ) if i < len(UpperCAmelCase ) - 2: UpperCAmelCase : Union[str, Any] = sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2] sagrams.append(UpperCAmelCase ) if i < len(UpperCAmelCase ) - 3: UpperCAmelCase : int = sagrams[i] + ''' ''' + sagrams[i + 1] + ''' ''' + sagrams[i + 2] + ''' ''' + sagrams[i + 3] sagrams.append(UpperCAmelCase ) for i in range(0 , len(UpperCAmelCase ) - 1 ): if i < len(UpperCAmelCase ) - 1: UpperCAmelCase : Any = cagrams[i] + ''' ''' + cagrams[i + 1] cagrams.append(UpperCAmelCase ) if i < len(UpperCAmelCase ) - 2: UpperCAmelCase : Union[str, Any] = cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2] cagrams.append(UpperCAmelCase ) if i < len(UpperCAmelCase ) - 3: UpperCAmelCase : int = cagrams[i] + ''' ''' + cagrams[i + 1] + ''' ''' + cagrams[i + 2] + ''' ''' + cagrams[i + 3] cagrams.append(UpperCAmelCase ) ((UpperCAmelCase) , (UpperCAmelCase) , (UpperCAmelCase)) : Dict = SARIngram(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) ((UpperCAmelCase) , (UpperCAmelCase) , (UpperCAmelCase)) : Optional[int] = SARIngram(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) ((UpperCAmelCase) , (UpperCAmelCase) , (UpperCAmelCase)) : Optional[Any] = SARIngram(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) ((UpperCAmelCase) , (UpperCAmelCase) , (UpperCAmelCase)) : Optional[Any] = SARIngram(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) UpperCAmelCase : List[str] = sum([keepascore, keepascore, keepascore, keepascore] ) / 4 UpperCAmelCase : Union[str, Any] = sum([delascore, delascore, delascore, delascore] ) / 4 UpperCAmelCase : Optional[int] = sum([addascore, addascore, addascore, addascore] ) / 4 UpperCAmelCase : int = (avgkeepscore + avgdelscore + avgaddscore) / 3 return finalscore def a__ ( UpperCAmelCase : Tuple , UpperCAmelCase : bool = True , UpperCAmelCase : str = "13a" , UpperCAmelCase : bool = True ) -> int: # Normalization is requried for the ASSET dataset (one of the primary # datasets in sentence simplification) to allow using space # to split the sentence. Even though Wiki-Auto and TURK datasets, # do not require normalization, we do it for consistency. # Code adapted from the EASSE library [1] written by the authors of the ASSET dataset. # [1] https://github.com/feralvam/easse/blob/580bba7e1378fc8289c663f864e0487188fe8067/easse/utils/preprocessing.py#L7 if lowercase: UpperCAmelCase : Dict = sentence.lower() if tokenizer in ["13a", "intl"]: if version.parse(sacrebleu.__version__ ).major >= 2: UpperCAmelCase : Optional[int] = sacrebleu.metrics.bleu._get_tokenizer(UpperCAmelCase )()(UpperCAmelCase ) else: UpperCAmelCase : Union[str, Any] = sacrebleu.TOKENIZERS[tokenizer]()(UpperCAmelCase ) elif tokenizer == "moses": UpperCAmelCase : Optional[Any] = sacremoses.MosesTokenizer().tokenize(UpperCAmelCase , return_str=UpperCAmelCase , escape=UpperCAmelCase ) elif tokenizer == "penn": UpperCAmelCase : Any = sacremoses.MosesTokenizer().penn_tokenize(UpperCAmelCase , return_str=UpperCAmelCase ) else: UpperCAmelCase : Any = sentence if not return_str: UpperCAmelCase : Dict = normalized_sent.split() return normalized_sent def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : int , UpperCAmelCase : Any ) -> List[Any]: if not (len(UpperCAmelCase ) == len(UpperCAmelCase ) == len(UpperCAmelCase )): raise ValueError('''Sources length must match predictions and references lengths.''' ) UpperCAmelCase : str = 0 for src, pred, refs in zip(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ): sari_score += SARIsent(normalize(UpperCAmelCase ) , normalize(UpperCAmelCase ) , [normalize(UpperCAmelCase ) for sent in refs] ) UpperCAmelCase : Dict = sari_score / len(UpperCAmelCase ) return 100 * sari_score def a__ ( UpperCAmelCase : Tuple , UpperCAmelCase : Tuple , UpperCAmelCase : Union[str, Any]="exp" , UpperCAmelCase : Tuple=None , UpperCAmelCase : Union[str, Any]=False , UpperCAmelCase : str=False , UpperCAmelCase : List[Any]=False , ) -> Optional[Any]: UpperCAmelCase : List[str] = len(references[0] ) if any(len(UpperCAmelCase ) != references_per_prediction for refs in references ): raise ValueError('''Sacrebleu requires the same number of references for each prediction''' ) UpperCAmelCase : Tuple = [[refs[i] for refs in references] for i in range(UpperCAmelCase )] UpperCAmelCase : Dict = sacrebleu.corpus_bleu( UpperCAmelCase , UpperCAmelCase , smooth_method=UpperCAmelCase , smooth_value=UpperCAmelCase , force=UpperCAmelCase , lowercase=UpperCAmelCase , use_effective_order=UpperCAmelCase , ) return output.score @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class __UpperCAmelCase ( datasets.Metric ): def __magic_name__ ( self : List[Any] ): return datasets.MetricInfo( description=_DESCRIPTION, citation=_CITATION, inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features( { '''predictions''': datasets.Value('''string''', id='''sequence''' ), '''references''': datasets.Sequence(datasets.Value('''string''', id='''sequence''' ), id='''references''' ), } ), codebase_urls=[ '''https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py''', '''https://github.com/cocoxu/simplification/blob/master/SARI.py''', '''https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py''', '''https://github.com/mjpost/sacreBLEU''', ], reference_urls=[ '''https://www.aclweb.org/anthology/Q16-1029.pdf''', '''https://github.com/mjpost/sacreBLEU''', '''https://en.wikipedia.org/wiki/BLEU''', '''https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213''', ], ) def __magic_name__ ( self : str, __A : Union[str, Any], __A : List[Any], __A : Optional[int] ): UpperCAmelCase : Optional[Any] = {} result.update({'''sari''': compute_sari(sources=__A, predictions=__A, references=__A )} ) result.update({'''sacrebleu''': compute_sacrebleu(predictions=__A, references=__A )} ) result.update({'''exact''': compute_em(predictions=__A, references=__A )} ) return result
336
import os from typing import List, Optional, Union from ...tokenization_utils import PreTrainedTokenizer from ...tokenization_utils_base import AddedToken from ...utils import logging _lowerCamelCase : Optional[Any] = logging.get_logger(__name__) _lowerCamelCase : Dict = {"vocab_file": "vocab.txt"} _lowerCamelCase : List[str] = { "vocab_file": { "facebook/esm2_t6_8M_UR50D": "https://huggingface.co/facebook/esm2_t6_8M_UR50D/resolve/main/vocab.txt", "facebook/esm2_t12_35M_UR50D": "https://huggingface.co/facebook/esm2_t12_35M_UR50D/resolve/main/vocab.txt", }, } _lowerCamelCase : List[Any] = { "facebook/esm2_t6_8M_UR50D": 1_0_2_4, "facebook/esm2_t12_35M_UR50D": 1_0_2_4, } def a__ ( UpperCAmelCase : List[str] ) -> Any: with open(UpperCAmelCase , '''r''' ) as f: UpperCAmelCase : Dict = f.read().splitlines() return [l.strip() for l in lines] class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = VOCAB_FILES_NAMES UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase = ["""input_ids""", """attention_mask"""] def __init__( self : Any, __A : Dict, __A : List[Any]="<unk>", __A : List[str]="<cls>", __A : Any="<pad>", __A : Union[str, Any]="<mask>", __A : int="<eos>", **__A : Tuple, ): super().__init__(**__A ) UpperCAmelCase : Tuple = load_vocab_file(__A ) UpperCAmelCase : List[Any] = dict(enumerate(self.all_tokens ) ) UpperCAmelCase : str = {tok: ind for ind, tok in enumerate(self.all_tokens )} UpperCAmelCase : Union[str, Any] = unk_token UpperCAmelCase : Optional[Any] = cls_token UpperCAmelCase : Optional[int] = pad_token UpperCAmelCase : Optional[int] = mask_token UpperCAmelCase : List[str] = eos_token UpperCAmelCase : Optional[Any] = self.all_tokens self._create_trie(self.unique_no_split_tokens ) def __magic_name__ ( self : Tuple, __A : int ): return self._id_to_token.get(__A, self.unk_token ) def __magic_name__ ( self : List[Any], __A : str ): return self._token_to_id.get(__A, self._token_to_id.get(self.unk_token ) ) def __magic_name__ ( self : Any, __A : Optional[Any], **__A : Union[str, Any] ): return text.split() def __magic_name__ ( self : Optional[int], __A : Dict=False ): return len(self._id_to_token ) def __magic_name__ ( self : int ): return {token: i for i, token in enumerate(self.all_tokens )} def __magic_name__ ( self : Tuple, __A : str ): return self._token_to_id.get(__A, self._token_to_id.get(self.unk_token ) ) def __magic_name__ ( self : Any, __A : int ): return self._id_to_token.get(__A, self.unk_token ) def __magic_name__ ( self : Union[str, Any], __A : List[int], __A : Optional[List[int]] = None ): UpperCAmelCase : Optional[int] = [self.cls_token_id] UpperCAmelCase : Optional[int] = [self.eos_token_id] # No sep token in ESM vocabulary if token_ids_a is None: if self.eos_token_id is None: return cls + token_ids_a else: return cls + token_ids_a + sep elif self.eos_token_id is None: raise ValueError('''Cannot tokenize multiple sequences when EOS token is not set!''' ) return cls + token_ids_a + sep + token_ids_a + sep # Multiple inputs always have an EOS token def __magic_name__ ( self : Any, __A : List, __A : Optional[List] = None, __A : bool = False ): if already_has_special_tokens: if token_ids_a is not None: raise ValueError( '''You should not supply a second sequence if the provided sequence of ''' '''ids is already formatted with special tokens for the model.''' ) return [1 if token in self.all_special_ids else 0 for token in token_ids_a] UpperCAmelCase : Dict = [1] + ([0] * len(__A )) + [1] if token_ids_a is not None: mask += [0] * len(__A ) + [1] return mask def __magic_name__ ( self : Optional[int], __A : List[Any], __A : Dict ): UpperCAmelCase : Union[str, Any] = os.path.join(__A, (filename_prefix + '''-''' if filename_prefix else '''''') + '''vocab.txt''' ) with open(__A, '''w''' ) as f: f.write('''\n'''.join(self.all_tokens ) ) return (vocab_file,) @property def __magic_name__ ( self : Dict ): return self.get_vocab_size(with_added_tokens=__A ) def __magic_name__ ( self : Optional[int], __A : Union[List[str], List[AddedToken]], __A : bool = False ): return super()._add_tokens(__A, special_tokens=__A )
336
1
import warnings from contextlib import contextmanager from ...processing_utils import ProcessorMixin class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """Speech2TextFeatureExtractor""" UpperCamelCase = """Speech2TextTokenizer""" def __init__( self : Tuple, __A : Union[str, Any], __A : str ): super().__init__(__A, __A ) UpperCAmelCase : str = self.feature_extractor UpperCAmelCase : Any = False def __call__( self : str, *__A : List[Any], **__A : Tuple ): # For backward compatibility if self._in_target_context_manager: return self.current_processor(*__A, **__A ) if "raw_speech" in kwargs: warnings.warn('''Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.''' ) UpperCAmelCase : Optional[Any] = kwargs.pop('''raw_speech''' ) else: UpperCAmelCase : List[Any] = kwargs.pop('''audio''', __A ) UpperCAmelCase : Optional[int] = kwargs.pop('''sampling_rate''', __A ) UpperCAmelCase : Tuple = kwargs.pop('''text''', __A ) if len(__A ) > 0: UpperCAmelCase : List[str] = args[0] UpperCAmelCase : Optional[Any] = args[1:] if audio is None and text is None: raise ValueError('''You need to specify either an `audio` or `text` input to process.''' ) if audio is not None: UpperCAmelCase : int = self.feature_extractor(__A, *__A, sampling_rate=__A, **__A ) if text is not None: UpperCAmelCase : Union[str, Any] = self.tokenizer(__A, **__A ) if text is None: return inputs elif audio is None: return encodings else: UpperCAmelCase : Optional[Any] = encodings['''input_ids'''] return inputs def __magic_name__ ( self : str, *__A : Union[str, Any], **__A : Union[str, Any] ): return self.tokenizer.batch_decode(*__A, **__A ) def __magic_name__ ( self : Optional[int], *__A : Any, **__A : Dict ): return self.tokenizer.decode(*__A, **__A ) @contextmanager def __magic_name__ ( self : Any ): warnings.warn( '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your ''' '''labels by using the argument `text` of the regular `__call__` method (either in the same call as ''' '''your audio inputs, or in a separate call.''' ) UpperCAmelCase : List[str] = True UpperCAmelCase : List[Any] = self.tokenizer yield UpperCAmelCase : Tuple = self.feature_extractor UpperCAmelCase : Union[str, Any] = False
336
import inspect import unittest from transformers import MobileNetVaConfig 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 transformers import MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation, MobileNetVaModel from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import MobileNetVaImageProcessor class __UpperCAmelCase ( lowerCamelCase__ ): def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : str = self.config_class(**self.inputs_dict ) self.parent.assertTrue(hasattr(__A, '''tf_padding''' ) ) self.parent.assertTrue(hasattr(__A, '''depth_multiplier''' ) ) class __UpperCAmelCase : def __init__( self : int, __A : List[Any], __A : str=1_3, __A : Dict=3, __A : int=3_2, __A : int=0.2_5, __A : List[str]=8, __A : int=8, __A : Dict=6, __A : str=3_2, __A : Any=True, __A : str=True, __A : int=True, __A : Union[str, Any]="relu6", __A : Any=1_2_8_0, __A : List[Any]=0.1, __A : Optional[Any]=0.0_2, __A : Tuple=True, __A : List[Any]=True, __A : str=1_0, __A : Optional[Any]=None, ): UpperCAmelCase : Optional[int] = parent UpperCAmelCase : List[str] = batch_size UpperCAmelCase : List[str] = num_channels UpperCAmelCase : str = image_size UpperCAmelCase : Optional[int] = depth_multiplier UpperCAmelCase : Union[str, Any] = depth_divisible_by UpperCAmelCase : Optional[Any] = min_depth UpperCAmelCase : List[str] = expand_ratio UpperCAmelCase : Dict = tf_padding UpperCAmelCase : str = output_stride UpperCAmelCase : Union[str, Any] = first_layer_is_expansion UpperCAmelCase : List[Any] = finegrained_output UpperCAmelCase : Optional[Any] = hidden_act UpperCAmelCase : str = last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier ) UpperCAmelCase : Optional[Any] = classifier_dropout_prob UpperCAmelCase : Dict = use_labels UpperCAmelCase : List[str] = is_training UpperCAmelCase : Tuple = num_labels UpperCAmelCase : Union[str, Any] = initializer_range UpperCAmelCase : Any = scope def __magic_name__ ( self : List[Any] ): UpperCAmelCase : List[str] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : Dict = None UpperCAmelCase : Any = None if self.use_labels: UpperCAmelCase : Dict = ids_tensor([self.batch_size], self.num_labels ) UpperCAmelCase : Optional[int] = ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels ) UpperCAmelCase : Optional[Any] = self.get_config() return config, pixel_values, labels, pixel_labels def __magic_name__ ( self : Any ): return MobileNetVaConfig( num_channels=self.num_channels, image_size=self.image_size, depth_multiplier=self.depth_multiplier, depth_divisible_by=self.depth_divisible_by, min_depth=self.min_depth, expand_ratio=self.expand_ratio, output_stride=self.output_stride, first_layer_is_expansion=self.first_layer_is_expansion, finegrained_output=self.finegrained_output, hidden_act=self.hidden_act, tf_padding=self.tf_padding, classifier_dropout_prob=self.classifier_dropout_prob, initializer_range=self.initializer_range, ) def __magic_name__ ( self : List[Any], __A : Dict, __A : Optional[Any], __A : Optional[int], __A : Union[str, Any] ): UpperCAmelCase : Any = MobileNetVaModel(config=__A ) model.to(__A ) model.eval() UpperCAmelCase : Optional[Any] = model(__A ) self.parent.assertEqual( result.last_hidden_state.shape, ( self.batch_size, self.last_hidden_size, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) self.parent.assertEqual( result.pooler_output.shape, (self.batch_size, self.last_hidden_size), ) def __magic_name__ ( self : str, __A : Union[str, Any], __A : Dict, __A : Optional[Any], __A : str ): UpperCAmelCase : Optional[int] = self.num_labels UpperCAmelCase : Any = MobileNetVaForImageClassification(__A ) model.to(__A ) model.eval() UpperCAmelCase : Optional[int] = model(__A, labels=__A ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels) ) def __magic_name__ ( self : List[Any], __A : Optional[Any], __A : List[str], __A : Dict, __A : Dict ): UpperCAmelCase : Tuple = self.num_labels UpperCAmelCase : Dict = MobileNetVaForSemanticSegmentation(__A ) model.to(__A ) model.eval() UpperCAmelCase : Dict = model(__A ) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) UpperCAmelCase : Optional[Any] = model(__A, labels=__A ) self.parent.assertEqual( result.logits.shape, ( self.batch_size, self.num_labels, self.image_size // self.output_stride, self.image_size // self.output_stride, ), ) def __magic_name__ ( self : Tuple ): UpperCAmelCase : List[str] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : int = config_and_inputs UpperCAmelCase : Optional[int] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = ( (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation) if is_torch_available() else () ) UpperCamelCase = ( { """feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification, """image-segmentation""": MobileNetVaForSemanticSegmentation, } if is_torch_available() else {} ) UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : List[Any] = MobileNetVaModelTester(self ) UpperCAmelCase : List[Any] = MobileNetVaConfigTester(self, config_class=__A, has_text_modality=__A ) def __magic_name__ ( self : Tuple ): self.config_tester.run_common_tests() @unittest.skip(reason='''MobileNetV2 does not use inputs_embeds''' ) def __magic_name__ ( self : Optional[int] ): pass @unittest.skip(reason='''MobileNetV2 does not support input and output embeddings''' ) def __magic_name__ ( self : Tuple ): pass @unittest.skip(reason='''MobileNetV2 does not output attentions''' ) def __magic_name__ ( self : Any ): pass def __magic_name__ ( self : Optional[int] ): UpperCAmelCase , UpperCAmelCase : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Optional[Any] = model_class(__A ) UpperCAmelCase : Optional[int] = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : Union[str, Any] = [*signature.parameters.keys()] UpperCAmelCase : Any = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : List[Any] ): UpperCAmelCase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : int ): def check_hidden_states_output(__A : Any, __A : Optional[Any], __A : str ): UpperCAmelCase : Union[str, Any] = model_class(__A ) model.to(__A ) model.eval() with torch.no_grad(): UpperCAmelCase : Dict = model(**self._prepare_for_class(__A, __A ) ) UpperCAmelCase : Optional[Any] = outputs.hidden_states UpperCAmelCase : List[Any] = 1_6 self.assertEqual(len(__A ), __A ) UpperCAmelCase , UpperCAmelCase : int = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Tuple = True check_hidden_states_output(__A, __A, __A ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] UpperCAmelCase : Tuple = True check_hidden_states_output(__A, __A, __A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__A ) def __magic_name__ ( self : int ): UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__A ) @slow def __magic_name__ ( self : Dict ): for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase : Optional[Any] = MobileNetVaModel.from_pretrained(__A ) self.assertIsNotNone(__A ) def a__ ( ) -> int: UpperCAmelCase : Dict = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_torch @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : List[Any] ): return ( MobileNetVaImageProcessor.from_pretrained('''google/mobilenet_v2_1.0_224''' ) if is_vision_available() else None ) @slow def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : List[Any] = MobileNetVaForImageClassification.from_pretrained('''google/mobilenet_v2_1.0_224''' ).to(__A ) UpperCAmelCase : Optional[int] = self.default_image_processor UpperCAmelCase : Optional[Any] = prepare_img() UpperCAmelCase : Dict = image_processor(images=__A, return_tensors='''pt''' ).to(__A ) # forward pass with torch.no_grad(): UpperCAmelCase : str = model(**__A ) # verify the logits UpperCAmelCase : int = torch.Size((1, 1_0_0_1) ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : Tuple = torch.tensor([0.2_4_4_5, -1.1_9_9_3, 0.1_9_0_5] ).to(__A ) self.assertTrue(torch.allclose(outputs.logits[0, :3], __A, atol=1E-4 ) ) @slow def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Tuple = MobileNetVaForSemanticSegmentation.from_pretrained('''google/deeplabv3_mobilenet_v2_1.0_513''' ) UpperCAmelCase : List[Any] = model.to(__A ) UpperCAmelCase : Tuple = MobileNetVaImageProcessor.from_pretrained('''google/deeplabv3_mobilenet_v2_1.0_513''' ) UpperCAmelCase : List[Any] = prepare_img() UpperCAmelCase : int = image_processor(images=__A, return_tensors='''pt''' ).to(__A ) # forward pass with torch.no_grad(): UpperCAmelCase : Union[str, Any] = model(**__A ) UpperCAmelCase : Optional[Any] = outputs.logits # verify the logits UpperCAmelCase : Tuple = torch.Size((1, 2_1, 6_5, 6_5) ) self.assertEqual(logits.shape, __A ) UpperCAmelCase : Tuple = torch.tensor( [ [[1_7.5_7_9_0, 1_7.7_5_8_1, 1_8.3_3_5_5], [1_8.3_2_5_7, 1_8.4_2_3_0, 1_8.8_9_7_3], [1_8.6_1_6_9, 1_8.8_6_5_0, 1_9.2_1_8_7]], [[-2.1_5_9_5, -2.0_9_7_7, -2.3_7_4_1], [-2.4_2_2_6, -2.3_0_2_8, -2.6_8_3_5], [-2.7_8_1_9, -2.5_9_9_1, -2.7_7_0_6]], [[4.2_0_5_8, 4.8_3_1_7, 4.7_6_3_8], [4.4_1_3_6, 5.0_3_6_1, 4.9_3_8_3], [4.5_0_2_8, 4.9_6_4_4, 4.8_7_3_4]], ], device=__A, ) self.assertTrue(torch.allclose(logits[0, :3, :3, :3], __A, atol=1E-4 ) )
336
1
import dataclasses import json import sys import types from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser, ArgumentTypeError from copy import copy from enum import Enum from inspect import isclass from pathlib import Path from typing import Any, Callable, Dict, Iterable, List, Literal, NewType, Optional, Tuple, Union, get_type_hints import yaml _lowerCamelCase : List[Any] = NewType("DataClass", Any) _lowerCamelCase : List[str] = NewType("DataClassType", Any) def a__ ( UpperCAmelCase : Any ) -> int: if isinstance(UpperCAmelCase , UpperCAmelCase ): return v if v.lower() in ("yes", "true", "t", "y", "1"): return True elif v.lower() in ("no", "false", "f", "n", "0"): return False else: raise ArgumentTypeError( f'''Truthy value expected: got {v} but expected one of yes/no, true/false, t/f, y/n, 1/0 (case insensitive).''' ) def a__ ( UpperCAmelCase : list ) -> Callable[[str], Any]: UpperCAmelCase : Optional[int] = {str(UpperCAmelCase ): choice for choice in choices} return lambda UpperCAmelCase : str_to_choice.get(UpperCAmelCase , UpperCAmelCase ) def a__ ( *, UpperCAmelCase : Union[str, List[str]] = None , UpperCAmelCase : str = None , UpperCAmelCase : Any = dataclasses.MISSING , UpperCAmelCase : Callable[[], Any] = dataclasses.MISSING , UpperCAmelCase : dict = None , **UpperCAmelCase : Dict , ) -> dataclasses.Field: if metadata is None: # Important, don't use as default param in function signature because dict is mutable and shared across function calls UpperCAmelCase : Optional[Any] = {} if aliases is not None: UpperCAmelCase : List[str] = aliases if help is not None: UpperCAmelCase : int = help return dataclasses.field(metadata=UpperCAmelCase , default=UpperCAmelCase , default_factory=UpperCAmelCase , **UpperCAmelCase ) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = 42 def __init__( self : Optional[int], __A : Union[DataClassType, Iterable[DataClassType]], **__A : Tuple ): # To make the default appear when using --help if "formatter_class" not in kwargs: UpperCAmelCase : Union[str, Any] = ArgumentDefaultsHelpFormatter super().__init__(**__A ) if dataclasses.is_dataclass(__A ): UpperCAmelCase : List[Any] = [dataclass_types] UpperCAmelCase : List[str] = list(__A ) for dtype in self.dataclass_types: self._add_dataclass_arguments(__A ) @staticmethod def __magic_name__ ( __A : ArgumentParser, __A : dataclasses.Field ): UpperCAmelCase : Union[str, Any] = F'''--{field.name}''' UpperCAmelCase : str = field.metadata.copy() # field.metadata is not used at all by Data Classes, # it is provided as a third-party extension mechanism. if isinstance(field.type, __A ): raise RuntimeError( '''Unresolved type detected, which should have been done with the help of ''' '''`typing.get_type_hints` method by default''' ) UpperCAmelCase : int = kwargs.pop('''aliases''', [] ) if isinstance(__A, __A ): UpperCAmelCase : int = [aliases] UpperCAmelCase : Optional[Any] = getattr(field.type, '''__origin__''', field.type ) if origin_type is Union or (hasattr(__A, '''UnionType''' ) and isinstance(__A, types.UnionType )): if str not in field.type.__args__ and ( len(field.type.__args__ ) != 2 or type(__A ) not in field.type.__args__ ): raise ValueError( '''Only `Union[X, NoneType]` (i.e., `Optional[X]`) is allowed for `Union` because''' ''' the argument parser only supports one type per argument.''' F''' Problem encountered in field \'{field.name}\'.''' ) if type(__A ) not in field.type.__args__: # filter `str` in Union UpperCAmelCase : Any = field.type.__args__[0] if field.type.__args__[1] == str else field.type.__args__[1] UpperCAmelCase : str = getattr(field.type, '''__origin__''', field.type ) elif bool not in field.type.__args__: # filter `NoneType` in Union (except for `Union[bool, NoneType]`) UpperCAmelCase : List[Any] = ( field.type.__args__[0] if isinstance(__A, field.type.__args__[1] ) else field.type.__args__[1] ) UpperCAmelCase : Tuple = getattr(field.type, '''__origin__''', field.type ) # A variable to store kwargs for a boolean field, if needed # so that we can init a `no_*` complement argument (see below) UpperCAmelCase : List[Any] = {} if origin_type is Literal or (isinstance(field.type, __A ) and issubclass(field.type, __A )): if origin_type is Literal: UpperCAmelCase : Tuple = field.type.__args__ else: UpperCAmelCase : Optional[Any] = [x.value for x in field.type] UpperCAmelCase : Dict = make_choice_type_function(kwargs['''choices'''] ) if field.default is not dataclasses.MISSING: UpperCAmelCase : Union[str, Any] = field.default else: UpperCAmelCase : List[str] = True elif field.type is bool or field.type == Optional[bool]: # Copy the currect kwargs to use to instantiate a `no_*` complement argument below. # We do not initialize it here because the `no_*` alternative must be instantiated after the real argument UpperCAmelCase : List[str] = copy(__A ) # Hack because type=bool in argparse does not behave as we want. UpperCAmelCase : List[Any] = string_to_bool if field.type is bool or (field.default is not None and field.default is not dataclasses.MISSING): # Default value is False if we have no default when of type bool. UpperCAmelCase : str = False if field.default is dataclasses.MISSING else field.default # This is the value that will get picked if we don't include --field_name in any way UpperCAmelCase : List[Any] = default # This tells argparse we accept 0 or 1 value after --field_name UpperCAmelCase : List[Any] = '''?''' # This is the value that will get picked if we do --field_name (without value) UpperCAmelCase : List[Any] = True elif isclass(__A ) and issubclass(__A, __A ): UpperCAmelCase : Any = field.type.__args__[0] UpperCAmelCase : Dict = '''+''' if field.default_factory is not dataclasses.MISSING: UpperCAmelCase : Dict = field.default_factory() elif field.default is dataclasses.MISSING: UpperCAmelCase : Optional[int] = True else: UpperCAmelCase : Any = field.type if field.default is not dataclasses.MISSING: UpperCAmelCase : List[str] = field.default elif field.default_factory is not dataclasses.MISSING: UpperCAmelCase : Optional[Any] = field.default_factory() else: UpperCAmelCase : Tuple = True parser.add_argument(__A, *__A, **__A ) # Add a complement `no_*` argument for a boolean field AFTER the initial field has already been added. # Order is important for arguments with the same destination! # We use a copy of earlier kwargs because the original kwargs have changed a lot before reaching down # here and we do not need those changes/additional keys. if field.default is True and (field.type is bool or field.type == Optional[bool]): UpperCAmelCase : Tuple = False parser.add_argument(F'''--no_{field.name}''', action='''store_false''', dest=field.name, **__A ) def __magic_name__ ( self : int, __A : DataClassType ): if hasattr(__A, '''_argument_group_name''' ): UpperCAmelCase : Optional[Any] = self.add_argument_group(dtype._argument_group_name ) else: UpperCAmelCase : str = self try: UpperCAmelCase : Dict[str, type] = get_type_hints(__A ) except NameError: raise RuntimeError( F'''Type resolution failed for {dtype}. Try declaring the class in global scope or ''' '''removing line of `from __future__ import annotations` which opts in Postponed ''' '''Evaluation of Annotations (PEP 563)''' ) except TypeError as ex: # Remove this block when we drop Python 3.9 support if sys.version_info[:2] < (3, 1_0) and "unsupported operand type(s) for |" in str(__A ): UpperCAmelCase : List[str] = '''.'''.join(map(__A, sys.version_info[:3] ) ) raise RuntimeError( F'''Type resolution failed for {dtype} on Python {python_version}. Try removing ''' '''line of `from __future__ import annotations` which opts in union types as ''' '''`X | Y` (PEP 604) via Postponed Evaluation of Annotations (PEP 563). To ''' '''support Python versions that lower than 3.10, you need to use ''' '''`typing.Union[X, Y]` instead of `X | Y` and `typing.Optional[X]` instead of ''' '''`X | None`.''' ) from ex raise for field in dataclasses.fields(__A ): if not field.init: continue UpperCAmelCase : int = type_hints[field.name] self._parse_dataclass_field(__A, __A ) def __magic_name__ ( self : Optional[int], __A : str=None, __A : Any=False, __A : Optional[int]=True, __A : int=None, __A : List[Any]=None, ): if args_file_flag or args_filename or (look_for_args_file and len(sys.argv )): UpperCAmelCase : Any = [] if args_filename: args_files.append(Path(__A ) ) elif look_for_args_file and len(sys.argv ): args_files.append(Path(sys.argv[0] ).with_suffix('''.args''' ) ) # args files specified via command line flag should overwrite default args files so we add them last if args_file_flag: # Create special parser just to extract the args_file_flag values UpperCAmelCase : Tuple = ArgumentParser() args_file_parser.add_argument(__A, type=__A, action='''append''' ) # Use only remaining args for further parsing (remove the args_file_flag) UpperCAmelCase , UpperCAmelCase : List[str] = args_file_parser.parse_known_args(args=__A ) UpperCAmelCase : Union[str, Any] = vars(__A ).get(args_file_flag.lstrip('''-''' ), __A ) if cmd_args_file_paths: args_files.extend([Path(__A ) for p in cmd_args_file_paths] ) UpperCAmelCase : Union[str, Any] = [] for args_file in args_files: if args_file.exists(): file_args += args_file.read_text().split() # in case of duplicate arguments the last one has precedence # args specified via the command line should overwrite args from files, so we add them last UpperCAmelCase : Optional[int] = file_args + args if args is not None else file_args + sys.argv[1:] UpperCAmelCase , UpperCAmelCase : List[str] = self.parse_known_args(args=__A ) UpperCAmelCase : Tuple = [] for dtype in self.dataclass_types: UpperCAmelCase : Optional[Any] = {f.name for f in dataclasses.fields(__A ) if f.init} UpperCAmelCase : Tuple = {k: v for k, v in vars(__A ).items() if k in keys} for k in keys: delattr(__A, __A ) UpperCAmelCase : Dict = dtype(**__A ) outputs.append(__A ) if len(namespace.__dict__ ) > 0: # additional namespace. outputs.append(__A ) if return_remaining_strings: return (*outputs, remaining_args) else: if remaining_args: raise ValueError(F'''Some specified arguments are not used by the HfArgumentParser: {remaining_args}''' ) return (*outputs,) def __magic_name__ ( self : Optional[int], __A : Dict[str, Any], __A : bool = False ): UpperCAmelCase : Tuple = set(args.keys() ) UpperCAmelCase : Dict = [] for dtype in self.dataclass_types: UpperCAmelCase : Any = {f.name for f in dataclasses.fields(__A ) if f.init} UpperCAmelCase : List[Any] = {k: v for k, v in args.items() if k in keys} unused_keys.difference_update(inputs.keys() ) UpperCAmelCase : Tuple = dtype(**__A ) outputs.append(__A ) if not allow_extra_keys and unused_keys: raise ValueError(F'''Some keys are not used by the HfArgumentParser: {sorted(__A )}''' ) return tuple(__A ) def __magic_name__ ( self : Tuple, __A : str, __A : bool = False ): with open(Path(__A ), encoding='''utf-8''' ) as open_json_file: UpperCAmelCase : List[str] = json.loads(open_json_file.read() ) UpperCAmelCase : Dict = self.parse_dict(__A, allow_extra_keys=__A ) return tuple(__A ) def __magic_name__ ( self : Union[str, Any], __A : str, __A : bool = False ): UpperCAmelCase : List[Any] = self.parse_dict(yaml.safe_load(Path(__A ).read_text() ), allow_extra_keys=__A ) return tuple(__A )
336
from collections import OrderedDict from typing import Any, List, Mapping, Optional from ... import PreTrainedTokenizer, TensorType, is_torch_available from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfigWithPast, PatchingSpec from ...utils import logging _lowerCamelCase : str = logging.get_logger(__name__) _lowerCamelCase : Optional[int] = { "Salesforce/codegen-350M-nl": "https://huggingface.co/Salesforce/codegen-350M-nl/resolve/main/config.json", "Salesforce/codegen-350M-multi": "https://huggingface.co/Salesforce/codegen-350M-multi/resolve/main/config.json", "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/config.json", "Salesforce/codegen-2B-nl": "https://huggingface.co/Salesforce/codegen-2B-nl/resolve/main/config.json", "Salesforce/codegen-2B-multi": "https://huggingface.co/Salesforce/codegen-2B-multi/resolve/main/config.json", "Salesforce/codegen-2B-mono": "https://huggingface.co/Salesforce/codegen-2B-mono/resolve/main/config.json", "Salesforce/codegen-6B-nl": "https://huggingface.co/Salesforce/codegen-6B-nl/resolve/main/config.json", "Salesforce/codegen-6B-multi": "https://huggingface.co/Salesforce/codegen-6B-multi/resolve/main/config.json", "Salesforce/codegen-6B-mono": "https://huggingface.co/Salesforce/codegen-6B-mono/resolve/main/config.json", "Salesforce/codegen-16B-nl": "https://huggingface.co/Salesforce/codegen-16B-nl/resolve/main/config.json", "Salesforce/codegen-16B-multi": "https://huggingface.co/Salesforce/codegen-16B-multi/resolve/main/config.json", "Salesforce/codegen-16B-mono": "https://huggingface.co/Salesforce/codegen-16B-mono/resolve/main/config.json", } class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """codegen""" UpperCamelCase = { """max_position_embeddings""": """n_positions""", """hidden_size""": """n_embd""", """num_attention_heads""": """n_head""", """num_hidden_layers""": """n_layer""", } def __init__( self : Any, __A : Optional[int]=5_0_4_0_0, __A : Tuple=2_0_4_8, __A : Optional[int]=2_0_4_8, __A : List[str]=4_0_9_6, __A : List[str]=2_8, __A : Union[str, Any]=1_6, __A : Tuple=6_4, __A : Union[str, Any]=None, __A : Union[str, Any]="gelu_new", __A : Any=0.0, __A : Dict=0.0, __A : str=0.0, __A : Optional[int]=1E-5, __A : Any=0.0_2, __A : Any=True, __A : Union[str, Any]=5_0_2_5_6, __A : List[str]=5_0_2_5_6, __A : int=False, **__A : List[Any], ): UpperCAmelCase : int = vocab_size UpperCAmelCase : Tuple = n_ctx UpperCAmelCase : Tuple = n_positions UpperCAmelCase : Optional[int] = n_embd UpperCAmelCase : Union[str, Any] = n_layer UpperCAmelCase : List[str] = n_head UpperCAmelCase : Tuple = n_inner UpperCAmelCase : int = rotary_dim UpperCAmelCase : List[Any] = activation_function UpperCAmelCase : List[str] = resid_pdrop UpperCAmelCase : Optional[Any] = embd_pdrop UpperCAmelCase : str = attn_pdrop UpperCAmelCase : Tuple = layer_norm_epsilon UpperCAmelCase : Dict = initializer_range UpperCAmelCase : Union[str, Any] = use_cache UpperCAmelCase : Any = bos_token_id UpperCAmelCase : List[str] = eos_token_id super().__init__( bos_token_id=__A, eos_token_id=__A, tie_word_embeddings=__A, **__A ) class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Any, __A : PretrainedConfig, __A : str = "default", __A : List[PatchingSpec] = None, __A : bool = False, ): super().__init__(__A, task=__A, patching_specs=__A, use_past=__A ) if not getattr(self._config, '''pad_token_id''', __A ): # TODO: how to do that better? UpperCAmelCase : Union[str, Any] = 0 @property def __magic_name__ ( self : str ): UpperCAmelCase : Union[str, Any] = OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}} ) if self.use_past: self.fill_with_past_key_values_(__A, direction='''inputs''' ) UpperCAmelCase : int = {0: '''batch''', 1: '''past_sequence + sequence'''} else: UpperCAmelCase : List[Any] = {0: '''batch''', 1: '''sequence'''} return common_inputs @property def __magic_name__ ( self : Dict ): return self._config.n_layer @property def __magic_name__ ( self : List[str] ): return self._config.n_head def __magic_name__ ( self : str, __A : PreTrainedTokenizer, __A : int = -1, __A : int = -1, __A : bool = False, __A : Optional[TensorType] = None, ): UpperCAmelCase : Union[str, Any] = super(__A, self ).generate_dummy_inputs( __A, batch_size=__A, seq_length=__A, is_pair=__A, framework=__A ) # We need to order the input in the way they appears in the forward() UpperCAmelCase : Union[str, Any] = OrderedDict({'''input_ids''': common_inputs['''input_ids''']} ) # Need to add the past_keys if self.use_past: if not is_torch_available(): raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.''' ) else: import torch UpperCAmelCase , UpperCAmelCase : str = common_inputs['''input_ids'''].shape # Not using the same length for past_key_values UpperCAmelCase : str = seqlen + 2 UpperCAmelCase : Optional[int] = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) UpperCAmelCase : Optional[int] = [ (torch.zeros(__A ), torch.zeros(__A )) for _ in range(self.num_layers ) ] UpperCAmelCase : Union[str, Any] = common_inputs['''attention_mask'''] if self.use_past: UpperCAmelCase : Optional[Any] = ordered_inputs['''attention_mask'''].dtype UpperCAmelCase : Dict = torch.cat( [ordered_inputs['''attention_mask'''], torch.ones(__A, __A, dtype=__A )], dim=1 ) return ordered_inputs @property def __magic_name__ ( self : Tuple ): return 1_3
336
1
import warnings from typing import Any, Dict, List, Optional, Union import numpy as np from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function from ...feature_extraction_sequence_utils import SequenceFeatureExtractor from ...feature_extraction_utils import BatchFeature from ...utils import PaddingStrategy, TensorType, logging _lowerCamelCase : List[str] = logging.get_logger(__name__) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = ["""input_values""", """attention_mask"""] def __init__( self : Union[str, Any], __A : int = 1, __A : int = 1_6_0_0_0, __A : float = 0.0, __A : bool = False, __A : int = 8_0, __A : int = 1_6, __A : int = 6_4, __A : str = "hann_window", __A : float = 1.0, __A : float = 8_0, __A : float = 7_6_0_0, __A : float = 1E-10, __A : int = 2, __A : bool = True, **__A : Dict, ): super().__init__(feature_size=__A, sampling_rate=__A, padding_value=__A, **__A ) UpperCAmelCase : Optional[Any] = do_normalize UpperCAmelCase : Dict = return_attention_mask UpperCAmelCase : Union[str, Any] = num_mel_bins UpperCAmelCase : str = hop_length UpperCAmelCase : List[str] = win_length UpperCAmelCase : Optional[Any] = win_function UpperCAmelCase : Dict = frame_signal_scale UpperCAmelCase : List[Any] = fmin UpperCAmelCase : Any = fmax UpperCAmelCase : str = mel_floor UpperCAmelCase : str = reduction_factor UpperCAmelCase : Union[str, Any] = win_length * sampling_rate // 1_0_0_0 UpperCAmelCase : int = hop_length * sampling_rate // 1_0_0_0 UpperCAmelCase : int = optimal_fft_length(self.sample_size ) UpperCAmelCase : int = (self.n_fft // 2) + 1 UpperCAmelCase : Tuple = window_function(window_length=self.sample_size, name=self.win_function, periodic=__A ) UpperCAmelCase : Tuple = mel_filter_bank( num_frequency_bins=self.n_freqs, num_mel_filters=self.num_mel_bins, min_frequency=self.fmin, max_frequency=self.fmax, sampling_rate=self.sampling_rate, norm='''slaney''', mel_scale='''slaney''', ) if frame_signal_scale != 1.0: warnings.warn( '''The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers''', __A, ) if reduction_factor != 2.0: warnings.warn( '''The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers''', __A, ) @staticmethod # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm def __magic_name__ ( __A : List[np.ndarray], __A : List[np.ndarray], __A : float = 0.0 ): if attention_mask is not None: UpperCAmelCase : List[str] = np.array(__A, np.intaa ) UpperCAmelCase : List[Any] = [] for vector, length in zip(__A, attention_mask.sum(-1 ) ): UpperCAmelCase : Optional[Any] = (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7 ) if length < normed_slice.shape[0]: UpperCAmelCase : Tuple = padding_value normed_input_values.append(__A ) else: UpperCAmelCase : Any = [(x - x.mean()) / np.sqrt(x.var() + 1E-7 ) for x in input_values] return normed_input_values def __magic_name__ ( self : List[str], __A : np.ndarray, ): UpperCAmelCase : List[str] = spectrogram( __A, window=self.window, frame_length=self.sample_size, hop_length=self.sample_stride, fft_length=self.n_fft, mel_filters=self.mel_filters, mel_floor=self.mel_floor, log_mel='''log10''', ) return log_mel_spec.T def __call__( self : List[str], __A : Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None, __A : Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None, __A : Union[bool, str, PaddingStrategy] = False, __A : Optional[int] = None, __A : bool = False, __A : Optional[int] = None, __A : Optional[bool] = None, __A : Optional[Union[str, TensorType]] = None, __A : Optional[int] = None, **__A : int, ): if audio is None and audio_target is None: raise ValueError('''You must provide either `audio` or `audio_target` values.''' ) if sampling_rate is not None: if sampling_rate != self.sampling_rate: raise ValueError( F'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of''' F''' {self.sampling_rate}. Please make sure that the provided audio input was sampled with''' F''' {self.sampling_rate} and not {sampling_rate}.''' ) else: logger.warning( '''It is strongly recommended to pass the ``sampling_rate`` argument to this function. ''' '''Failing to do so can result in silent errors that might be hard to debug.''' ) if audio is not None: UpperCAmelCase : Union[str, Any] = self._process_audio( __A, __A, __A, __A, __A, __A, __A, __A, **__A, ) else: UpperCAmelCase : Optional[int] = None if audio_target is not None: UpperCAmelCase : Any = self._process_audio( __A, __A, __A, __A, __A, __A, __A, __A, **__A, ) if inputs is None: return inputs_target else: UpperCAmelCase : Optional[int] = inputs_target['''input_values'''] UpperCAmelCase : Dict = inputs_target.get('''attention_mask''' ) if decoder_attention_mask is not None: UpperCAmelCase : str = decoder_attention_mask return inputs def __magic_name__ ( self : Optional[Any], __A : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]], __A : bool = False, __A : Union[bool, str, PaddingStrategy] = False, __A : Optional[int] = None, __A : bool = False, __A : Optional[int] = None, __A : Optional[bool] = None, __A : Optional[Union[str, TensorType]] = None, **__A : Tuple, ): UpperCAmelCase : Union[str, Any] = isinstance(__A, np.ndarray ) and len(speech.shape ) > 1 if is_batched_numpy and len(speech.shape ) > 2: raise ValueError(F'''Only mono-channel audio is supported for input to {self}''' ) UpperCAmelCase : Union[str, Any] = is_batched_numpy or ( isinstance(__A, (list, tuple) ) and (isinstance(speech[0], (np.ndarray, tuple, list) )) ) if is_batched: UpperCAmelCase : Tuple = [np.asarray(__A, dtype=np.floataa ) for speech in speech] elif not is_batched and not isinstance(__A, np.ndarray ): UpperCAmelCase : Tuple = np.asarray(__A, dtype=np.floataa ) elif isinstance(__A, np.ndarray ) and speech.dtype is np.dtype(np.floataa ): UpperCAmelCase : List[Any] = speech.astype(np.floataa ) # always return batch if not is_batched: UpperCAmelCase : int = [speech] # needed to make pad() work on spectrogram inputs UpperCAmelCase : Tuple = self.feature_size # convert into correct format for padding if is_target: UpperCAmelCase : Dict = [self._extract_mel_features(__A ) for waveform in speech] UpperCAmelCase : Optional[Any] = BatchFeature({'''input_values''': features} ) UpperCAmelCase : Tuple = self.num_mel_bins else: UpperCAmelCase : Optional[Any] = BatchFeature({'''input_values''': speech} ) UpperCAmelCase : List[str] = self.pad( __A, padding=__A, max_length=__A, truncation=__A, pad_to_multiple_of=__A, return_attention_mask=__A, **__A, ) UpperCAmelCase : List[Any] = feature_size_hack # convert input values to correct format UpperCAmelCase : Optional[int] = padded_inputs['''input_values'''] if not isinstance(input_values[0], np.ndarray ): UpperCAmelCase : List[Any] = [np.asarray(__A, dtype=np.floataa ) for array in input_values] elif ( not isinstance(__A, np.ndarray ) and isinstance(input_values[0], np.ndarray ) and input_values[0].dtype is np.dtype(np.floataa ) ): UpperCAmelCase : str = [array.astype(np.floataa ) for array in input_values] elif isinstance(__A, np.ndarray ) and input_values.dtype is np.dtype(np.floataa ): UpperCAmelCase : Dict = input_values.astype(np.floataa ) # convert attention_mask to correct format UpperCAmelCase : List[str] = padded_inputs.get('''attention_mask''' ) if attention_mask is not None: UpperCAmelCase : str = [np.asarray(__A, dtype=np.intaa ) for array in attention_mask] # zero-mean and unit-variance normalization if not is_target and self.do_normalize: UpperCAmelCase : int = ( attention_mask if self._get_padding_strategies(__A, max_length=__A ) is not PaddingStrategy.DO_NOT_PAD else None ) UpperCAmelCase : Any = self.zero_mean_unit_var_norm( padded_inputs['''input_values'''], attention_mask=__A, padding_value=self.padding_value ) if return_tensors is not None: UpperCAmelCase : Optional[Any] = padded_inputs.convert_to_tensors(__A ) return padded_inputs def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : Any = super().to_dict() # Don't serialize these as they are derived from the other properties. UpperCAmelCase : int = ['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs'''] for name in names: if name in output: del output[name] return output
336
# limitations under the License. # NOTE: This file is deprecated and will be removed in a future version. # It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works from .pipelines import DiffusionPipeline, ImagePipelineOutput # noqa: F401 from .utils import deprecate deprecate( "pipelines_utils", "0.22.0", "Importing `DiffusionPipeline` or `ImagePipelineOutput` from diffusers.pipeline_utils is deprecated. Please import from diffusers.pipelines.pipeline_utils instead.", standard_warn=False, stacklevel=3, )
336
1
from math import factorial, radians def a__ ( UpperCAmelCase : float , UpperCAmelCase : int = 18 , UpperCAmelCase : int = 10 ) -> float: UpperCAmelCase : Any = angle_in_degrees - ((angle_in_degrees // 360.0) * 360.0) # Converting from degrees to radians UpperCAmelCase : Tuple = radians(UpperCAmelCase ) UpperCAmelCase : Any = angle_in_radians UpperCAmelCase : Tuple = 3 UpperCAmelCase : Tuple = -1 for _ in range(UpperCAmelCase ): result += (b * (angle_in_radians**a)) / factorial(UpperCAmelCase ) UpperCAmelCase : Union[str, Any] = -b # One positive term and the next will be negative and so on... a += 2 # Increased by 2 for every term. return round(UpperCAmelCase , UpperCAmelCase ) if __name__ == "__main__": __import__("doctest").testmod()
336
from dataclasses import dataclass from typing import Optional, Tuple, Union import flax import jax.numpy as jnp from jax import random from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput from .scheduling_utils_flax import FlaxSchedulerMixin @flax.struct.dataclass class __UpperCAmelCase : # setable values UpperCamelCase = None UpperCamelCase = None UpperCamelCase = None # sigma(t_i) @classmethod def __magic_name__ ( cls : Any ): return cls() @dataclass class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = 42 UpperCamelCase = 42 UpperCamelCase = 42 class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ ): @property def __magic_name__ ( self : Optional[int] ): return True @register_to_config def __init__( self : Optional[int], __A : float = 0.0_2, __A : float = 1_0_0, __A : float = 1.0_0_7, __A : float = 8_0, __A : float = 0.0_5, __A : float = 5_0, ): pass def __magic_name__ ( self : Optional[Any] ): return KarrasVeSchedulerState.create() def __magic_name__ ( self : int, __A : KarrasVeSchedulerState, __A : int, __A : Tuple = () ): UpperCAmelCase : Optional[Any] = jnp.arange(0, __A )[::-1].copy() UpperCAmelCase : Union[str, Any] = [ ( self.config.sigma_max**2 * (self.config.sigma_min**2 / self.config.sigma_max**2) ** (i / (num_inference_steps - 1)) ) for i in timesteps ] return state.replace( num_inference_steps=__A, schedule=jnp.array(__A, dtype=jnp.floataa ), timesteps=__A, ) def __magic_name__ ( self : List[Any], __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : random.KeyArray, ): if self.config.s_min <= sigma <= self.config.s_max: UpperCAmelCase : int = min(self.config.s_churn / state.num_inference_steps, 2**0.5 - 1 ) else: UpperCAmelCase : Optional[int] = 0 # sample eps ~ N(0, S_noise^2 * I) UpperCAmelCase : Union[str, Any] = random.split(__A, num=1 ) UpperCAmelCase : List[str] = self.config.s_noise * random.normal(key=__A, shape=sample.shape ) UpperCAmelCase : Tuple = sigma + gamma * sigma UpperCAmelCase : List[str] = sample + ((sigma_hat**2 - sigma**2) ** 0.5 * eps) return sample_hat, sigma_hat def __magic_name__ ( self : Tuple, __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : float, __A : jnp.ndarray, __A : bool = True, ): UpperCAmelCase : int = sample_hat + sigma_hat * model_output UpperCAmelCase : Dict = (sample_hat - pred_original_sample) / sigma_hat UpperCAmelCase : int = sample_hat + (sigma_prev - sigma_hat) * derivative if not return_dict: return (sample_prev, derivative, state) return FlaxKarrasVeOutput(prev_sample=__A, derivative=__A, state=__A ) def __magic_name__ ( self : Tuple, __A : KarrasVeSchedulerState, __A : jnp.ndarray, __A : float, __A : float, __A : jnp.ndarray, __A : jnp.ndarray, __A : jnp.ndarray, __A : bool = True, ): UpperCAmelCase : Tuple = sample_prev + sigma_prev * model_output UpperCAmelCase : List[str] = (sample_prev - pred_original_sample) / sigma_prev UpperCAmelCase : Union[str, Any] = sample_hat + (sigma_prev - sigma_hat) * (0.5 * derivative + 0.5 * derivative_corr) if not return_dict: return (sample_prev, derivative, state) return FlaxKarrasVeOutput(prev_sample=__A, derivative=__A, state=__A ) def __magic_name__ ( self : Optional[Any], __A : KarrasVeSchedulerState, __A : Optional[int], __A : int, __A : Union[str, Any] ): raise NotImplementedError()
336
1
import heapq as hq import math from collections.abc import Iterator class __UpperCAmelCase : def __init__( self : int, __A : Union[str, Any] ): UpperCAmelCase : Dict = str(id_ ) UpperCAmelCase : int = None UpperCAmelCase : Any = None UpperCAmelCase : str = [] UpperCAmelCase : Any = {} # {vertex:distance} def __lt__( self : List[str], __A : List[Any] ): return self.key < other.key def __repr__( self : Optional[Any] ): return self.id def __magic_name__ ( self : List[Any], __A : Union[str, Any] ): self.neighbors.append(__A ) def __magic_name__ ( self : Optional[int], __A : List[Any], __A : Tuple ): UpperCAmelCase : Any = weight def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Optional[int] , UpperCAmelCase : List[Any] , UpperCAmelCase : Union[str, Any] ) -> Dict: # add the neighbors: graph[a - 1].add_neighbor(graph[b - 1] ) graph[b - 1].add_neighbor(graph[a - 1] ) # add the edges: graph[a - 1].add_edge(graph[b - 1] , UpperCAmelCase ) graph[b - 1].add_edge(graph[a - 1] , UpperCAmelCase ) def a__ ( UpperCAmelCase : list , UpperCAmelCase : Vertex ) -> list: UpperCAmelCase : Optional[Any] = [] for u in graph: UpperCAmelCase : int = math.inf UpperCAmelCase : Dict = None UpperCAmelCase : List[Any] = 0 UpperCAmelCase : List[Any] = graph[:] while q: UpperCAmelCase : int = min(UpperCAmelCase ) q.remove(UpperCAmelCase ) for v in u.neighbors: if (v in q) and (u.edges[v.id] < v.key): UpperCAmelCase : Tuple = u UpperCAmelCase : List[str] = u.edges[v.id] for i in range(1 , len(UpperCAmelCase ) ): a.append((int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) ) return a def a__ ( UpperCAmelCase : list , UpperCAmelCase : Vertex ) -> Iterator[tuple]: for u in graph: UpperCAmelCase : Optional[Any] = math.inf UpperCAmelCase : List[Any] = None UpperCAmelCase : List[Any] = 0 UpperCAmelCase : Tuple = list(UpperCAmelCase ) hq.heapify(UpperCAmelCase ) while h: UpperCAmelCase : int = hq.heappop(UpperCAmelCase ) for v in u.neighbors: if (v in h) and (u.edges[v.id] < v.key): UpperCAmelCase : int = u UpperCAmelCase : Any = u.edges[v.id] hq.heapify(UpperCAmelCase ) for i in range(1 , len(UpperCAmelCase ) ): yield (int(graph[i].id ) + 1, int(graph[i].pi.id ) + 1) def a__ ( ) -> None: pass if __name__ == "__main__": import doctest doctest.testmod()
336
import os import sys from contextlib import contextmanager # Windows only if os.name == "nt": import ctypes import msvcrt # noqa class __UpperCAmelCase ( ctypes.Structure ): # _fields is a specific attr expected by ctypes UpperCamelCase = [("""size""", ctypes.c_int), ("""visible""", ctypes.c_byte)] def a__ ( ) -> Dict: if os.name == "nt": UpperCAmelCase : List[str] = CursorInfo() UpperCAmelCase : List[Any] = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) UpperCAmelCase : Dict = False ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) elif os.name == "posix": sys.stdout.write('''\033[?25l''' ) sys.stdout.flush() def a__ ( ) -> Optional[int]: if os.name == "nt": UpperCAmelCase : int = CursorInfo() UpperCAmelCase : int = ctypes.windll.kernelaa.GetStdHandle(-11 ) ctypes.windll.kernelaa.GetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) UpperCAmelCase : Any = True ctypes.windll.kernelaa.SetConsoleCursorInfo(UpperCAmelCase , ctypes.byref(UpperCAmelCase ) ) elif os.name == "posix": sys.stdout.write('''\033[?25h''' ) sys.stdout.flush() @contextmanager def a__ ( ) -> Optional[Any]: try: hide_cursor() yield finally: show_cursor()
336
1
from ...configuration_utils import PretrainedConfig from ...utils import logging _lowerCamelCase : Tuple = logging.get_logger(__name__) _lowerCamelCase : Union[str, Any] = { "google/canine-s": "https://huggingface.co/google/canine-s/resolve/main/config.json", # See all CANINE models at https://huggingface.co/models?filter=canine } class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """canine""" def __init__( self : Dict, __A : str=7_6_8, __A : Tuple=1_2, __A : str=1_2, __A : List[str]=3_0_7_2, __A : Union[str, Any]="gelu", __A : Any=0.1, __A : Union[str, Any]=0.1, __A : Dict=1_6_3_8_4, __A : List[str]=1_6, __A : str=0.0_2, __A : List[str]=1E-12, __A : Optional[int]=0, __A : str=0XE000, __A : int=0XE001, __A : Any=4, __A : Tuple=4, __A : str=8, __A : Optional[int]=1_6_3_8_4, __A : Optional[Any]=1_2_8, **__A : List[Any], ): super().__init__(pad_token_id=__A, bos_token_id=__A, eos_token_id=__A, **__A ) UpperCAmelCase : List[str] = max_position_embeddings UpperCAmelCase : Any = hidden_size UpperCAmelCase : Dict = num_hidden_layers UpperCAmelCase : int = num_attention_heads UpperCAmelCase : str = intermediate_size UpperCAmelCase : Dict = hidden_act UpperCAmelCase : Optional[Any] = hidden_dropout_prob UpperCAmelCase : Optional[Any] = attention_probs_dropout_prob UpperCAmelCase : Optional[Any] = initializer_range UpperCAmelCase : Optional[int] = type_vocab_size UpperCAmelCase : Union[str, Any] = layer_norm_eps # Character config: UpperCAmelCase : Dict = downsampling_rate UpperCAmelCase : Tuple = upsampling_kernel_size UpperCAmelCase : str = num_hash_functions UpperCAmelCase : Tuple = num_hash_buckets UpperCAmelCase : Dict = local_transformer_stride
336
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) _lowerCamelCase : Tuple = { "configuration_encodec": [ "ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP", "EncodecConfig", ], "feature_extraction_encodec": ["EncodecFeatureExtractor"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[Any] = [ "ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST", "EncodecModel", "EncodecPreTrainedModel", ] if TYPE_CHECKING: from .configuration_encodec import ( ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP, EncodecConfig, ) from .feature_extraction_encodec import EncodecFeatureExtractor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_encodec import ( ENCODEC_PRETRAINED_MODEL_ARCHIVE_LIST, EncodecModel, EncodecPreTrainedModel, ) else: import sys _lowerCamelCase : Optional[Any] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
1
def a__ ( UpperCAmelCase : float ) -> float: return 10 - x * x def a__ ( UpperCAmelCase : float , UpperCAmelCase : float ) -> float: # Bolzano theory in order to find if there is a root between a and b if equation(UpperCAmelCase ) * equation(UpperCAmelCase ) >= 0: raise ValueError('''Wrong space!''' ) UpperCAmelCase : Optional[Any] = a while (b - a) >= 0.01: # Find middle point UpperCAmelCase : Optional[Any] = (a + b) / 2 # Check if middle point is root if equation(UpperCAmelCase ) == 0.0: break # Decide the side to repeat the steps if equation(UpperCAmelCase ) * equation(UpperCAmelCase ) < 0: UpperCAmelCase : Union[str, Any] = c else: UpperCAmelCase : str = c return c if __name__ == "__main__": import doctest doctest.testmod() print(bisection(-2, 5)) print(bisection(0, 6))
336
from __future__ import annotations def a__ ( UpperCAmelCase : int , UpperCAmelCase : int ) -> list[str]: if partitions <= 0: raise ValueError('''partitions must be a positive number!''' ) if partitions > number_of_bytes: raise ValueError('''partitions can not > number_of_bytes!''' ) UpperCAmelCase : str = number_of_bytes // partitions UpperCAmelCase : Dict = [] for i in range(UpperCAmelCase ): UpperCAmelCase : int = i * bytes_per_partition + 1 UpperCAmelCase : Optional[int] = ( number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition ) allocation_list.append(f'''{start_bytes}-{end_bytes}''' ) return allocation_list if __name__ == "__main__": import doctest doctest.testmod()
336
1
from ....utils import logging _lowerCamelCase : Optional[int] = logging.get_logger(__name__) class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Tuple, __A : List[str], __A : Any=None, __A : int=2_0_4_8 ): UpperCAmelCase : Union[str, Any] = config.__dict__ UpperCAmelCase : int = modal_hidden_size if num_labels: UpperCAmelCase : Tuple = num_labels
336
# Copyright 2022 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 import subprocess from packaging.version import Version, parse from accelerate.commands.config.config_args import default_config_file, load_config_from_file _lowerCamelCase : Union[str, Any] = "Run commands across TPU VMs for initial setup before running `accelerate launch`." def a__ ( UpperCAmelCase : Dict=None ) -> Optional[int]: if subparsers is not None: UpperCAmelCase : Tuple = subparsers.add_parser('''tpu-config''' , description=_description ) else: UpperCAmelCase : Dict = argparse.ArgumentParser('''Accelerate tpu-config command''' , description=_description ) # Core arguments UpperCAmelCase : Optional[int] = parser.add_argument_group( '''Config Arguments''' , '''Arguments that can be configured through `accelerate config`.''' ) config_args.add_argument( '''--config_file''' , type=UpperCAmelCase , default=UpperCAmelCase , help='''Path to the config file to use for accelerate.''' , ) config_args.add_argument( '''--tpu_name''' , default=UpperCAmelCase , help='''The name of the TPU to use. If not specified, will use the TPU specified in the config file.''' , ) config_args.add_argument( '''--tpu_zone''' , default=UpperCAmelCase , help='''The zone of the TPU to use. If not specified, will use the zone specified in the config file.''' , ) UpperCAmelCase : Union[str, Any] = parser.add_argument_group('''TPU Arguments''' , '''Arguments for options ran inside the TPU.''' ) pod_args.add_argument( '''--use_alpha''' , action='''store_true''' , help='''Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.''' , ) pod_args.add_argument( '''--command_file''' , default=UpperCAmelCase , help='''The path to the file containing the commands to run on the pod on startup.''' , ) pod_args.add_argument( '''--command''' , action='''append''' , nargs='''+''' , help='''A command to run on the pod. Can be passed multiple times.''' , ) pod_args.add_argument( '''--install_accelerate''' , action='''store_true''' , help='''Whether to install accelerate on the pod. Defaults to False.''' , ) pod_args.add_argument( '''--accelerate_version''' , default='''latest''' , help='''The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify \'dev\' to install from GitHub.''' , ) pod_args.add_argument( '''--debug''' , action='''store_true''' , help='''If set, will print the command that would be run instead of running it.''' ) if subparsers is not None: parser.set_defaults(func=UpperCAmelCase ) return parser def a__ ( UpperCAmelCase : Optional[int] ) -> Union[str, Any]: UpperCAmelCase : Union[str, Any] = None # Get the default from the config file if it exists. if args.config_file is not None or os.path.isfile(UpperCAmelCase ): UpperCAmelCase : Union[str, Any] = load_config_from_file(args.config_file ) if not args.command_file and defaults.command_file is not None and not args.command: UpperCAmelCase : List[Any] = defaults.command_file if not args.command and defaults.commands is not None: UpperCAmelCase : List[str] = defaults.commands if not args.tpu_name: UpperCAmelCase : Tuple = defaults.tpu_name if not args.tpu_zone: UpperCAmelCase : int = defaults.tpu_zone if args.accelerate_version == "dev": UpperCAmelCase : Tuple = '''git+https://github.com/huggingface/accelerate.git''' elif args.accelerate_version == "latest": UpperCAmelCase : Dict = '''accelerate -U''' elif isinstance(parse(args.accelerate_version ) , UpperCAmelCase ): UpperCAmelCase : Optional[int] = f'''accelerate=={args.accelerate_version}''' if not args.command_file and not args.command: raise ValueError('''You must specify either a command file or a command to run on the pod.''' ) if args.command_file: with open(args.command_file , '''r''' ) as f: UpperCAmelCase : int = [f.read().splitlines()] # To turn list of lists into list of strings if isinstance(args.command[0] , UpperCAmelCase ): UpperCAmelCase : int = [line for cmd in args.command for line in cmd] # Default to the shared folder and install accelerate UpperCAmelCase : Optional[int] = ['''cd /usr/share'''] if args.install_accelerate: new_cmd += [f'''pip install {args.accelerate_version}'''] new_cmd += args.command UpperCAmelCase : int = '''; '''.join(UpperCAmelCase ) # Then send it to gcloud # Eventually try to use google-api-core to do this instead of subprocess UpperCAmelCase : Any = ['''gcloud'''] if args.use_alpha: cmd += ["alpha"] cmd += [ "compute", "tpus", "tpu-vm", "ssh", args.tpu_name, "--zone", args.tpu_zone, "--command", args.command, "--worker", "all", ] if args.debug: print(f'''Running {" ".join(UpperCAmelCase )}''' ) return subprocess.run(UpperCAmelCase ) print('''Successfully setup pod.''' ) def a__ ( ) -> Any: UpperCAmelCase : Any = tpu_command_parser() UpperCAmelCase : Tuple = parser.parse_args() tpu_command_launcher(UpperCAmelCase )
336
1
from __future__ import annotations def a__ ( UpperCAmelCase : dict , UpperCAmelCase : str ) -> set[str]: UpperCAmelCase , UpperCAmelCase : Optional[int] = set(UpperCAmelCase ), [start] while stack: UpperCAmelCase : Any = stack.pop() explored.add(UpperCAmelCase ) # Differences from BFS: # 1) pop last element instead of first one # 2) add adjacent elements to stack without exploring them for adj in reversed(graph[v] ): if adj not in explored: stack.append(UpperCAmelCase ) return explored _lowerCamelCase : Optional[Any] = { "A": ["B", "C", "D"], "B": ["A", "D", "E"], "C": ["A", "F"], "D": ["B", "D"], "E": ["B", "F"], "F": ["C", "E", "G"], "G": ["F"], } if __name__ == "__main__": import doctest doctest.testmod() print(depth_first_search(G, "A"))
336
import argparse import collections import json from pathlib import Path import requests import torch import yaml from huggingface_hub import hf_hub_download from PIL import Image from transformers import ( MobileViTImageProcessor, MobileViTVaConfig, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, ) from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : Optional[int] = logging.get_logger(__name__) def a__ ( UpperCAmelCase : Union[str, Any] ) -> Optional[Any]: print('''Loading config file...''' ) def flatten_yaml_as_dict(UpperCAmelCase : Tuple , UpperCAmelCase : Any="" , UpperCAmelCase : Dict="." ): UpperCAmelCase : List[str] = [] for k, v in d.items(): UpperCAmelCase : List[Any] = parent_key + sep + k if parent_key else k if isinstance(UpperCAmelCase , collections.abc.MutableMapping ): items.extend(flatten_yaml_as_dict(UpperCAmelCase , UpperCAmelCase , sep=UpperCAmelCase ).items() ) else: items.append((new_key, v) ) return dict(UpperCAmelCase ) UpperCAmelCase : List[str] = argparse.Namespace() with open(UpperCAmelCase , '''r''' ) as yaml_file: try: UpperCAmelCase : List[str] = yaml.load(UpperCAmelCase , Loader=yaml.FullLoader ) UpperCAmelCase : Optional[int] = flatten_yaml_as_dict(UpperCAmelCase ) for k, v in flat_cfg.items(): setattr(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) except yaml.YAMLError as exc: logger.error('''Error while loading config file: {}. Error message: {}'''.format(UpperCAmelCase , str(UpperCAmelCase ) ) ) return config def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : int ) -> List[Any]: UpperCAmelCase : int = MobileViTVaConfig() UpperCAmelCase : str = False # dataset if task_name.startswith('''imagenet1k_''' ): UpperCAmelCase : Any = 1_000 if int(task_name.strip().split('''_''' )[-1] ) == 384: UpperCAmelCase : Any = 384 else: UpperCAmelCase : Tuple = 256 UpperCAmelCase : int = '''imagenet-1k-id2label.json''' elif task_name.startswith('''imagenet21k_to_1k_''' ): UpperCAmelCase : Optional[Any] = 21_000 if int(task_name.strip().split('''_''' )[-1] ) == 384: UpperCAmelCase : str = 384 else: UpperCAmelCase : Dict = 256 UpperCAmelCase : List[Any] = '''imagenet-22k-id2label.json''' elif task_name.startswith('''ade20k_''' ): UpperCAmelCase : Optional[Any] = 151 UpperCAmelCase : Tuple = 512 UpperCAmelCase : Tuple = '''ade20k-id2label.json''' UpperCAmelCase : Tuple = True elif task_name.startswith('''voc_''' ): UpperCAmelCase : Dict = 21 UpperCAmelCase : str = 512 UpperCAmelCase : Union[str, Any] = '''pascal-voc-id2label.json''' UpperCAmelCase : Dict = True # orig_config UpperCAmelCase : List[Any] = load_orig_config_file(UpperCAmelCase ) assert getattr(UpperCAmelCase , '''model.classification.name''' , -1 ) == "mobilevit_v2", "Invalid model" UpperCAmelCase : Tuple = getattr(UpperCAmelCase , '''model.classification.mitv2.width_multiplier''' , 1.0 ) assert ( getattr(UpperCAmelCase , '''model.classification.mitv2.attn_norm_layer''' , -1 ) == "layer_norm_2d" ), "Norm layers other than layer_norm_2d is not supported" UpperCAmelCase : int = getattr(UpperCAmelCase , '''model.classification.activation.name''' , '''swish''' ) # config.image_size == getattr(orig_config, 'sampler.bs.crop_size_width', 256) if is_segmentation_model: UpperCAmelCase : str = getattr(UpperCAmelCase , '''model.segmentation.output_stride''' , 16 ) if "_deeplabv3" in task_name: UpperCAmelCase : int = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_rates''' , [12, 24, 36] ) UpperCAmelCase : Any = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_out_channels''' , 512 ) UpperCAmelCase : Optional[Any] = getattr(UpperCAmelCase , '''model.segmentation.deeplabv3.aspp_dropout''' , 0.1 ) # id2label UpperCAmelCase : Union[str, Any] = '''huggingface/label-files''' UpperCAmelCase : List[Any] = json.load(open(hf_hub_download(UpperCAmelCase , UpperCAmelCase , repo_type='''dataset''' ) , '''r''' ) ) UpperCAmelCase : Any = {int(UpperCAmelCase ): v for k, v in idalabel.items()} UpperCAmelCase : int = idalabel UpperCAmelCase : Optional[int] = {v: k for k, v in idalabel.items()} return config def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : Optional[int] ) -> List[str]: UpperCAmelCase : Union[str, Any] = dct.pop(UpperCAmelCase ) UpperCAmelCase : List[str] = val def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : int=False ) -> Union[str, Any]: if base_model: UpperCAmelCase : Dict = '''''' else: UpperCAmelCase : Dict = '''mobilevitv2.''' UpperCAmelCase : Optional[int] = [] for k in state_dict.keys(): if k[:8] == "encoder.": UpperCAmelCase : List[str] = k[8:] else: UpperCAmelCase : Dict = k if ".block." in k: UpperCAmelCase : List[Any] = k_new.replace('''.block.''' , '''.''' ) if ".conv." in k: UpperCAmelCase : Optional[int] = k_new.replace('''.conv.''' , '''.convolution.''' ) if ".norm." in k: UpperCAmelCase : List[str] = k_new.replace('''.norm.''' , '''.normalization.''' ) if "conv_1." in k: UpperCAmelCase : Union[str, Any] = k_new.replace('''conv_1.''' , f'''{model_prefix}conv_stem.''' ) for i in [1, 2]: if f'''layer_{i}.''' in k: UpperCAmelCase : Union[str, Any] = k_new.replace(f'''layer_{i}.''' , f'''{model_prefix}encoder.layer.{i-1}.layer.''' ) if ".exp_1x1." in k: UpperCAmelCase : Optional[Any] = k_new.replace('''.exp_1x1.''' , '''.expand_1x1.''' ) if ".red_1x1." in k: UpperCAmelCase : int = k_new.replace('''.red_1x1.''' , '''.reduce_1x1.''' ) for i in [3, 4, 5]: if f'''layer_{i}.0.''' in k: UpperCAmelCase : Any = k_new.replace(f'''layer_{i}.0.''' , f'''{model_prefix}encoder.layer.{i-1}.downsampling_layer.''' ) if f'''layer_{i}.1.local_rep.0.''' in k: UpperCAmelCase : str = k_new.replace(f'''layer_{i}.1.local_rep.0.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_kxk.''' ) if f'''layer_{i}.1.local_rep.1.''' in k: UpperCAmelCase : int = k_new.replace(f'''layer_{i}.1.local_rep.1.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_1x1.''' ) for i in [3, 4, 5]: if i == 3: UpperCAmelCase : Dict = [0, 1] elif i == 4: UpperCAmelCase : Dict = [0, 1, 2, 3] elif i == 5: UpperCAmelCase : int = [0, 1, 2] for j in j_in: if f'''layer_{i}.1.global_rep.{j}.''' in k: UpperCAmelCase : Optional[Any] = k_new.replace( f'''layer_{i}.1.global_rep.{j}.''' , f'''{model_prefix}encoder.layer.{i-1}.transformer.layer.{j}.''' ) if f'''layer_{i}.1.global_rep.{j+1}.''' in k: UpperCAmelCase : Any = k_new.replace( f'''layer_{i}.1.global_rep.{j+1}.''' , f'''{model_prefix}encoder.layer.{i-1}.layernorm.''' ) if f'''layer_{i}.1.conv_proj.''' in k: UpperCAmelCase : Union[str, Any] = k_new.replace(f'''layer_{i}.1.conv_proj.''' , f'''{model_prefix}encoder.layer.{i-1}.conv_projection.''' ) if "pre_norm_attn.0." in k: UpperCAmelCase : Optional[int] = k_new.replace('''pre_norm_attn.0.''' , '''layernorm_before.''' ) if "pre_norm_attn.1." in k: UpperCAmelCase : Optional[Any] = k_new.replace('''pre_norm_attn.1.''' , '''attention.''' ) if "pre_norm_ffn.0." in k: UpperCAmelCase : List[Any] = k_new.replace('''pre_norm_ffn.0.''' , '''layernorm_after.''' ) if "pre_norm_ffn.1." in k: UpperCAmelCase : List[Any] = k_new.replace('''pre_norm_ffn.1.''' , '''ffn.conv1.''' ) if "pre_norm_ffn.3." in k: UpperCAmelCase : Any = k_new.replace('''pre_norm_ffn.3.''' , '''ffn.conv2.''' ) if "classifier.1." in k: UpperCAmelCase : Optional[int] = k_new.replace('''classifier.1.''' , '''classifier.''' ) if "seg_head." in k: UpperCAmelCase : Union[str, Any] = k_new.replace('''seg_head.''' , '''segmentation_head.''' ) if ".aspp_layer." in k: UpperCAmelCase : Tuple = k_new.replace('''.aspp_layer.''' , '''.''' ) if ".aspp_pool." in k: UpperCAmelCase : Optional[int] = k_new.replace('''.aspp_pool.''' , '''.''' ) rename_keys.append((k, k_new) ) return rename_keys def a__ ( UpperCAmelCase : Union[str, Any] ) -> Any: UpperCAmelCase : str = [] for k in state_dict.keys(): if k.startswith('''seg_head.aux_head.''' ): keys_to_ignore.append(UpperCAmelCase ) for k in keys_to_ignore: state_dict.pop(UpperCAmelCase , UpperCAmelCase ) def a__ ( ) -> Union[str, Any]: UpperCAmelCase : int = '''http://images.cocodataset.org/val2017/000000039769.jpg''' # url = "https://cdn.britannica.com/86/141086-050-9D7C75EE/Gulfstream-G450-business-jet-passengers.jpg" UpperCAmelCase : List[str] = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ) return im @torch.no_grad() def a__ ( UpperCAmelCase : int , UpperCAmelCase : int , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : List[Any] ) -> Union[str, Any]: UpperCAmelCase : Union[str, Any] = get_mobilevitva_config(UpperCAmelCase , UpperCAmelCase ) # load original state_dict UpperCAmelCase : List[str] = torch.load(UpperCAmelCase , map_location='''cpu''' ) # load huggingface model if task_name.startswith('''ade20k_''' ) or task_name.startswith('''voc_''' ): UpperCAmelCase : str = MobileViTVaForSemanticSegmentation(UpperCAmelCase ).eval() UpperCAmelCase : str = False else: UpperCAmelCase : Union[str, Any] = MobileViTVaForImageClassification(UpperCAmelCase ).eval() UpperCAmelCase : Any = False # remove and rename some keys of load the original model UpperCAmelCase : Optional[Any] = checkpoint remove_unused_keys(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = create_rename_keys(UpperCAmelCase , base_model=UpperCAmelCase ) for rename_key_src, rename_key_dest in rename_keys: rename_key(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) # load modified state_dict model.load_state_dict(UpperCAmelCase ) # Check outputs on an image, prepared by MobileViTImageProcessor UpperCAmelCase : Dict = MobileViTImageProcessor(crop_size=config.image_size , size=config.image_size + 32 ) UpperCAmelCase : Any = image_processor(images=prepare_img() , return_tensors='''pt''' ) UpperCAmelCase : Union[str, Any] = model(**UpperCAmelCase ) # verify classification model if task_name.startswith('''imagenet''' ): UpperCAmelCase : Optional[Any] = outputs.logits UpperCAmelCase : int = logits.argmax(-1 ).item() print('''Predicted class:''' , model.config.idalabel[predicted_class_idx] ) if task_name.startswith('''imagenet1k_256''' ) and config.width_multiplier == 1.0: # expected_logits for base variant UpperCAmelCase : str = torch.tensor([-1.6_336E00, -7.3_204E-02, -5.1_883E-01] ) assert torch.allclose(logits[0, :3] , UpperCAmelCase , atol=1E-4 ) Path(UpperCAmelCase ).mkdir(exist_ok=UpperCAmelCase ) print(f'''Saving model {task_name} to {pytorch_dump_folder_path}''' ) model.save_pretrained(UpperCAmelCase ) print(f'''Saving image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(UpperCAmelCase ) if __name__ == "__main__": _lowerCamelCase : str = argparse.ArgumentParser() # Required parameters parser.add_argument( "--task", default="imagenet1k_256", type=str, help=( "Name of the task for which the MobileViTV2 model you'd like to convert is trained on . " "\n Classification (ImageNet-1k)\n - MobileViTV2 (256x256) : imagenet1k_256\n - MobileViTV2 (Trained on 256x256 and Finetuned on 384x384) : imagenet1k_384\n - MobileViTV2 (Trained on ImageNet-21k and Finetuned on ImageNet-1k 256x256) :\n imagenet21k_to_1k_256\n - MobileViTV2 (Trained on ImageNet-21k, Finetuned on ImageNet-1k 256x256, and Finetuned on\n ImageNet-1k 384x384) : imagenet21k_to_1k_384\n Segmentation\n - ADE20K Dataset : ade20k_deeplabv3\n - Pascal VOC 2012 Dataset: voc_deeplabv3\n " ), choices=[ "imagenet1k_256", "imagenet1k_384", "imagenet21k_to_1k_256", "imagenet21k_to_1k_384", "ade20k_deeplabv3", "voc_deeplabv3", ], ) parser.add_argument( "--orig_checkpoint_path", required=True, type=str, help="Path to the original state dict (.pt file)." ) parser.add_argument("--orig_config_path", required=True, type=str, help="Path to the original config file.") parser.add_argument( "--pytorch_dump_folder_path", required=True, type=str, help="Path to the output PyTorch model directory." ) _lowerCamelCase : Optional[int] = parser.parse_args() convert_mobilevitva_checkpoint( args.task, args.orig_checkpoint_path, args.orig_config_path, args.pytorch_dump_folder_path )
336
1
from math import ceil def a__ ( UpperCAmelCase : int = 1_001 ) -> int: UpperCAmelCase : Optional[int] = 1 for i in range(1 , int(ceil(n / 2.0 ) ) ): UpperCAmelCase : Dict = 2 * i + 1 UpperCAmelCase : Union[str, Any] = 2 * i UpperCAmelCase : Tuple = total + 4 * odd**2 - 6 * even return total if __name__ == "__main__": import sys if len(sys.argv) == 1: print(solution()) else: try: _lowerCamelCase : Tuple = int(sys.argv[1]) print(solution(n)) except ValueError: print("Invalid entry - please enter a number")
336
import inspect import tempfile from collections import OrderedDict, UserDict from collections.abc import MutableMapping from contextlib import ExitStack, contextmanager from dataclasses import fields from enum import Enum from typing import Any, ContextManager, List, Tuple import numpy as np from .import_utils import is_flax_available, is_tf_available, is_torch_available, is_torch_fx_proxy if is_flax_available(): import jax.numpy as jnp class __UpperCAmelCase ( lowerCamelCase__ ): def __get__( self : Tuple, __A : Optional[Any], __A : Optional[int]=None ): # See docs.python.org/3/howto/descriptor.html#properties if obj is None: return self if self.fget is None: raise AttributeError('''unreadable attribute''' ) UpperCAmelCase : str = '''__cached_''' + self.fget.__name__ UpperCAmelCase : int = getattr(__A, __A, __A ) if cached is None: UpperCAmelCase : Any = self.fget(__A ) setattr(__A, __A, __A ) return cached def a__ ( UpperCAmelCase : Optional[Any] ) -> Any: UpperCAmelCase : Any = val.lower() if val in {"y", "yes", "t", "true", "on", "1"}: return 1 if val in {"n", "no", "f", "false", "off", "0"}: return 0 raise ValueError(f'''invalid truth value {val!r}''' ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: if is_torch_fx_proxy(UpperCAmelCase ): return True if is_torch_available(): import torch if isinstance(UpperCAmelCase , torch.Tensor ): return True if is_tf_available(): import tensorflow as tf if isinstance(UpperCAmelCase , tf.Tensor ): return True if is_flax_available(): import jax.numpy as jnp from jax.core import Tracer if isinstance(UpperCAmelCase , (jnp.ndarray, Tracer) ): return True return isinstance(UpperCAmelCase , np.ndarray ) def a__ ( UpperCAmelCase : List[Any] ) -> Union[str, Any]: return isinstance(UpperCAmelCase , np.ndarray ) def a__ ( UpperCAmelCase : str ) -> Tuple: return _is_numpy(UpperCAmelCase ) def a__ ( UpperCAmelCase : str ) -> List[Any]: import torch return isinstance(UpperCAmelCase , torch.Tensor ) def a__ ( UpperCAmelCase : str ) -> List[Any]: return False if not is_torch_available() else _is_torch(UpperCAmelCase ) def a__ ( UpperCAmelCase : Tuple ) -> List[str]: import torch return isinstance(UpperCAmelCase , torch.device ) def a__ ( UpperCAmelCase : Any ) -> Any: return False if not is_torch_available() else _is_torch_device(UpperCAmelCase ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: import torch if isinstance(UpperCAmelCase , UpperCAmelCase ): if hasattr(UpperCAmelCase , UpperCAmelCase ): UpperCAmelCase : Union[str, Any] = getattr(UpperCAmelCase , UpperCAmelCase ) else: return False return isinstance(UpperCAmelCase , torch.dtype ) def a__ ( UpperCAmelCase : Optional[Any] ) -> Union[str, Any]: return False if not is_torch_available() else _is_torch_dtype(UpperCAmelCase ) def a__ ( UpperCAmelCase : Any ) -> str: import tensorflow as tf return isinstance(UpperCAmelCase , tf.Tensor ) def a__ ( UpperCAmelCase : int ) -> Union[str, Any]: return False if not is_tf_available() else _is_tensorflow(UpperCAmelCase ) def a__ ( UpperCAmelCase : List[str] ) -> Tuple: import tensorflow as tf # the `is_symbolic_tensor` predicate is only available starting with TF 2.14 if hasattr(UpperCAmelCase , '''is_symbolic_tensor''' ): return tf.is_symbolic_tensor(UpperCAmelCase ) return type(UpperCAmelCase ) == tf.Tensor def a__ ( UpperCAmelCase : int ) -> List[Any]: return False if not is_tf_available() else _is_tf_symbolic_tensor(UpperCAmelCase ) def a__ ( UpperCAmelCase : List[Any] ) -> Dict: import jax.numpy as jnp # noqa: F811 return isinstance(UpperCAmelCase , jnp.ndarray ) def a__ ( UpperCAmelCase : List[Any] ) -> Optional[int]: return False if not is_flax_available() else _is_jax(UpperCAmelCase ) def a__ ( UpperCAmelCase : int ) -> Tuple: if isinstance(UpperCAmelCase , (dict, UserDict) ): return {k: to_py_obj(UpperCAmelCase ) for k, v in obj.items()} elif isinstance(UpperCAmelCase , (list, tuple) ): return [to_py_obj(UpperCAmelCase ) for o in obj] elif is_tf_tensor(UpperCAmelCase ): return obj.numpy().tolist() elif is_torch_tensor(UpperCAmelCase ): return obj.detach().cpu().tolist() elif is_jax_tensor(UpperCAmelCase ): return np.asarray(UpperCAmelCase ).tolist() elif isinstance(UpperCAmelCase , (np.ndarray, np.number) ): # tolist also works on 0d np arrays return obj.tolist() else: return obj def a__ ( UpperCAmelCase : Any ) -> List[str]: if isinstance(UpperCAmelCase , (dict, UserDict) ): return {k: to_numpy(UpperCAmelCase ) for k, v in obj.items()} elif isinstance(UpperCAmelCase , (list, tuple) ): return np.array(UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): return obj.numpy() elif is_torch_tensor(UpperCAmelCase ): return obj.detach().cpu().numpy() elif is_jax_tensor(UpperCAmelCase ): return np.asarray(UpperCAmelCase ) else: return obj class __UpperCAmelCase ( lowerCamelCase__ ): def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : Optional[Any] = fields(self ) # Safety and consistency checks if not len(__A ): raise ValueError(F'''{self.__class__.__name__} has no fields.''' ) if not all(field.default is None for field in class_fields[1:] ): raise ValueError(F'''{self.__class__.__name__} should not have more than one required field.''' ) UpperCAmelCase : int = getattr(self, class_fields[0].name ) UpperCAmelCase : str = all(getattr(self, field.name ) is None for field in class_fields[1:] ) if other_fields_are_none and not is_tensor(__A ): if isinstance(__A, __A ): UpperCAmelCase : Tuple = first_field.items() UpperCAmelCase : Any = True else: try: UpperCAmelCase : Optional[Any] = iter(__A ) UpperCAmelCase : Optional[Any] = True except TypeError: UpperCAmelCase : Optional[int] = False # if we provided an iterator as first field and the iterator is a (key, value) iterator # set the associated fields if first_field_iterator: for idx, element in enumerate(__A ): if ( not isinstance(__A, (list, tuple) ) or not len(__A ) == 2 or not isinstance(element[0], __A ) ): if idx == 0: # If we do not have an iterator of key/values, set it as attribute UpperCAmelCase : Any = first_field else: # If we have a mixed iterator, raise an error raise ValueError( F'''Cannot set key/value for {element}. It needs to be a tuple (key, value).''' ) break setattr(self, element[0], element[1] ) if element[1] is not None: UpperCAmelCase : Union[str, Any] = element[1] elif first_field is not None: UpperCAmelCase : Union[str, Any] = first_field else: for field in class_fields: UpperCAmelCase : Optional[Any] = getattr(self, field.name ) if v is not None: UpperCAmelCase : Optional[int] = v def __delitem__( self : Union[str, Any], *__A : str, **__A : Tuple ): raise Exception(F'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : List[str], *__A : Union[str, Any], **__A : Optional[Any] ): raise Exception(F'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : Any, *__A : Dict, **__A : str ): raise Exception(F'''You cannot use ``pop`` on a {self.__class__.__name__} instance.''' ) def __magic_name__ ( self : Dict, *__A : int, **__A : Dict ): raise Exception(F'''You cannot use ``update`` on a {self.__class__.__name__} instance.''' ) def __getitem__( self : List[str], __A : List[str] ): if isinstance(__A, __A ): UpperCAmelCase : int = dict(self.items() ) return inner_dict[k] else: return self.to_tuple()[k] def __setattr__( self : Optional[Any], __A : Dict, __A : Union[str, Any] ): if name in self.keys() and value is not None: # Don't call self.__setitem__ to avoid recursion errors super().__setitem__(__A, __A ) super().__setattr__(__A, __A ) def __setitem__( self : Dict, __A : List[Any], __A : Union[str, Any] ): # Will raise a KeyException if needed super().__setitem__(__A, __A ) # Don't call self.__setattr__ to avoid recursion errors super().__setattr__(__A, __A ) def __magic_name__ ( self : List[str] ): return tuple(self[k] for k in self.keys() ) class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ ): @classmethod def __magic_name__ ( cls : List[Any], __A : Tuple ): raise ValueError( F'''{value} is not a valid {cls.__name__}, please select one of {list(cls._valueamember_map_.keys() )}''' ) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """longest""" UpperCamelCase = """max_length""" UpperCamelCase = """do_not_pad""" class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """pt""" UpperCamelCase = """tf""" UpperCamelCase = """np""" UpperCamelCase = """jax""" class __UpperCAmelCase : def __init__( self : Any, __A : List[ContextManager] ): UpperCAmelCase : Tuple = context_managers UpperCAmelCase : Tuple = ExitStack() def __enter__( self : Any ): for context_manager in self.context_managers: self.stack.enter_context(__A ) def __exit__( self : List[Any], *__A : Union[str, Any], **__A : Dict ): self.stack.__exit__(*__A, **__A ) def a__ ( UpperCAmelCase : Union[str, Any] ) -> str: UpperCAmelCase : int = infer_framework(UpperCAmelCase ) if framework == "tf": UpperCAmelCase : List[str] = inspect.signature(model_class.call ) # TensorFlow models elif framework == "pt": UpperCAmelCase : List[Any] = inspect.signature(model_class.forward ) # PyTorch models else: UpperCAmelCase : Tuple = inspect.signature(model_class.__call__ ) # Flax models for p in signature.parameters: if p == "return_loss" and signature.parameters[p].default is True: return True return False def a__ ( UpperCAmelCase : Dict ) -> Any: UpperCAmelCase : List[Any] = model_class.__name__ UpperCAmelCase : Union[str, Any] = infer_framework(UpperCAmelCase ) if framework == "tf": UpperCAmelCase : Tuple = inspect.signature(model_class.call ) # TensorFlow models elif framework == "pt": UpperCAmelCase : Dict = inspect.signature(model_class.forward ) # PyTorch models else: UpperCAmelCase : Dict = inspect.signature(model_class.__call__ ) # Flax models if "QuestionAnswering" in model_name: return [p for p in signature.parameters if "label" in p or p in ("start_positions", "end_positions")] else: return [p for p in signature.parameters if "label" in p] def a__ ( UpperCAmelCase : MutableMapping , UpperCAmelCase : str = "" , UpperCAmelCase : str = "." ) -> Union[str, Any]: def _flatten_dict(UpperCAmelCase : Optional[Any] , UpperCAmelCase : List[str]="" , UpperCAmelCase : Any="." ): for k, v in d.items(): UpperCAmelCase : List[str] = str(UpperCAmelCase ) + delimiter + str(UpperCAmelCase ) if parent_key else k if v and isinstance(UpperCAmelCase , UpperCAmelCase ): yield from flatten_dict(UpperCAmelCase , UpperCAmelCase , delimiter=UpperCAmelCase ).items() else: yield key, v return dict(_flatten_dict(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) ) @contextmanager def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : bool = False ) -> Optional[Any]: if use_temp_dir: with tempfile.TemporaryDirectory() as tmp_dir: yield tmp_dir else: yield working_dir def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : List[str]=None ) -> Optional[Any]: if is_numpy_array(UpperCAmelCase ): return np.transpose(UpperCAmelCase , axes=UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.T if axes is None else array.permute(*UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.transpose(UpperCAmelCase , perm=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.transpose(UpperCAmelCase , axes=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for transpose: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : Optional[int] ) -> List[str]: if is_numpy_array(UpperCAmelCase ): return np.reshape(UpperCAmelCase , UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.reshape(*UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.reshape(UpperCAmelCase , UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.reshape(UpperCAmelCase , UpperCAmelCase ) else: raise ValueError(f'''Type not supported for reshape: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : Tuple , UpperCAmelCase : Optional[int]=None ) -> Any: if is_numpy_array(UpperCAmelCase ): return np.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.squeeze() if axis is None else array.squeeze(dim=UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.squeeze(UpperCAmelCase , axis=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for squeeze: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : str , UpperCAmelCase : int ) -> str: if is_numpy_array(UpperCAmelCase ): return np.expand_dims(UpperCAmelCase , UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.unsqueeze(dim=UpperCAmelCase ) elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.expand_dims(UpperCAmelCase , axis=UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return jnp.expand_dims(UpperCAmelCase , axis=UpperCAmelCase ) else: raise ValueError(f'''Type not supported for expand_dims: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : Dict ) -> List[str]: if is_numpy_array(UpperCAmelCase ): return np.size(UpperCAmelCase ) elif is_torch_tensor(UpperCAmelCase ): return array.numel() elif is_tf_tensor(UpperCAmelCase ): import tensorflow as tf return tf.size(UpperCAmelCase ) elif is_jax_tensor(UpperCAmelCase ): return array.size else: raise ValueError(f'''Type not supported for expand_dims: {type(UpperCAmelCase )}.''' ) def a__ ( UpperCAmelCase : List[str] , UpperCAmelCase : List[str] ) -> Dict: for key, value in auto_map.items(): if isinstance(UpperCAmelCase , (tuple, list) ): UpperCAmelCase : List[Any] = [f'''{repo_id}--{v}''' if (v is not None and '''--''' not in v) else v for v in value] elif value is not None and "--" not in value: UpperCAmelCase : List[Any] = f'''{repo_id}--{value}''' return auto_map def a__ ( UpperCAmelCase : Tuple ) -> Union[str, Any]: for base_class in inspect.getmro(UpperCAmelCase ): UpperCAmelCase : Any = base_class.__module__ UpperCAmelCase : Dict = base_class.__name__ if module.startswith('''tensorflow''' ) or module.startswith('''keras''' ) or name == "TFPreTrainedModel": return "tf" elif module.startswith('''torch''' ) or name == "PreTrainedModel": return "pt" elif module.startswith('''flax''' ) or module.startswith('''jax''' ) or name == "FlaxPreTrainedModel": return "flax" else: raise TypeError(f'''Could not infer framework from class {model_class}.''' )
336
1
import os import re import warnings from shutil import copyfile from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer if TYPE_CHECKING: from ...tokenization_utils_base import TextInput from ...utils import logging _lowerCamelCase : Optional[Any] = logging.get_logger(__name__) _lowerCamelCase : Optional[int] = {"vocab_file": "spiece.model"} _lowerCamelCase : Dict = { "vocab_file": { "t5-small": "https://huggingface.co/t5-small/resolve/main/spiece.model", "t5-base": "https://huggingface.co/t5-base/resolve/main/spiece.model", "t5-large": "https://huggingface.co/t5-large/resolve/main/spiece.model", "t5-3b": "https://huggingface.co/t5-3b/resolve/main/spiece.model", "t5-11b": "https://huggingface.co/t5-11b/resolve/main/spiece.model", } } # TODO(PVP) - this should be removed in Transformers v5 _lowerCamelCase : Any = { "t5-small": 5_1_2, "t5-base": 5_1_2, "t5-large": 5_1_2, "t5-3b": 5_1_2, "t5-11b": 5_1_2, } _lowerCamelCase : List[Any] = "▁" class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = VOCAB_FILES_NAMES UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase = ["""input_ids""", """attention_mask"""] def __init__( self : int, __A : Any, __A : Any="</s>", __A : List[str]="<unk>", __A : Dict="<pad>", __A : List[Any]=1_0_0, __A : Any=None, __A : Optional[Dict[str, Any]] = None, __A : List[str]=True, **__A : Tuple, ): # Add extra_ids to the special token list if extra_ids > 0 and additional_special_tokens is None: UpperCAmelCase : Any = [F'''<extra_id_{i}>''' for i in range(__A )] elif extra_ids > 0 and additional_special_tokens is not None: # Check that we have the right number of extra_id special tokens UpperCAmelCase : Union[str, Any] = len(set(filter(lambda __A : bool('''extra_id''' in str(__A ) ), __A ) ) ) if extra_tokens != extra_ids: raise ValueError( F'''Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are''' ''' provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids''' ''' tokens''' ) if legacy: logger.warning_once( F'''You are using the legacy behaviour of the {self.__class__}. This means that tokens that come after special tokens will not be properly handled. We recommend you to''' ''' read the related pull request available at https://github.com/huggingface/transformers/pull/24565''' ) UpperCAmelCase : List[Any] = legacy UpperCAmelCase : int = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( eos_token=__A, unk_token=__A, pad_token=__A, extra_ids=__A, additional_special_tokens=__A, sp_model_kwargs=self.sp_model_kwargs, legacy=__A, **__A, ) UpperCAmelCase : Union[str, Any] = vocab_file UpperCAmelCase : str = extra_ids UpperCAmelCase : Union[str, Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(__A ) @staticmethod def __magic_name__ ( __A : str, __A : Union[str, Any], __A : List[Any] ): if pretrained_model_name_or_path in TaTokenizer.max_model_input_sizes: UpperCAmelCase : int = TaTokenizer.max_model_input_sizes[pretrained_model_name_or_path] if init_max_model_length is not None and init_max_model_length != max_model_length: return init_max_model_length elif init_max_model_length is None: warnings.warn( '''This tokenizer was incorrectly instantiated with a model max length of''' F''' {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this''' ''' behavior is kept to avoid breaking backwards compatibility when padding/encoding with''' ''' `truncation is True`.\n- Be aware that you SHOULD NOT rely on''' F''' {pretrained_model_name_or_path} automatically truncating your input to''' F''' {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences''' F''' longer than {deprecated_max_model_length} you can either instantiate this tokenizer with''' ''' `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please''' ''' instantiate this tokenizer with `model_max_length` set to your preferred value.''', __A, ) return max_model_length @property def __magic_name__ ( self : List[str] ): return self.sp_model.get_piece_size() + self._extra_ids def __magic_name__ ( self : Dict ): UpperCAmelCase : int = {self.convert_ids_to_tokens(__A ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __magic_name__ ( self : str, __A : List[int], __A : Optional[List[int]] = None, __A : bool = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=__A, token_ids_a=__A, already_has_special_tokens=__A ) # normal case: some special tokens if token_ids_a is None: return ([0] * len(__A )) + [1] return ([0] * len(__A )) + [1] + ([0] * len(__A )) + [1] def __magic_name__ ( self : str ): return list( set(filter(lambda __A : bool(re.search(R'''<extra_id_\d+>''', __A ) ) is not None, self.additional_special_tokens ) ) ) def __magic_name__ ( self : Union[str, Any] ): return [self._convert_token_to_id(__A ) for token in self.get_sentinel_tokens()] def __magic_name__ ( self : Tuple, __A : List[int] ): if len(__A ) > 0 and token_ids[-1] == self.eos_token_id: warnings.warn( F'''This sequence already has {self.eos_token}. In future versions this behavior may lead to duplicated''' ''' eos tokens being added.''' ) return token_ids else: return token_ids + [self.eos_token_id] def __magic_name__ ( self : List[Any], __A : List[int], __A : Optional[List[int]] = None ): UpperCAmelCase : Tuple = [self.eos_token_id] if token_ids_a is None: return len(token_ids_a + eos ) * [0] return len(token_ids_a + eos + token_ids_a + eos ) * [0] def __magic_name__ ( self : List[Any], __A : List[int], __A : Optional[List[int]] = None ): UpperCAmelCase : List[Any] = self._add_eos_if_not_present(__A ) if token_ids_a is None: return token_ids_a else: UpperCAmelCase : Union[str, Any] = self._add_eos_if_not_present(__A ) return token_ids_a + token_ids_a def __getstate__( self : Dict ): UpperCAmelCase : List[Any] = self.__dict__.copy() UpperCAmelCase : List[Any] = None return state def __setstate__( self : List[str], __A : List[str] ): UpperCAmelCase : List[Any] = d # for backward compatibility if not hasattr(self, '''sp_model_kwargs''' ): UpperCAmelCase : List[str] = {} UpperCAmelCase : List[str] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def __magic_name__ ( self : Union[str, Any], __A : "TextInput", **__A : List[str] ): # Replace the SPIECE_UNDERLINE with a space to make sure SPIECE_UNDERLINE is only used at # the beginning of the text if not self.legacy: UpperCAmelCase : int = SPIECE_UNDERLINE + text.replace(__A, ''' ''' ) return super().tokenize(__A, **__A ) def __magic_name__ ( self : List[Any], __A : Tuple, **__A : Any ): if not self.legacy: UpperCAmelCase : int = text.startswith(__A ) if is_first: UpperCAmelCase : str = text[1:] UpperCAmelCase : str = self.sp_model.encode(__A, out_type=__A ) if not self.legacy and not is_first and not text.startswith(''' ''' ) and tokens[0].startswith(__A ): UpperCAmelCase : Optional[Any] = ([tokens[0][1:]] if len(tokens[0] ) > 1 else []) + tokens[1:] return tokens def __magic_name__ ( self : Union[str, Any], __A : Dict ): if token.startswith('''<extra_id_''' ): UpperCAmelCase : Union[str, Any] = re.match(R'''<extra_id_(\d+)>''', __A ) UpperCAmelCase : Optional[Any] = int(match.group(1 ) ) return self.vocab_size - num - 1 return self.sp_model.piece_to_id(__A ) def __magic_name__ ( self : Union[str, Any], __A : Optional[int] ): if index < self.sp_model.get_piece_size(): UpperCAmelCase : Union[str, Any] = self.sp_model.IdToPiece(__A ) else: UpperCAmelCase : Tuple = F'''<extra_id_{self.vocab_size - 1 - index}>''' return token def __magic_name__ ( self : Tuple, __A : Union[str, Any] ): UpperCAmelCase : str = [] UpperCAmelCase : Any = '''''' UpperCAmelCase : Union[str, Any] = False for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: if not prev_is_special: out_string += " " out_string += self.sp_model.decode(__A ) + token UpperCAmelCase : Union[str, Any] = True UpperCAmelCase : int = [] else: current_sub_tokens.append(__A ) UpperCAmelCase : Any = False out_string += self.sp_model.decode(__A ) return out_string.strip() def __magic_name__ ( self : Optional[Any], __A : str, __A : Optional[str] = None ): if not os.path.isdir(__A ): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' ) return UpperCAmelCase : Optional[Any] = os.path.join( __A, (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(__A ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file, __A ) elif not os.path.isfile(self.vocab_file ): with open(__A, '''wb''' ) as fi: UpperCAmelCase : Any = self.sp_model.serialized_model_proto() fi.write(__A ) return (out_vocab_file,)
336
import os import unittest from transformers import LayoutLMTokenizer, LayoutLMTokenizerFast from transformers.models.layoutlm.tokenization_layoutlm import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class __UpperCAmelCase ( lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = LayoutLMTokenizer UpperCamelCase = LayoutLMTokenizerFast UpperCamelCase = True UpperCamelCase = True def __magic_name__ ( self : Any ): super().setUp() UpperCAmelCase : Dict = [ '''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''', ''',''', '''low''', '''lowest''', ] UpperCAmelCase : int = os.path.join(self.tmpdirname, VOCAB_FILES_NAMES['''vocab_file'''] ) with open(self.vocab_file, '''w''', encoding='''utf-8''' ) as vocab_writer: vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens] ) ) def __magic_name__ ( self : Union[str, Any], **__A : List[str] ): return LayoutLMTokenizer.from_pretrained(self.tmpdirname, **__A ) def __magic_name__ ( self : Optional[int], __A : int ): UpperCAmelCase : Optional[Any] = '''UNwant\u00E9d,running''' UpperCAmelCase : Optional[int] = '''unwanted, running''' return input_text, output_text def __magic_name__ ( self : Any ): UpperCAmelCase : Union[str, Any] = self.tokenizer_class(self.vocab_file ) UpperCAmelCase : Optional[Any] = tokenizer.tokenize('''UNwant\u00E9d,running''' ) self.assertListEqual(__A, ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing'''] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__A ), [7, 4, 5, 1_0, 8, 9] ) def __magic_name__ ( self : Optional[int] ): pass
336
1
import json import os import re import sys import urllib.request import requests from bsa import BeautifulSoup _lowerCamelCase : str = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" " (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.19582" } def a__ ( UpperCAmelCase : str = "dhaka" , UpperCAmelCase : int = 5 ) -> int: UpperCAmelCase : List[Any] = min(UpperCAmelCase , 50 ) # Prevent abuse! UpperCAmelCase : Tuple = { '''q''': query, '''tbm''': '''isch''', '''hl''': '''en''', '''ijn''': '''0''', } UpperCAmelCase : Optional[Any] = requests.get('''https://www.google.com/search''' , params=UpperCAmelCase , headers=UpperCAmelCase ) UpperCAmelCase : Optional[Any] = BeautifulSoup(html.text , '''html.parser''' ) UpperCAmelCase : Optional[Any] = ''''''.join( re.findall(r'''AF_initDataCallback\(([^<]+)\);''' , str(soup.select('''script''' ) ) ) ) UpperCAmelCase : Tuple = json.dumps(UpperCAmelCase ) UpperCAmelCase : Dict = json.loads(UpperCAmelCase ) UpperCAmelCase : Any = re.findall( r'''\[\"GRID_STATE0\",null,\[\[1,\[0,\".*?\",(.*),\"All\",''' , UpperCAmelCase , ) if not matched_google_image_data: return 0 UpperCAmelCase : Optional[Any] = re.sub( r'''\[\"(https\:\/\/encrypted-tbn0\.gstatic\.com\/images\?.*?)\",\d+,\d+\]''' , '''''' , str(UpperCAmelCase ) , ) UpperCAmelCase : List[Any] = re.findall( r'''(?:\'|,),\[\"(https:|http.*?)\",\d+,\d+\]''' , UpperCAmelCase , ) for index, fixed_full_res_image in enumerate(UpperCAmelCase ): if index >= max_images: return index UpperCAmelCase : Tuple = bytes(UpperCAmelCase , '''ascii''' ).decode( '''unicode-escape''' ) UpperCAmelCase : int = bytes(UpperCAmelCase , '''ascii''' ).decode( '''unicode-escape''' ) UpperCAmelCase : str = urllib.request.build_opener() UpperCAmelCase : Union[str, Any] = [ ( '''User-Agent''', '''Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36''' ''' (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.19582''', ) ] urllib.request.install_opener(UpperCAmelCase ) UpperCAmelCase : int = f'''query_{query.replace(" " , "_" )}''' if not os.path.exists(UpperCAmelCase ): os.makedirs(UpperCAmelCase ) urllib.request.urlretrieve( # noqa: S310 UpperCAmelCase , f'''{path_name}/original_size_img_{index}.jpg''' ) return index if __name__ == "__main__": try: _lowerCamelCase : Dict = download_images_from_google_query(sys.argv[1]) print(f"""{image_count} images were downloaded to disk.""") except IndexError: print("Please provide a search term.") raise
336
from __future__ import annotations import copy import inspect import json import math import os import tempfile import unittest from importlib import import_module import numpy as np from transformers import ViTMAEConfig from transformers.file_utils import cached_property, is_tf_available, is_vision_available from transformers.testing_utils import require_tf, require_vision, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import TFViTMAEForPreTraining, TFViTMAEModel if is_vision_available(): from PIL import Image from transformers import ViTImageProcessor class __UpperCAmelCase : def __init__( self : Any, __A : str, __A : Dict=1_3, __A : int=3_0, __A : Tuple=2, __A : Union[str, Any]=3, __A : Any=True, __A : str=True, __A : Dict=3_2, __A : List[Any]=2, __A : Optional[Any]=4, __A : Union[str, Any]=3_7, __A : int="gelu", __A : int=0.1, __A : List[Any]=0.1, __A : Tuple=1_0, __A : Tuple=0.0_2, __A : Any=3, __A : List[str]=0.6, __A : Any=None, ): UpperCAmelCase : Union[str, Any] = parent UpperCAmelCase : Dict = batch_size UpperCAmelCase : List[str] = image_size UpperCAmelCase : Dict = patch_size UpperCAmelCase : int = num_channels UpperCAmelCase : Union[str, Any] = is_training UpperCAmelCase : Union[str, Any] = use_labels UpperCAmelCase : Union[str, Any] = hidden_size UpperCAmelCase : Optional[int] = num_hidden_layers UpperCAmelCase : Union[str, Any] = num_attention_heads UpperCAmelCase : List[str] = intermediate_size UpperCAmelCase : Optional[int] = hidden_act UpperCAmelCase : Tuple = hidden_dropout_prob UpperCAmelCase : List[Any] = attention_probs_dropout_prob UpperCAmelCase : Any = type_sequence_label_size UpperCAmelCase : Tuple = initializer_range UpperCAmelCase : Tuple = mask_ratio UpperCAmelCase : Any = scope # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above # (we add 1 for the [CLS] token) UpperCAmelCase : Tuple = (image_size // patch_size) ** 2 UpperCAmelCase : List[Any] = int(math.ceil((1 - mask_ratio) * (num_patches + 1) ) ) def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : int = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : Any = None if self.use_labels: UpperCAmelCase : Optional[Any] = ids_tensor([self.batch_size], self.type_sequence_label_size ) UpperCAmelCase : str = self.get_config() return config, pixel_values, labels def __magic_name__ ( self : Optional[Any] ): 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, decoder_hidden_size=self.hidden_size, decoder_num_hidden_layers=self.num_hidden_layers, decoder_num_attention_heads=self.num_attention_heads, decoder_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 __magic_name__ ( self : str, __A : List[Any], __A : Any, __A : Any ): UpperCAmelCase : Optional[Any] = TFViTMAEModel(config=__A ) UpperCAmelCase : Tuple = model(__A, training=__A ) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__ ( self : Tuple, __A : str, __A : int, __A : str ): UpperCAmelCase : Dict = TFViTMAEForPreTraining(__A ) UpperCAmelCase : int = model(__A, training=__A ) # expected sequence length = num_patches UpperCAmelCase : int = (self.image_size // self.patch_size) ** 2 UpperCAmelCase : Optional[Any] = self.patch_size**2 * self.num_channels self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels) ) # test greyscale images UpperCAmelCase : Tuple = 1 UpperCAmelCase : List[Any] = TFViTMAEForPreTraining(__A ) UpperCAmelCase : Union[str, Any] = floats_tensor([self.batch_size, 1, self.image_size, self.image_size] ) UpperCAmelCase : List[Any] = model(__A, training=__A ) UpperCAmelCase : Union[str, Any] = self.patch_size**2 self.parent.assertEqual(result.logits.shape, (self.batch_size, num_patches, expected_num_channels) ) def __magic_name__ ( self : List[Any] ): UpperCAmelCase : Dict = self.prepare_config_and_inputs() ((UpperCAmelCase) , (UpperCAmelCase) , (UpperCAmelCase)) : Union[str, Any] = config_and_inputs UpperCAmelCase : Optional[Any] = {'''pixel_values''': pixel_values} return config, inputs_dict @require_tf class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else () UpperCamelCase = {"""feature-extraction""": TFViTMAEModel} if is_tf_available() else {} UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = TFViTMAEModelTester(self ) UpperCAmelCase : int = ConfigTester(self, config_class=__A, has_text_modality=__A, hidden_size=3_7 ) def __magic_name__ ( self : List[str] ): self.config_tester.run_common_tests() @unittest.skip(reason='''ViTMAE does not use inputs_embeds''' ) def __magic_name__ ( self : List[Any] ): pass def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : List[str] = model_class(__A ) self.assertIsInstance(model.get_input_embeddings(), (tf.keras.layers.Layer) ) UpperCAmelCase : Union[str, Any] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__A, tf.keras.layers.Layer ) ) def __magic_name__ ( self : str ): UpperCAmelCase , UpperCAmelCase : str = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Any = model_class(__A ) UpperCAmelCase : Any = inspect.signature(model.call ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : int = [*signature.parameters.keys()] UpperCAmelCase : Tuple = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : str ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*__A ) def __magic_name__ ( self : int ): # make the mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Tuple = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : List[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : str = model_class(__A ) UpperCAmelCase : int = self._prepare_for_class(__A, __A ) UpperCAmelCase : Dict = model(__A, noise=__A ) UpperCAmelCase : Any = copy.deepcopy(self._prepare_for_class(__A, __A ) ) UpperCAmelCase : Union[str, Any] = model(**__A, noise=__A ) UpperCAmelCase : Dict = outputs_dict[0].numpy() UpperCAmelCase : Tuple = outputs_keywords[0].numpy() self.assertLess(np.sum(np.abs(output_dict - output_keywords ) ), 1E-6 ) def __magic_name__ ( self : Optional[Any] ): # make the mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Any = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : str = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Union[str, Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) def prepare_numpy_arrays(__A : Union[str, Any] ): UpperCAmelCase : str = {} for k, v in inputs_dict.items(): if tf.is_tensor(__A ): UpperCAmelCase : Tuple = v.numpy() else: UpperCAmelCase : str = np.array(__A ) return inputs_np_dict for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) UpperCAmelCase : Any = self._prepare_for_class(__A, __A ) UpperCAmelCase : Optional[int] = prepare_numpy_arrays(__A ) UpperCAmelCase : str = model(__A, noise=__A ) UpperCAmelCase : str = model(**__A, noise=__A ) self.assert_outputs_same(__A, __A ) def __magic_name__ ( self : int, __A : str, __A : Union[str, Any], __A : Optional[Any] ): # make masks reproducible np.random.seed(2 ) UpperCAmelCase : Any = int((tf_model.config.image_size // tf_model.config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) UpperCAmelCase : int = tf.constant(__A ) # Add `noise` argument. # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument UpperCAmelCase : List[Any] = tf_noise super().check_pt_tf_models(__A, __A, __A ) def __magic_name__ ( self : str ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Union[str, Any] = { module_member for model_class in self.all_model_classes for module in (import_module(model_class.__module__ ),) for module_member_name in dir(__A ) if module_member_name.endswith('''MainLayer''' ) # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`. and module_member_name[: -len('''MainLayer''' )] == model_class.__name__[: -len('''Model''' )] for module_member in (getattr(__A, __A ),) if isinstance(__A, __A ) and tf.keras.layers.Layer in module_member.__bases__ and getattr(__A, '''_keras_serializable''', __A ) } UpperCAmelCase : Union[str, Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Optional[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) UpperCAmelCase : str = tf.convert_to_tensor(__A ) inputs_dict.update({'''noise''': noise} ) for main_layer_class in tf_main_layer_classes: UpperCAmelCase : Tuple = main_layer_class(__A ) UpperCAmelCase : int = { name: tf.keras.Input(tensor.shape[1:], dtype=tensor.dtype ) for name, tensor in inputs_dict.items() } UpperCAmelCase : List[Any] = tf.keras.Model(__A, outputs=main_layer(__A ) ) UpperCAmelCase : List[Any] = model(__A ) with tempfile.TemporaryDirectory() as tmpdirname: UpperCAmelCase : Any = os.path.join(__A, '''keras_model.h5''' ) model.save(__A ) UpperCAmelCase : List[str] = tf.keras.models.load_model( __A, custom_objects={main_layer_class.__name__: main_layer_class} ) assert isinstance(__A, tf.keras.Model ) UpperCAmelCase : Tuple = model(__A ) self.assert_outputs_same(__A, __A ) @slow def __magic_name__ ( self : Dict ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Dict = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Optional[Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Optional[Any] = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : int = model_class(__A ) UpperCAmelCase : List[str] = self._prepare_for_class(__A, __A ) UpperCAmelCase : Union[str, Any] = model(__A, noise=__A ) if model_class.__name__ == "TFViTMAEModel": UpperCAmelCase : Optional[int] = outputs.last_hidden_state.numpy() UpperCAmelCase : Union[str, Any] = 0 else: UpperCAmelCase : Optional[int] = outputs.logits.numpy() UpperCAmelCase : int = 0 with tempfile.TemporaryDirectory() as tmpdirname: model.save_pretrained(__A, saved_model=__A ) UpperCAmelCase : Dict = model_class.from_pretrained(__A ) UpperCAmelCase : str = model(__A, noise=__A ) if model_class.__name__ == "TFViTMAEModel": UpperCAmelCase : int = after_outputs['''last_hidden_state'''].numpy() UpperCAmelCase : Dict = 0 else: UpperCAmelCase : Any = after_outputs['''logits'''].numpy() UpperCAmelCase : Dict = 0 UpperCAmelCase : Union[str, Any] = np.amax(np.abs(out_a - out_a ) ) self.assertLessEqual(__A, 1E-5 ) def __magic_name__ ( self : Optional[Any] ): # make mask reproducible np.random.seed(2 ) UpperCAmelCase , UpperCAmelCase : Dict = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : List[Any] = int((config.image_size // config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(self.model_tester.batch_size, num_patches) ) for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) UpperCAmelCase : int = self._prepare_for_class(__A, __A ) UpperCAmelCase : List[Any] = model(__A, noise=__A ) UpperCAmelCase : str = model.get_config() # make sure that returned config is jsonifiable, which is required by keras json.dumps(__A ) UpperCAmelCase : int = model_class.from_config(model.get_config() ) # make sure it also accepts a normal config UpperCAmelCase : str = model_class.from_config(model.config ) UpperCAmelCase : List[str] = new_model(__A ) # Build model new_model.set_weights(model.get_weights() ) UpperCAmelCase : Tuple = new_model(__A, noise=__A ) self.assert_outputs_same(__A, __A ) @unittest.skip( reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load to get deterministic results.''' ) def __magic_name__ ( self : Optional[int] ): pass @unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load''' ) def __magic_name__ ( self : Tuple ): pass @slow def __magic_name__ ( self : str ): UpperCAmelCase : Tuple = TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224''' ) self.assertIsNotNone(__A ) def a__ ( ) -> Dict: UpperCAmelCase : int = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_tf @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : List[str] ): return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base''' ) if is_vision_available() else None @slow def __magic_name__ ( self : str ): # make random mask reproducible across the PT and TF model np.random.seed(2 ) UpperCAmelCase : Tuple = TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base''' ) UpperCAmelCase : List[str] = self.default_image_processor UpperCAmelCase : Any = prepare_img() UpperCAmelCase : str = image_processor(images=__A, return_tensors='''tf''' ) # 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) UpperCAmelCase : Optional[int] = ViTMAEConfig() UpperCAmelCase : int = int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2 ) UpperCAmelCase : Tuple = np.random.uniform(size=(1, num_patches) ) # forward pass UpperCAmelCase : Optional[int] = model(**__A, noise=__A ) # verify the logits UpperCAmelCase : Union[str, Any] = tf.convert_to_tensor([1, 1_9_6, 7_6_8] ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : List[str] = tf.convert_to_tensor( [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]] ) tf.debugging.assert_near(outputs.logits[0, :3, :3], __A, atol=1E-4 )
336
1
# Copyright 2023 The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import TYPE_CHECKING # rely on isort to merge the imports from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available _lowerCamelCase : Optional[Any] = {"configuration_mra": ["MRA_PRETRAINED_CONFIG_ARCHIVE_MAP", "MraConfig"]} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[Any] = [ "MRA_PRETRAINED_MODEL_ARCHIVE_LIST", "MraForMaskedLM", "MraForMultipleChoice", "MraForQuestionAnswering", "MraForSequenceClassification", "MraForTokenClassification", "MraLayer", "MraModel", "MraPreTrainedModel", ] if TYPE_CHECKING: from .configuration_mra import MRA_PRETRAINED_CONFIG_ARCHIVE_MAP, MraConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mra import ( MRA_PRETRAINED_MODEL_ARCHIVE_LIST, MraForMaskedLM, MraForMultipleChoice, MraForQuestionAnswering, MraForSequenceClassification, MraForTokenClassification, MraLayer, MraModel, MraPreTrainedModel, ) else: import sys _lowerCamelCase : int = _LazyModule(__name__, globals()["__file__"], _import_structure)
336
def a__ ( UpperCAmelCase : int ) -> int: UpperCAmelCase : list[list[int]] = [[0 for _ in range(UpperCAmelCase )] for _ in range(m + 1 )] for i in range(m + 1 ): UpperCAmelCase : Optional[Any] = 1 for n in range(m + 1 ): for k in range(1 , UpperCAmelCase ): memo[n][k] += memo[n][k - 1] if n - k > 0: memo[n][k] += memo[n - k - 1][k] return memo[m][m - 1] if __name__ == "__main__": import sys if len(sys.argv) == 1: try: _lowerCamelCase : List[Any] = int(input("Enter a number: ").strip()) print(partition(n)) except ValueError: print("Please enter a number.") else: try: _lowerCamelCase : str = int(sys.argv[1]) print(partition(n)) except ValueError: print("Please pass a number.")
336
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) _lowerCamelCase : Optional[int] = { "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[Any] = ["ElectraTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : int = [ "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 : int = [ "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 : Tuple = [ "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 : Any = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
from __future__ import annotations def a__ ( UpperCAmelCase : list[list[int]] ) -> bool: UpperCAmelCase : Union[str, Any] = len(UpperCAmelCase ) # We need to create solution object to save path. UpperCAmelCase : int = [[0 for _ in range(UpperCAmelCase )] for _ in range(UpperCAmelCase )] UpperCAmelCase : Union[str, Any] = run_maze(UpperCAmelCase , 0 , 0 , UpperCAmelCase ) if solved: print('''\n'''.join(str(UpperCAmelCase ) for row in solutions ) ) else: print('''No solution exists!''' ) return solved def a__ ( UpperCAmelCase : list[list[int]] , UpperCAmelCase : int , UpperCAmelCase : int , UpperCAmelCase : list[list[int]] ) -> bool: UpperCAmelCase : Dict = len(UpperCAmelCase ) # Final check point. if i == j == (size - 1): UpperCAmelCase : Dict = 1 return True UpperCAmelCase : Union[str, Any] = (not i < 0) and (not j < 0) # Check lower bounds UpperCAmelCase : List[Any] = (i < size) and (j < size) # Check upper bounds if lower_flag and upper_flag: # check for already visited and block points. UpperCAmelCase : Any = (not solutions[i][j]) and (not maze[i][j]) if block_flag: # check visited UpperCAmelCase : str = 1 # check for directions if ( run_maze(UpperCAmelCase , i + 1 , UpperCAmelCase , UpperCAmelCase ) or run_maze(UpperCAmelCase , UpperCAmelCase , j + 1 , UpperCAmelCase ) or run_maze(UpperCAmelCase , i - 1 , UpperCAmelCase , UpperCAmelCase ) or run_maze(UpperCAmelCase , UpperCAmelCase , j - 1 , UpperCAmelCase ) ): return True UpperCAmelCase : Any = 0 return False return False if __name__ == "__main__": import doctest doctest.testmod()
336
1
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) _lowerCamelCase : Tuple = { "configuration_gpt_bigcode": ["GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTBigCodeConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : int = [ "GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST", "GPTBigCodeForSequenceClassification", "GPTBigCodeForTokenClassification", "GPTBigCodeForCausalLM", "GPTBigCodeModel", "GPTBigCodePreTrainedModel", ] if TYPE_CHECKING: from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_bigcode import ( GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST, GPTBigCodeForCausalLM, GPTBigCodeForSequenceClassification, GPTBigCodeForTokenClassification, GPTBigCodeModel, GPTBigCodePreTrainedModel, ) else: import sys _lowerCamelCase : Optional[int] = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
import inspect import unittest from transformers import ViTHybridConfig from transformers.testing_utils import require_accelerate, 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, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image class __UpperCAmelCase : def __init__( self : List[Any], __A : List[str], __A : List[str]=1_3, __A : Any=6_4, __A : Optional[Any]=2, __A : str=3, __A : str=True, __A : str=True, __A : Optional[Any]=3_2, __A : List[str]=5, __A : int=4, __A : str=3_7, __A : str="gelu", __A : Dict=0.1, __A : List[Any]=0.1, __A : Dict=1_0, __A : int=0.0_2, __A : Any=[1, 1_6, 4, 4], __A : Optional[int]=None, ): UpperCAmelCase : Union[str, Any] = parent UpperCAmelCase : Any = batch_size UpperCAmelCase : List[str] = image_size UpperCAmelCase : List[str] = patch_size UpperCAmelCase : Dict = num_channels UpperCAmelCase : List[Any] = is_training UpperCAmelCase : Dict = use_labels UpperCAmelCase : Optional[int] = hidden_size UpperCAmelCase : Union[str, Any] = num_hidden_layers UpperCAmelCase : Optional[Any] = num_attention_heads UpperCAmelCase : Any = intermediate_size UpperCAmelCase : Any = hidden_act UpperCAmelCase : Any = hidden_dropout_prob UpperCAmelCase : Optional[int] = attention_probs_dropout_prob UpperCAmelCase : str = type_sequence_label_size UpperCAmelCase : Any = initializer_range UpperCAmelCase : int = scope UpperCAmelCase : List[str] = backbone_featmap_shape # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token) # the number of patches is based on the feature map of the backbone, which by default uses an output stride # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size UpperCAmelCase : str = (self.image_size // 3_2) ** 2 UpperCAmelCase : List[str] = num_patches + 1 def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCAmelCase : str = None if self.use_labels: UpperCAmelCase : Any = ids_tensor([self.batch_size], self.type_sequence_label_size ) UpperCAmelCase : Optional[int] = self.get_config() return config, pixel_values, labels def __magic_name__ ( self : Any ): UpperCAmelCase : Dict = { '''global_padding''': '''same''', '''layer_type''': '''bottleneck''', '''depths''': [3, 4, 9], '''out_features''': ['''stage1''', '''stage2''', '''stage3'''], '''embedding_dynamic_padding''': True, '''hidden_sizes''': [4, 8, 1_6, 3_2], '''num_groups''': 2, } return ViTHybridConfig( 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, backbone_featmap_shape=self.backbone_featmap_shape, backbone_config=__A, ) def __magic_name__ ( self : Optional[int], __A : Optional[int], __A : int, __A : Tuple ): UpperCAmelCase : int = ViTHybridModel(config=__A ) model.to(__A ) model.eval() UpperCAmelCase : Tuple = model(__A ) self.parent.assertEqual(result.last_hidden_state.shape, (self.batch_size, self.seq_length, self.hidden_size) ) def __magic_name__ ( self : Tuple, __A : Dict, __A : str, __A : List[str] ): UpperCAmelCase : str = self.type_sequence_label_size UpperCAmelCase : List[Any] = ViTHybridForImageClassification(__A ) model.to(__A ) model.eval() UpperCAmelCase : Dict = model(__A, labels=__A ) self.parent.assertEqual(result.logits.shape, (self.batch_size, self.type_sequence_label_size) ) def __magic_name__ ( self : int ): UpperCAmelCase : Union[str, Any] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[str] = config_and_inputs UpperCAmelCase : int = {'''pixel_values''': pixel_values} return config, inputs_dict @require_torch class __UpperCAmelCase ( lowerCamelCase__ , lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else () UpperCamelCase = ( {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification} if is_torch_available() else {} ) UpperCamelCase = False UpperCamelCase = False UpperCamelCase = False def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Any = ViTHybridModelTester(self ) UpperCAmelCase : List[Any] = ConfigTester(self, config_class=__A, has_text_modality=__A, hidden_size=3_7 ) def __magic_name__ ( self : int ): self.config_tester.run_common_tests() @unittest.skip(reason='''ViT does not use inputs_embeds''' ) def __magic_name__ ( self : List[Any] ): pass def __magic_name__ ( self : int ): UpperCAmelCase , UpperCAmelCase : List[str] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : Dict = model_class(__A ) self.assertIsInstance(model.get_input_embeddings(), (nn.Module) ) UpperCAmelCase : Optional[int] = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__A, nn.Linear ) ) def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCAmelCase : List[Any] = model_class(__A ) UpperCAmelCase : Tuple = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCAmelCase : str = [*signature.parameters.keys()] UpperCAmelCase : Optional[Any] = ['''pixel_values'''] self.assertListEqual(arg_names[:1], __A ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : List[Any] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__A ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Tuple = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*__A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase , UpperCAmelCase : Optional[Any] = self.model_tester.prepare_config_and_inputs_for_common() UpperCAmelCase : Dict = _config_zero_init(__A ) for model_class in self.all_model_classes: UpperCAmelCase : Optional[Any] = model_class(config=__A ) # Skip the check for the backbone for name, module in model.named_modules(): if module.__class__.__name__ == "ViTHybridPatchEmbeddings": UpperCAmelCase : Union[str, Any] = [F'''{name}.{key}''' for key in module.state_dict().keys()] break for name, param in model.named_parameters(): if param.requires_grad: if name in backbone_params: continue 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''', ) @slow def __magic_name__ ( self : List[str] ): for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCAmelCase : Union[str, Any] = ViTHybridModel.from_pretrained(__A ) self.assertIsNotNone(__A ) def a__ ( ) -> Tuple: UpperCAmelCase : Any = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) return image @require_torch @require_vision class __UpperCAmelCase ( unittest.TestCase ): @cached_property def __magic_name__ ( self : str ): return ( ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def __magic_name__ ( self : List[str] ): UpperCAmelCase : int = ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to( __A ) UpperCAmelCase : Tuple = self.default_image_processor UpperCAmelCase : int = prepare_img() UpperCAmelCase : Union[str, Any] = image_processor(images=__A, return_tensors='''pt''' ).to(__A ) # forward pass with torch.no_grad(): UpperCAmelCase : Optional[Any] = model(**__A ) # verify the logits UpperCAmelCase : str = torch.Size((1, 1_0_0_0) ) self.assertEqual(outputs.logits.shape, __A ) UpperCAmelCase : Optional[Any] = torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9] ).to(__A ) self.assertTrue(torch.allclose(outputs.logits[0, :3], __A, atol=1E-4 ) ) @slow @require_accelerate def __magic_name__ ( self : Dict ): UpperCAmelCase : Union[str, Any] = ViTHybridImageProcessor.from_pretrained('''google/vit-hybrid-base-bit-384''' ) UpperCAmelCase : int = ViTHybridForImageClassification.from_pretrained('''google/vit-hybrid-base-bit-384''', device_map='''auto''' ) UpperCAmelCase : Tuple = prepare_img() UpperCAmelCase : Optional[int] = image_processor(images=__A, return_tensors='''pt''' ) UpperCAmelCase : Dict = model(**__A ) UpperCAmelCase : Any = outputs.logits # model predicts one of the 1000 ImageNet classes UpperCAmelCase : Dict = logits.argmax(-1 ).item() self.assertTrue(model.config.idalabel[predicted_class_idx], '''tabby, tabby cat''' )
336
1
from ...configuration_utils import PretrainedConfig from ...utils import logging _lowerCamelCase : Dict = logging.get_logger(__name__) _lowerCamelCase : str = { "MIT/ast-finetuned-audioset-10-10-0.4593": ( "https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json" ), } class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = """audio-spectrogram-transformer""" def __init__( self : Dict, __A : Optional[int]=7_6_8, __A : Optional[int]=1_2, __A : Optional[int]=1_2, __A : Tuple=3_0_7_2, __A : str="gelu", __A : Optional[Any]=0.0, __A : int=0.0, __A : List[str]=0.0_2, __A : Optional[Any]=1E-12, __A : Tuple=1_6, __A : str=True, __A : List[str]=1_0, __A : str=1_0, __A : List[Any]=1_0_2_4, __A : List[Any]=1_2_8, **__A : Dict, ): super().__init__(**__A ) UpperCAmelCase : str = hidden_size UpperCAmelCase : Any = num_hidden_layers UpperCAmelCase : str = num_attention_heads UpperCAmelCase : Dict = intermediate_size UpperCAmelCase : List[str] = hidden_act UpperCAmelCase : str = hidden_dropout_prob UpperCAmelCase : Union[str, Any] = attention_probs_dropout_prob UpperCAmelCase : Tuple = initializer_range UpperCAmelCase : Union[str, Any] = layer_norm_eps UpperCAmelCase : List[str] = patch_size UpperCAmelCase : List[str] = qkv_bias UpperCAmelCase : int = frequency_stride UpperCAmelCase : Optional[int] = time_stride UpperCAmelCase : Any = max_length UpperCAmelCase : Optional[Any] = num_mel_bins
336
from __future__ import annotations from itertools import permutations from random import randint from timeit import repeat def a__ ( ) -> tuple[list[int], int]: UpperCAmelCase : str = [randint(-1_000 , 1_000 ) for i in range(10 )] UpperCAmelCase : Any = randint(-5_000 , 5_000 ) return (arr, r) _lowerCamelCase : Any = make_dataset() def a__ ( UpperCAmelCase : list[int] , UpperCAmelCase : int ) -> tuple[int, ...]: for triplet in permutations(UpperCAmelCase , 3 ): if sum(UpperCAmelCase ) == target: return tuple(sorted(UpperCAmelCase ) ) return (0, 0, 0) def a__ ( UpperCAmelCase : list[int] , UpperCAmelCase : int ) -> tuple[int, int, int]: arr.sort() UpperCAmelCase : Tuple = len(UpperCAmelCase ) for i in range(n - 1 ): UpperCAmelCase , UpperCAmelCase : int = i + 1, n - 1 while left < right: if arr[i] + arr[left] + arr[right] == target: return (arr[i], arr[left], arr[right]) elif arr[i] + arr[left] + arr[right] < target: left += 1 elif arr[i] + arr[left] + arr[right] > target: right -= 1 return (0, 0, 0) def a__ ( ) -> tuple[float, float]: UpperCAmelCase : Union[str, Any] = ''' from __main__ import dataset, triplet_sum1, triplet_sum2 ''' UpperCAmelCase : Tuple = ''' triplet_sum1(*dataset) ''' UpperCAmelCase : List[str] = ''' triplet_sum2(*dataset) ''' UpperCAmelCase : Tuple = repeat(setup=UpperCAmelCase , stmt=UpperCAmelCase , repeat=5 , number=10_000 ) UpperCAmelCase : str = repeat(setup=UpperCAmelCase , stmt=UpperCAmelCase , repeat=5 , number=10_000 ) return (min(UpperCAmelCase ), min(UpperCAmelCase )) if __name__ == "__main__": from doctest import testmod testmod() _lowerCamelCase : int = solution_times() print(f"""The time for naive implementation is {times[0]}.""") print(f"""The time for optimized implementation is {times[1]}.""")
336
1
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available _lowerCamelCase : Dict = { "configuration_gpt_neo": ["GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTNeoConfig", "GPTNeoOnnxConfig"], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Optional[int] = [ "GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST", "GPTNeoForCausalLM", "GPTNeoForQuestionAnswering", "GPTNeoForSequenceClassification", "GPTNeoForTokenClassification", "GPTNeoModel", "GPTNeoPreTrainedModel", "load_tf_weights_in_gpt_neo", ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _lowerCamelCase : Dict = [ "FlaxGPTNeoForCausalLM", "FlaxGPTNeoModel", "FlaxGPTNeoPreTrainedModel", ] if TYPE_CHECKING: from .configuration_gpt_neo import GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoConfig, GPTNeoOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_neo import ( GPT_NEO_PRETRAINED_MODEL_ARCHIVE_LIST, GPTNeoForCausalLM, GPTNeoForQuestionAnswering, GPTNeoForSequenceClassification, GPTNeoForTokenClassification, GPTNeoModel, GPTNeoPreTrainedModel, load_tf_weights_in_gpt_neo, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_gpt_neo import FlaxGPTNeoForCausalLM, FlaxGPTNeoModel, FlaxGPTNeoPreTrainedModel else: import sys _lowerCamelCase : Any = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
336
from queue import Queue from typing import TYPE_CHECKING, Optional if TYPE_CHECKING: from ..models.auto import AutoTokenizer class __UpperCAmelCase : def __magic_name__ ( self : int, __A : Dict ): raise NotImplementedError() def __magic_name__ ( self : int ): raise NotImplementedError() class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : str, __A : "AutoTokenizer", __A : bool = False, **__A : str ): UpperCAmelCase : List[str] = tokenizer UpperCAmelCase : str = skip_prompt UpperCAmelCase : List[str] = decode_kwargs # variables used in the streaming process UpperCAmelCase : Dict = [] UpperCAmelCase : List[str] = 0 UpperCAmelCase : Union[str, Any] = True def __magic_name__ ( self : Dict, __A : Optional[int] ): if len(value.shape ) > 1 and value.shape[0] > 1: raise ValueError('''TextStreamer only supports batch size 1''' ) elif len(value.shape ) > 1: UpperCAmelCase : Union[str, Any] = value[0] if self.skip_prompt and self.next_tokens_are_prompt: UpperCAmelCase : Optional[int] = False return # Add the new token to the cache and decodes the entire thing. self.token_cache.extend(value.tolist() ) UpperCAmelCase : Any = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) # After the symbol for a new line, we flush the cache. if text.endswith('''\n''' ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] UpperCAmelCase : int = [] UpperCAmelCase : int = 0 # If the last token is a CJK character, we print the characters. elif len(__A ) > 0 and self._is_chinese_char(ord(text[-1] ) ): UpperCAmelCase : Union[str, Any] = text[self.print_len :] self.print_len += len(__A ) # 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: UpperCAmelCase : Optional[Any] = text[self.print_len : text.rfind(''' ''' ) + 1] self.print_len += len(__A ) self.on_finalized_text(__A ) def __magic_name__ ( self : str ): # Flush the cache, if it exists if len(self.token_cache ) > 0: UpperCAmelCase : int = self.tokenizer.decode(self.token_cache, **self.decode_kwargs ) UpperCAmelCase : Dict = text[self.print_len :] UpperCAmelCase : List[Any] = [] UpperCAmelCase : List[Any] = 0 else: UpperCAmelCase : Dict = '''''' UpperCAmelCase : str = True self.on_finalized_text(__A, stream_end=__A ) def __magic_name__ ( self : List[str], __A : str, __A : bool = False ): print(__A, flush=__A, end='''''' if not stream_end else None ) def __magic_name__ ( self : List[Any], __A : Optional[int] ): # 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 >= 0X4E00 and cp <= 0X9FFF) or (cp >= 0X3400 and cp <= 0X4DBF) # or (cp >= 0X20000 and cp <= 0X2A6DF) # or (cp >= 0X2A700 and cp <= 0X2B73F) # or (cp >= 0X2B740 and cp <= 0X2B81F) # or (cp >= 0X2B820 and cp <= 0X2CEAF) # or (cp >= 0XF900 and cp <= 0XFAFF) or (cp >= 0X2F800 and cp <= 0X2FA1F) # ): # return True return False class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Dict, __A : "AutoTokenizer", __A : bool = False, __A : Optional[float] = None, **__A : str ): super().__init__(__A, __A, **__A ) UpperCAmelCase : Dict = Queue() UpperCAmelCase : Any = None UpperCAmelCase : Any = timeout def __magic_name__ ( self : Dict, __A : str, __A : bool = False ): self.text_queue.put(__A, timeout=self.timeout ) if stream_end: self.text_queue.put(self.stop_signal, timeout=self.timeout ) def __iter__( self : int ): return self def __magic_name__ ( self : Optional[int] ): UpperCAmelCase : List[Any] = self.text_queue.get(timeout=self.timeout ) if value == self.stop_signal: raise StopIteration() else: return value
336
1
import numpy as np import torch from torch.utils.data import Dataset from utils import logger class __UpperCAmelCase ( lowerCamelCase__ ): def __init__( self : Dict, __A : Union[str, Any], __A : List[str] ): UpperCAmelCase : int = params UpperCAmelCase : Dict = np.array(__A ) UpperCAmelCase : Optional[Any] = np.array([len(__A ) for t in data] ) self.check() self.remove_long_sequences() self.remove_empty_sequences() self.remove_unknown_sequences() self.check() self.print_statistics() def __getitem__( self : int, __A : Dict ): return (self.token_ids[index], self.lengths[index]) def __len__( self : Union[str, Any] ): return len(self.lengths ) def __magic_name__ ( self : int ): assert len(self.token_ids ) == len(self.lengths ) assert all(self.lengths[i] == len(self.token_ids[i] ) for i in range(len(self.lengths ) ) ) def __magic_name__ ( self : Dict ): UpperCAmelCase : List[Any] = self.params.max_model_input_size UpperCAmelCase : Dict = self.lengths > max_len logger.info(F'''Splitting {sum(__A )} too long sequences.''' ) def divide_chunks(__A : Union[str, Any], __A : int ): return [l[i : i + n] for i in range(0, len(__A ), __A )] UpperCAmelCase : Optional[int] = [] UpperCAmelCase : Optional[int] = [] if self.params.mlm: UpperCAmelCase , UpperCAmelCase : Optional[Any] = self.params.special_tok_ids['''cls_token'''], self.params.special_tok_ids['''sep_token'''] else: UpperCAmelCase , UpperCAmelCase : Optional[int] = self.params.special_tok_ids['''bos_token'''], self.params.special_tok_ids['''eos_token'''] for seq_, len_ in zip(self.token_ids, self.lengths ): assert (seq_[0] == cls_id) and (seq_[-1] == sep_id), seq_ if len_ <= max_len: new_tok_ids.append(seq_ ) new_lengths.append(len_ ) else: UpperCAmelCase : Dict = [] for sub_s in divide_chunks(seq_, max_len - 2 ): if sub_s[0] != cls_id: UpperCAmelCase : int = np.insert(__A, 0, __A ) if sub_s[-1] != sep_id: UpperCAmelCase : Union[str, Any] = np.insert(__A, len(__A ), __A ) assert len(__A ) <= max_len assert (sub_s[0] == cls_id) and (sub_s[-1] == sep_id), sub_s sub_seqs.append(__A ) new_tok_ids.extend(__A ) new_lengths.extend([len(__A ) for l in sub_seqs] ) UpperCAmelCase : str = np.array(__A ) UpperCAmelCase : Optional[int] = np.array(__A ) def __magic_name__ ( self : List[str] ): UpperCAmelCase : Dict = len(self ) UpperCAmelCase : Optional[int] = self.lengths > 1_1 UpperCAmelCase : int = self.token_ids[indices] UpperCAmelCase : Optional[Any] = self.lengths[indices] UpperCAmelCase : str = len(self ) logger.info(F'''Remove {init_size - new_size} too short (<=11 tokens) sequences.''' ) def __magic_name__ ( self : Optional[Any] ): if "unk_token" not in self.params.special_tok_ids: return else: UpperCAmelCase : Dict = self.params.special_tok_ids['''unk_token'''] UpperCAmelCase : Union[str, Any] = len(self ) UpperCAmelCase : List[Any] = np.array([np.count_nonzero(a == unk_token_id ) for a in self.token_ids] ) UpperCAmelCase : Tuple = (unk_occs / self.lengths) < 0.5 UpperCAmelCase : Union[str, Any] = self.token_ids[indices] UpperCAmelCase : str = self.lengths[indices] UpperCAmelCase : Union[str, Any] = len(self ) logger.info(F'''Remove {init_size - new_size} sequences with a high level of unknown tokens (50%).''' ) def __magic_name__ ( self : int ): if not self.params.is_master: return logger.info(F'''{len(self )} sequences''' ) # data_len = sum(self.lengths) # nb_unique_tokens = len(Counter(list(chain(*self.token_ids)))) # logger.info(f'{data_len} tokens ({nb_unique_tokens} unique)') # unk_idx = self.params.special_tok_ids['unk_token'] # nb_unknown = sum([(t==unk_idx).sum() for t in self.token_ids]) # logger.info(f'{nb_unknown} unknown tokens (covering {100*nb_unknown/data_len:.2f}% of the data)') def __magic_name__ ( self : str, __A : Union[str, Any] ): UpperCAmelCase : Dict = [t[0] for t in batch] UpperCAmelCase : Any = [t[1] for t in batch] assert len(__A ) == len(__A ) # Max for paddings UpperCAmelCase : List[str] = max(__A ) # Pad token ids if self.params.mlm: UpperCAmelCase : Tuple = self.params.special_tok_ids['''pad_token'''] else: UpperCAmelCase : Optional[int] = self.params.special_tok_ids['''unk_token'''] UpperCAmelCase : Any = [list(t.astype(__A ) ) + [pad_idx] * (max_seq_len_ - len(__A )) for t in token_ids] assert len(tk_ ) == len(__A ) assert all(len(__A ) == max_seq_len_ for t in tk_ ) UpperCAmelCase : Optional[Any] = torch.tensor(tk_ ) # (bs, max_seq_len_) UpperCAmelCase : int = torch.tensor(__A ) # (bs) return tk_t, lg_t
336
import numpy # List of input, output pairs _lowerCamelCase : Dict = ( ((5, 2, 3), 1_5), ((6, 5, 9), 2_5), ((1_1, 1_2, 1_3), 4_1), ((1, 1, 1), 8), ((1_1, 1_2, 1_3), 4_1), ) _lowerCamelCase : str = (((5_1_5, 2_2, 1_3), 5_5_5), ((6_1, 3_5, 4_9), 1_5_0)) _lowerCamelCase : Dict = [2, 4, 1, 5] _lowerCamelCase : Dict = len(train_data) _lowerCamelCase : int = 0.0_0_9 def a__ ( UpperCAmelCase : Dict , UpperCAmelCase : Optional[int]="train" ) -> Dict: return calculate_hypothesis_value(UpperCAmelCase , UpperCAmelCase ) - output( UpperCAmelCase , UpperCAmelCase ) def a__ ( UpperCAmelCase : int ) -> Any: UpperCAmelCase : str = 0 for i in range(len(UpperCAmelCase ) - 1 ): hyp_val += data_input_tuple[i] * parameter_vector[i + 1] hyp_val += parameter_vector[0] return hyp_val def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : Optional[Any] ) -> Optional[int]: if data_set == "train": return train_data[example_no][1] elif data_set == "test": return test_data[example_no][1] return None def a__ ( UpperCAmelCase : int , UpperCAmelCase : Optional[Any] ) -> 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 a__ ( UpperCAmelCase : Dict , UpperCAmelCase : str=m ) -> Dict: UpperCAmelCase : Optional[int] = 0 for i in range(UpperCAmelCase ): if index == -1: summation_value += _error(UpperCAmelCase ) else: summation_value += _error(UpperCAmelCase ) * train_data[i][0][index] return summation_value def a__ ( UpperCAmelCase : Dict ) -> Dict: UpperCAmelCase : Dict = summation_of_cost_derivative(UpperCAmelCase , UpperCAmelCase ) / m return cost_derivative_value def a__ ( ) -> List[Any]: global parameter_vector # Tune these values to set a tolerance value for predicted output UpperCAmelCase : List[str] = 0.000002 UpperCAmelCase : Any = 0 UpperCAmelCase : Dict = 0 while True: j += 1 UpperCAmelCase : List[Any] = [0, 0, 0, 0] for i in range(0 , len(UpperCAmelCase ) ): UpperCAmelCase : List[str] = get_cost_derivative(i - 1 ) UpperCAmelCase : Tuple = ( parameter_vector[i] - LEARNING_RATE * cost_derivative ) if numpy.allclose( UpperCAmelCase , UpperCAmelCase , atol=UpperCAmelCase , rtol=UpperCAmelCase , ): break UpperCAmelCase : int = temp_parameter_vector print(('''Number of iterations:''', j) ) def a__ ( ) -> List[Any]: for i in range(len(UpperCAmelCase ) ): print(('''Actual output value:''', output(UpperCAmelCase , '''test''' )) ) print(('''Hypothesis output:''', calculate_hypothesis_value(UpperCAmelCase , '''test''' )) ) if __name__ == "__main__": run_gradient_descent() print("\nTesting gradient descent for a linear hypothesis function.\n") test_gradient_descent()
336
1
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 rescale, resize, to_channel_dimension_format from ...image_utils import ( ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_vision_available(): import PIL _lowerCamelCase : Optional[Any] = logging.get_logger(__name__) def a__ ( UpperCAmelCase : str , UpperCAmelCase : Tuple ) -> Dict: UpperCAmelCase : Union[str, Any] = b.T UpperCAmelCase : int = np.sum(np.square(UpperCAmelCase ) , axis=1 ) UpperCAmelCase : str = np.sum(np.square(UpperCAmelCase ) , axis=0 ) UpperCAmelCase : List[str] = np.matmul(UpperCAmelCase , UpperCAmelCase ) UpperCAmelCase : Tuple = aa[:, None] - 2 * ab + ba[None, :] return d def a__ ( UpperCAmelCase : int , UpperCAmelCase : Any ) -> List[Any]: UpperCAmelCase : str = x.reshape(-1 , 3 ) UpperCAmelCase : Any = squared_euclidean_distance(UpperCAmelCase , UpperCAmelCase ) return np.argmin(UpperCAmelCase , axis=1 ) class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = ["""pixel_values"""] def __init__( self : List[str], __A : Optional[Union[List[List[int]], np.ndarray]] = None, __A : bool = True, __A : Dict[str, int] = None, __A : PILImageResampling = PILImageResampling.BILINEAR, __A : bool = True, __A : bool = True, **__A : Dict, ): super().__init__(**__A ) UpperCAmelCase : Any = size if size is not None else {'''height''': 2_5_6, '''width''': 2_5_6} UpperCAmelCase : Optional[int] = get_size_dict(__A ) UpperCAmelCase : int = np.array(__A ) if clusters is not None else None UpperCAmelCase : str = do_resize UpperCAmelCase : Optional[int] = size UpperCAmelCase : Optional[Any] = resample UpperCAmelCase : Dict = do_normalize UpperCAmelCase : str = do_color_quantize def __magic_name__ ( self : str, __A : np.ndarray, __A : Dict[str, int], __A : PILImageResampling = PILImageResampling.BILINEAR, __A : Optional[Union[str, ChannelDimension]] = None, **__A : Optional[Any], ): UpperCAmelCase : Any = get_size_dict(__A ) if "height" not in size or "width" not in size: raise ValueError(F'''Size dictionary must contain both height and width keys. Got {size.keys()}''' ) return resize( __A, size=(size['''height'''], size['''width''']), resample=__A, data_format=__A, **__A ) def __magic_name__ ( self : Dict, __A : np.ndarray, __A : Optional[Union[str, ChannelDimension]] = None, ): UpperCAmelCase : Tuple = rescale(image=__A, scale=1 / 1_2_7.5, data_format=__A ) UpperCAmelCase : Optional[int] = image - 1 return image def __magic_name__ ( self : List[Any], __A : ImageInput, __A : bool = None, __A : Dict[str, int] = None, __A : PILImageResampling = None, __A : bool = None, __A : Optional[bool] = None, __A : Optional[Union[List[List[int]], np.ndarray]] = None, __A : Optional[Union[str, TensorType]] = None, __A : Optional[Union[str, ChannelDimension]] = ChannelDimension.FIRST, **__A : Dict, ): UpperCAmelCase : Dict = do_resize if do_resize is not None else self.do_resize UpperCAmelCase : Any = size if size is not None else self.size UpperCAmelCase : List[str] = get_size_dict(__A ) UpperCAmelCase : Tuple = resample if resample is not None else self.resample UpperCAmelCase : Union[str, Any] = do_normalize if do_normalize is not None else self.do_normalize UpperCAmelCase : Tuple = do_color_quantize if do_color_quantize is not None else self.do_color_quantize UpperCAmelCase : Optional[int] = clusters if clusters is not None else self.clusters UpperCAmelCase : Any = np.array(__A ) UpperCAmelCase : Optional[Any] = 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 or resample is None: raise ValueError('''Size and resample must be specified if do_resize is True.''' ) if do_color_quantize and clusters is None: raise ValueError('''Clusters must be specified if do_color_quantize is True.''' ) # All transformations expect numpy arrays. UpperCAmelCase : int = [to_numpy_array(__A ) for image in images] if do_resize: UpperCAmelCase : Tuple = [self.resize(image=__A, size=__A, resample=__A ) for image in images] if do_normalize: UpperCAmelCase : int = [self.normalize(image=__A ) for image in images] if do_color_quantize: UpperCAmelCase : str = [to_channel_dimension_format(__A, ChannelDimension.LAST ) for image in images] # color quantize from (batch_size, height, width, 3) to (batch_size, height, width) UpperCAmelCase : List[str] = np.array(__A ) UpperCAmelCase : Optional[Any] = color_quantize(__A, __A ).reshape(images.shape[:-1] ) # flatten to (batch_size, height*width) UpperCAmelCase : List[Any] = images.shape[0] UpperCAmelCase : Tuple = images.reshape(__A, -1 ) # We need to convert back to a list of images to keep consistent behaviour across processors. UpperCAmelCase : Dict = list(__A ) else: UpperCAmelCase : Optional[int] = [to_channel_dimension_format(__A, __A ) for image in images] UpperCAmelCase : Tuple = {'''input_ids''': images} return BatchFeature(data=__A, tensor_type=__A )
336
def a__ ( UpperCAmelCase : List[Any] , UpperCAmelCase : Optional[int] ) -> Optional[Any]: UpperCAmelCase : List[str] = 0 UpperCAmelCase : List[Any] = len(UpperCAmelCase ) - 1 while left <= right: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : Optional[int] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None UpperCAmelCase : Optional[Any] = sorted_collection[point] if current_item == item: return point else: if point < left: UpperCAmelCase : Any = left UpperCAmelCase : List[str] = point elif point > right: UpperCAmelCase : Any = right UpperCAmelCase : List[str] = point else: if item < current_item: UpperCAmelCase : Optional[int] = point - 1 else: UpperCAmelCase : str = point + 1 return None def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : int , UpperCAmelCase : str , UpperCAmelCase : Union[str, Any] ) -> Dict: # avoid divided by 0 during interpolation if sorted_collection[left] == sorted_collection[right]: if sorted_collection[left] == item: return left else: return None UpperCAmelCase : List[str] = left + ((item - sorted_collection[left]) * (right - left)) // ( sorted_collection[right] - sorted_collection[left] ) # out of range check if point < 0 or point >= len(UpperCAmelCase ): return None if sorted_collection[point] == item: return point elif point < left: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) elif point > right: return interpolation_search_by_recursion(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) else: if sorted_collection[point] > item: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , point - 1 ) else: return interpolation_search_by_recursion( UpperCAmelCase , UpperCAmelCase , point + 1 , UpperCAmelCase ) def a__ ( UpperCAmelCase : Union[str, Any] ) -> int: if collection != sorted(UpperCAmelCase ): raise ValueError('''Collection must be ascending sorted''' ) return True if __name__ == "__main__": import sys _lowerCamelCase : Optional[int] = 0 if debug == 1: _lowerCamelCase : Dict = [1_0, 3_0, 4_0, 4_5, 5_0, 6_6, 7_7, 9_3] try: __assert_sorted(collection) except ValueError: sys.exit("Sequence must be ascending sorted to apply interpolation search") _lowerCamelCase : List[Any] = 6_7 _lowerCamelCase : Optional[Any] = interpolation_search(collection, target) if result is not None: print(f"""{target} found at positions: {result}""") else: print("Not found")
336
1
import os 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 logging _lowerCamelCase : str = logging.get_logger(__name__) _lowerCamelCase : int = {"vocab_file": "sentencepiece.bpe.model"} _lowerCamelCase : List[Any] = { "vocab_file": { "camembert-base": "https://huggingface.co/camembert-base/resolve/main/sentencepiece.bpe.model", } } _lowerCamelCase : Optional[Any] = { "camembert-base": 5_1_2, } _lowerCamelCase : Any = "▁" class __UpperCAmelCase ( lowerCamelCase__ ): UpperCamelCase = VOCAB_FILES_NAMES UpperCamelCase = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase = ["""input_ids""", """attention_mask"""] def __init__( self : int, __A : List[Any], __A : str="<s>", __A : str="</s>", __A : List[Any]="</s>", __A : Any="<s>", __A : Optional[int]="<unk>", __A : str="<pad>", __A : str="<mask>", __A : Union[str, Any]=["<s>NOTUSED", "</s>NOTUSED"], __A : Optional[Dict[str, Any]] = None, **__A : Union[str, Any], ): # Mask token behave like a normal word, i.e. include the space before it UpperCAmelCase : Optional[int] = AddedToken(__A, lstrip=__A, rstrip=__A ) if isinstance(__A, __A ) else mask_token UpperCAmelCase : Any = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( bos_token=__A, eos_token=__A, unk_token=__A, sep_token=__A, cls_token=__A, pad_token=__A, mask_token=__A, additional_special_tokens=__A, sp_model_kwargs=self.sp_model_kwargs, **__A, ) UpperCAmelCase : Optional[int] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(__A ) ) UpperCAmelCase : str = vocab_file # HACK: These tokens were added by fairseq but don't seem to be actually used when duplicated in the actual # sentencepiece vocabulary (this is the case for <s> and </s> UpperCAmelCase : Optional[int] = {'''<s>NOTUSED''': 0, '''<pad>''': 1, '''</s>NOTUSED''': 2, '''<unk>''': 3} UpperCAmelCase : Any = len(self.fairseq_tokens_to_ids ) UpperCAmelCase : str = len(self.sp_model ) + len(self.fairseq_tokens_to_ids ) UpperCAmelCase : Tuple = {v: k for k, v in self.fairseq_tokens_to_ids.items()} def __magic_name__ ( self : List[Any], __A : List[int], __A : Optional[List[int]] = None ): if token_ids_a is None: return [self.cls_token_id] + token_ids_a + [self.sep_token_id] UpperCAmelCase : str = [self.cls_token_id] UpperCAmelCase : Optional[Any] = [self.sep_token_id] return cls + token_ids_a + sep + sep + token_ids_a + sep def __magic_name__ ( self : Dict, __A : List[int], __A : Optional[List[int]] = None, __A : bool = False ): if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=__A, token_ids_a=__A, already_has_special_tokens=__A ) if token_ids_a is None: return [1] + ([0] * len(__A )) + [1] return [1] + ([0] * len(__A )) + [1, 1] + ([0] * len(__A )) + [1] def __magic_name__ ( self : Tuple, __A : List[int], __A : Optional[List[int]] = None ): UpperCAmelCase : Tuple = [self.sep_token_id] UpperCAmelCase : Optional[int] = [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] @property def __magic_name__ ( self : List[str] ): return len(self.fairseq_tokens_to_ids ) + len(self.sp_model ) def __magic_name__ ( self : Union[str, Any] ): UpperCAmelCase : Optional[Any] = {self.convert_ids_to_tokens(__A ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __magic_name__ ( self : Optional[int], __A : str ): return self.sp_model.encode(__A, out_type=__A ) def __magic_name__ ( self : Dict, __A : List[Any] ): if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] elif self.sp_model.PieceToId(__A ) == 0: # Convert sentence piece unk token to fairseq unk token index return self.unk_token_id return self.fairseq_offset + self.sp_model.PieceToId(__A ) def __magic_name__ ( self : Dict, __A : List[str] ): if index in self.fairseq_ids_to_tokens: return self.fairseq_ids_to_tokens[index] return self.sp_model.IdToPiece(index - self.fairseq_offset ) def __magic_name__ ( self : int, __A : List[Any] ): UpperCAmelCase : str = [] UpperCAmelCase : Tuple = '''''' UpperCAmelCase : int = False for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: if not prev_is_special: out_string += " " out_string += self.sp_model.decode(__A ) + token UpperCAmelCase : Optional[Any] = True UpperCAmelCase : Optional[Any] = [] else: current_sub_tokens.append(__A ) UpperCAmelCase : Any = False out_string += self.sp_model.decode(__A ) return out_string.strip() def __getstate__( self : int ): UpperCAmelCase : List[str] = self.__dict__.copy() UpperCAmelCase : Tuple = None return state def __setstate__( self : Tuple, __A : Optional[int] ): UpperCAmelCase : Dict = d # for backward compatibility if not hasattr(self, '''sp_model_kwargs''' ): UpperCAmelCase : int = {} UpperCAmelCase : List[Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def __magic_name__ ( self : Any, __A : str, __A : Optional[str] = None ): if not os.path.isdir(__A ): logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' ) return UpperCAmelCase : List[str] = os.path.join( __A, (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(__A ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file, __A ) elif not os.path.isfile(self.vocab_file ): with open(__A, '''wb''' ) as fi: UpperCAmelCase : Optional[int] = self.sp_model.serialized_model_proto() fi.write(__A ) return (out_vocab_file,)
336
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 BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor from transformers.image_utils import PILImageResampling from transformers.utils import logging logging.set_verbosity_info() _lowerCamelCase : Any = logging.get_logger(__name__) def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Optional[Any]=False , UpperCAmelCase : List[str]=False ) -> Any: UpperCAmelCase : Optional[int] = '''backbone.''' if is_semantic else '''''' UpperCAmelCase : Dict = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f'''{prefix}blocks.{i}.norm1.weight''', f'''beit.encoder.layer.{i}.layernorm_before.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm1.bias''', f'''beit.encoder.layer.{i}.layernorm_before.bias''') ) rename_keys.append( (f'''{prefix}blocks.{i}.attn.proj.weight''', f'''beit.encoder.layer.{i}.attention.output.dense.weight''') ) rename_keys.append( (f'''{prefix}blocks.{i}.attn.proj.bias''', f'''beit.encoder.layer.{i}.attention.output.dense.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm2.weight''', f'''beit.encoder.layer.{i}.layernorm_after.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.norm2.bias''', f'''beit.encoder.layer.{i}.layernorm_after.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc1.weight''', f'''beit.encoder.layer.{i}.intermediate.dense.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc1.bias''', f'''beit.encoder.layer.{i}.intermediate.dense.bias''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc2.weight''', f'''beit.encoder.layer.{i}.output.dense.weight''') ) rename_keys.append((f'''{prefix}blocks.{i}.mlp.fc2.bias''', f'''beit.encoder.layer.{i}.output.dense.bias''') ) # projection layer + position embeddings rename_keys.extend( [ (f'''{prefix}cls_token''', '''beit.embeddings.cls_token'''), (f'''{prefix}patch_embed.proj.weight''', '''beit.embeddings.patch_embeddings.projection.weight'''), (f'''{prefix}patch_embed.proj.bias''', '''beit.embeddings.patch_embeddings.projection.bias'''), (f'''{prefix}pos_embed''', '''beit.embeddings.position_embeddings'''), ] ) if has_lm_head: # mask token + layernorm rename_keys.extend( [ ('''mask_token''', '''beit.embeddings.mask_token'''), ('''norm.weight''', '''layernorm.weight'''), ('''norm.bias''', '''layernorm.bias'''), ] ) else: # layernorm + classification head rename_keys.extend( [ ('''fc_norm.weight''', '''beit.pooler.layernorm.weight'''), ('''fc_norm.bias''', '''beit.pooler.layernorm.bias'''), ('''head.weight''', '''classifier.weight'''), ('''head.bias''', '''classifier.bias'''), ] ) return rename_keys def a__ ( UpperCAmelCase : Union[str, Any] , UpperCAmelCase : str , UpperCAmelCase : str=False , UpperCAmelCase : Dict=False ) -> Any: for i in range(config.num_hidden_layers ): UpperCAmelCase : Tuple = '''backbone.''' if is_semantic else '''''' # queries, keys and values UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.qkv.weight''' ) UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.q_bias''' ) UpperCAmelCase : List[Any] = state_dict.pop(f'''{prefix}blocks.{i}.attn.v_bias''' ) UpperCAmelCase : Union[str, Any] = in_proj_weight[ : config.hidden_size, : ] UpperCAmelCase : str = q_bias UpperCAmelCase : List[str] = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] UpperCAmelCase : List[str] = in_proj_weight[ -config.hidden_size :, : ] UpperCAmelCase : int = v_bias # gamma_1 and gamma_2 # we call them lambda because otherwise they are renamed when using .from_pretrained UpperCAmelCase : int = state_dict.pop(f'''{prefix}blocks.{i}.gamma_1''' ) UpperCAmelCase : Optional[Any] = state_dict.pop(f'''{prefix}blocks.{i}.gamma_2''' ) UpperCAmelCase : str = gamma_a UpperCAmelCase : Dict = gamma_a def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : List[Any] , UpperCAmelCase : Tuple ) -> Optional[Any]: UpperCAmelCase : Union[str, Any] = dct.pop(UpperCAmelCase ) UpperCAmelCase : str = val def a__ ( ) -> Optional[int]: UpperCAmelCase : List[Any] = '''http://images.cocodataset.org/val2017/000000039769.jpg''' UpperCAmelCase : Union[str, Any] = Image.open(requests.get(UpperCAmelCase , stream=UpperCAmelCase ).raw ) return im @torch.no_grad() def a__ ( UpperCAmelCase : Optional[int] , UpperCAmelCase : Tuple , UpperCAmelCase : List[Any]=False ) -> Union[str, Any]: UpperCAmelCase : Dict = False if '''rvlcdip''' in checkpoint_url else True UpperCAmelCase : Any = BeitConfig(use_absolute_position_embeddings=UpperCAmelCase , use_mask_token=UpperCAmelCase ) # size of the architecture if "large" in checkpoint_url or "dit-l" in checkpoint_url: UpperCAmelCase : List[Any] = 1_024 UpperCAmelCase : Optional[Any] = 4_096 UpperCAmelCase : Any = 24 UpperCAmelCase : Union[str, Any] = 16 # labels if "rvlcdip" in checkpoint_url: UpperCAmelCase : Optional[Any] = 16 UpperCAmelCase : List[Any] = '''huggingface/label-files''' UpperCAmelCase : Any = '''rvlcdip-id2label.json''' UpperCAmelCase : List[str] = json.load(open(hf_hub_download(UpperCAmelCase , UpperCAmelCase , repo_type='''dataset''' ) , '''r''' ) ) UpperCAmelCase : Dict = {int(UpperCAmelCase ): v for k, v in idalabel.items()} UpperCAmelCase : Union[str, Any] = idalabel UpperCAmelCase : Tuple = {v: k for k, v in idalabel.items()} # load state_dict of original model, remove and rename some keys UpperCAmelCase : Tuple = torch.hub.load_state_dict_from_url(UpperCAmelCase , map_location='''cpu''' )['''model'''] UpperCAmelCase : List[str] = create_rename_keys(UpperCAmelCase , has_lm_head=UpperCAmelCase ) for src, dest in rename_keys: rename_key(UpperCAmelCase , UpperCAmelCase , UpperCAmelCase ) read_in_q_k_v(UpperCAmelCase , UpperCAmelCase , has_lm_head=UpperCAmelCase ) # load HuggingFace model UpperCAmelCase : Tuple = BeitForMaskedImageModeling(UpperCAmelCase ) if has_lm_head else BeitForImageClassification(UpperCAmelCase ) model.eval() model.load_state_dict(UpperCAmelCase ) # Check outputs on an image UpperCAmelCase : Dict = BeitImageProcessor( size=config.image_size , resample=PILImageResampling.BILINEAR , do_center_crop=UpperCAmelCase ) UpperCAmelCase : List[str] = prepare_img() UpperCAmelCase : Optional[Any] = image_processor(images=UpperCAmelCase , return_tensors='''pt''' ) UpperCAmelCase : str = encoding['''pixel_values'''] UpperCAmelCase : Any = model(UpperCAmelCase ) UpperCAmelCase : Optional[Any] = outputs.logits # verify logits UpperCAmelCase : List[Any] = [1, 16] if '''rvlcdip''' in checkpoint_url else [1, 196, 8_192] assert logits.shape == torch.Size(UpperCAmelCase ), "Shape of logits not as expected" Path(UpperCAmelCase ).mkdir(exist_ok=UpperCAmelCase ) print(f'''Saving model to {pytorch_dump_folder_path}''' ) model.save_pretrained(UpperCAmelCase ) print(f'''Saving image processor to {pytorch_dump_folder_path}''' ) image_processor.save_pretrained(UpperCAmelCase ) if push_to_hub: if has_lm_head: UpperCAmelCase : List[Any] = '''dit-base''' if '''base''' in checkpoint_url else '''dit-large''' else: UpperCAmelCase : Any = '''dit-base-finetuned-rvlcdip''' if '''dit-b''' in checkpoint_url else '''dit-large-finetuned-rvlcdip''' image_processor.push_to_hub( repo_path_or_name=Path(UpperCAmelCase , UpperCAmelCase ) , organization='''nielsr''' , commit_message='''Add image processor''' , use_temp_dir=UpperCAmelCase , ) model.push_to_hub( repo_path_or_name=Path(UpperCAmelCase , UpperCAmelCase ) , organization='''nielsr''' , commit_message='''Add model''' , use_temp_dir=UpperCAmelCase , ) if __name__ == "__main__": _lowerCamelCase : Tuple = argparse.ArgumentParser() parser.add_argument( "--checkpoint_url", default="https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth", type=str, help="URL to the original PyTorch checkpoint (.pth file).", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model." ) parser.add_argument( "--push_to_hub", action="store_true", ) _lowerCamelCase : Optional[int] = parser.parse_args() convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)
336
1
import argparse from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird from transformers.utils import logging logging.set_verbosity_info() def a__ ( UpperCAmelCase : Optional[Any] , UpperCAmelCase : Union[str, Any] , UpperCAmelCase : int , UpperCAmelCase : Union[str, Any] ) -> List[str]: # Initialise PyTorch model UpperCAmelCase : Union[str, Any] = BigBirdConfig.from_json_file(UpperCAmelCase ) print(f'''Building PyTorch model from configuration: {config}''' ) if is_trivia_qa: UpperCAmelCase : str = BigBirdForQuestionAnswering(UpperCAmelCase ) else: UpperCAmelCase : str = BigBirdForPreTraining(UpperCAmelCase ) # Load weights from tf checkpoint load_tf_weights_in_big_bird(UpperCAmelCase , UpperCAmelCase , is_trivia_qa=UpperCAmelCase ) # Save pytorch-model print(f'''Save PyTorch model to {pytorch_dump_path}''' ) model.save_pretrained(UpperCAmelCase ) if __name__ == "__main__": _lowerCamelCase : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path." ) parser.add_argument( "--big_bird_config_file", default=None, type=str, required=True, help=( "The config json file corresponding to the pre-trained BERT model. \n" "This specifies the model architecture." ), ) parser.add_argument( "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model." ) parser.add_argument( "--is_trivia_qa", action="store_true", help="Whether to convert a model with a trivia_qa head." ) _lowerCamelCase : int = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa )
336
import unittest import numpy as np from transformers import RobertaConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask if is_flax_available(): from transformers.models.roberta.modeling_flax_roberta import ( FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaModel, ) class __UpperCAmelCase ( unittest.TestCase ): def __init__( self : Optional[int], __A : Optional[int], __A : Any=1_3, __A : str=7, __A : Optional[int]=True, __A : Tuple=True, __A : Union[str, Any]=True, __A : Any=True, __A : Optional[int]=9_9, __A : Tuple=3_2, __A : str=5, __A : Union[str, Any]=4, __A : List[str]=3_7, __A : Tuple="gelu", __A : Optional[int]=0.1, __A : int=0.1, __A : Optional[Any]=5_1_2, __A : int=1_6, __A : Optional[Any]=2, __A : Union[str, Any]=0.0_2, __A : Optional[int]=4, ): UpperCAmelCase : Any = parent UpperCAmelCase : List[Any] = batch_size UpperCAmelCase : Any = seq_length UpperCAmelCase : Tuple = is_training UpperCAmelCase : str = use_attention_mask UpperCAmelCase : List[str] = use_token_type_ids UpperCAmelCase : int = use_labels UpperCAmelCase : List[Any] = vocab_size UpperCAmelCase : Optional[int] = hidden_size UpperCAmelCase : str = num_hidden_layers UpperCAmelCase : Dict = num_attention_heads UpperCAmelCase : Tuple = intermediate_size UpperCAmelCase : List[str] = hidden_act UpperCAmelCase : str = hidden_dropout_prob UpperCAmelCase : int = attention_probs_dropout_prob UpperCAmelCase : List[Any] = max_position_embeddings UpperCAmelCase : Optional[Any] = type_vocab_size UpperCAmelCase : Any = type_sequence_label_size UpperCAmelCase : Optional[Any] = initializer_range UpperCAmelCase : Any = num_choices def __magic_name__ ( self : str ): UpperCAmelCase : Any = ids_tensor([self.batch_size, self.seq_length], self.vocab_size ) UpperCAmelCase : List[Any] = None if self.use_attention_mask: UpperCAmelCase : Any = random_attention_mask([self.batch_size, self.seq_length] ) UpperCAmelCase : Any = None if self.use_token_type_ids: UpperCAmelCase : Any = ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size ) UpperCAmelCase : Union[str, Any] = RobertaConfig( vocab_size=self.vocab_size, hidden_size=self.hidden_size, num_hidden_layers=self.num_hidden_layers, num_attention_heads=self.num_attention_heads, intermediate_size=self.intermediate_size, hidden_act=self.hidden_act, hidden_dropout_prob=self.hidden_dropout_prob, attention_probs_dropout_prob=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, type_vocab_size=self.type_vocab_size, is_decoder=__A, initializer_range=self.initializer_range, ) return config, input_ids, token_type_ids, attention_mask def __magic_name__ ( self : int ): UpperCAmelCase : Any = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : List[Any] = config_and_inputs UpperCAmelCase : Dict = {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask} return config, inputs_dict def __magic_name__ ( self : List[str] ): UpperCAmelCase : List[Any] = self.prepare_config_and_inputs() UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase : Dict = config_and_inputs UpperCAmelCase : Any = True UpperCAmelCase : Union[str, Any] = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) UpperCAmelCase : List[Any] = ids_tensor([self.batch_size, self.seq_length], vocab_size=2 ) return ( config, input_ids, token_type_ids, encoder_hidden_states, encoder_attention_mask, ) @require_flax class __UpperCAmelCase ( lowerCamelCase__ , unittest.TestCase ): UpperCamelCase = True UpperCamelCase = ( ( FlaxRobertaModel, FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, ) if is_flax_available() else () ) def __magic_name__ ( self : Optional[Any] ): UpperCAmelCase : Dict = FlaxRobertaModelTester(self ) @slow def __magic_name__ ( self : Any ): for model_class_name in self.all_model_classes: UpperCAmelCase : Dict = model_class_name.from_pretrained('''roberta-base''', from_pt=__A ) UpperCAmelCase : List[str] = model(np.ones((1, 1) ) ) self.assertIsNotNone(__A )
336
1