code
stringlengths
86
54.5k
code_codestyle
int64
0
371
style_context
stringlengths
87
49.2k
style_context_codestyle
int64
0
349
label
int64
0
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_owlvit import OwlViTImageProcessor lowercase__ = logging.get_logger(__name__) class __lowerCamelCase ( lowerCAmelCase__ ): '''simple docstring''' def __init__( self : str , *a_ : int , **a_ : str ): warnings.warn( "The class OwlViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please" " use OwlViTImageProcessor instead." , _lowerCamelCase , ) super().__init__(*_lowerCamelCase , **_lowerCamelCase )
241
"""simple docstring""" 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 lowerCamelCase ( unittest.TestCase ): '''simple docstring''' def __init__(self , _lowerCamelCase , _lowerCamelCase=13 , _lowerCamelCase=7 , _lowerCamelCase=True , _lowerCamelCase=True , _lowerCamelCase=True , _lowerCamelCase=True , _lowerCamelCase=99 , _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=4 , ): """simple docstring""" UpperCAmelCase__ : Optional[Any] = parent UpperCAmelCase__ : Any = batch_size UpperCAmelCase__ : Optional[int] = seq_length UpperCAmelCase__ : Any = is_training UpperCAmelCase__ : int = use_attention_mask UpperCAmelCase__ : Any = use_token_type_ids UpperCAmelCase__ : Any = use_labels UpperCAmelCase__ : Union[str, Any] = vocab_size UpperCAmelCase__ : str = hidden_size UpperCAmelCase__ : List[Any] = num_hidden_layers UpperCAmelCase__ : Optional[Any] = num_attention_heads UpperCAmelCase__ : str = intermediate_size UpperCAmelCase__ : Dict = hidden_act UpperCAmelCase__ : Union[str, Any] = hidden_dropout_prob UpperCAmelCase__ : str = attention_probs_dropout_prob UpperCAmelCase__ : str = max_position_embeddings UpperCAmelCase__ : Union[str, Any] = type_vocab_size UpperCAmelCase__ : Dict = type_sequence_label_size UpperCAmelCase__ : Optional[int] = initializer_range UpperCAmelCase__ : int = num_choices def _a (self ): """simple docstring""" UpperCAmelCase__ : List[Any] = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) UpperCAmelCase__ : int = None if self.use_attention_mask: UpperCAmelCase__ : Optional[int] = random_attention_mask([self.batch_size, self.seq_length] ) UpperCAmelCase__ : List[Any] = None if self.use_token_type_ids: UpperCAmelCase__ : Tuple = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) UpperCAmelCase__ : Optional[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=_lowerCamelCase , initializer_range=self.initializer_range , ) return config, input_ids, token_type_ids, attention_mask def _a (self ): """simple docstring""" UpperCAmelCase__ : int = self.prepare_config_and_inputs() UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ : Tuple = config_and_inputs UpperCAmelCase__ : Dict = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": attention_mask} return config, inputs_dict def _a (self ): """simple docstring""" UpperCAmelCase__ : List[Any] = self.prepare_config_and_inputs() UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ : List[Any] = config_and_inputs UpperCAmelCase__ : Dict = True UpperCAmelCase__ : Optional[Any] = floats_tensor([self.batch_size, self.seq_length, self.hidden_size] ) UpperCAmelCase__ : Optional[int] = 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 lowerCamelCase ( lowerCAmelCase__ , unittest.TestCase ): '''simple docstring''' SCREAMING_SNAKE_CASE = True SCREAMING_SNAKE_CASE = ( ( FlaxRobertaModel, FlaxRobertaForCausalLM, FlaxRobertaForMaskedLM, FlaxRobertaForSequenceClassification, FlaxRobertaForTokenClassification, FlaxRobertaForMultipleChoice, FlaxRobertaForQuestionAnswering, ) if is_flax_available() else () ) def _a (self ): """simple docstring""" UpperCAmelCase__ : str = FlaxRobertaModelTester(self ) @slow def _a (self ): """simple docstring""" for model_class_name in self.all_model_classes: UpperCAmelCase__ : Dict = model_class_name.from_pretrained("""roberta-base""" , from_pt=_lowerCamelCase ) UpperCAmelCase__ : Union[str, Any] = model(np.ones((1, 1) ) ) self.assertIsNotNone(_lowerCamelCase )
171
0
"""simple docstring""" def A ( snake_case :int , snake_case :int ) -> str: if a < 0 or b < 0: raise ValueError('the value of both inputs must be positive' ) __UpperCamelCase = str(bin(snake_case ) )[2:] # remove the leading "0b" __UpperCamelCase = str(bin(snake_case ) )[2:] __UpperCamelCase = max(len(snake_case ) , len(snake_case ) ) return "0b" + "".join( str(int('1' in (char_a, char_b) ) ) for char_a, char_b in zip(a_binary.zfill(snake_case ) , b_binary.zfill(snake_case ) ) ) if __name__ == "__main__": import doctest doctest.testmod()
263
"""simple docstring""" from unittest import TestCase from datasets import Dataset from minhash_deduplication import deduplicate_dataset, make_duplicate_clusters def A ( ) -> Any: __UpperCamelCase = { 'repo_name': ['test_repo1', 'test_repo2', 'test_repo3'], 'path': ['test_1.py', 'test_2.py', 'unit_test.py'], 'content': ['a ' * 2_0, 'a ' * 3_0, 'b ' * 7], } __UpperCamelCase = Dataset.from_dict(snake_case ) return dataset class __lowerCAmelCase ( __SCREAMING_SNAKE_CASE ): def UpperCAmelCase ( self ): '''simple docstring''' __UpperCamelCase = get_dataset() __UpperCamelCase = make_duplicate_clusters(__UpperCAmelCase , 0.8_5 ) self.assertEqual(len(duplicate_clusters[0] ) , 2 ) def UpperCAmelCase ( self ): '''simple docstring''' __UpperCamelCase = get_dataset() __UpperCamelCase , __UpperCamelCase = deduplicate_dataset(__UpperCAmelCase ) self.assertEqual(len(__UpperCAmelCase ) , 2 ) print(__UpperCAmelCase ) self.assertEqual(duplicate_clusters[0][0]['copies'] , 2 ) self.assertEqual(duplicate_clusters[0][0]['is_extreme'] , __UpperCAmelCase )
263
1
import math from typing import Any, Callable, List, Optional, Tuple, Union import numpy as np import torch from ...models import TaFilmDecoder from ...schedulers import DDPMScheduler from ...utils import is_onnx_available, logging, randn_tensor if is_onnx_available(): from ..onnx_utils import OnnxRuntimeModel from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline from .continous_encoder import SpectrogramContEncoder from .notes_encoder import SpectrogramNotesEncoder UpperCAmelCase_ : Optional[Any] = logging.get_logger(__name__) # pylint: disable=invalid-name UpperCAmelCase_ : Union[str, Any] = 256 class SCREAMING_SNAKE_CASE__ ( lowercase__ ): snake_case__ : Union[str, Any] = ['''melgan'''] def __init__( self : Any , SCREAMING_SNAKE_CASE__ : SpectrogramNotesEncoder , SCREAMING_SNAKE_CASE__ : SpectrogramContEncoder , SCREAMING_SNAKE_CASE__ : TaFilmDecoder , SCREAMING_SNAKE_CASE__ : DDPMScheduler , SCREAMING_SNAKE_CASE__ : OnnxRuntimeModel if is_onnx_available() else Any , ) -> None: super().__init__() # From MELGAN a_ : Optional[Any] = math.log(1E-5 ) # Matches MelGAN training. a_ : Optional[Any] = 4.0 # Largest value for most examples a_ : Any = 1_2_8 self.register_modules( notes_encoder=SCREAMING_SNAKE_CASE__ , continuous_encoder=SCREAMING_SNAKE_CASE__ , decoder=SCREAMING_SNAKE_CASE__ , scheduler=SCREAMING_SNAKE_CASE__ , melgan=SCREAMING_SNAKE_CASE__ , ) def SCREAMING_SNAKE_CASE ( self : int , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : Dict=(-1.0, 1.0) , SCREAMING_SNAKE_CASE__ : Union[str, Any]=False ) -> List[str]: a_ , a_ : str = output_range if clip: a_ : Dict = torch.clip(SCREAMING_SNAKE_CASE__ , self.min_value , self.max_value ) # Scale to [0, 1]. a_ : str = (features - self.min_value) / (self.max_value - self.min_value) # Scale to [min_out, max_out]. return zero_one * (max_out - min_out) + min_out def SCREAMING_SNAKE_CASE ( self : Optional[Any] , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : str=(-1.0, 1.0) , SCREAMING_SNAKE_CASE__ : Union[str, Any]=False ) -> str: a_ , a_ : str = input_range a_ : Tuple = torch.clip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) if clip else outputs # Scale to [0, 1]. a_ : str = (outputs - min_out) / (max_out - min_out) # Scale to [self.min_value, self.max_value]. return zero_one * (self.max_value - self.min_value) + self.min_value def SCREAMING_SNAKE_CASE ( self : Union[str, Any] , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : str , SCREAMING_SNAKE_CASE__ : Any ) -> Union[str, Any]: a_ : Optional[Any] = input_tokens > 0 a_ , a_ : Tuple = self.notes_encoder( encoder_input_tokens=SCREAMING_SNAKE_CASE__ , encoder_inputs_mask=SCREAMING_SNAKE_CASE__ ) a_ , a_ : Union[str, Any] = self.continuous_encoder( encoder_inputs=SCREAMING_SNAKE_CASE__ , encoder_inputs_mask=SCREAMING_SNAKE_CASE__ ) return [(tokens_encoded, tokens_mask), (continuous_encoded, continuous_mask)] def SCREAMING_SNAKE_CASE ( self : str , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : Optional[Any] , SCREAMING_SNAKE_CASE__ : List[str] ) -> int: a_ : Union[str, Any] = noise_time if not torch.is_tensor(SCREAMING_SNAKE_CASE__ ): a_ : int = torch.tensor([timesteps] , dtype=torch.long , device=input_tokens.device ) elif torch.is_tensor(SCREAMING_SNAKE_CASE__ ) and len(timesteps.shape ) == 0: a_ : Dict = timesteps[None].to(input_tokens.device ) # broadcast to batch dimension in a way that's compatible with ONNX/Core ML a_ : Optional[int] = timesteps * torch.ones(input_tokens.shape[0] , dtype=timesteps.dtype , device=timesteps.device ) a_ : Optional[Any] = self.decoder( encodings_and_masks=SCREAMING_SNAKE_CASE__ , decoder_input_tokens=SCREAMING_SNAKE_CASE__ , decoder_noise_time=SCREAMING_SNAKE_CASE__ ) return logits @torch.no_grad() def __call__( self : Union[str, Any] , SCREAMING_SNAKE_CASE__ : List[List[int]] , SCREAMING_SNAKE_CASE__ : Optional[torch.Generator] = None , SCREAMING_SNAKE_CASE__ : int = 1_0_0 , SCREAMING_SNAKE_CASE__ : bool = True , SCREAMING_SNAKE_CASE__ : str = "numpy" , SCREAMING_SNAKE_CASE__ : Optional[Callable[[int, int, torch.FloatTensor], None]] = None , SCREAMING_SNAKE_CASE__ : int = 1 , ) -> Union[AudioPipelineOutput, Tuple]: 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__ )}.""" ) a_ : Tuple = np.zeros([1, TARGET_FEATURE_LENGTH, self.n_dims] , dtype=np.floataa ) a_ : Any = np.zeros([1, 0, self.n_dims] , np.floataa ) a_ : str = torch.ones((1, TARGET_FEATURE_LENGTH) , dtype=SCREAMING_SNAKE_CASE__ , device=self.device ) for i, encoder_input_tokens in enumerate(SCREAMING_SNAKE_CASE__ ): if i == 0: a_ : List[Any] = torch.from_numpy(pred_mel[:1].copy() ).to( device=self.device , dtype=self.decoder.dtype ) # The first chunk has no previous context. a_ : List[str] = torch.zeros((1, TARGET_FEATURE_LENGTH) , dtype=SCREAMING_SNAKE_CASE__ , device=self.device ) else: # The full song pipeline does not feed in a context feature, so the mask # will be all 0s after the feature converter. Because we know we're # feeding in a full context chunk from the previous prediction, set it # to all 1s. a_ : Optional[int] = ones a_ : Union[str, Any] = self.scale_features( SCREAMING_SNAKE_CASE__ , output_range=[-1.0, 1.0] , clip=SCREAMING_SNAKE_CASE__ ) a_ : Any = self.encode( input_tokens=torch.IntTensor([encoder_input_tokens] ).to(device=self.device ) , continuous_inputs=SCREAMING_SNAKE_CASE__ , continuous_mask=SCREAMING_SNAKE_CASE__ , ) # Sample encoder_continuous_inputs shaped gaussian noise to begin loop a_ : str = randn_tensor( shape=encoder_continuous_inputs.shape , generator=SCREAMING_SNAKE_CASE__ , device=self.device , dtype=self.decoder.dtype , ) # set step values self.scheduler.set_timesteps(SCREAMING_SNAKE_CASE__ ) # Denoising diffusion loop for j, t in enumerate(self.progress_bar(self.scheduler.timesteps ) ): a_ : str = self.decode( encodings_and_masks=SCREAMING_SNAKE_CASE__ , input_tokens=SCREAMING_SNAKE_CASE__ , noise_time=t / self.scheduler.config.num_train_timesteps , ) # Compute previous output: x_t -> x_t-1 a_ : List[str] = self.scheduler.step(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , generator=SCREAMING_SNAKE_CASE__ ).prev_sample a_ : List[Any] = self.scale_to_features(SCREAMING_SNAKE_CASE__ , input_range=[-1.0, 1.0] ) a_ : Optional[Any] = mel[:1] a_ : List[str] = mel.cpu().float().numpy() a_ : List[str] = np.concatenate([full_pred_mel, pred_mel[:1]] , axis=1 ) # call the callback, if provided if callback is not None and i % callback_steps == 0: callback(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) logger.info('Generated segment' , SCREAMING_SNAKE_CASE__ ) if output_type == "numpy" and not is_onnx_available(): raise ValueError( 'Cannot return output in \'np\' format if ONNX is not available. Make sure to have ONNX installed or set \'output_type\' to \'mel\'.' ) elif output_type == "numpy" and self.melgan is None: raise ValueError( 'Cannot return output in \'np\' format if melgan component is not defined. Make sure to define `self.melgan` or set \'output_type\' to \'mel\'.' ) if output_type == "numpy": a_ : List[Any] = self.melgan(input_features=full_pred_mel.astype(np.floataa ) ) else: a_ : Any = full_pred_mel if not return_dict: return (output,) return AudioPipelineOutput(audios=SCREAMING_SNAKE_CASE__ )
32
import re def lowerCAmelCase__ ( SCREAMING_SNAKE_CASE_ ) -> str: if len(re.findall('[ATCG]' , SCREAMING_SNAKE_CASE_ ) ) != len(SCREAMING_SNAKE_CASE_ ): raise ValueError('Invalid Strand' ) return dna.translate(dna.maketrans('ATCG' , 'TAGC' ) ) if __name__ == "__main__": import doctest doctest.testmod()
212
0
'''simple docstring''' import argparse from typing import Dict import tensorflow as tf import torch from tqdm import tqdm from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration a : Optional[int] = [ # tf -> hf ("""/""", """."""), ("""layer_""", """layers."""), ("""kernel""", """weight"""), ("""beta""", """bias"""), ("""gamma""", """weight"""), ("""pegasus""", """model"""), ] a : Tuple = [ (""".output.dense""", """.fc2"""), ("""intermediate.LayerNorm""", """final_layer_norm"""), ("""intermediate.dense""", """fc1"""), ] a : Tuple = ( INIT_COMMON + [ ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.out_proj"""), ("""attention.self""", """self_attn"""), ("""attention.encdec.LayerNorm""", """encoder_attn_layer_norm"""), ("""attention.encdec_output.dense""", """encoder_attn.out_proj"""), ("""attention.encdec""", """encoder_attn"""), ("""key""", """k_proj"""), ("""value""", """v_proj"""), ("""query""", """q_proj"""), ("""decoder.LayerNorm""", """decoder.layernorm_embedding"""), ] + END_COMMON ) a : str = ( INIT_COMMON + [ ("""embeddings.word_embeddings""", """shared.weight"""), ("""embeddings.position_embeddings""", """embed_positions.weight"""), ("""attention.self.LayerNorm""", """self_attn_layer_norm"""), ("""attention.output.dense""", """self_attn.output"""), ("""attention.self""", """self_attn.self"""), ("""encoder.LayerNorm""", """encoder.layernorm_embedding"""), ] + END_COMMON ) a : List[Any] = [ """encdec/key/bias""", """encdec/query/bias""", """encdec/value/bias""", """self/key/bias""", """self/query/bias""", """self/value/bias""", """encdec_output/dense/bias""", """attention/output/dense/bias""", ] def __lowerCamelCase ( _lowercase , _lowercase ) -> int: for tf_name, hf_name in patterns: UpperCAmelCase : Union[str, Any] = k.replace(_lowercase , _lowercase ) return k def __lowerCamelCase ( _lowercase , _lowercase ) -> BigBirdPegasusForConditionalGeneration: UpperCAmelCase : Any = BigBirdPegasusConfig(**_lowercase ) UpperCAmelCase : Any = BigBirdPegasusForConditionalGeneration(_lowercase ) UpperCAmelCase : Optional[Any] = torch_model.state_dict() UpperCAmelCase : Optional[int] = {} # separating decoder weights UpperCAmelCase : Union[str, Any] = {k: tf_weights[k] for k in tf_weights if k.startswith("""pegasus/decoder""" )} UpperCAmelCase : List[Any] = {k: tf_weights[k] for k in tf_weights if not k.startswith("""pegasus/decoder""" )} for k, v in tqdm(decoder_weights.items() , """tf -> hf conversion""" ): UpperCAmelCase : str = [k.endswith(_lowercase ) for ending in KEYS_TO_IGNORE] if any(_lowercase ): continue UpperCAmelCase : int = DECODER_PATTERNS UpperCAmelCase : Union[str, Any] = rename_state_dict_key(_lowercase , _lowercase ) if new_k not in state_dict: raise ValueError(F'''could not find new key {new_k} in state dict. (converted from {k})''' ) if any(True if i in k else False for i in ["""dense""", """query""", """key""", """value"""] ): UpperCAmelCase : int = v.T UpperCAmelCase : List[str] = torch.from_numpy(_lowercase ) assert v.shape == state_dict[new_k].shape, F'''{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}''' for k, v in tqdm(remaining_weights.items() , """tf -> hf conversion""" ): UpperCAmelCase : str = [k.endswith(_lowercase ) for ending in KEYS_TO_IGNORE] if any(_lowercase ): continue UpperCAmelCase : int = REMAINING_PATTERNS UpperCAmelCase : Dict = rename_state_dict_key(_lowercase , _lowercase ) if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings": raise ValueError(F'''could not find new key {new_k} in state dict. (converted from {k})''' ) if any(True if i in k else False for i in ["""dense""", """query""", """key""", """value"""] ): UpperCAmelCase : List[Any] = v.T UpperCAmelCase : Dict = torch.from_numpy(_lowercase ) if k != "pegasus/embeddings/position_embeddings": assert v.shape == state_dict[new_k].shape, F'''{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}''' UpperCAmelCase : Any = mapping["""model.embed_positions.weight"""] UpperCAmelCase : List[str] = mapping.pop("""model.embed_positions.weight""" ) UpperCAmelCase , UpperCAmelCase : Optional[int] = torch_model.load_state_dict(_lowercase , strict=_lowercase ) UpperCAmelCase : Tuple = [ k for k in missing if k not in [ """final_logits_bias""", """model.encoder.embed_tokens.weight""", """model.decoder.embed_tokens.weight""", """lm_head.weight""", ] ] assert unexpected_missing == [], F'''no matches found for the following torch keys {unexpected_missing}''' assert extra == [], F'''no matches found for the following tf keys {extra}''' return torch_model def __lowerCamelCase ( _lowercase ) -> Dict: UpperCAmelCase : Dict = tf.train.list_variables(_lowercase ) UpperCAmelCase : List[str] = {} UpperCAmelCase : List[Any] = ["""global_step"""] for name, shape in tqdm(_lowercase , desc="""converting tf checkpoint to dict""" ): UpperCAmelCase : Dict = any(pat in name for pat in ignore_name ) if skip_key: continue UpperCAmelCase : Dict = tf.train.load_variable(_lowercase , _lowercase ) UpperCAmelCase : str = array return tf_weights def __lowerCamelCase ( _lowercase , _lowercase , _lowercase ) -> Dict: UpperCAmelCase : Dict = get_tf_weights_as_numpy(_lowercase ) UpperCAmelCase : int = convert_bigbird_pegasus(_lowercase , _lowercase ) torch_model.save_pretrained(_lowercase ) if __name__ == "__main__": a : Tuple = argparse.ArgumentParser() parser.add_argument("""--tf_ckpt_path""", type=str, help="""passed to tf.train.list_variables""") parser.add_argument("""--save_dir""", default=None, type=str, help="""Path to the output PyTorch model.""") a : List[str] = parser.parse_args() a : Any = {} convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)
338
'''simple docstring''' from typing import List, Optional from tokenizers import ByteLevelBPETokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_blenderbot_small import BlenderbotSmallTokenizer a : List[Any] = logging.get_logger(__name__) a : List[str] = { """vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_config_file""": """tokenizer_config.json""", } a : List[Any] = { """vocab_file""": { """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json""" }, """merges_file""": { """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt""" }, """tokenizer_config_file""": { """facebook/blenderbot_small-90M""": ( """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json""" ) }, } a : List[Any] = { """facebook/blenderbot_small-90M""": 5_1_2, } class UpperCamelCase_ ( __magic_name__ ): lowercase = VOCAB_FILES_NAMES lowercase = PRETRAINED_VOCAB_FILES_MAP lowercase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase = BlenderbotSmallTokenizer def __init__( self , A=None , A=None , A="<|endoftext|>" , A="<|endoftext|>" , A="<|endoftext|>" , A=False , A=True , **A , ) -> Union[str, Any]: super().__init__( ByteLevelBPETokenizer( vocab=A , merges=A , add_prefix_space=A , trim_offsets=A , ) , bos_token=A , eos_token=A , unk_token=A , **A , ) UpperCAmelCase : Optional[Any] = add_prefix_space def _lowercase( self , A , A=None ) -> Optional[Any]: UpperCAmelCase : Optional[Any] = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def _lowercase( self , A , A = None ) -> List[int]: UpperCAmelCase : Any = [self.sep_token_id] UpperCAmelCase : Tuple = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
338
1
"""simple docstring""" from __future__ import annotations def __A ( a_ :Optional[int] , a_ :Tuple) -> bool: if len(__lowerCamelCase) == 0: return False __a : Optional[Any] = len(__lowerCamelCase) // 2 if a_list[midpoint] == item: return True if item < a_list[midpoint]: return binary_search(a_list[:midpoint] , __lowerCamelCase) else: return binary_search(a_list[midpoint + 1 :] , __lowerCamelCase) if __name__ == "__main__": A = input('''Enter numbers separated by comma:\n''').strip() A = [int(item.strip()) for item in user_input.split(''',''')] A = int(input('''Enter the number to be found in the list:\n''').strip()) A = "" if binary_search(sequence, target) else "not " print(F'{target} was {not_str}found in {sequence}')
160
from __future__ import annotations from collections.abc import Iterator class __lowerCAmelCase : def __init__( self :Optional[Any] , __magic_name__ :int ): '''simple docstring''' a = value a = None a = None class __lowerCAmelCase : def __init__( self :str , __magic_name__ :Node ): '''simple docstring''' a = tree def lowerCamelCase__ ( self :str , __magic_name__ :Node | None ): '''simple docstring''' if node is None: return 0 return node.value + ( self.depth_first_search(node.left ) + self.depth_first_search(node.right ) ) def __iter__( self :Tuple ): '''simple docstring''' yield self.depth_first_search(self.tree ) if __name__ == "__main__": import doctest doctest.testmod()
228
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available A_ = { 'configuration_pegasus_x': ['PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP', 'PegasusXConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: A_ = [ '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 A_ = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
363
"""simple docstring""" from typing import List, Optional, Tuple, Union import torch from ...utils import logging, randn_tensor from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline A_ = logging.get_logger(__name__) # pylint: disable=invalid-name class lowercase( __a ): '''simple docstring''' def __init__( self: Optional[int], a_: str, a_: Optional[Any] ): '''simple docstring''' super().__init__() self.register_modules(unet=a_, scheduler=a_ ) @torch.no_grad() def __call__( self: Any, a_: int = 1, a_: int = 100, a_: Optional[Union[torch.Generator, List[torch.Generator]]] = None, a_: Optional[float] = None, a_: bool = True, ): '''simple docstring''' if audio_length_in_s is None: _snake_case : Dict = self.unet.config.sample_size / self.unet.config.sample_rate _snake_case : Optional[int] = audio_length_in_s * self.unet.config.sample_rate _snake_case : int = 2 ** len(self.unet.up_blocks ) if sample_size < 3 * down_scale_factor: raise ValueError( f"{audio_length_in_s} is too small. Make sure it's bigger or equal to" f" {3 * down_scale_factor / self.unet.config.sample_rate}." ) _snake_case : Union[str, Any] = int(a_ ) if sample_size % down_scale_factor != 0: _snake_case : Optional[Any] = ( (audio_length_in_s * self.unet.config.sample_rate) // down_scale_factor + 1 ) * down_scale_factor logger.info( f"{audio_length_in_s} is increased to {sample_size / self.unet.config.sample_rate} so that it can be handled" f" by the model. It will be cut to {original_sample_size / self.unet.config.sample_rate} after the denoising" """ process.""" ) _snake_case : str = int(a_ ) _snake_case : int = next(iter(self.unet.parameters() ) ).dtype _snake_case : Optional[Any] = (batch_size, self.unet.config.in_channels, sample_size) if isinstance(a_, a_ ) and len(a_ ) != batch_size: raise ValueError( f"You have passed a list of generators of length {len(a_ )}, but requested an effective batch" f" size of {batch_size}. Make sure the batch size matches the length of the generators." ) _snake_case : Optional[Any] = randn_tensor(a_, generator=a_, device=self.device, dtype=a_ ) # set step values self.scheduler.set_timesteps(a_, device=audio.device ) _snake_case : Optional[int] = self.scheduler.timesteps.to(a_ ) for t in self.progress_bar(self.scheduler.timesteps ): # 1. predict noise model_output _snake_case : str = self.unet(a_, a_ ).sample # 2. compute previous image: x_t -> t_t-1 _snake_case : Optional[Any] = self.scheduler.step(a_, a_, a_ ).prev_sample _snake_case : Tuple = audio.clamp(-1, 1 ).float().cpu().numpy() _snake_case : Dict = audio[:, :, :original_sample_size] if not return_dict: return (audio,) return AudioPipelineOutput(audios=a_ )
132
0
import logging import os from dataclasses import dataclass, field from typing import Dict, Optional import datasets import numpy as np import tensorflow as tf from transformers import ( AutoConfig, AutoTokenizer, EvalPrediction, HfArgumentParser, PreTrainedTokenizer, TFAutoModelForSequenceClassification, TFTrainer, TFTrainingArguments, ) from transformers.utils import logging as hf_logging hf_logging.set_verbosity_info() hf_logging.enable_default_handler() hf_logging.enable_explicit_format() def __magic_name__ ( __a : str , __a : str , __a : str , __a : PreTrainedTokenizer , __a : int , __a : Optional[int] = None , ): '''simple docstring''' UpperCamelCase__ = {} if train_file is not None: UpperCamelCase__ = [train_file] if eval_file is not None: UpperCamelCase__ = [eval_file] if test_file is not None: UpperCamelCase__ = [test_file] UpperCamelCase__ = datasets.load_dataset("""csv""" , data_files=__a ) UpperCamelCase__ = list(ds[list(files.keys() )[0]].features.keys() ) UpperCamelCase__ = features_name.pop(__a ) UpperCamelCase__ = list(set(ds[list(files.keys() )[0]][label_name] ) ) UpperCamelCase__ = {label: i for i, label in enumerate(__a )} UpperCamelCase__ = tokenizer.model_input_names UpperCamelCase__ = {} if len(__a ) == 1: for k in files.keys(): UpperCamelCase__ = ds[k].map( lambda __a : tokenizer.batch_encode_plus( example[features_name[0]] , truncation=__a , max_length=__a , padding="""max_length""" ) , batched=__a , ) elif len(__a ) == 2: for k in files.keys(): UpperCamelCase__ = ds[k].map( lambda __a : tokenizer.batch_encode_plus( (example[features_name[0]], example[features_name[1]]) , truncation=__a , max_length=__a , padding="""max_length""" , ) , batched=__a , ) def gen_train(): for ex in transformed_ds[datasets.Split.TRAIN]: UpperCamelCase__ = {k: v for k, v in ex.items() if k in input_names} UpperCamelCase__ = labelaid[ex[label_name]] yield (d, label) def gen_val(): for ex in transformed_ds[datasets.Split.VALIDATION]: UpperCamelCase__ = {k: v for k, v in ex.items() if k in input_names} UpperCamelCase__ = labelaid[ex[label_name]] yield (d, label) def gen_test(): for ex in transformed_ds[datasets.Split.TEST]: UpperCamelCase__ = {k: v for k, v in ex.items() if k in input_names} UpperCamelCase__ = labelaid[ex[label_name]] yield (d, label) UpperCamelCase__ = ( tf.data.Dataset.from_generator( __a , ({k: tf.intaa for k in input_names}, tf.intaa) , ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] )) , ) if datasets.Split.TRAIN in transformed_ds else None ) if train_ds is not None: UpperCamelCase__ = train_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TRAIN] ) ) ) UpperCamelCase__ = ( tf.data.Dataset.from_generator( __a , ({k: tf.intaa for k in input_names}, tf.intaa) , ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] )) , ) if datasets.Split.VALIDATION in transformed_ds else None ) if val_ds is not None: UpperCamelCase__ = val_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.VALIDATION] ) ) ) UpperCamelCase__ = ( tf.data.Dataset.from_generator( __a , ({k: tf.intaa for k in input_names}, tf.intaa) , ({k: tf.TensorShape([None] ) for k in input_names}, tf.TensorShape([] )) , ) if datasets.Split.TEST in transformed_ds else None ) if test_ds is not None: UpperCamelCase__ = test_ds.apply(tf.data.experimental.assert_cardinality(len(ds[datasets.Split.TEST] ) ) ) return train_ds, val_ds, test_ds, labelaid lowerCamelCase_ = logging.getLogger(__name__) @dataclass class __A: """simple docstring""" SCREAMING_SNAKE_CASE__ = field(metadata={"""help""": """Which column contains the label"""} ) SCREAMING_SNAKE_CASE__ = field(default=__lowerCamelCase , metadata={"""help""": """The path of the training file"""} ) SCREAMING_SNAKE_CASE__ = field(default=__lowerCamelCase , metadata={"""help""": """The path of the development file"""} ) SCREAMING_SNAKE_CASE__ = field(default=__lowerCamelCase , metadata={"""help""": """The path of the test file"""} ) SCREAMING_SNAKE_CASE__ = field( default=128 , metadata={ """help""": ( """The maximum total input sequence length after tokenization. Sequences longer """ """than this will be truncated, sequences shorter will be padded.""" ) } , ) SCREAMING_SNAKE_CASE__ = field( default=__lowerCamelCase , metadata={"""help""": """Overwrite the cached training and evaluation sets"""} ) @dataclass class __A: """simple docstring""" SCREAMING_SNAKE_CASE__ = field( metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""} ) SCREAMING_SNAKE_CASE__ = field( default=__lowerCamelCase , metadata={"""help""": """Pretrained config name or path if not the same as model_name"""} ) SCREAMING_SNAKE_CASE__ = field( default=__lowerCamelCase , metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""} ) SCREAMING_SNAKE_CASE__ = field(default=__lowerCamelCase , metadata={"""help""": """Set this flag to use fast tokenization."""} ) # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script, # or just modify its tokenizer_config.json. SCREAMING_SNAKE_CASE__ = field( default=__lowerCamelCase , metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""} , ) def __magic_name__ ( ): '''simple docstring''' UpperCamelCase__ = HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments) ) UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ = parser.parse_args_into_dataclasses() if ( os.path.exists(training_args.output_dir ) and os.listdir(training_args.output_dir ) and training_args.do_train and not training_args.overwrite_output_dir ): raise ValueError( f"Output directory ({training_args.output_dir}) already exists and is not empty. Use" """ --overwrite_output_dir to overcome.""" ) # Setup logging logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , level=logging.INFO , ) logger.info( f"n_replicas: {training_args.n_replicas}, distributed training: {bool(training_args.n_replicas > 1 )}, " f"16-bits training: {training_args.fpaa}" ) logger.info(f"Training/evaluation parameters {training_args}" ) # Load pretrained model and tokenizer # # Distributed training: # The .from_pretrained methods guarantee that only one local process can concurrently # download model & vocab. UpperCamelCase__ = AutoTokenizer.from_pretrained( model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path , cache_dir=model_args.cache_dir , ) UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ , UpperCamelCase__ = get_tfds( train_file=data_args.train_file , eval_file=data_args.dev_file , test_file=data_args.test_file , tokenizer=__a , label_column_id=data_args.label_column_id , max_seq_length=data_args.max_seq_length , ) UpperCamelCase__ = AutoConfig.from_pretrained( model_args.config_name if model_args.config_name else model_args.model_name_or_path , num_labels=len(__a ) , labelaid=__a , idalabel={id: label for label, id in labelaid.items()} , finetuning_task="""text-classification""" , cache_dir=model_args.cache_dir , ) with training_args.strategy.scope(): UpperCamelCase__ = TFAutoModelForSequenceClassification.from_pretrained( model_args.model_name_or_path , from_pt=bool(""".bin""" in model_args.model_name_or_path ) , config=__a , cache_dir=model_args.cache_dir , ) def compute_metrics(__a : EvalPrediction ) -> Dict: UpperCamelCase__ = np.argmax(p.predictions , axis=1 ) return {"acc": (preds == p.label_ids).mean()} # Initialize our Trainer UpperCamelCase__ = TFTrainer( model=__a , args=__a , train_dataset=__a , eval_dataset=__a , compute_metrics=__a , ) # Training if training_args.do_train: trainer.train() trainer.save_model() tokenizer.save_pretrained(training_args.output_dir ) # Evaluation UpperCamelCase__ = {} if training_args.do_eval: logger.info("""*** Evaluate ***""" ) UpperCamelCase__ = trainer.evaluate() UpperCamelCase__ = os.path.join(training_args.output_dir , """eval_results.txt""" ) with open(__a , """w""" ) as writer: logger.info("""***** Eval results *****""" ) for key, value in result.items(): logger.info(f" {key} = {value}" ) writer.write(f"{key} = {value}\n" ) results.update(__a ) return results if __name__ == "__main__": main()
244
import torch from diffusers import StableDiffusionPipeline lowerCamelCase_ = '''path-to-your-trained-model''' lowerCamelCase_ = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.floataa).to('''cuda''') lowerCamelCase_ = '''A photo of sks dog in a bucket''' lowerCamelCase_ = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0] image.save('''dog-bucket.png''')
244
1
'''simple docstring''' import unittest from transformers import SPIECE_UNDERLINE from transformers.models.speechta import SpeechTaTokenizer from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow from transformers.tokenization_utils import AddedToken from ...test_tokenization_common import TokenizerTesterMixin __snake_case = get_tests_dir('''fixtures/test_sentencepiece_bpe_char.model''') @require_sentencepiece @require_tokenizers class lowercase ( A__ , unittest.TestCase ): """simple docstring""" _a = SpeechTaTokenizer _a = False _a = True def lowerCAmelCase__ ( self ): '''simple docstring''' super().setUp() # We have a SentencePiece fixture for testing UpperCamelCase__ :str = SpeechTaTokenizer(UpperCamelCase_ ) UpperCamelCase__ :Optional[int] = AddedToken('''<mask>''' , lstrip=UpperCamelCase_ , rstrip=UpperCamelCase_ ) UpperCamelCase__ :Any = mask_token tokenizer.add_special_tokens({'''mask_token''': mask_token} ) tokenizer.add_tokens(['''<ctc_blank>'''] ) tokenizer.save_pretrained(self.tmpdirname ) def lowerCAmelCase__ ( self , UpperCamelCase_ ): '''simple docstring''' UpperCamelCase__ :int = '''this is a test''' UpperCamelCase__ :Any = '''this is a test''' return input_text, output_text def lowerCAmelCase__ ( self , UpperCamelCase_ , UpperCamelCase_=False , UpperCamelCase_=20 , UpperCamelCase_=5 ): '''simple docstring''' UpperCamelCase__ , UpperCamelCase__ :int = self.get_input_output_texts(UpperCamelCase_ ) UpperCamelCase__ :Dict = tokenizer.encode(UpperCamelCase_ , add_special_tokens=UpperCamelCase_ ) UpperCamelCase__ :Any = tokenizer.decode(UpperCamelCase_ , clean_up_tokenization_spaces=UpperCamelCase_ ) return text, ids def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Dict = '''<pad>''' UpperCamelCase__ :Any = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(UpperCamelCase_ ) , UpperCamelCase_ ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(UpperCamelCase_ ) , UpperCamelCase_ ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :List[Any] = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-4] , '''œ''' ) self.assertEqual(vocab_keys[-2] , '''<mask>''' ) self.assertEqual(vocab_keys[-1] , '''<ctc_blank>''' ) self.assertEqual(len(UpperCamelCase_ ) , 81 ) def lowerCAmelCase__ ( self ): '''simple docstring''' self.assertEqual(self.get_tokenizer().vocab_size , 79 ) def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[Any] = self.get_tokenizers(do_lower_case=UpperCamelCase_ ) for tokenizer in tokenizers: with self.subTest(F'''{tokenizer.__class__.__name__}''' ): UpperCamelCase__ :List[str] = tokenizer.vocab_size UpperCamelCase__ :Dict = len(UpperCamelCase_ ) self.assertNotEqual(UpperCamelCase_ , 0 ) # We usually have added tokens from the start in tests because our vocab fixtures are # smaller than the original vocabs - let's not assert this # self.assertEqual(vocab_size, all_size) UpperCamelCase__ :Union[str, Any] = ['''aaaaa bbbbbb''', '''cccccccccdddddddd'''] UpperCamelCase__ :Optional[Any] = tokenizer.add_tokens(UpperCamelCase_ ) UpperCamelCase__ :List[Any] = tokenizer.vocab_size UpperCamelCase__ :int = len(UpperCamelCase_ ) self.assertNotEqual(UpperCamelCase_ , 0 ) self.assertEqual(UpperCamelCase_ , UpperCamelCase_ ) self.assertEqual(UpperCamelCase_ , len(UpperCamelCase_ ) ) self.assertEqual(UpperCamelCase_ , all_size + len(UpperCamelCase_ ) ) UpperCamelCase__ :List[str] = tokenizer.encode('''aaaaa bbbbbb low cccccccccdddddddd l''' , add_special_tokens=UpperCamelCase_ ) self.assertGreaterEqual(len(UpperCamelCase_ ) , 4 ) self.assertGreater(tokens[0] , tokenizer.vocab_size - 1 ) self.assertGreater(tokens[-3] , tokenizer.vocab_size - 1 ) UpperCamelCase__ :Dict = {'''eos_token''': '''>>>>|||<||<<|<<''', '''pad_token''': '''<<<<<|||>|>>>>|>'''} UpperCamelCase__ :List[str] = tokenizer.add_special_tokens(UpperCamelCase_ ) UpperCamelCase__ :Optional[Any] = tokenizer.vocab_size UpperCamelCase__ :str = len(UpperCamelCase_ ) self.assertNotEqual(UpperCamelCase_ , 0 ) self.assertEqual(UpperCamelCase_ , UpperCamelCase_ ) self.assertEqual(UpperCamelCase_ , len(UpperCamelCase_ ) ) self.assertEqual(UpperCamelCase_ , all_size_a + len(UpperCamelCase_ ) ) UpperCamelCase__ :Dict = tokenizer.encode( '''>>>>|||<||<<|<< aaaaabbbbbb low cccccccccdddddddd <<<<<|||>|>>>>|> l''' , add_special_tokens=UpperCamelCase_ ) self.assertGreaterEqual(len(UpperCamelCase_ ) , 6 ) self.assertGreater(tokens[0] , tokenizer.vocab_size - 1 ) self.assertGreater(tokens[0] , tokens[1] ) self.assertGreater(tokens[-3] , tokenizer.vocab_size - 1 ) self.assertGreater(tokens[-3] , tokens[-4] ) self.assertEqual(tokens[0] , tokenizer.eos_token_id ) self.assertEqual(tokens[-3] , tokenizer.pad_token_id ) def lowerCAmelCase__ ( self ): '''simple docstring''' pass def lowerCAmelCase__ ( self ): '''simple docstring''' pass def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[int] = self.get_tokenizer() UpperCamelCase__ :Any = tokenizer.tokenize('''This is a test''' ) # fmt: off self.assertListEqual(UpperCamelCase_ , [SPIECE_UNDERLINE, '''T''', '''h''', '''i''', '''s''', SPIECE_UNDERLINE, '''i''', '''s''', SPIECE_UNDERLINE, '''a''', SPIECE_UNDERLINE, '''t''', '''e''', '''s''', '''t'''] ) # fmt: on self.assertListEqual( tokenizer.convert_tokens_to_ids(UpperCamelCase_ ) , [4, 32, 11, 10, 12, 4, 10, 12, 4, 7, 4, 6, 5, 12, 6] , ) UpperCamelCase__ :List[Any] = tokenizer.tokenize('''I was born in 92000, and this is falsé.''' ) self.assertListEqual( UpperCamelCase_ , [SPIECE_UNDERLINE, '''I''', SPIECE_UNDERLINE, '''w''', '''a''', '''s''', SPIECE_UNDERLINE, '''b''', '''o''', '''r''', '''n''', SPIECE_UNDERLINE, '''i''', '''n''', SPIECE_UNDERLINE, '''92000''', ''',''', SPIECE_UNDERLINE, '''a''', '''n''', '''d''', SPIECE_UNDERLINE, '''t''', '''h''', '''i''', '''s''', SPIECE_UNDERLINE, '''i''', '''s''', SPIECE_UNDERLINE, '''f''', '''a''', '''l''', '''s''', '''é''', '''.'''] ) UpperCamelCase__ :Dict = tokenizer.convert_tokens_to_ids(UpperCamelCase_ ) # fmt: off self.assertListEqual(UpperCamelCase_ , [4, 30, 4, 20, 7, 12, 4, 25, 8, 13, 9, 4, 10, 9, 4, 3, 23, 4, 7, 9, 14, 4, 6, 11, 10, 12, 4, 10, 12, 4, 19, 7, 15, 12, 73, 26] ) # fmt: on UpperCamelCase__ :int = tokenizer.convert_ids_to_tokens(UpperCamelCase_ ) self.assertListEqual( UpperCamelCase_ , [SPIECE_UNDERLINE, '''I''', SPIECE_UNDERLINE, '''w''', '''a''', '''s''', SPIECE_UNDERLINE, '''b''', '''o''', '''r''', '''n''', SPIECE_UNDERLINE, '''i''', '''n''', SPIECE_UNDERLINE, '''<unk>''', ''',''', SPIECE_UNDERLINE, '''a''', '''n''', '''d''', SPIECE_UNDERLINE, '''t''', '''h''', '''i''', '''s''', SPIECE_UNDERLINE, '''i''', '''s''', SPIECE_UNDERLINE, '''f''', '''a''', '''l''', '''s''', '''é''', '''.'''] ) @slow def lowerCAmelCase__ ( self ): '''simple docstring''' UpperCamelCase__ :Optional[int] = [ '''Transformers (formerly known as pytorch-transformers and pytorch-pretrained-bert) provides ''' '''general-purpose architectures (BERT, GPT, RoBERTa, XLM, DistilBert, XLNet...) for Natural ''' '''Language Understanding (NLU) and Natural Language Generation (NLG) with over thirty-two pretrained ''' '''models in one hundred plus languages and deep interoperability between Jax, PyTorch and TensorFlow.''', '''BERT is designed to pre-train deep bidirectional representations from unlabeled text by jointly ''' '''conditioning on both left and right context in all layers.''', '''The quick brown fox jumps over the lazy dog.''', ] # fmt: off UpperCamelCase__ :Union[str, Any] = { '''input_ids''': [ [4, 32, 13, 7, 9, 12, 19, 8, 13, 18, 5, 13, 12, 4, 64, 19, 8, 13, 18, 5, 13, 15, 22, 4, 28, 9, 8, 20, 9, 4, 7, 12, 4, 24, 22, 6, 8, 13, 17, 11, 39, 6, 13, 7, 9, 12, 19, 8, 13, 18, 5, 13, 12, 4, 7, 9, 14, 4, 24, 22, 6, 8, 13, 17, 11, 39, 24, 13, 5, 6, 13, 7, 10, 9, 5, 14, 39, 25, 5, 13, 6, 63, 4, 24, 13, 8, 27, 10, 14, 5, 12, 4, 21, 5, 9, 5, 13, 7, 15, 39, 24, 16, 13, 24, 8, 12, 5, 4, 7, 13, 17, 11, 10, 6, 5, 17, 6, 16, 13, 5, 12, 4, 64, 40, 47, 54, 32, 23, 4, 53, 49, 32, 23, 4, 54, 8, 40, 47, 54, 32, 7, 23, 4, 69, 52, 43, 23, 4, 51, 10, 12, 6, 10, 15, 40, 5, 13, 6, 23, 4, 69, 52, 48, 5, 6, 26, 26, 26, 63, 4, 19, 8, 13, 4, 48, 7, 6, 16, 13, 7, 15, 4, 52, 7, 9, 21, 16, 7, 21, 5, 4, 61, 9, 14, 5, 13, 12, 6, 7, 9, 14, 10, 9, 21, 4, 64, 48, 52, 61, 63, 4, 7, 9, 14, 4, 48, 7, 6, 16, 13, 7, 15, 4, 52, 7, 9, 21, 16, 7, 21, 5, 4, 53, 5, 9, 5, 13, 7, 6, 10, 8, 9, 4, 64, 48, 52, 53, 63, 4, 20, 10, 6, 11, 4, 8, 27, 5, 13, 4, 6, 11, 10, 13, 6, 22, 39, 6, 20, 8, 4, 24, 13, 5, 6, 13, 7, 10, 9, 5, 14, 4, 18, 8, 14, 5, 15, 12, 4, 10, 9, 4, 8, 9, 5, 4, 11, 16, 9, 14, 13, 5, 14, 4, 24, 15, 16, 12, 4, 15, 7, 9, 21, 16, 7, 21, 5, 12, 4, 7, 9, 14, 4, 14, 5, 5, 24, 4, 10, 9, 6, 5, 13, 8, 24, 5, 13, 7, 25, 10, 15, 10, 6, 22, 4, 25, 5, 6, 20, 5, 5, 9, 4, 58, 7, 37, 23, 4, 49, 22, 32, 8, 13, 17, 11, 4, 7, 9, 14, 4, 32, 5, 9, 12, 8, 13, 55, 15, 8, 20, 26, 2], [4, 40, 47, 54, 32, 4, 10, 12, 4, 14, 5, 12, 10, 21, 9, 5, 14, 4, 6, 8, 4, 24, 13, 5, 39, 6, 13, 7, 10, 9, 4, 14, 5, 5, 24, 4, 25, 10, 14, 10, 13, 5, 17, 6, 10, 8, 9, 7, 15, 4, 13, 5, 24, 13, 5, 12, 5, 9, 6, 7, 6, 10, 8, 9, 12, 4, 19, 13, 8, 18, 4, 16, 9, 15, 7, 25, 5, 15, 5, 14, 4, 6, 5, 37, 6, 4, 25, 22, 4, 46, 8, 10, 9, 6, 15, 22, 4, 17, 8, 9, 14, 10, 6, 10, 8, 9, 10, 9, 21, 4, 8, 9, 4, 25, 8, 6, 11, 4, 15, 5, 19, 6, 4, 7, 9, 14, 4, 13, 10, 21, 11, 6, 4, 17, 8, 9, 6, 5, 37, 6, 4, 10, 9, 4, 7, 15, 15, 4, 15, 7, 22, 5, 13, 12, 26, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [4, 32, 11, 5, 4, 45, 16, 10, 17, 28, 4, 25, 13, 8, 20, 9, 4, 19, 8, 37, 4, 46, 16, 18, 24, 12, 4, 8, 27, 5, 13, 4, 6, 11, 5, 4, 15, 7, 57, 22, 4, 14, 8, 21, 26, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], ], '''attention_mask''': [ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] } # fmt: on self.tokenizer_integration_test_util( expected_encoding=UpperCamelCase_ , model_name='''microsoft/speecht5_asr''' , revision='''c5ef64c71905caeccde0e4462ef3f9077224c524''' , sequences=UpperCamelCase_ , )
219
'''simple docstring''' from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging __snake_case = logging.get_logger(__name__) __snake_case = { '''distilbert-base-uncased''': '''https://huggingface.co/distilbert-base-uncased/resolve/main/config.json''', '''distilbert-base-uncased-distilled-squad''': ( '''https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json''' ), '''distilbert-base-cased''': '''https://huggingface.co/distilbert-base-cased/resolve/main/config.json''', '''distilbert-base-cased-distilled-squad''': ( '''https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json''' ), '''distilbert-base-german-cased''': '''https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json''', '''distilbert-base-multilingual-cased''': ( '''https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json''' ), '''distilbert-base-uncased-finetuned-sst-2-english''': ( '''https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json''' ), } class lowercase ( A__ ): """simple docstring""" _a = 'distilbert' _a = { 'hidden_size': 'dim', 'num_attention_heads': 'n_heads', 'num_hidden_layers': 'n_layers', } def __init__( self , UpperCamelCase_=30522 , UpperCamelCase_=512 , UpperCamelCase_=False , UpperCamelCase_=6 , UpperCamelCase_=12 , UpperCamelCase_=768 , UpperCamelCase_=4 * 768 , UpperCamelCase_=0.1 , UpperCamelCase_=0.1 , UpperCamelCase_="gelu" , UpperCamelCase_=0.02 , UpperCamelCase_=0.1 , UpperCamelCase_=0.2 , UpperCamelCase_=0 , **UpperCamelCase_ , ): '''simple docstring''' UpperCamelCase__ :List[Any] = vocab_size UpperCamelCase__ :Dict = max_position_embeddings UpperCamelCase__ :str = sinusoidal_pos_embds UpperCamelCase__ :Any = n_layers UpperCamelCase__ :str = n_heads UpperCamelCase__ :Tuple = dim UpperCamelCase__ :str = hidden_dim UpperCamelCase__ :Dict = dropout UpperCamelCase__ :int = attention_dropout UpperCamelCase__ :Optional[Any] = activation UpperCamelCase__ :Optional[int] = initializer_range UpperCamelCase__ :Union[str, Any] = qa_dropout UpperCamelCase__ :Dict = seq_classif_dropout super().__init__(**UpperCamelCase_ , pad_token_id=UpperCamelCase_ ) class lowercase ( A__ ): """simple docstring""" @property def lowerCAmelCase__ ( self ): '''simple docstring''' if self.task == "multiple-choice": UpperCamelCase__ :str = {0: '''batch''', 1: '''choice''', 2: '''sequence'''} else: UpperCamelCase__ :str = {0: '''batch''', 1: '''sequence'''} return OrderedDict( [ ('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ] )
219
1
from __future__ import annotations from typing import Any class A : '''simple docstring''' def __init__(self : Any , _UpperCAmelCase : int = 6 ) -> None: """simple docstring""" lowercase__ = None lowercase__ = None self.create_linked_list(_UpperCAmelCase ) def lowerCamelCase__ (self : str , _UpperCAmelCase : int ) -> None: """simple docstring""" lowercase__ = Node() lowercase__ = current_node lowercase__ = current_node lowercase__ = current_node for _ in range(1 , _UpperCAmelCase ): lowercase__ = Node() lowercase__ = current_node lowercase__ = previous_node lowercase__ = current_node lowercase__ = self.front lowercase__ = previous_node def lowerCamelCase__ (self : List[Any] ) -> bool: """simple docstring""" return ( self.front == self.rear and self.front is not None and self.front.data is None ) def lowerCamelCase__ (self : Optional[int] ) -> Any | None: """simple docstring""" self.check_can_perform_operation() return self.front.data if self.front else None def lowerCamelCase__ (self : Optional[int] , _UpperCAmelCase : Any ) -> None: """simple docstring""" if self.rear is None: return self.check_is_full() if not self.is_empty(): lowercase__ = self.rear.next if self.rear: lowercase__ = data def lowerCamelCase__ (self : Tuple ) -> Any: """simple docstring""" self.check_can_perform_operation() if self.rear is None or self.front is None: return None if self.front == self.rear: lowercase__ = self.front.data lowercase__ = None return data lowercase__ = self.front lowercase__ = old_front.next lowercase__ = old_front.data lowercase__ = None return data def lowerCamelCase__ (self : Optional[int] ) -> None: """simple docstring""" if self.is_empty(): raise Exception("""Empty Queue""" ) def lowerCamelCase__ (self : Tuple ) -> None: """simple docstring""" if self.rear and self.rear.next == self.front: raise Exception("""Full Queue""" ) class A : '''simple docstring''' def __init__(self : str ) -> None: """simple docstring""" lowercase__ = None lowercase__ = None lowercase__ = None if __name__ == "__main__": import doctest doctest.testmod()
305
import gc import random import unittest import numpy as np import torch from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline from diffusers.pipelines.shap_e import ShapERenderer from diffusers.utils import floats_tensor, load_image, load_numpy, slow from diffusers.utils.testing_utils import require_torch_gpu, torch_device from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference class A ( UpperCAmelCase__ , unittest.TestCase ): '''simple docstring''' A__ = ShapEImgaImgPipeline A__ = ['''image'''] A__ = ['''image'''] A__ = [ '''num_images_per_prompt''', '''num_inference_steps''', '''generator''', '''latents''', '''guidance_scale''', '''frame_size''', '''output_type''', '''return_dict''', ] A__ = False @property def lowerCamelCase__ (self : Optional[Any] ) -> List[str]: """simple docstring""" return 32 @property def lowerCamelCase__ (self : str ) -> Any: """simple docstring""" return 32 @property def lowerCamelCase__ (self : str ) -> List[str]: """simple docstring""" return self.time_input_dim * 4 @property def lowerCamelCase__ (self : List[Any] ) -> Any: """simple docstring""" return 8 @property def lowerCamelCase__ (self : int ) -> List[str]: """simple docstring""" torch.manual_seed(0 ) lowercase__ = CLIPVisionConfig( hidden_size=self.text_embedder_hidden_size , image_size=64 , projection_dim=self.text_embedder_hidden_size , intermediate_size=37 , num_attention_heads=4 , num_channels=3 , num_hidden_layers=5 , patch_size=1 , ) lowercase__ = CLIPVisionModel(_UpperCAmelCase ) return model @property def lowerCamelCase__ (self : Any ) -> List[Any]: """simple docstring""" lowercase__ = CLIPImageProcessor( crop_size=224 , do_center_crop=_UpperCAmelCase , do_normalize=_UpperCAmelCase , do_resize=_UpperCAmelCase , image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073] , image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711] , resample=3 , size=224 , ) return image_processor @property def lowerCamelCase__ (self : int ) -> Optional[Any]: """simple docstring""" torch.manual_seed(0 ) lowercase__ = { """num_attention_heads""": 2, """attention_head_dim""": 16, """embedding_dim""": self.time_input_dim, """num_embeddings""": 32, """embedding_proj_dim""": self.text_embedder_hidden_size, """time_embed_dim""": self.time_embed_dim, """num_layers""": 1, """clip_embed_dim""": self.time_input_dim * 2, """additional_embeddings""": 0, """time_embed_act_fn""": """gelu""", """norm_in_type""": """layer""", """embedding_proj_norm_type""": """layer""", """encoder_hid_proj_type""": None, """added_emb_type""": None, } lowercase__ = PriorTransformer(**_UpperCAmelCase ) return model @property def lowerCamelCase__ (self : Union[str, Any] ) -> Tuple: """simple docstring""" torch.manual_seed(0 ) lowercase__ = { """param_shapes""": ( (self.renderer_dim, 93), (self.renderer_dim, 8), (self.renderer_dim, 8), (self.renderer_dim, 8), ), """d_latent""": self.time_input_dim, """d_hidden""": self.renderer_dim, """n_output""": 12, """background""": ( 0.1, 0.1, 0.1, ), } lowercase__ = ShapERenderer(**_UpperCAmelCase ) return model def lowerCamelCase__ (self : int ) -> Optional[int]: """simple docstring""" lowercase__ = self.dummy_prior lowercase__ = self.dummy_image_encoder lowercase__ = self.dummy_image_processor lowercase__ = self.dummy_renderer lowercase__ = HeunDiscreteScheduler( beta_schedule="""exp""" , num_train_timesteps=1024 , prediction_type="""sample""" , use_karras_sigmas=_UpperCAmelCase , clip_sample=_UpperCAmelCase , clip_sample_range=1.0 , ) lowercase__ = { """prior""": prior, """image_encoder""": image_encoder, """image_processor""": image_processor, """renderer""": renderer, """scheduler""": scheduler, } return components def lowerCamelCase__ (self : Dict , _UpperCAmelCase : List[Any] , _UpperCAmelCase : str=0 ) -> str: """simple docstring""" lowercase__ = floats_tensor((1, 3, 64, 64) , rng=random.Random(_UpperCAmelCase ) ).to(_UpperCAmelCase ) if str(_UpperCAmelCase ).startswith("""mps""" ): lowercase__ = torch.manual_seed(_UpperCAmelCase ) else: lowercase__ = torch.Generator(device=_UpperCAmelCase ).manual_seed(_UpperCAmelCase ) lowercase__ = { """image""": input_image, """generator""": generator, """num_inference_steps""": 1, """frame_size""": 32, """output_type""": """np""", } return inputs def lowerCamelCase__ (self : str ) -> List[str]: """simple docstring""" lowercase__ = """cpu""" lowercase__ = self.get_dummy_components() lowercase__ = self.pipeline_class(**_UpperCAmelCase ) lowercase__ = pipe.to(_UpperCAmelCase ) pipe.set_progress_bar_config(disable=_UpperCAmelCase ) lowercase__ = pipe(**self.get_dummy_inputs(_UpperCAmelCase ) ) lowercase__ = output.images[0] lowercase__ = image[0, -3:, -3:, -1] assert image.shape == (20, 32, 32, 3) lowercase__ = np.array( [ 0.00_039_216, 0.00_039_216, 0.00_039_216, 0.00_039_216, 0.00_039_216, 0.00_039_216, 0.00_039_216, 0.00_039_216, 0.00_039_216, ] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2 def lowerCamelCase__ (self : str ) -> Any: """simple docstring""" self._test_inference_batch_consistent(batch_sizes=[1, 2] ) def lowerCamelCase__ (self : Optional[int] ) -> str: """simple docstring""" lowercase__ = torch_device == """cpu""" lowercase__ = True self._test_inference_batch_single_identical( batch_size=2 , test_max_difference=_UpperCAmelCase , relax_max_difference=_UpperCAmelCase , ) def lowerCamelCase__ (self : Union[str, Any] ) -> int: """simple docstring""" lowercase__ = self.get_dummy_components() lowercase__ = self.pipeline_class(**_UpperCAmelCase ) lowercase__ = pipe.to(_UpperCAmelCase ) pipe.set_progress_bar_config(disable=_UpperCAmelCase ) lowercase__ = 1 lowercase__ = 2 lowercase__ = self.get_dummy_inputs(_UpperCAmelCase ) for key in inputs.keys(): if key in self.batch_params: lowercase__ = batch_size * [inputs[key]] lowercase__ = pipe(**_UpperCAmelCase , num_images_per_prompt=_UpperCAmelCase )[0] assert images.shape[0] == batch_size * num_images_per_prompt @slow @require_torch_gpu class A ( unittest.TestCase ): '''simple docstring''' def lowerCamelCase__ (self : Dict ) -> List[Any]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def lowerCamelCase__ (self : Any ) -> str: """simple docstring""" lowercase__ = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/shap_e/corgi.png""" ) lowercase__ = load_numpy( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/shap_e/test_shap_e_img2img_out.npy""" ) lowercase__ = ShapEImgaImgPipeline.from_pretrained("""openai/shap-e-img2img""" ) lowercase__ = pipe.to(_UpperCAmelCase ) pipe.set_progress_bar_config(disable=_UpperCAmelCase ) lowercase__ = torch.Generator(device=_UpperCAmelCase ).manual_seed(0 ) lowercase__ = pipe( _UpperCAmelCase , generator=_UpperCAmelCase , guidance_scale=3.0 , num_inference_steps=64 , frame_size=64 , output_type="""np""" , ).images[0] assert images.shape == (20, 64, 64, 3) assert_mean_pixel_difference(_UpperCAmelCase , _UpperCAmelCase )
305
1
"""simple docstring""" from unittest import TestCase from datasets import Sequence, Value from datasets.arrow_dataset import Dataset class _lowerCamelCase ( _lowercase ): def snake_case_ (self ) -> List[str]: return [ {"col_1": 3, "col_2": "a"}, {"col_1": 2, "col_2": "b"}, {"col_1": 1, "col_2": "c"}, {"col_1": 0, "col_2": "d"}, ] def snake_case_ (self ) -> Optional[Any]: UpperCamelCase = {"col_1": [3, 2, 1, 0], "col_2": ["a", "b", "c", "d"]} return Dataset.from_dict(__a ) def snake_case_ (self ) -> Any: UpperCamelCase = self._create_example_records() UpperCamelCase = Dataset.from_list(__a ) self.assertListEqual(dset.column_names , ["col_1", "col_2"] ) for i, r in enumerate(__a ): self.assertDictEqual(__a , example_records[i] ) def snake_case_ (self ) -> Tuple: UpperCamelCase = self._create_example_records() UpperCamelCase = Dataset.from_list(__a ) UpperCamelCase = Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]} ) self.assertEqual(dset.info , dset_from_dict.info ) def snake_case_ (self ) -> str: # checks what happens with missing columns UpperCamelCase = [{"col_1": 1}, {"col_2": "x"}] UpperCamelCase = Dataset.from_list(__a ) self.assertDictEqual(dset[0] , {"col_1": 1} ) self.assertDictEqual(dset[1] , {"col_1": None} ) # NB: first record is used for columns def snake_case_ (self ) -> Union[str, Any]: # checks if the type can be inferred from the second record UpperCamelCase = [{"col_1": []}, {"col_1": [1, 2]}] UpperCamelCase = Dataset.from_list(__a ) self.assertEqual(dset.info.features["col_1"] , Sequence(Value("int64" ) ) ) def snake_case_ (self ) -> List[str]: UpperCamelCase = Dataset.from_list([] ) self.assertEqual(len(__a ) , 0 ) self.assertListEqual(dset.column_names , [] )
352
"""simple docstring""" def a__ ( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): """simple docstring""" if len(_SCREAMING_SNAKE_CASE ) != len(_SCREAMING_SNAKE_CASE ): raise ValueError("The length of profit and weight must be same." ) if max_weight <= 0: raise ValueError("max_weight must greater than zero." ) if any(p < 0 for p in profit ): raise ValueError("Profit can not be negative." ) if any(w < 0 for w in weight ): raise ValueError("Weight can not be negative." ) # List created to store profit gained for the 1kg in case of each weight # respectively. Calculate and append profit/weight for each element. UpperCamelCase = [p / w for p, w in zip(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )] # Creating a copy of the list and sorting profit/weight in ascending order UpperCamelCase = sorted(_SCREAMING_SNAKE_CASE ) # declaring useful variables UpperCamelCase = len(_SCREAMING_SNAKE_CASE ) UpperCamelCase = 0 UpperCamelCase = 0 UpperCamelCase = 0 # loop till the total weight do not reach max limit e.g. 15 kg and till i<length while limit <= max_weight and i < length: # flag value for encountered greatest element in sorted_profit_by_weight UpperCamelCase = sorted_profit_by_weight[length - i - 1] UpperCamelCase = profit_by_weight.index(_SCREAMING_SNAKE_CASE ) UpperCamelCase = -1 # check if the weight encountered is less than the total weight # encountered before. if max_weight - limit >= weight[index]: limit += weight[index] # Adding profit gained for the given weight 1 === # weight[index]/weight[index] gain += 1 * profit[index] else: # Since the weight encountered is greater than limit, therefore take the # required number of remaining kgs and calculate profit for it. # weight remaining / weight[index] gain += (max_weight - limit) / weight[index] * profit[index] break i += 1 return gain if __name__ == "__main__": print( '''Input profits, weights, and then max_weight (all positive ints) separated by ''' '''spaces.''' ) lowerCAmelCase__ = [int(x) for x in input('''Input profits separated by spaces: ''').split()] lowerCAmelCase__ = [int(x) for x in input('''Input weights separated by spaces: ''').split()] lowerCAmelCase__ = int(input('''Max weight allowed: ''')) # Function Call calc_profit(profit, weight, max_weight)
244
0
import os from itertools import chain from random import randrange, shuffle import pytest from .sola import PokerHand lowercase_ = ( "4S 3H 2C 7S 5H", "9D 8H 2C 6S 7H", "2D 6D 9D TH 7D", "TC 8C 2S JH 6C", "JH 8S TH AH QH", "TS KS 5S 9S AC", "KD 6S 9D TH AD", "KS 8D 4D 9S 4S", # pair "8C 4S KH JS 4D", # pair "QH 8H KD JH 8S", # pair "KC 4H KS 2H 8D", # pair "KD 4S KC 3H 8S", # pair "AH 8S AS KC JH", # pair "3H 4C 4H 3S 2H", # 2 pairs "5S 5D 2C KH KH", # 2 pairs "3C KH 5D 5S KH", # 2 pairs "AS 3C KH AD KH", # 2 pairs "7C 7S 3S 7H 5S", # 3 of a kind "7C 7S KH 2H 7H", # 3 of a kind "AC KH QH AH AS", # 3 of a kind "2H 4D 3C AS 5S", # straight (low ace) "3C 5C 4C 2C 6H", # straight "6S 8S 7S 5H 9H", # straight "JS QS 9H TS KH", # straight "QC KH TS JS AH", # straight (high ace) "8C 9C 5C 3C TC", # flush "3S 8S 9S 5S KS", # flush "4C 5C 9C 8C KC", # flush "JH 8H AH KH QH", # flush "3D 2H 3H 2C 2D", # full house "2H 2C 3S 3H 3D", # full house "KH KC 3S 3H 3D", # full house "JC 6H JS JD JH", # 4 of a kind "JC 7H JS JD JH", # 4 of a kind "JC KH JS JD JH", # 4 of a kind "2S AS 4S 5S 3S", # straight flush (low ace) "2D 6D 3D 4D 5D", # straight flush "5C 6C 3C 7C 4C", # straight flush "JH 9H TH KH QH", # straight flush "JH AH TH KH QH", # royal flush (high ace straight flush) ) lowercase_ = ( ("2H 3H 4H 5H 6H", "KS AS TS QS JS", "Loss"), ("2H 3H 4H 5H 6H", "AS AD AC AH JD", "Win"), ("AS AH 2H AD AC", "JS JD JC JH 3D", "Win"), ("2S AH 2H AS AC", "JS JD JC JH AD", "Loss"), ("2S AH 2H AS AC", "2H 3H 5H 6H 7H", "Win"), ("AS 3S 4S 8S 2S", "2H 3H 5H 6H 7H", "Win"), ("2H 3H 5H 6H 7H", "2S 3H 4H 5S 6C", "Win"), ("2S 3H 4H 5S 6C", "3D 4C 5H 6H 2S", "Tie"), ("2S 3H 4H 5S 6C", "AH AC 5H 6H AS", "Win"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H AS", "Loss"), ("2S 2H 4H 5S 4C", "AH AC 5H 6H 7S", "Win"), ("6S AD 7H 4S AS", "AH AC 5H 6H 7S", "Loss"), ("2S AH 4H 5S KC", "AH AC 5H 6H 7S", "Loss"), ("2S 3H 6H 7S 9C", "7H 3C TH 6H 9S", "Loss"), ("4S 5H 6H TS AC", "3S 5H 6H TS AC", "Win"), ("2S AH 4H 5S 6C", "AD 4C 5H 6H 2C", "Tie"), ("AS AH 3H AD AC", "AS AH 2H AD AC", "Win"), ("AH AC 5H 5C QS", "AH AC 5H 5C KS", "Loss"), ("AH AC 5H 5C QS", "KH KC 5H 5C QS", "Win"), ("7C 7S KH 2H 7H", "3C 3S AH 2H 3H", "Win"), ("3C 3S AH 2H 3H", "7C 7S KH 2H 7H", "Loss"), ("6H 5H 4H 3H 2H", "5H 4H 3H 2H AH", "Win"), ("5H 4H 3H 2H AH", "5H 4H 3H 2H AH", "Tie"), ("5H 4H 3H 2H AH", "6H 5H 4H 3H 2H", "Loss"), ("AH AD KS KC AC", "AH KD KH AC KC", "Win"), ("2H 4D 3C AS 5S", "2H 4D 3C 6S 5S", "Loss"), ("2H 3S 3C 3H 2S", "3S 3C 2S 2H 2D", "Win"), ("4D 6D 5D 2D JH", "3S 8S 3H TC KH", "Loss"), ("4S 6C 8S 3S 7S", "AD KS 2D 7D 7C", "Loss"), ("6S 4C 7H 8C 3H", "5H JC AH 9D 9C", "Loss"), ("9D 9H JH TC QH", "3C 2S JS 5C 7H", "Win"), ("2H TC 8S AD 9S", "4H TS 7H 2C 5C", "Win"), ("9D 3S 2C 7S 7C", "JC TD 3C TC 9H", "Loss"), ) lowercase_ = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", True), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", False), ("AS 3S 4S 8S 2S", True), ) lowercase_ = ( ("2H 3H 4H 5H 6H", True), ("AS AH 2H AD AC", False), ("2H 3H 5H 6H 7H", False), ("KS AS TS QS JS", True), ("8H 9H QS JS TH", True), ) lowercase_ = ( ("2H 4D 3C AS 5S", True, [5, 4, 3, 2, 14]), ("2H 5D 3C AS 5S", False, [14, 5, 5, 3, 2]), ("JH QD KC AS TS", False, [14, 13, 12, 11, 10]), ("9D 3S 2C 7S 7C", False, [9, 7, 7, 3, 2]), ) lowercase_ = ( ("JH AH TH KH QH", 0), ("JH 9H TH KH QH", 0), ("JC KH JS JD JH", 7), ("KH KC 3S 3H 3D", 6), ("8C 9C 5C 3C TC", 0), ("JS QS 9H TS KH", 0), ("7C 7S KH 2H 7H", 3), ("3C KH 5D 5S KH", 2), ("QH 8H KD JH 8S", 1), ("2D 6D 9D TH 7D", 0), ) lowercase_ = ( ("JH AH TH KH QH", 23), ("JH 9H TH KH QH", 22), ("JC KH JS JD JH", 21), ("KH KC 3S 3H 3D", 20), ("8C 9C 5C 3C TC", 19), ("JS QS 9H TS KH", 18), ("7C 7S KH 2H 7H", 17), ("3C KH 5D 5S KH", 16), ("QH 8H KD JH 8S", 15), ("2D 6D 9D TH 7D", 14), ) def _snake_case( ) -> str: '''simple docstring''' A__ = randrange(len(_a ) ), randrange(len(_a ) ) A__ = ["Loss", "Tie", "Win"][(play >= oppo) + (play > oppo)] A__ = SORTED_HANDS[play], SORTED_HANDS[oppo] return hand, other, expected def _snake_case( SCREAMING_SNAKE_CASE__ : Optional[Any] = 100 ) -> Tuple: '''simple docstring''' return (generate_random_hand() for _ in range(_a )) @pytest.mark.parametrize('hand, expected' , _a ) def _snake_case( SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : str ) -> Union[str, Any]: '''simple docstring''' assert PokerHand(_a )._is_flush() == expected @pytest.mark.parametrize('hand, expected' , _a ) def _snake_case( SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : Tuple ) -> Optional[Any]: '''simple docstring''' assert PokerHand(_a )._is_straight() == expected @pytest.mark.parametrize('hand, expected, card_values' , _a ) def _snake_case( SCREAMING_SNAKE_CASE__ : Union[str, Any] , SCREAMING_SNAKE_CASE__ : Any , SCREAMING_SNAKE_CASE__ : List[Any] ) -> Optional[Any]: '''simple docstring''' A__ = PokerHand(_a ) assert player._is_five_high_straight() == expected assert player._card_values == card_values @pytest.mark.parametrize('hand, expected' , _a ) def _snake_case( SCREAMING_SNAKE_CASE__ : Optional[Any] , SCREAMING_SNAKE_CASE__ : Union[str, Any] ) -> Union[str, Any]: '''simple docstring''' assert PokerHand(_a )._is_same_kind() == expected @pytest.mark.parametrize('hand, expected' , _a ) def _snake_case( SCREAMING_SNAKE_CASE__ : Tuple , SCREAMING_SNAKE_CASE__ : Optional[int] ) -> str: '''simple docstring''' assert PokerHand(_a )._hand_type == expected @pytest.mark.parametrize('hand, other, expected' , _a ) def _snake_case( SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : Optional[int] , SCREAMING_SNAKE_CASE__ : Dict ) -> Optional[Any]: '''simple docstring''' assert PokerHand(_a ).compare_with(PokerHand(_a ) ) == expected @pytest.mark.parametrize('hand, other, expected' , generate_random_hands() ) def _snake_case( SCREAMING_SNAKE_CASE__ : Union[str, Any] , SCREAMING_SNAKE_CASE__ : Union[str, Any] , SCREAMING_SNAKE_CASE__ : int ) -> Optional[Any]: '''simple docstring''' assert PokerHand(_a ).compare_with(PokerHand(_a ) ) == expected def _snake_case( ) -> List[str]: '''simple docstring''' A__ = [PokerHand(_a ) for hand in SORTED_HANDS] A__ = poker_hands.copy() shuffle(_a ) A__ = chain(sorted(_a ) ) for index, hand in enumerate(_a ): assert hand == poker_hands[index] def _snake_case( ) -> List[Any]: '''simple docstring''' A__ = [PokerHand('2D AC 3H 4H 5S' ), PokerHand('2S 3H 4H 5S 6C' )] pokerhands.sort(reverse=_a ) assert pokerhands[0].__str__() == "2S 3H 4H 5S 6C" def _snake_case( ) -> Any: '''simple docstring''' A__ = PokerHand('2C 4S AS 3D 5C' ) A__ = True A__ = [5, 4, 3, 2, 14] for _ in range(10 ): assert pokerhand._is_five_high_straight() == expected assert pokerhand._card_values == expected_card_values def _snake_case( ) -> Tuple: '''simple docstring''' A__ = 0 A__ = os.path.abspath(os.path.dirname(_a ) ) A__ = os.path.join(_a , 'poker_hands.txt' ) with open(_a ) as file_hand: for line in file_hand: A__ = line[:14].strip() A__ = line[15:].strip() A__ = PokerHand(_a ), PokerHand(_a ) A__ = player.compare_with(_a ) if output == "Win": answer += 1 assert answer == 376
7
# tests directory-specific settings - this file is run automatically # by pytest before any tests are run import sys import warnings from os.path import abspath, dirname, join # allow having multiple repository checkouts and not needing to remember to rerun # 'pip install -e .[dev]' when switching between checkouts and running tests. a_ = abspath(join(dirname(dirname(__file__)), 'src')) sys.path.insert(1, git_repo_path) # silence FutureWarning warnings in tests since often we can't act on them until # they become normal warnings - i.e. the tests still need to test the current functionality warnings.simplefilter(action='ignore', category=FutureWarning) def lowerCamelCase__ ( _a): from diffusers.utils.testing_utils import pytest_addoption_shared pytest_addoption_shared(_a) def lowerCamelCase__ ( _a): from diffusers.utils.testing_utils import pytest_terminal_summary_main SCREAMING_SNAKE_CASE : Union[str, Any] = terminalreporter.config.getoption("--make-reports") if make_reports: pytest_terminal_summary_main(_a , id=_a)
76
0
'''simple docstring''' from math import acos, sin from typing import List, Tuple, Union import numpy as np import torch from PIL import Image from ...models import AutoencoderKL, UNetaDConditionModel from ...schedulers import DDIMScheduler, DDPMScheduler from ...utils import randn_tensor from ..pipeline_utils import AudioPipelineOutput, BaseOutput, DiffusionPipeline, ImagePipelineOutput from .mel import Mel class UpperCAmelCase_ ( __lowercase ): lowerCamelCase : Dict = ["vqvae"] def __init__( self : Optional[Any] , UpperCAmelCase__ : AutoencoderKL , UpperCAmelCase__ : UNetaDConditionModel , UpperCAmelCase__ : Mel , UpperCAmelCase__ : Union[DDIMScheduler, DDPMScheduler] , ) -> List[str]: super().__init__() self.register_modules(unet=snake_case_ , scheduler=snake_case_ , mel=snake_case_ , vqvae=snake_case_ ) def __UpperCAmelCase ( self : Tuple ) -> Union[str, Any]: return 5_0 if isinstance(self.scheduler , snake_case_ ) else 1_0_0_0 @torch.no_grad() def __call__( self : Optional[int] , UpperCAmelCase__ : int = 1 , UpperCAmelCase__ : str = None , UpperCAmelCase__ : np.ndarray = None , UpperCAmelCase__ : int = 0 , UpperCAmelCase__ : int = 0 , UpperCAmelCase__ : int = None , UpperCAmelCase__ : torch.Generator = None , UpperCAmelCase__ : float = 0 , UpperCAmelCase__ : float = 0 , UpperCAmelCase__ : torch.Generator = None , UpperCAmelCase__ : float = 0 , UpperCAmelCase__ : torch.Tensor = None , UpperCAmelCase__ : torch.Tensor = None , UpperCAmelCase__ : Tuple=True , ) -> Union[str, Any]: lowerCAmelCase = steps or self.get_default_steps() self.scheduler.set_timesteps(snake_case_ ) lowerCAmelCase = step_generator or generator # For backwards compatibility if type(self.unet.config.sample_size ) == int: lowerCAmelCase = (self.unet.config.sample_size, self.unet.config.sample_size) if noise is None: lowerCAmelCase = randn_tensor( ( batch_size, self.unet.config.in_channels, self.unet.config.sample_size[0], self.unet.config.sample_size[1], ) , generator=snake_case_ , device=self.device , ) lowerCAmelCase = noise lowerCAmelCase = None if audio_file is not None or raw_audio is not None: self.mel.load_audio(snake_case_ , snake_case_ ) lowerCAmelCase = self.mel.audio_slice_to_image(snake_case_ ) lowerCAmelCase = np.frombuffer(input_image.tobytes() , dtype='uint8' ).reshape( (input_image.height, input_image.width) ) lowerCAmelCase = (input_image / 2_5_5) * 2 - 1 lowerCAmelCase = torch.tensor(input_image[np.newaxis, :, :] , dtype=torch.float ).to(self.device ) if self.vqvae is not None: lowerCAmelCase = self.vqvae.encode(torch.unsqueeze(snake_case_ , 0 ) ).latent_dist.sample( generator=snake_case_ )[0] lowerCAmelCase = self.vqvae.config.scaling_factor * input_images if start_step > 0: lowerCAmelCase = self.scheduler.add_noise(snake_case_ , snake_case_ , self.scheduler.timesteps[start_step - 1] ) lowerCAmelCase = ( self.unet.config.sample_size[1] * self.mel.get_sample_rate() / self.mel.x_res / self.mel.hop_length ) lowerCAmelCase = int(mask_start_secs * pixels_per_second ) lowerCAmelCase = int(mask_end_secs * pixels_per_second ) lowerCAmelCase = self.scheduler.add_noise(snake_case_ , snake_case_ , torch.tensor(self.scheduler.timesteps[start_step:] ) ) for step, t in enumerate(self.progress_bar(self.scheduler.timesteps[start_step:] ) ): if isinstance(self.unet , snake_case_ ): lowerCAmelCase = self.unet(snake_case_ , snake_case_ , snake_case_ )['''sample'''] else: lowerCAmelCase = self.unet(snake_case_ , snake_case_ )['''sample'''] if isinstance(self.scheduler , snake_case_ ): lowerCAmelCase = self.scheduler.step( model_output=snake_case_ , timestep=snake_case_ , sample=snake_case_ , eta=snake_case_ , generator=snake_case_ , )['''prev_sample'''] else: lowerCAmelCase = self.scheduler.step( model_output=snake_case_ , timestep=snake_case_ , sample=snake_case_ , generator=snake_case_ , )['''prev_sample'''] if mask is not None: if mask_start > 0: lowerCAmelCase = mask[:, step, :, :mask_start] if mask_end > 0: lowerCAmelCase = mask[:, step, :, -mask_end:] if self.vqvae is not None: # 0.18215 was scaling factor used in training to ensure unit variance lowerCAmelCase = 1 / self.vqvae.config.scaling_factor * images lowerCAmelCase = self.vqvae.decode(snake_case_ )['''sample'''] lowerCAmelCase = (images / 2 + 0.5).clamp(0 , 1 ) lowerCAmelCase = images.cpu().permute(0 , 2 , 3 , 1 ).numpy() lowerCAmelCase = (images * 2_5_5).round().astype('uint8' ) lowerCAmelCase = list( (Image.fromarray(_[:, :, 0] ) for _ in images) if images.shape[3] == 1 else (Image.fromarray(snake_case_ , mode='RGB' ).convert('L' ) for _ in images) ) lowerCAmelCase = [self.mel.image_to_audio(snake_case_ ) for _ in images] if not return_dict: return images, (self.mel.get_sample_rate(), audios) return BaseOutput(**AudioPipelineOutput(np.array(snake_case_ )[:, np.newaxis, :] ) , **ImagePipelineOutput(snake_case_ ) ) @torch.no_grad() def __UpperCAmelCase ( self : int , UpperCAmelCase__ : List[Image.Image] , UpperCAmelCase__ : int = 5_0 ) -> Optional[Any]: assert isinstance(self.scheduler , snake_case_ ) self.scheduler.set_timesteps(snake_case_ ) lowerCAmelCase = np.array( [np.frombuffer(image.tobytes() , dtype='uint8' ).reshape((1, image.height, image.width) ) for image in images] ) lowerCAmelCase = (sample / 2_5_5) * 2 - 1 lowerCAmelCase = torch.Tensor(snake_case_ ).to(self.device ) for t in self.progress_bar(torch.flip(self.scheduler.timesteps , (0,) ) ): lowerCAmelCase = t - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps lowerCAmelCase = self.scheduler.alphas_cumprod[t] lowerCAmelCase = ( self.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.scheduler.final_alpha_cumprod ) lowerCAmelCase = 1 - alpha_prod_t lowerCAmelCase = self.unet(snake_case_ , snake_case_ )['''sample'''] lowerCAmelCase = (1 - alpha_prod_t_prev) ** 0.5 * model_output lowerCAmelCase = (sample - pred_sample_direction) * alpha_prod_t_prev ** (-0.5) lowerCAmelCase = sample * alpha_prod_t ** 0.5 + beta_prod_t ** 0.5 * model_output return sample @staticmethod def __UpperCAmelCase ( UpperCAmelCase__ : torch.Tensor , UpperCAmelCase__ : torch.Tensor , UpperCAmelCase__ : float ) -> Optional[Any]: lowerCAmelCase = acos(torch.dot(torch.flatten(snake_case_ ) , torch.flatten(snake_case_ ) ) / torch.norm(snake_case_ ) / torch.norm(snake_case_ ) ) return sin((1 - alpha) * theta ) * xa / sin(snake_case_ ) + sin(alpha * theta ) * xa / sin(snake_case_ )
351
'''simple docstring''' import unittest from transformers import AutoTokenizer, FalconConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( FalconForCausalLM, FalconForQuestionAnswering, FalconForSequenceClassification, FalconForTokenClassification, FalconModel, ) class UpperCAmelCase_ : def __init__( self : List[str] , UpperCAmelCase__ : Any , UpperCAmelCase__ : int=3 , UpperCAmelCase__ : Optional[Any]=7 , UpperCAmelCase__ : List[str]=True , UpperCAmelCase__ : Optional[Any]=True , UpperCAmelCase__ : Tuple=False , UpperCAmelCase__ : List[Any]=True , UpperCAmelCase__ : List[str]=9_9 , UpperCAmelCase__ : Tuple=3_2 , UpperCAmelCase__ : str=5 , UpperCAmelCase__ : List[Any]=4 , UpperCAmelCase__ : Any=3_7 , UpperCAmelCase__ : int="gelu" , UpperCAmelCase__ : Optional[Any]=0.1 , UpperCAmelCase__ : List[Any]=0.1 , UpperCAmelCase__ : Dict=5_1_2 , UpperCAmelCase__ : Dict=1_6 , UpperCAmelCase__ : Optional[Any]=2 , UpperCAmelCase__ : Dict=0.02 , UpperCAmelCase__ : Union[str, Any]=3 , UpperCAmelCase__ : List[Any]=4 , UpperCAmelCase__ : List[str]=None , ) -> str: 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 = 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 __UpperCAmelCase ( self : Any ) -> List[str]: lowerCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) lowerCAmelCase = None if self.use_input_mask: lowerCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) lowerCAmelCase = None lowerCAmelCase = None lowerCAmelCase = None 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 __UpperCAmelCase ( self : Optional[Any] ) -> List[str]: return FalconConfig( vocab_size=self.vocab_size , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , type_vocab_size=self.type_vocab_size , is_decoder=UpperCAmelCase__ , initializer_range=self.initializer_range , pad_token_id=1 , new_decoder_architecture=UpperCAmelCase__ , ) def __UpperCAmelCase ( self : Any , UpperCAmelCase__ : Tuple , UpperCAmelCase__ : Tuple , UpperCAmelCase__ : Any , UpperCAmelCase__ : Tuple , UpperCAmelCase__ : int , UpperCAmelCase__ : str , UpperCAmelCase__ : str ) -> int: lowerCAmelCase = FalconModel(config=UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() lowerCAmelCase = model(UpperCAmelCase__ , attention_mask=UpperCAmelCase__ ) lowerCAmelCase = model(UpperCAmelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def __UpperCAmelCase ( self : Union[str, Any] , UpperCAmelCase__ : str , UpperCAmelCase__ : Optional[int] , UpperCAmelCase__ : Optional[Any] , UpperCAmelCase__ : int , UpperCAmelCase__ : Tuple , UpperCAmelCase__ : List[Any] , UpperCAmelCase__ : int , UpperCAmelCase__ : Tuple , UpperCAmelCase__ : List[Any] , ) -> Tuple: lowerCAmelCase = True lowerCAmelCase = FalconModel(UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() lowerCAmelCase = model( UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , encoder_hidden_states=UpperCAmelCase__ , encoder_attention_mask=UpperCAmelCase__ , ) lowerCAmelCase = model( UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , encoder_hidden_states=UpperCAmelCase__ , ) lowerCAmelCase = model(UpperCAmelCase__ , attention_mask=UpperCAmelCase__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def __UpperCAmelCase ( self : Tuple , UpperCAmelCase__ : List[Any] , UpperCAmelCase__ : List[Any] , UpperCAmelCase__ : Union[str, Any] , UpperCAmelCase__ : Optional[int] , UpperCAmelCase__ : List[Any] , UpperCAmelCase__ : Union[str, Any] , UpperCAmelCase__ : Optional[int] , UpperCAmelCase__ : Dict , UpperCAmelCase__ : List[str] , ) -> List[str]: lowerCAmelCase = FalconForCausalLM(config=UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() lowerCAmelCase = model(UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , labels=UpperCAmelCase__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def __UpperCAmelCase ( self : Optional[int] , UpperCAmelCase__ : str , UpperCAmelCase__ : Optional[Any] , UpperCAmelCase__ : Union[str, Any] , UpperCAmelCase__ : str , UpperCAmelCase__ : Union[str, Any] , UpperCAmelCase__ : str , UpperCAmelCase__ : Any , UpperCAmelCase__ : Tuple , UpperCAmelCase__ : Optional[Any] , ) -> List[str]: lowerCAmelCase = True lowerCAmelCase = True lowerCAmelCase = FalconForCausalLM(config=UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() # first forward pass lowerCAmelCase = model( UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , encoder_hidden_states=UpperCAmelCase__ , encoder_attention_mask=UpperCAmelCase__ , use_cache=UpperCAmelCase__ , ) lowerCAmelCase = outputs.past_key_values # create hypothetical multiple next token and extent to next_input_ids lowerCAmelCase = ids_tensor((self.batch_size, 3) , config.vocab_size ) lowerCAmelCase = ids_tensor((self.batch_size, 3) , vocab_size=2 ) # append to next input_ids and lowerCAmelCase = torch.cat([input_ids, next_tokens] , dim=-1 ) lowerCAmelCase = torch.cat([input_mask, next_mask] , dim=-1 ) lowerCAmelCase = model( UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , encoder_hidden_states=UpperCAmelCase__ , encoder_attention_mask=UpperCAmelCase__ , output_hidden_states=UpperCAmelCase__ , )['hidden_states'][0] lowerCAmelCase = model( UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , encoder_hidden_states=UpperCAmelCase__ , encoder_attention_mask=UpperCAmelCase__ , past_key_values=UpperCAmelCase__ , output_hidden_states=UpperCAmelCase__ , )['hidden_states'][0] # select random slice lowerCAmelCase = ids_tensor((1,) , output_from_past.shape[-1] ).item() lowerCAmelCase = output_from_no_past[:, -3:, random_slice_idx].detach() lowerCAmelCase = output_from_past[:, :, random_slice_idx].detach() self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] ) # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(UpperCAmelCase__ , UpperCAmelCase__ , atol=1E-3 ) ) def __UpperCAmelCase ( self : Tuple ) -> List[str]: lowerCAmelCase = self.prepare_config_and_inputs() ( ( lowerCAmelCase ) , ( lowerCAmelCase ) , ( lowerCAmelCase ) , ( lowerCAmelCase ) , ( lowerCAmelCase ) , ( lowerCAmelCase ) , ( lowerCAmelCase ) , ) = config_and_inputs lowerCAmelCase = {'input_ids': input_ids, 'attention_mask': input_mask} return config, inputs_dict @require_torch class UpperCAmelCase_ ( __lowercase , __lowercase , __lowercase , unittest.TestCase ): lowerCamelCase : Tuple = ( ( FalconModel, FalconForCausalLM, FalconForSequenceClassification, FalconForTokenClassification, FalconForQuestionAnswering, ) if is_torch_available() else () ) lowerCamelCase : Dict = (FalconForCausalLM,) if is_torch_available() else () lowerCamelCase : int = ( { '''feature-extraction''': FalconModel, '''text-classification''': FalconForSequenceClassification, '''text-generation''': FalconForCausalLM, '''question-answering''': FalconForQuestionAnswering, '''token-classification''': FalconForTokenClassification, '''zero-shot''': FalconForSequenceClassification, } if is_torch_available() else {} ) lowerCamelCase : int = False lowerCamelCase : Union[str, Any] = False def __UpperCAmelCase ( self : Any ) -> Optional[Any]: lowerCAmelCase = FalconModelTester(self ) lowerCAmelCase = ConfigTester(self , config_class=UpperCAmelCase__ , hidden_size=3_7 ) def __UpperCAmelCase ( self : Optional[int] ) -> Optional[Any]: self.config_tester.run_common_tests() def __UpperCAmelCase ( self : Any ) -> Tuple: lowerCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*UpperCAmelCase__ ) def __UpperCAmelCase ( self : str ) -> Tuple: lowerCAmelCase , *lowerCAmelCase = self.model_tester.prepare_config_and_inputs() for alibi in [True, False]: lowerCAmelCase = alibi self.model_tester.create_and_check_model(UpperCAmelCase__ , *UpperCAmelCase__ ) def __UpperCAmelCase ( self : Union[str, Any] ) -> Union[str, Any]: lowerCAmelCase , lowerCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() lowerCAmelCase = 3 lowerCAmelCase = input_dict['input_ids'] lowerCAmelCase = input_ids.ne(1 ).to(UpperCAmelCase__ ) lowerCAmelCase = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) lowerCAmelCase = FalconForSequenceClassification(UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() lowerCAmelCase = model(UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , labels=UpperCAmelCase__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def __UpperCAmelCase ( self : Any ) -> Dict: lowerCAmelCase , lowerCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() lowerCAmelCase = 3 lowerCAmelCase = 'single_label_classification' lowerCAmelCase = input_dict['input_ids'] lowerCAmelCase = input_ids.ne(1 ).to(UpperCAmelCase__ ) lowerCAmelCase = ids_tensor([self.model_tester.batch_size] , self.model_tester.type_sequence_label_size ) lowerCAmelCase = FalconForSequenceClassification(UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() lowerCAmelCase = model(UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , labels=UpperCAmelCase__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def __UpperCAmelCase ( self : Tuple ) -> int: lowerCAmelCase , lowerCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() lowerCAmelCase = input_dict['input_ids'] lowerCAmelCase = FalconForCausalLM(UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() lowerCAmelCase = model(UpperCAmelCase__ , use_cache=UpperCAmelCase__ ) lowerCAmelCase = input_ids.shape[0] lowerCAmelCase = model._convert_to_rw_cache(result.past_key_values ) lowerCAmelCase = model._convert_cache_to_standard_format(UpperCAmelCase__ , UpperCAmelCase__ ) for layer in range(len(UpperCAmelCase__ ) ): for tensor_idx in range(2 ): self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3 ) self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4 ) self.assertTrue( torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx] ) ) def __UpperCAmelCase ( self : Any ) -> List[Any]: lowerCAmelCase , lowerCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() lowerCAmelCase = 3 lowerCAmelCase = 'multi_label_classification' lowerCAmelCase = input_dict['input_ids'] lowerCAmelCase = input_ids.ne(1 ).to(UpperCAmelCase__ ) lowerCAmelCase = ids_tensor( [self.model_tester.batch_size, config.num_labels] , self.model_tester.type_sequence_label_size ).to(torch.float ) lowerCAmelCase = FalconForSequenceClassification(UpperCAmelCase__ ) model.to(UpperCAmelCase__ ) model.eval() lowerCAmelCase = model(UpperCAmelCase__ , attention_mask=UpperCAmelCase__ , labels=UpperCAmelCase__ ) self.assertEqual(result.logits.shape , (self.model_tester.batch_size, self.model_tester.num_labels) ) def __UpperCAmelCase ( self : List[str] ) -> Union[str, Any]: # Falcon can have different numbers of KV-heads than the number of query heads, so we need # to override this test to use the right head counts. for model_class in self.all_generative_model_classes: lowerCAmelCase , lowerCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() # If it doesn't support cache, pass the test if not hasattr(UpperCAmelCase__ , 'use_cache' ): return lowerCAmelCase = model_class(UpperCAmelCase__ ).to(UpperCAmelCase__ ) if "use_cache" not in inputs: lowerCAmelCase = True lowerCAmelCase = model(**UpperCAmelCase__ ) # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format) if "past_key_values" not in outputs: return lowerCAmelCase = ( getattr(UpperCAmelCase__ , 'decoder_layers' , UpperCAmelCase__ ) or getattr(UpperCAmelCase__ , 'num_decoder_layers' , UpperCAmelCase__ ) or config.num_hidden_layers ) lowerCAmelCase = getattr(UpperCAmelCase__ , 'num_kv_heads' , config.num_attention_heads ) lowerCAmelCase = getattr(UpperCAmelCase__ , 'd_model' , config.hidden_size ) lowerCAmelCase = embed_dim // num_attention_heads lowerCAmelCase = outputs['past_key_values'] self.assertEqual(len(UpperCAmelCase__ ) , UpperCAmelCase__ ) lowerCAmelCase , lowerCAmelCase = inputs['input_ids'].shape for i in range(UpperCAmelCase__ ): if config.new_decoder_architecture: lowerCAmelCase = config.num_attention_heads elif config.multi_query: lowerCAmelCase = 1 self.assertEqual(len(past_kv[0] ) , 2 ) # K V for the decoder = 2 self.assertEqual( past_kv[i][0].shape , (batch_size, num_attention_heads, seq_length, per_head_embed_dim) ) self.assertEqual( past_kv[i][1].shape , (batch_size, num_attention_heads, seq_length, per_head_embed_dim) ) @require_torch class UpperCAmelCase_ ( unittest.TestCase ): @slow def __UpperCAmelCase ( self : List[str] ) -> Dict: lowerCAmelCase = AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b' ) lowerCAmelCase = FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b' ) model.eval() model.to(UpperCAmelCase__ ) lowerCAmelCase = tokenizer('My favorite food is' , return_tensors='pt' ).to(UpperCAmelCase__ ) lowerCAmelCase = ( 'My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.' ) lowerCAmelCase = model.generate(**UpperCAmelCase__ , do_sample=UpperCAmelCase__ , max_new_tokens=1_9 ) lowerCAmelCase = tokenizer.batch_decode(UpperCAmelCase__ )[0] self.assertEqual(UpperCAmelCase__ , UpperCAmelCase__ ) @slow def __UpperCAmelCase ( self : Optional[int] ) -> Dict: # The big models are way too big for the CI, so we use tiny random models that resemble their # architectures but with much smaller and fewer layers for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]: lowerCAmelCase = AutoTokenizer.from_pretrained(UpperCAmelCase__ ) lowerCAmelCase = FalconForCausalLM.from_pretrained(UpperCAmelCase__ ) model.eval() model.to(UpperCAmelCase__ ) lowerCAmelCase = tokenizer('My favorite food is' , return_tensors='pt' ).to(UpperCAmelCase__ ) # We just test that these run without errors - the models are randomly initialized # and so the actual text outputs will be garbage model.generate(**UpperCAmelCase__ , do_sample=UpperCAmelCase__ , max_new_tokens=4 ) model.generate(**UpperCAmelCase__ , do_sample=UpperCAmelCase__ , max_new_tokens=4 ) model.generate(**UpperCAmelCase__ , num_beams=2 , max_new_tokens=4 ) @slow def __UpperCAmelCase ( self : Optional[int] ) -> Dict: # The big models are way too big for the CI, so we use tiny random models that resemble their # architectures but with much smaller and fewer layers with torch.no_grad(): for repo in [ "Rocketknight1/falcon-rw-1b", "Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b", ]: lowerCAmelCase = AutoTokenizer.from_pretrained(UpperCAmelCase__ ) lowerCAmelCase = FalconForCausalLM.from_pretrained(UpperCAmelCase__ ) model.eval() model.to(device=UpperCAmelCase__ ) lowerCAmelCase = tokenizer('My favorite food is' , return_tensors='pt' ).to(UpperCAmelCase__ ) # Test results are the same with and without cache lowerCAmelCase = model.generate(**UpperCAmelCase__ , do_sample=UpperCAmelCase__ , max_new_tokens=2_0 , use_cache=UpperCAmelCase__ ) lowerCAmelCase = model.generate(**UpperCAmelCase__ , do_sample=UpperCAmelCase__ , max_new_tokens=2_0 , use_cache=UpperCAmelCase__ ) self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0 )
55
0
'''simple docstring''' from math import pow def __UpperCamelCase ( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , UpperCAmelCase , ): if current_sum == needed_sum: # If the sum of the powers is equal to needed_sum, then we have a solution. solutions_count += 1 return current_sum, solutions_count lowercase__ : Optional[Any] = int(pow(UpperCAmelCase , UpperCAmelCase ) ) if current_sum + i_to_n <= needed_sum: # If the sum of the powers is less than needed_sum, then continue adding powers. current_sum += i_to_n lowercase__ , lowercase__ : Dict = backtrack( UpperCAmelCase , UpperCAmelCase , current_number + 1 , UpperCAmelCase , UpperCAmelCase ) current_sum -= i_to_n if i_to_n < needed_sum: # If the power of i is less than needed_sum, then try with the next power. lowercase__ , lowercase__ : str = backtrack( UpperCAmelCase , UpperCAmelCase , current_number + 1 , UpperCAmelCase , UpperCAmelCase ) return current_sum, solutions_count def __UpperCamelCase ( UpperCAmelCase , UpperCAmelCase ): if not (1 <= needed_sum <= 1000 and 2 <= power <= 10): raise ValueError( '''Invalid input\n''' '''needed_sum must be between 1 and 1000, power between 2 and 10.''' ) return backtrack(UpperCAmelCase , UpperCAmelCase , 1 , 0 , 0 )[1] # Return the solutions_count if __name__ == "__main__": import doctest doctest.testmod()
198
'''simple docstring''' import copy from ...configuration_utils import PretrainedConfig from ...utils import logging __a: List[str] = logging.get_logger(__name__) class UpperCAmelCase ( a__ ): '''simple docstring''' SCREAMING_SNAKE_CASE = "encoder-decoder" SCREAMING_SNAKE_CASE = True def __init__( self , **__lowerCAmelCase ) -> int: super().__init__(**__lowerCAmelCase ) assert ( "encoder" in kwargs and "decoder" in kwargs ), "Config has to be initialized with encoder and decoder config" lowercase__ : Optional[int] = kwargs.pop('''encoder''' ) lowercase__ : Union[str, Any] = encoder_config.pop('''model_type''' ) lowercase__ : Any = kwargs.pop('''decoder''' ) lowercase__ : Any = decoder_config.pop('''model_type''' ) from ..auto.configuration_auto import AutoConfig lowercase__ : Union[str, Any] = AutoConfig.for_model(__lowerCAmelCase , **__lowerCAmelCase ) lowercase__ : Optional[Any] = AutoConfig.for_model(__lowerCAmelCase , **__lowerCAmelCase ) lowercase__ : Tuple = True @classmethod def _lowerCAmelCase( cls , __lowerCAmelCase , __lowerCAmelCase , **__lowerCAmelCase ) -> PretrainedConfig: logger.info('''Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config''' ) lowercase__ : Union[str, Any] = True lowercase__ : Any = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **__lowerCAmelCase ) def _lowerCAmelCase( self ) -> Any: lowercase__ : Any = copy.deepcopy(self.__dict__ ) lowercase__ : Optional[Any] = self.encoder.to_dict() lowercase__ : Tuple = self.decoder.to_dict() lowercase__ : Dict = self.__class__.model_type return output
198
1
"""simple docstring""" from typing import Union from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_vision_available(): from PIL import Image from ..image_utils import load_image if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING SCREAMING_SNAKE_CASE__:str = logging.get_logger(__name__) @add_end_docstrings(lowercase__ ) class snake_case__ ( lowercase__ ): def __init__( self , *lowerCamelCase , **lowerCamelCase ): super().__init__(*_UpperCamelCase , **_UpperCamelCase ) self.check_model_type(_UpperCamelCase ) def a__ ( self , lowerCamelCase=None , lowerCamelCase=None , lowerCamelCase=None , **lowerCamelCase ): __a = {}, {} if padding is not None: __a = padding if truncation is not None: __a = truncation if top_k is not None: __a = top_k return preprocess_params, {}, postprocess_params def __call__( self , lowerCamelCase , lowerCamelCase = None , **lowerCamelCase ): if isinstance(_UpperCamelCase , (Image.Image, str) ) and isinstance(_UpperCamelCase , _UpperCamelCase ): __a = {"""image""": image, """question""": question} else: __a = image __a = super().__call__(_UpperCamelCase , **_UpperCamelCase ) return results def a__ ( self , lowerCamelCase , lowerCamelCase=False , lowerCamelCase=False ): __a = load_image(inputs["image"] ) __a = self.tokenizer( inputs["question"] , return_tensors=self.framework , padding=_UpperCamelCase , truncation=_UpperCamelCase ) __a = self.image_processor(images=_UpperCamelCase , return_tensors=self.framework ) model_inputs.update(_UpperCamelCase ) return model_inputs def a__ ( self , lowerCamelCase ): __a = self.model(**_UpperCamelCase ) return model_outputs def a__ ( self , lowerCamelCase , lowerCamelCase=5 ): if top_k > self.model.config.num_labels: __a = self.model.config.num_labels if self.framework == "pt": __a = model_outputs.logits.sigmoid()[0] __a = probs.topk(_UpperCamelCase ) else: raise ValueError(F"Unsupported framework: {self.framework}" ) __a = scores.tolist() __a = ids.tolist() return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(_UpperCamelCase , _UpperCamelCase )]
358
"""simple docstring""" from ..utils import DummyObject, requires_backends class snake_case__ ( metaclass=snake_case_ ): _snake_case : Union[str, Any] = ["""onnx"""] def __init__( self , *lowerCamelCase , **lowerCamelCase ): requires_backends(self , ["onnx"] ) @classmethod def a__ ( cls , *lowerCamelCase , **lowerCamelCase ): requires_backends(cls , ["onnx"] ) @classmethod def a__ ( cls , *lowerCamelCase , **lowerCamelCase ): requires_backends(cls , ["onnx"] )
268
0
import unittest import numpy as np from transformers.testing_utils import require_torch, require_vision 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 ViTImageProcessor class lowercase__ ( unittest.TestCase): def __init__( self : Optional[Any] , UpperCamelCase__ : Dict , UpperCamelCase__ : List[Any]=13 , UpperCamelCase__ : Any=3 , UpperCamelCase__ : Union[str, Any]=224 , UpperCamelCase__ : List[Any]=30 , UpperCamelCase__ : int=400 , UpperCamelCase__ : Optional[Any]=True , UpperCamelCase__ : str=None , UpperCamelCase__ : Union[str, Any]=True , UpperCamelCase__ : Any=[0.5, 0.5, 0.5] , UpperCamelCase__ : Any=[0.5, 0.5, 0.5] , ): '''simple docstring''' SCREAMING_SNAKE_CASE : str = size if size is not None else {'''height''': 18, '''width''': 18} SCREAMING_SNAKE_CASE : List[str] = parent SCREAMING_SNAKE_CASE : Union[str, Any] = batch_size SCREAMING_SNAKE_CASE : str = num_channels SCREAMING_SNAKE_CASE : Tuple = image_size SCREAMING_SNAKE_CASE : Dict = min_resolution SCREAMING_SNAKE_CASE : Dict = max_resolution SCREAMING_SNAKE_CASE : str = do_resize SCREAMING_SNAKE_CASE : Union[str, Any] = size SCREAMING_SNAKE_CASE : int = do_normalize SCREAMING_SNAKE_CASE : Optional[int] = image_mean SCREAMING_SNAKE_CASE : Optional[Any] = image_std def __A ( self : Union[str, Any] ): '''simple docstring''' return { "image_mean": self.image_mean, "image_std": self.image_std, "do_normalize": self.do_normalize, "do_resize": self.do_resize, "size": self.size, } @require_torch @require_vision class lowercase__ ( UpperCamelCase_ , unittest.TestCase): UpperCamelCase_ = ViTImageProcessor if is_vision_available() else None def __A ( self : Tuple ): '''simple docstring''' SCREAMING_SNAKE_CASE : Optional[Any] = EfficientFormerImageProcessorTester(self ) @property def __A ( self : Union[str, Any] ): '''simple docstring''' return self.image_proc_tester.prepare_image_processor_dict() def __A ( self : Dict ): '''simple docstring''' SCREAMING_SNAKE_CASE : Union[str, Any] = 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 __A ( self : Dict ): '''simple docstring''' pass def __A ( self : Optional[int] ): '''simple docstring''' SCREAMING_SNAKE_CASE : str = self.image_processing_class(**self.image_processor_dict ) # create random PIL images SCREAMING_SNAKE_CASE : Union[str, Any] = prepare_image_inputs(self.image_proc_tester , equal_resolution=UpperCamelCase__ ) for image in image_inputs: self.assertIsInstance(UpperCamelCase__ , Image.Image ) # Test not batched input SCREAMING_SNAKE_CASE : Dict = image_processor(image_inputs[0] , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['''height'''], self.image_proc_tester.size['''width'''], ) , ) # Test batched SCREAMING_SNAKE_CASE : int = image_processor(UpperCamelCase__ , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['''height'''], self.image_proc_tester.size['''width'''], ) , ) def __A ( self : Optional[Any] ): '''simple docstring''' SCREAMING_SNAKE_CASE : Optional[int] = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors SCREAMING_SNAKE_CASE : List[Any] = prepare_image_inputs(self.image_proc_tester , equal_resolution=UpperCamelCase__ , numpify=UpperCamelCase__ ) for image in image_inputs: self.assertIsInstance(UpperCamelCase__ , np.ndarray ) # Test not batched input SCREAMING_SNAKE_CASE : Optional[int] = image_processor(image_inputs[0] , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['''height'''], self.image_proc_tester.size['''width'''], ) , ) # Test batched SCREAMING_SNAKE_CASE : Union[str, Any] = image_processor(UpperCamelCase__ , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['''height'''], self.image_proc_tester.size['''width'''], ) , ) def __A ( self : int ): '''simple docstring''' SCREAMING_SNAKE_CASE : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors SCREAMING_SNAKE_CASE : Any = prepare_image_inputs(self.image_proc_tester , equal_resolution=UpperCamelCase__ , torchify=UpperCamelCase__ ) for image in image_inputs: self.assertIsInstance(UpperCamelCase__ , torch.Tensor ) # Test not batched input SCREAMING_SNAKE_CASE : Optional[Any] = image_processor(image_inputs[0] , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_images.shape , ( 1, self.image_proc_tester.num_channels, self.image_proc_tester.size['''height'''], self.image_proc_tester.size['''width'''], ) , ) # Test batched SCREAMING_SNAKE_CASE : int = image_processor(UpperCamelCase__ , return_tensors='''pt''' ).pixel_values self.assertEqual( encoded_images.shape , ( self.image_proc_tester.batch_size, self.image_proc_tester.num_channels, self.image_proc_tester.size['''height'''], self.image_proc_tester.size['''width'''], ) , )
182
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available __UpperCamelCase : int = {'configuration_yolos': ['YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP', 'YolosConfig', 'YolosOnnxConfig']} try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCamelCase : int = ['YolosFeatureExtractor'] __UpperCamelCase : Union[str, Any] = ['YolosImageProcessor'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCamelCase : str = [ 'YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST', 'YolosForObjectDetection', 'YolosModel', 'YolosPreTrainedModel', ] if TYPE_CHECKING: from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_yolos import YolosFeatureExtractor from .image_processing_yolos import YolosImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_yolos import ( YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST, YolosForObjectDetection, YolosModel, YolosPreTrainedModel, ) else: import sys __UpperCamelCase : int = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
182
1
"""simple docstring""" import argparse import shutil from pathlib import Path from tqdm import tqdm from transformers import AutoTokenizer def a__ ( SCREAMING_SNAKE_CASE : List[Any] , SCREAMING_SNAKE_CASE : Any , SCREAMING_SNAKE_CASE : str , SCREAMING_SNAKE_CASE : Dict=1_0_2_4 ): '''simple docstring''' lowerCAmelCase : Any = [], [] lowerCAmelCase : List[Any] = list(zip(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) ) lowerCAmelCase : Optional[int] = sorted_examples[0] def is_too_big(SCREAMING_SNAKE_CASE : int ): return tok(SCREAMING_SNAKE_CASE , return_tensors="pt" ).input_ids.shape[1] > max_tokens for src, tgt in tqdm(sorted_examples[1:] ): lowerCAmelCase : Union[str, Any] = new_src + " " + src lowerCAmelCase : List[Any] = new_tgt + " " + tgt if is_too_big(SCREAMING_SNAKE_CASE ) or is_too_big(SCREAMING_SNAKE_CASE ): # cant fit, finalize example finished_src.append(SCREAMING_SNAKE_CASE ) finished_tgt.append(SCREAMING_SNAKE_CASE ) lowerCAmelCase : List[str] = src, tgt else: # can fit, keep adding lowerCAmelCase : List[Any] = cand_src, cand_tgt # cleanup if new_src: assert new_tgt finished_src.append(SCREAMING_SNAKE_CASE ) finished_tgt.append(SCREAMING_SNAKE_CASE ) return finished_src, finished_tgt def a__ ( SCREAMING_SNAKE_CASE : Tuple , SCREAMING_SNAKE_CASE : Path , SCREAMING_SNAKE_CASE : Union[str, Any] , SCREAMING_SNAKE_CASE : int ): '''simple docstring''' lowerCAmelCase : Union[str, Any] = Path(SCREAMING_SNAKE_CASE ) save_path.mkdir(exist_ok=SCREAMING_SNAKE_CASE ) for split in ["train"]: lowerCAmelCase : List[Any] = data_dir / f"""{split}.source""", data_dir / f"""{split}.target""" lowerCAmelCase : List[str] = [x.rstrip() for x in Path(SCREAMING_SNAKE_CASE ).open().readlines()] lowerCAmelCase : int = [x.rstrip() for x in Path(SCREAMING_SNAKE_CASE ).open().readlines()] lowerCAmelCase : List[str] = pack_examples(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE ) print(f"""packed {split} split from {len(SCREAMING_SNAKE_CASE )} examples -> {len(SCREAMING_SNAKE_CASE )}.""" ) Path(save_path / f"""{split}.source""" ).open("w" ).write("\n".join(SCREAMING_SNAKE_CASE ) ) Path(save_path / f"""{split}.target""" ).open("w" ).write("\n".join(SCREAMING_SNAKE_CASE ) ) for split in ["val", "test"]: lowerCAmelCase : Union[str, Any] = data_dir / f"""{split}.source""", data_dir / f"""{split}.target""" shutil.copyfile(SCREAMING_SNAKE_CASE , save_path / f"""{split}.source""" ) shutil.copyfile(SCREAMING_SNAKE_CASE , save_path / f"""{split}.target""" ) def a__ ( ): '''simple docstring''' lowerCAmelCase : List[str] = argparse.ArgumentParser() parser.add_argument("--tok_name" , type=SCREAMING_SNAKE_CASE , help="like facebook/bart-large-cnn,t5-base, etc." ) parser.add_argument("--max_seq_len" , type=SCREAMING_SNAKE_CASE , default=1_2_8 ) parser.add_argument("--data_dir" , type=SCREAMING_SNAKE_CASE ) parser.add_argument("--save_path" , type=SCREAMING_SNAKE_CASE ) lowerCAmelCase : str = parser.parse_args() lowerCAmelCase : str = AutoTokenizer.from_pretrained(args.tok_name ) return pack_data_dir(SCREAMING_SNAKE_CASE , Path(args.data_dir ) , args.max_seq_len , args.save_path ) if __name__ == "__main__": packer_cli()
357
"""simple docstring""" from typing import List, Optional from ...configuration_utils import PretrainedConfig from ...utils import logging lowerCAmelCase__ = logging.get_logger(__name__) lowerCAmelCase__ = { '''huggingface/autoformer-tourism-monthly''': '''https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json''', } class SCREAMING_SNAKE_CASE__ ( lowercase ): """simple docstring""" a : Dict ="autoformer" a : Dict ={ "hidden_size": "d_model", "num_attention_heads": "encoder_attention_heads", "num_hidden_layers": "encoder_layers", } def __init__( self , snake_case__ = None , snake_case__ = None , snake_case__ = "student_t" , snake_case__ = "nll" , snake_case__ = 1 , snake_case__ = [1, 2, 3, 4, 5, 6, 7] , snake_case__ = True , snake_case__ = 0 , snake_case__ = 0 , snake_case__ = 0 , snake_case__ = 0 , snake_case__ = None , snake_case__ = None , snake_case__ = 64 , snake_case__ = 2 , snake_case__ = 2 , snake_case__ = 2 , snake_case__ = 2 , snake_case__ = 32 , snake_case__ = 32 , snake_case__ = "gelu" , snake_case__ = 0.1 , snake_case__ = 0.1 , snake_case__ = 0.1 , snake_case__ = 0.1 , snake_case__ = 0.1 , snake_case__ = 100 , snake_case__ = 0.02 , snake_case__ = True , snake_case__=True , snake_case__ = 10 , snake_case__ = 25 , snake_case__ = 3 , **snake_case__ , ): """simple docstring""" lowerCAmelCase : Any = prediction_length lowerCAmelCase : Dict = context_length if context_length is not None else prediction_length lowerCAmelCase : Tuple = distribution_output lowerCAmelCase : List[Any] = loss lowerCAmelCase : int = input_size lowerCAmelCase : str = num_time_features lowerCAmelCase : str = lags_sequence lowerCAmelCase : List[str] = scaling lowerCAmelCase : List[Any] = num_dynamic_real_features lowerCAmelCase : Tuple = num_static_real_features lowerCAmelCase : Dict = num_static_categorical_features if cardinality is not None and num_static_categorical_features > 0: if len(snake_case__ ) != num_static_categorical_features: raise ValueError( "The cardinality should be a list of the same length as `num_static_categorical_features`" ) lowerCAmelCase : Any = cardinality else: lowerCAmelCase : Union[str, Any] = [0] if embedding_dimension is not None and num_static_categorical_features > 0: if len(snake_case__ ) != num_static_categorical_features: raise ValueError( "The embedding dimension should be a list of the same length as `num_static_categorical_features`" ) lowerCAmelCase : Tuple = embedding_dimension else: lowerCAmelCase : Any = [min(50 , (cat + 1) // 2 ) for cat in self.cardinality] lowerCAmelCase : Any = num_parallel_samples # Transformer architecture configuration lowerCAmelCase : str = input_size * len(self.lags_sequence ) + self._number_of_features lowerCAmelCase : Any = d_model lowerCAmelCase : List[str] = encoder_attention_heads lowerCAmelCase : Union[str, Any] = decoder_attention_heads lowerCAmelCase : Optional[int] = encoder_ffn_dim lowerCAmelCase : Optional[Any] = decoder_ffn_dim lowerCAmelCase : int = encoder_layers lowerCAmelCase : int = decoder_layers lowerCAmelCase : List[Any] = dropout lowerCAmelCase : Optional[int] = attention_dropout lowerCAmelCase : Union[str, Any] = activation_dropout lowerCAmelCase : Optional[int] = encoder_layerdrop lowerCAmelCase : Dict = decoder_layerdrop lowerCAmelCase : Tuple = activation_function lowerCAmelCase : Optional[Any] = init_std lowerCAmelCase : List[Any] = use_cache # Autoformer lowerCAmelCase : Any = label_length lowerCAmelCase : Any = moving_average lowerCAmelCase : Optional[Any] = autocorrelation_factor super().__init__(is_encoder_decoder=snake_case__ , **snake_case__ ) @property def lowercase__ ( self ): """simple docstring""" return ( sum(self.embedding_dimension ) + self.num_dynamic_real_features + self.num_time_features + self.num_static_real_features + self.input_size * 2 # the log1p(abs(loc)) and log(scale) features )
133
0
import argparse import fairseq import torch from torch import nn from transformers import ( MBartaaTokenizer, MBartConfig, MBartForCausalLM, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel, WavaVecaConfig, WavaVecaFeatureExtractor, WavaVecaModel, logging, ) logging.set_verbosity_info() lowerCAmelCase__ :List[Any] = logging.get_logger(__name__) lowerCAmelCase__ :Optional[Any] = { '''post_extract_proj''': '''feature_projection.projection''', '''encoder.pos_conv.0''': '''encoder.pos_conv_embed.conv''', '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''', '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''', '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''', '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''', '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''', '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''', '''fc2''': '''encoder.layers.*.feed_forward.output_dense''', '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''', '''encoder.layer_norm''': '''encoder.layer_norm''', '''w2v_model.layer_norm''': '''feature_projection.layer_norm''', '''quantizer.weight_proj''': '''quantizer.weight_proj''', '''quantizer.vars''': '''quantizer.codevectors''', '''project_q''': '''project_q''', '''final_proj''': '''project_hid''', '''w2v_encoder.proj''': '''lm_head''', '''mask_emb''': '''masked_spec_embed''', } lowerCAmelCase__ :Optional[int] = [ '''lm_head''', '''quantizer.weight_proj''', '''quantizer.codevectors''', '''project_q''', '''project_hid''', ] def lowerCAmelCase__ ( a__: int , a__: List[str] , a__: Tuple , a__: Optional[Any] , a__: List[Any] ) -> List[Any]: '''simple docstring''' for attribute in key.split('.' ): _UpperCAmelCase = getattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) if weight_type is not None: _UpperCAmelCase = getattr(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ).shape else: _UpperCAmelCase = hf_pointer.shape assert hf_shape == value.shape, ( F'''Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be''' F''' {value.shape} for {full_name}''' ) if weight_type == "weight": _UpperCAmelCase = value elif weight_type == "weight_g": _UpperCAmelCase = value elif weight_type == "weight_v": _UpperCAmelCase = value elif weight_type == "bias": _UpperCAmelCase = value else: _UpperCAmelCase = value logger.info(F'''{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.''' ) def lowerCAmelCase__ ( a__: Optional[Any] , a__: Dict ) -> List[str]: '''simple docstring''' _UpperCAmelCase = [] _UpperCAmelCase = fairseq_model.state_dict() _UpperCAmelCase = hf_model.feature_extractor _UpperCAmelCase = hf_model.adapter for name, value in fairseq_dict.items(): _UpperCAmelCase = False if "conv_layers" in name: load_conv_layer( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , hf_model.config.feat_extract_norm == 'group' , ) _UpperCAmelCase = True elif any(x in name for x in ['adaptor', 'w2v_encoder.proj.', 'w2v_proj_ln.'] ): load_adapter(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) _UpperCAmelCase = True else: for key, mapped_key in MAPPING.items(): if key in name or key.split('w2v_model.' )[-1] == name.split('.' )[0]: _UpperCAmelCase = True if "*" in mapped_key: _UpperCAmelCase = name.split(_SCREAMING_SNAKE_CASE )[0].split('.' )[-2] _UpperCAmelCase = mapped_key.replace('*' , _SCREAMING_SNAKE_CASE ) if "weight_g" in name: _UpperCAmelCase = 'weight_g' elif "weight_v" in name: _UpperCAmelCase = 'weight_v' elif "bias" in name: _UpperCAmelCase = 'bias' elif "weight" in name: _UpperCAmelCase = 'weight' else: _UpperCAmelCase = None set_recursively(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) continue if not is_used: unused_weights.append(_SCREAMING_SNAKE_CASE ) logger.warning(F'''Unused weights: {unused_weights}''' ) def lowerCAmelCase__ ( a__: Optional[Any] , a__: Optional[Any] , a__: Dict , a__: Optional[Any] , a__: Any ) -> Optional[int]: '''simple docstring''' _UpperCAmelCase = full_name.split('conv_layers.' )[-1] _UpperCAmelCase = name.split('.' ) _UpperCAmelCase = int(items[0] ) _UpperCAmelCase = int(items[1] ) if type_id == 0: if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, ( F'''{full_name} has size {value.shape}, but''' F''' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.''' ) _UpperCAmelCase = value logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, ( F'''{full_name} has size {value.shape}, but''' F''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.''' ) _UpperCAmelCase = value logger.info(F'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, ( F'''{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was''' " found." ) _UpperCAmelCase = value logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, ( F'''{full_name} has size {value.shape}, but''' F''' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.''' ) _UpperCAmelCase = value logger.info(F'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' ) else: unused_weights.append(_SCREAMING_SNAKE_CASE ) def lowerCAmelCase__ ( a__: str , a__: Optional[Any] , a__: Any , a__: Dict ) -> str: '''simple docstring''' _UpperCAmelCase = full_name.split('adaptor.' )[-1] _UpperCAmelCase = name.split('.' ) if items[1].isdigit(): _UpperCAmelCase = int(items[1] ) else: _UpperCAmelCase = None if "adaptor" not in full_name: if "proj_ln" in full_name: # has to be layer norm if "bias" in name: assert ( value.shape == adapter.proj_layer_norm.bias.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found.''' _UpperCAmelCase = value logger.info(F'''Adapter proj layer norm bias was initialized from {full_name}.''' ) if "weight" in name: assert ( value.shape == adapter.proj_layer_norm.weight.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found.''' _UpperCAmelCase = value else: # has to be projection layer if "bias" in name: assert ( value.shape == adapter.proj.bias.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found.''' _UpperCAmelCase = value logger.info(F'''Adapter proj layer bias was initialized from {full_name}.''' ) if "weight" in name: assert ( value.shape == adapter.proj.weight.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found.''' _UpperCAmelCase = value logger.info(F'''Adapter proj layer weight was initialized from {full_name}.''' ) elif isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): if "bias" in name: assert ( value.shape == adapter.layers[layer_id].conv.bias.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found.''' _UpperCAmelCase = value logger.info(F'''Adapter layer {layer_id} bias was initialized from {full_name}.''' ) elif "weight" in name: assert ( value.shape == adapter.layers[layer_id].conv.weight.data.shape ), F'''{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found.''' _UpperCAmelCase = value logger.info(F'''Adapter layer {layer_id} bias was initialized from {full_name}.''' ) else: unused_weights.append(_SCREAMING_SNAKE_CASE ) def lowerCAmelCase__ ( a__: Optional[int] ) -> Union[str, Any]: '''simple docstring''' _UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , bias=_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = emb.weight.data return lin_layer @torch.no_grad() def lowerCAmelCase__ ( a__: int , a__: List[Any] , a__: Optional[Any] , a__: Union[str, Any] , a__: Any , a__: Tuple , a__: Dict , a__: str , a__: Optional[int] , a__: Optional[Any] , a__: int , ) -> int: '''simple docstring''' _UpperCAmelCase = WavaVecaConfig.from_pretrained( _SCREAMING_SNAKE_CASE , add_adapter=_SCREAMING_SNAKE_CASE , adapter_stride=_SCREAMING_SNAKE_CASE , adapter_kernel_size=_SCREAMING_SNAKE_CASE , use_auth_token=_SCREAMING_SNAKE_CASE , output_hidden_size=_SCREAMING_SNAKE_CASE , ) _UpperCAmelCase = MBartConfig.from_pretrained(_SCREAMING_SNAKE_CASE ) # load model _UpperCAmelCase = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={ 'config_yaml': config_yaml_path, 'data': '/'.join(dict_path.split('/' )[:-1] ), 'w2v_path': checkpoint_path, 'load_pretrained_decoder_from': None, } , ) _UpperCAmelCase = model[0].eval() # load feature extractor _UpperCAmelCase = WavaVecaFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE , use_auth_token=_SCREAMING_SNAKE_CASE ) # set weights for wav2vec2 encoder _UpperCAmelCase = WavaVecaModel(_SCREAMING_SNAKE_CASE ) recursively_load_weights_wavaveca(model.encoder , _SCREAMING_SNAKE_CASE ) # load decoder weights _UpperCAmelCase = MBartForCausalLM(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() , strict=_SCREAMING_SNAKE_CASE ) logger.warning(F'''The following keys are missing when loading the decoder weights: {missing_keys}''' ) logger.warning(F'''The following keys are unexpected when loading the decoder weights: {unexpected_keys}''' ) _UpperCAmelCase = SpeechEncoderDecoderModel(encoder=_SCREAMING_SNAKE_CASE , decoder=_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = False _UpperCAmelCase = MBartaaTokenizer(_SCREAMING_SNAKE_CASE ) tokenizer.save_pretrained(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = hf_wavavec.config.to_dict() _UpperCAmelCase = tokenizer.pad_token_id _UpperCAmelCase = tokenizer.bos_token_id _UpperCAmelCase = tokenizer.eos_token_id _UpperCAmelCase = 'mbart50' _UpperCAmelCase = 'wav2vec2' _UpperCAmelCase = tokenizer.eos_token_id _UpperCAmelCase = 2_5_0_0_0_4 _UpperCAmelCase = tokenizer.eos_token_id _UpperCAmelCase = SpeechEncoderDecoderConfig.from_dict(_SCREAMING_SNAKE_CASE ) hf_wavavec.save_pretrained(_SCREAMING_SNAKE_CASE ) feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE ) if __name__ == "__main__": lowerCAmelCase__ :Dict = argparse.ArgumentParser() parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''') parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''') parser.add_argument('''--dict_path''', default=None, type=str, help='''Path to dict of fine-tuned model''') parser.add_argument('''--config_yaml_path''', default=None, type=str, help='''Path to yaml file of fine-tuned model''') parser.add_argument( '''--encoder_config_path''', default='''facebook/wav2vec2-xls-r-1b''', type=str, help='''Path to hf encoder wav2vec2 checkpoint config''', ) parser.add_argument( '''--decoder_config_path''', default='''facebook/mbart-large-50-one-to-many-mmt''', type=str, help='''Path to hf decoder checkpoint config''', ) parser.add_argument('''--add_adapter''', default=True, type=bool, help='''whethere to add model adapter layers''') parser.add_argument('''--adapter_stride''', default=2, type=int, help='''stride of adapter layers''') parser.add_argument('''--adapter_kernel_size''', default=3, type=int, help='''kernel size of adapter layers''') parser.add_argument('''--encoder_output_dim''', default=1_0_2_4, type=int, help='''encoder output dim''') parser.add_argument('''--start_token_id''', default=2_5_0_0_0_4, type=int, help='''`decoder_start_token_id` of model config''') lowerCAmelCase__ :List[str] = parser.parse_args() convert_wavaveca_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.dict_path, args.config_yaml_path, encoder_config_path=args.encoder_config_path, decoder_config_path=args.decoder_config_path, add_adapter=args.add_adapter, adapter_kernel_size=args.adapter_kernel_size, adapter_stride=args.adapter_stride, decoder_start_token_id=args.start_token_id, encoder_output_dim=args.encoder_output_dim, )
329
"""simple docstring""" from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging lowercase__ = logging.get_logger(__name__) lowercase__ = { 'andreasmadsen/efficient_mlm_m0.40': ( 'https://huggingface.co/andreasmadsen/efficient_mlm_m0.40/resolve/main/config.json' ), } class __snake_case ( __lowerCAmelCase ): a__ = """roberta-prelayernorm""" def __init__( self , lowercase=5_02_65 , lowercase=7_68 , lowercase=12 , lowercase=12 , lowercase=30_72 , lowercase="gelu" , lowercase=0.1 , lowercase=0.1 , lowercase=5_12 , lowercase=2 , lowercase=0.02 , lowercase=1e-12 , lowercase=1 , lowercase=0 , lowercase=2 , lowercase="absolute" , lowercase=True , lowercase=None , **lowercase , ) -> Any: '''simple docstring''' super().__init__(pad_token_id=lowercase , bos_token_id=lowercase , eos_token_id=lowercase , **lowercase) a__: Union[str, Any] = vocab_size a__: str = hidden_size a__: Tuple = num_hidden_layers a__: List[str] = num_attention_heads a__: Dict = hidden_act a__: int = intermediate_size a__: Tuple = hidden_dropout_prob a__: str = attention_probs_dropout_prob a__: Tuple = max_position_embeddings a__: Tuple = type_vocab_size a__: Optional[Any] = initializer_range a__: Tuple = layer_norm_eps a__: Optional[int] = position_embedding_type a__: Any = use_cache a__: Dict = classifier_dropout class __snake_case ( __lowerCAmelCase ): @property def lowerCamelCase_ ( self) -> Mapping[str, Mapping[int, str]]: '''simple docstring''' if self.task == "multiple-choice": a__: str = {0: 'batch', 1: 'choice', 2: 'sequence'} else: a__: Union[str, Any] = {0: 'batch', 1: 'sequence'} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ])
290
0
"""simple docstring""" import json import os import tempfile import unittest import numpy as np from datasets import load_dataset 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 if is_torch_available(): import torch if is_vision_available(): from PIL import Image from transformers import ImageGPTImageProcessor class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' def __init__( self , lowercase , lowercase=7 , lowercase=3 , lowercase=18 , lowercase=30 , lowercase=400 , lowercase=True , lowercase=None , lowercase=True , ): _lowerCamelCase : int = size if size is not None else {'height': 18, 'width': 18} _lowerCamelCase : List[str] = parent _lowerCamelCase : Optional[Any] = batch_size _lowerCamelCase : Optional[int] = num_channels _lowerCamelCase : Dict = image_size _lowerCamelCase : int = min_resolution _lowerCamelCase : Tuple = max_resolution _lowerCamelCase : List[str] = do_resize _lowerCamelCase : Dict = size _lowerCamelCase : Dict = do_normalize def A_ ( self ): return { # here we create 2 clusters for the sake of simplicity "clusters": np.asarray( [ [0.88_66_44_36_34_03_32_03, 0.66_18_82_93_69_54_49_83, 0.38_91_74_64_01_78_68_04], [-0.60_42_55_91_46_88_11_04, -0.0_22_95_00_88_60_52_84_69, 0.54_23_79_73_69_00_32_96], ] ), "do_resize": self.do_resize, "size": self.size, "do_normalize": self.do_normalize, } @require_torch @require_vision class lowerCAmelCase__ ( lowercase, unittest.TestCase ): '''simple docstring''' lowerCamelCase__ = ImageGPTImageProcessor if is_vision_available() else None def A_ ( self ): _lowerCamelCase : Dict = ImageGPTImageProcessingTester(self ) @property def A_ ( self ): return self.image_processor_tester.prepare_image_processor_dict() def A_ ( self ): _lowerCamelCase : Optional[Any] = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(_A , 'clusters' ) ) self.assertTrue(hasattr(_A , 'do_resize' ) ) self.assertTrue(hasattr(_A , 'size' ) ) self.assertTrue(hasattr(_A , 'do_normalize' ) ) def A_ ( self ): _lowerCamelCase : Optional[int] = self.image_processing_class.from_dict(self.image_processor_dict ) self.assertEqual(image_processor.size , {'height': 18, 'width': 18} ) _lowerCamelCase : Optional[int] = self.image_processing_class.from_dict(self.image_processor_dict , size=42 ) self.assertEqual(image_processor.size , {'height': 42, 'width': 42} ) def A_ ( self ): _lowerCamelCase : int = self.image_processing_class(**self.image_processor_dict ) _lowerCamelCase : Optional[int] = json.loads(image_processor.to_json_string() ) for key, value in self.image_processor_dict.items(): if key == "clusters": self.assertTrue(np.array_equal(_A , obj[key] ) ) else: self.assertEqual(obj[key] , _A ) def A_ ( self ): _lowerCamelCase : Dict = self.image_processing_class(**self.image_processor_dict ) with tempfile.TemporaryDirectory() as tmpdirname: _lowerCamelCase : List[Any] = os.path.join(_A , 'image_processor.json' ) image_processor_first.to_json_file(_A ) _lowerCamelCase : Optional[Any] = self.image_processing_class.from_json_file(_A ).to_dict() _lowerCamelCase : Optional[int] = image_processor_first.to_dict() for key, value in image_processor_first.items(): if key == "clusters": self.assertTrue(np.array_equal(_A , image_processor_second[key] ) ) else: self.assertEqual(image_processor_first[key] , _A ) def A_ ( self ): _lowerCamelCase : Union[str, Any] = self.image_processing_class(**self.image_processor_dict ) with tempfile.TemporaryDirectory() as tmpdirname: image_processor_first.save_pretrained(_A ) _lowerCamelCase : Optional[int] = self.image_processing_class.from_pretrained(_A ).to_dict() _lowerCamelCase : Any = image_processor_first.to_dict() for key, value in image_processor_first.items(): if key == "clusters": self.assertTrue(np.array_equal(_A , image_processor_second[key] ) ) else: self.assertEqual(image_processor_first[key] , _A ) @unittest.skip('ImageGPT requires clusters at initialization' ) def A_ ( self ): pass def _snake_case ( ): _lowerCamelCase : Tuple = load_dataset('hf-internal-testing/fixtures_image_utils' , split='test' ) _lowerCamelCase : List[str] = Image.open(dataset[4]['file'] ) _lowerCamelCase : List[Any] = Image.open(dataset[5]['file'] ) _lowerCamelCase : Any = [imagea, imagea] return images @require_vision @require_torch class lowerCAmelCase__ ( unittest.TestCase ): '''simple docstring''' @slow def A_ ( self ): _lowerCamelCase : Optional[int] = ImageGPTImageProcessor.from_pretrained('openai/imagegpt-small' ) _lowerCamelCase : Union[str, Any] = prepare_images() # test non-batched _lowerCamelCase : List[Any] = image_processing(images[0] , return_tensors='pt' ) self.assertIsInstance(encoding.input_ids , torch.LongTensor ) self.assertEqual(encoding.input_ids.shape , (1, 1024) ) _lowerCamelCase : int = [306, 191, 191] self.assertEqual(encoding.input_ids[0, :3].tolist() , _A ) # test batched _lowerCamelCase : List[str] = image_processing(_A , return_tensors='pt' ) self.assertIsInstance(encoding.input_ids , torch.LongTensor ) self.assertEqual(encoding.input_ids.shape , (2, 1024) ) _lowerCamelCase : Any = [303, 13, 13] self.assertEqual(encoding.input_ids[1, -3:].tolist() , _A )
356
"""simple docstring""" import torch from diffusers import UnCLIPScheduler from .test_schedulers import SchedulerCommonTest class lowerCAmelCase__ ( lowercase ): '''simple docstring''' lowerCamelCase__ = (UnCLIPScheduler,) def A_ ( self , **lowercase ): _lowerCamelCase : Any = { 'num_train_timesteps': 1000, 'variance_type': 'fixed_small_log', 'clip_sample': True, 'clip_sample_range': 1.0, 'prediction_type': 'epsilon', } config.update(**lowercase ) return config def A_ ( self ): for timesteps in [1, 5, 100, 1000]: self.check_over_configs(num_train_timesteps=lowercase ) def A_ ( self ): for variance in ["fixed_small_log", "learned_range"]: self.check_over_configs(variance_type=lowercase ) def A_ ( self ): for clip_sample in [True, False]: self.check_over_configs(clip_sample=lowercase ) def A_ ( self ): for clip_sample_range in [1, 5, 10, 20]: self.check_over_configs(clip_sample_range=lowercase ) def A_ ( self ): for prediction_type in ["epsilon", "sample"]: self.check_over_configs(prediction_type=lowercase ) def A_ ( self ): for time_step in [0, 500, 999]: for prev_timestep in [None, 5, 100, 250, 500, 750]: if prev_timestep is not None and prev_timestep >= time_step: continue self.check_over_forward(time_step=lowercase , prev_timestep=lowercase ) def A_ ( self ): _lowerCamelCase : Optional[Any] = self.scheduler_classes[0] _lowerCamelCase : Optional[int] = self.get_scheduler_config(variance_type='fixed_small_log' ) _lowerCamelCase : str = scheduler_class(**lowercase ) assert torch.sum(torch.abs(scheduler._get_variance(0 ) - 1.0000E-10 ) ) < 1E-5 assert torch.sum(torch.abs(scheduler._get_variance(487 ) - 0.0_54_96_25 ) ) < 1E-5 assert torch.sum(torch.abs(scheduler._get_variance(999 ) - 0.9_99_49_87 ) ) < 1E-5 def A_ ( self ): _lowerCamelCase : List[str] = self.scheduler_classes[0] _lowerCamelCase : Optional[Any] = self.get_scheduler_config(variance_type='learned_range' ) _lowerCamelCase : int = scheduler_class(**lowercase ) _lowerCamelCase : List[str] = 0.5 assert scheduler._get_variance(1 , predicted_variance=lowercase ) - -10.1_71_27_90 < 1E-5 assert scheduler._get_variance(487 , predicted_variance=lowercase ) - -5.7_99_80_52 < 1E-5 assert scheduler._get_variance(999 , predicted_variance=lowercase ) - -0.0_01_00_11 < 1E-5 def A_ ( self ): _lowerCamelCase : List[Any] = self.scheduler_classes[0] _lowerCamelCase : Optional[Any] = self.get_scheduler_config() _lowerCamelCase : Tuple = scheduler_class(**lowercase ) _lowerCamelCase : Union[str, Any] = scheduler.timesteps _lowerCamelCase : Any = self.dummy_model() _lowerCamelCase : Optional[Any] = self.dummy_sample_deter _lowerCamelCase : Optional[int] = torch.manual_seed(0 ) for i, t in enumerate(lowercase ): # 1. predict noise residual _lowerCamelCase : Tuple = model(lowercase , lowercase ) # 2. predict previous mean of sample x_t-1 _lowerCamelCase : List[Any] = scheduler.step(lowercase , lowercase , lowercase , generator=lowercase ).prev_sample _lowerCamelCase : Optional[int] = pred_prev_sample _lowerCamelCase : Optional[Any] = torch.sum(torch.abs(lowercase ) ) _lowerCamelCase : List[Any] = torch.mean(torch.abs(lowercase ) ) assert abs(result_sum.item() - 2_52.2_68_24_95 ) < 1E-2 assert abs(result_mean.item() - 0.3_28_47_43 ) < 1E-3 def A_ ( self ): _lowerCamelCase : Tuple = self.scheduler_classes[0] _lowerCamelCase : str = self.get_scheduler_config() _lowerCamelCase : Optional[Any] = scheduler_class(**lowercase ) scheduler.set_timesteps(25 ) _lowerCamelCase : Optional[Any] = scheduler.timesteps _lowerCamelCase : Optional[int] = self.dummy_model() _lowerCamelCase : Any = self.dummy_sample_deter _lowerCamelCase : str = torch.manual_seed(0 ) for i, t in enumerate(lowercase ): # 1. predict noise residual _lowerCamelCase : List[Any] = model(lowercase , lowercase ) if i + 1 == timesteps.shape[0]: _lowerCamelCase : Optional[int] = None else: _lowerCamelCase : List[str] = timesteps[i + 1] # 2. predict previous mean of sample x_t-1 _lowerCamelCase : Union[str, Any] = scheduler.step( lowercase , lowercase , lowercase , prev_timestep=lowercase , generator=lowercase ).prev_sample _lowerCamelCase : List[Any] = pred_prev_sample _lowerCamelCase : Optional[Any] = torch.sum(torch.abs(lowercase ) ) _lowerCamelCase : List[str] = torch.mean(torch.abs(lowercase ) ) assert abs(result_sum.item() - 2_58.2_04_49_83 ) < 1E-2 assert abs(result_mean.item() - 0.3_36_20_38 ) < 1E-3 def A_ ( self ): pass def A_ ( self ): pass
12
0
# Copyright 2021 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 packaging import version from .. import __version__ from .constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD from .doc import ( add_code_sample_docstrings, add_end_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, copy_func, replace_return_docstrings, ) from .generic import ( ContextManagers, ExplicitEnum, ModelOutput, PaddingStrategy, TensorType, add_model_info_to_auto_map, cached_property, can_return_loss, expand_dims, find_labels, flatten_dict, infer_framework, is_jax_tensor, is_numpy_array, is_tensor, is_tf_symbolic_tensor, is_tf_tensor, is_torch_device, is_torch_dtype, is_torch_tensor, reshape, squeeze, strtobool, tensor_size, to_numpy, to_py_obj, transpose, working_or_temp_dir, ) from .hub import ( CLOUDFRONT_DISTRIB_PREFIX, DISABLE_TELEMETRY, HF_MODULES_CACHE, HUGGINGFACE_CO_PREFIX, HUGGINGFACE_CO_RESOLVE_ENDPOINT, PYTORCH_PRETRAINED_BERT_CACHE, PYTORCH_TRANSFORMERS_CACHE, S3_BUCKET_PREFIX, TRANSFORMERS_CACHE, TRANSFORMERS_DYNAMIC_MODULE_NAME, EntryNotFoundError, PushToHubMixin, RepositoryNotFoundError, RevisionNotFoundError, cached_file, default_cache_path, define_sagemaker_information, download_url, extract_commit_hash, get_cached_models, get_file_from_repo, get_full_repo_name, has_file, http_user_agent, is_offline_mode, is_remote_url, move_cache, send_example_telemetry, try_to_load_from_cache, ) from .import_utils import ( ENV_VARS_TRUE_AND_AUTO_VALUES, ENV_VARS_TRUE_VALUES, TORCH_FX_REQUIRED_VERSION, USE_JAX, USE_TF, USE_TORCH, DummyObject, OptionalDependencyNotAvailable, _LazyModule, ccl_version, direct_transformers_import, get_torch_version, is_accelerate_available, is_apex_available, is_bitsandbytes_available, is_bsa_available, is_coloredlogs_available, is_cython_available, is_datasets_available, is_decord_available, is_detectrona_available, is_faiss_available, is_flax_available, is_ftfy_available, is_in_notebook, is_ipex_available, is_jieba_available, is_jumanpp_available, is_kenlm_available, is_keras_nlp_available, is_librosa_available, is_natten_available, is_ninja_available, is_onnx_available, is_openai_available, is_optimum_available, is_pandas_available, is_peft_available, is_phonemizer_available, is_protobuf_available, is_psutil_available, is_pyanvml_available, is_pyctcdecode_available, is_pytesseract_available, is_pytest_available, is_pytorch_quantization_available, is_rjieba_available, is_sacremoses_available, is_safetensors_available, is_sagemaker_dp_enabled, is_sagemaker_mp_enabled, is_scipy_available, is_sentencepiece_available, is_seqio_available, is_sklearn_available, is_soundfile_availble, is_spacy_available, is_speech_available, is_sudachi_available, is_tensorflow_probability_available, is_tensorflow_text_available, is_tfaonnx_available, is_tf_available, is_timm_available, is_tokenizers_available, is_torch_available, is_torch_bfaa_available, is_torch_bfaa_cpu_available, is_torch_bfaa_gpu_available, is_torch_compile_available, is_torch_cuda_available, is_torch_fx_available, is_torch_fx_proxy, is_torch_mps_available, is_torch_neuroncore_available, is_torch_tensorrt_fx_available, is_torch_tfaa_available, is_torch_tpu_available, is_torchaudio_available, is_torchdistx_available, is_torchdynamo_available, is_torchvision_available, is_training_run_on_sagemaker, is_vision_available, requires_backends, torch_only_method, ) _lowerCamelCase ="""pytorch_model.bin""" _lowerCamelCase ="""pytorch_model.bin.index.json""" _lowerCamelCase ="""adapter_config.json""" _lowerCamelCase ="""adapter_model.bin""" _lowerCamelCase ="""adapter_model.safetensors""" _lowerCamelCase ="""tf_model.h5""" _lowerCamelCase ="""tf_model.h5.index.json""" _lowerCamelCase ="""model.ckpt""" _lowerCamelCase ="""flax_model.msgpack""" _lowerCamelCase ="""flax_model.msgpack.index.json""" _lowerCamelCase ="""model.safetensors""" _lowerCamelCase ="""model.safetensors.index.json""" _lowerCamelCase ="""config.json""" _lowerCamelCase ="""preprocessor_config.json""" _lowerCamelCase =FEATURE_EXTRACTOR_NAME _lowerCamelCase ="""generation_config.json""" _lowerCamelCase ="""modelcard.json""" _lowerCamelCase ="""▁""" _lowerCamelCase =SENTENCEPIECE_UNDERLINE # Kept for backward compatibility _lowerCamelCase =[ [[0, 1, 0, 1], [1, 0, 0, 1]] ] * 2 # Needs to have 0s and 1s only since XLM uses it for langs too. _lowerCamelCase =[[7, 6, 0, 0, 1], [1, 2, 3, 0, 0], [0, 0, 0, 4, 5]] _lowerCamelCase =[[1, 1, 1, 1, 1], [1, 1, 1, 0, 0], [0, 0, 0, 1, 1]] def _a ( lowerCamelCase ): if version.parse(lowerCamelCase ) < version.parse(lowerCamelCase ): if "dev" in min_version: lowerCamelCase : Optional[int] = ( """This example requires a source install from HuggingFace Transformers (see """ """`https://huggingface.co/docs/transformers/installation#install-from-source`),""" ) else: lowerCamelCase : int = F'''This example requires a minimum version of {min_version},''' error_message += F''' but the version found is {__version__}.\n''' raise ImportError( error_message + """Check out https://github.com/huggingface/transformers/tree/main/examples#important-note for the examples corresponding to other """ """versions of HuggingFace Transformers.""" )
287
def _a ( lowerCamelCase = 100_0000 ): lowerCamelCase : Any = set(range(3, lowerCamelCase, 2 ) ) primes.add(2 ) for p in range(3, lowerCamelCase, 2 ): if p not in primes: continue primes.difference_update(set(range(p * p, lowerCamelCase, lowerCamelCase ) ) ) lowerCamelCase : Any = [float(lowerCamelCase ) for n in range(limit + 1 )] for p in primes: for n in range(lowerCamelCase, limit + 1, lowerCamelCase ): phi[n] *= 1 - 1 / p return int(sum(phi[2:] ) ) if __name__ == "__main__": print(f'''{solution() = }''')
287
1
"""simple docstring""" import os import sys import unittest lowerCamelCase_ = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, '''utils''')) import get_test_info # noqa: E402 from get_test_info import ( # noqa: E402 get_model_to_test_mapping, get_model_to_tester_mapping, get_test_to_tester_mapping, ) lowerCamelCase_ = os.path.join('''tests''', '''models''', '''bert''', '''test_modeling_bert.py''') lowerCamelCase_ = os.path.join('''tests''', '''models''', '''blip''', '''test_modeling_blip.py''') class UpperCamelCase_ (unittest.TestCase ): def _SCREAMING_SNAKE_CASE ( self : Optional[int] ) -> Optional[int]: UpperCAmelCase_ : str = get_test_to_tester_mapping(lowerCAmelCase_ ) UpperCAmelCase_ : Optional[Any] = get_test_to_tester_mapping(lowerCAmelCase_ ) UpperCAmelCase_ : Optional[Any] = {"BertModelTest": "BertModelTester"} UpperCAmelCase_ : Optional[int] = { "BlipModelTest": "BlipModelTester", "BlipTextImageModelTest": "BlipTextImageModelsModelTester", "BlipTextModelTest": "BlipTextModelTester", "BlipTextRetrievalModelTest": "BlipTextRetrievalModelTester", "BlipVQAModelTest": "BlipVQAModelTester", "BlipVisionModelTest": "BlipVisionModelTester", } self.assertEqual(get_test_info.to_json(lowerCAmelCase_ ) , lowerCAmelCase_ ) self.assertEqual(get_test_info.to_json(lowerCAmelCase_ ) , lowerCAmelCase_ ) def _SCREAMING_SNAKE_CASE ( self : Union[str, Any] ) -> List[Any]: UpperCAmelCase_ : Dict = get_model_to_test_mapping(lowerCAmelCase_ ) UpperCAmelCase_ : Tuple = get_model_to_test_mapping(lowerCAmelCase_ ) UpperCAmelCase_ : str = { "BertForMaskedLM": ["BertModelTest"], "BertForMultipleChoice": ["BertModelTest"], "BertForNextSentencePrediction": ["BertModelTest"], "BertForPreTraining": ["BertModelTest"], "BertForQuestionAnswering": ["BertModelTest"], "BertForSequenceClassification": ["BertModelTest"], "BertForTokenClassification": ["BertModelTest"], "BertLMHeadModel": ["BertModelTest"], "BertModel": ["BertModelTest"], } UpperCAmelCase_ : Optional[Any] = { "BlipForConditionalGeneration": ["BlipTextImageModelTest"], "BlipForImageTextRetrieval": ["BlipTextRetrievalModelTest"], "BlipForQuestionAnswering": ["BlipVQAModelTest"], "BlipModel": ["BlipModelTest"], "BlipTextModel": ["BlipTextModelTest"], "BlipVisionModel": ["BlipVisionModelTest"], } self.assertEqual(get_test_info.to_json(lowerCAmelCase_ ) , lowerCAmelCase_ ) self.assertEqual(get_test_info.to_json(lowerCAmelCase_ ) , lowerCAmelCase_ ) def _SCREAMING_SNAKE_CASE ( self : int ) -> Tuple: UpperCAmelCase_ : int = get_model_to_tester_mapping(lowerCAmelCase_ ) UpperCAmelCase_ : List[Any] = get_model_to_tester_mapping(lowerCAmelCase_ ) UpperCAmelCase_ : Union[str, Any] = { "BertForMaskedLM": ["BertModelTester"], "BertForMultipleChoice": ["BertModelTester"], "BertForNextSentencePrediction": ["BertModelTester"], "BertForPreTraining": ["BertModelTester"], "BertForQuestionAnswering": ["BertModelTester"], "BertForSequenceClassification": ["BertModelTester"], "BertForTokenClassification": ["BertModelTester"], "BertLMHeadModel": ["BertModelTester"], "BertModel": ["BertModelTester"], } UpperCAmelCase_ : Optional[int] = { "BlipForConditionalGeneration": ["BlipTextImageModelsModelTester"], "BlipForImageTextRetrieval": ["BlipTextRetrievalModelTester"], "BlipForQuestionAnswering": ["BlipVQAModelTester"], "BlipModel": ["BlipModelTester"], "BlipTextModel": ["BlipTextModelTester"], "BlipVisionModel": ["BlipVisionModelTester"], } self.assertEqual(get_test_info.to_json(lowerCAmelCase_ ) , lowerCAmelCase_ ) self.assertEqual(get_test_info.to_json(lowerCAmelCase_ ) , lowerCAmelCase_ )
358
"""simple docstring""" from __future__ import annotations import os from collections.abc import Mapping lowerCamelCase_ = tuple[int, int] class UpperCamelCase_ : def __init__( self : List[Any] , lowerCAmelCase_ : set[int] , lowerCAmelCase_ : Mapping[EdgeT, int] ) -> None: UpperCAmelCase_ : set[int] = vertices UpperCAmelCase_ : dict[EdgeT, int] = { (min(lowerCAmelCase_ ), max(lowerCAmelCase_ )): weight for edge, weight in edges.items() } def _SCREAMING_SNAKE_CASE ( self : Tuple , lowerCAmelCase_ : EdgeT , lowerCAmelCase_ : int ) -> None: self.vertices.add(edge[0] ) self.vertices.add(edge[1] ) UpperCAmelCase_ : Tuple = weight def _SCREAMING_SNAKE_CASE ( self : str ) -> Graph: UpperCAmelCase_ : Graph = Graph({min(self.vertices )} , {} ) UpperCAmelCase_ : EdgeT UpperCAmelCase_ : int UpperCAmelCase_ : EdgeT UpperCAmelCase_ : int while len(subgraph.vertices ) < len(self.vertices ): UpperCAmelCase_ : int = max(self.edges.values() ) + 1 for edge, weight in self.edges.items(): if (edge[0] in subgraph.vertices) ^ (edge[1] in subgraph.vertices): if weight < min_weight: UpperCAmelCase_ : Tuple = edge UpperCAmelCase_ : Dict = weight subgraph.add_edge(lowerCAmelCase_ , lowerCAmelCase_ ) return subgraph def snake_case ( A__ = "p107_network.txt" ): UpperCAmelCase_ : str = os.path.abspath(os.path.dirname(A__ ) ) UpperCAmelCase_ : str = os.path.join(A__ ,A__ ) UpperCAmelCase_ : dict[EdgeT, int] = {} UpperCAmelCase_ : list[str] UpperCAmelCase_ : int UpperCAmelCase_ : int with open(A__ ) as f: UpperCAmelCase_ : Dict = f.read().strip().split("\n" ) UpperCAmelCase_ : str = [line.split("," ) for line in data] for edgea in range(1 ,len(A__ ) ): for edgea in range(A__ ): if adjaceny_matrix[edgea][edgea] != "-": UpperCAmelCase_ : Union[str, Any] = int(adjaceny_matrix[edgea][edgea] ) UpperCAmelCase_ : Graph = Graph(set(range(len(A__ ) ) ) ,A__ ) UpperCAmelCase_ : Graph = graph.prims_algorithm() UpperCAmelCase_ : int = sum(graph.edges.values() ) UpperCAmelCase_ : int = sum(subgraph.edges.values() ) return initial_total - optimal_total if __name__ == "__main__": print(f'{solution() = }')
253
0
from transformers import DistilBertTokenizer, DistilBertTokenizerFast from transformers.testing_utils import require_tokenizers, slow from ..bert.test_tokenization_bert import BertTokenizationTest @require_tokenizers class lowerCamelCase (_snake_case ): '''simple docstring''' _snake_case : Any = DistilBertTokenizer _snake_case : int = DistilBertTokenizerFast _snake_case : Optional[int] = True @slow def __UpperCAmelCase ( self ) -> Optional[int]: UpperCAmelCase_ : Any = DistilBertTokenizer.from_pretrained('distilbert-base-uncased' ) UpperCAmelCase_ : str = tokenizer.encode('sequence builders' , add_special_tokens=_UpperCamelCase ) UpperCAmelCase_ : Optional[Any] = tokenizer.encode('multi-sequence build' , add_special_tokens=_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = tokenizer.build_inputs_with_special_tokens(_UpperCamelCase ) UpperCAmelCase_ : Union[str, Any] = tokenizer.build_inputs_with_special_tokens(_UpperCamelCase , _UpperCamelCase ) assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [ tokenizer.sep_token_id ]
29
import importlib import shutil import threading import warnings from typing import List import fsspec import fsspec.asyn from . import compression from .hffilesystem import HfFileSystem __UpperCAmelCase = importlib.util.find_spec('s3fs') is not None if _has_safs: from .safilesystem import SaFileSystem # noqa: F401 __UpperCAmelCase = [ 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 lowercase__ ( __snake_case : str ): '''simple docstring''' if "://" in dataset_path: UpperCAmelCase_ : int = dataset_path.split('://' )[1] return dataset_path def lowercase__ ( __snake_case : fsspec.AbstractFileSystem ): '''simple docstring''' if fs is not None and fs.protocol != "file": return True else: return False def lowercase__ ( __snake_case : fsspec.AbstractFileSystem , __snake_case : str , __snake_case : str ): '''simple docstring''' UpperCAmelCase_ : List[str] = not is_remote_filesystem(__snake_case ) if is_local: # LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory shutil.move(fs._strip_protocol(__snake_case ) , fs._strip_protocol(__snake_case ) ) else: fs.mv(__snake_case , __snake_case , recursive=__snake_case ) def lowercase__ ( ): '''simple docstring''' if hasattr(fsspec.asyn , 'reset_lock' ): # for future fsspec>2022.05.0 fsspec.asyn.reset_lock() else: UpperCAmelCase_ : Optional[Any] = None UpperCAmelCase_ : Union[str, Any] = None UpperCAmelCase_ : int = threading.Lock()
29
1
import pyarrow.parquet as pq import pytest from datasets import Audio, Dataset, DatasetDict, Features, NamedSplit, Sequence, Value, config from datasets.features.image import Image from datasets.io.parquet import ParquetDatasetReader, ParquetDatasetWriter, get_writer_batch_size from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases def __lowerCamelCase ( UpperCAmelCase_ : Tuple , UpperCAmelCase_ : int ): """simple docstring""" assert isinstance(UpperCAmelCase_ , UpperCAmelCase_ ) assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @pytest.mark.parametrize('''keep_in_memory''' , [False, True] ) def __lowerCamelCase ( UpperCAmelCase_ : Optional[int] , UpperCAmelCase_ : str , UpperCAmelCase_ : str ): """simple docstring""" a :Union[str, Any] = tmp_path / '''cache''' a :Dict = {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): a :Tuple = ParquetDatasetReader(UpperCAmelCase_ , cache_dir=UpperCAmelCase_ , keep_in_memory=UpperCAmelCase_ ).read() _check_parquet_dataset(UpperCAmelCase_ , UpperCAmelCase_ ) @pytest.mark.parametrize( '''features''' , [ None, {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}, {'''col_1''': '''string''', '''col_2''': '''string''', '''col_3''': '''string'''}, {'''col_1''': '''int32''', '''col_2''': '''int32''', '''col_3''': '''int32'''}, {'''col_1''': '''float32''', '''col_2''': '''float32''', '''col_3''': '''float32'''}, ] , ) def __lowerCamelCase ( UpperCAmelCase_ : str , UpperCAmelCase_ : Union[str, Any] , UpperCAmelCase_ : List[str] ): """simple docstring""" a :Optional[Any] = tmp_path / '''cache''' a :Tuple = {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''} a :str = features.copy() if features else default_expected_features a :Dict = ( Features({feature: Value(UpperCAmelCase_ ) for feature, dtype in features.items()} ) if features is not None else None ) a :List[str] = ParquetDatasetReader(UpperCAmelCase_ , features=UpperCAmelCase_ , cache_dir=UpperCAmelCase_ ).read() _check_parquet_dataset(UpperCAmelCase_ , UpperCAmelCase_ ) @pytest.mark.parametrize('''split''' , [None, NamedSplit('''train''' ), '''train''', '''test'''] ) def __lowerCamelCase ( UpperCAmelCase_ : int , UpperCAmelCase_ : Optional[Any] , UpperCAmelCase_ : Dict ): """simple docstring""" a :Optional[int] = tmp_path / '''cache''' a :Tuple = {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''} a :Optional[int] = ParquetDatasetReader(UpperCAmelCase_ , cache_dir=UpperCAmelCase_ , split=UpperCAmelCase_ ).read() _check_parquet_dataset(UpperCAmelCase_ , UpperCAmelCase_ ) assert dataset.split == split if split else "train" @pytest.mark.parametrize('''path_type''' , [str, list] ) def __lowerCamelCase ( UpperCAmelCase_ : str , UpperCAmelCase_ : Dict , UpperCAmelCase_ : Any ): """simple docstring""" if issubclass(UpperCAmelCase_ , UpperCAmelCase_ ): a :str = parquet_path elif issubclass(UpperCAmelCase_ , UpperCAmelCase_ ): a :Optional[int] = [parquet_path] a :Any = tmp_path / '''cache''' a :List[Any] = {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''} a :str = ParquetDatasetReader(UpperCAmelCase_ , cache_dir=UpperCAmelCase_ ).read() _check_parquet_dataset(UpperCAmelCase_ , UpperCAmelCase_ ) def __lowerCamelCase ( UpperCAmelCase_ : Optional[int] , UpperCAmelCase_ : Tuple , UpperCAmelCase_ : int=("train",) ): """simple docstring""" assert isinstance(UpperCAmelCase_ , UpperCAmelCase_ ) for split in splits: a :Optional[Any] = dataset_dict[split] assert dataset.num_rows == 4 assert dataset.num_columns == 3 assert dataset.column_names == ["col_1", "col_2", "col_3"] for feature, expected_dtype in expected_features.items(): assert dataset.features[feature].dtype == expected_dtype @pytest.mark.parametrize('''keep_in_memory''' , [False, True] ) def __lowerCamelCase ( UpperCAmelCase_ : Optional[int] , UpperCAmelCase_ : str , UpperCAmelCase_ : Optional[Any] ): """simple docstring""" a :Dict = tmp_path / '''cache''' a :List[str] = {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''} with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase(): a :Any = ParquetDatasetReader( {'''train''': parquet_path} , cache_dir=UpperCAmelCase_ , keep_in_memory=UpperCAmelCase_ ).read() _check_parquet_datasetdict(UpperCAmelCase_ , UpperCAmelCase_ ) @pytest.mark.parametrize( '''features''' , [ None, {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}, {'''col_1''': '''string''', '''col_2''': '''string''', '''col_3''': '''string'''}, {'''col_1''': '''int32''', '''col_2''': '''int32''', '''col_3''': '''int32'''}, {'''col_1''': '''float32''', '''col_2''': '''float32''', '''col_3''': '''float32'''}, ] , ) def __lowerCamelCase ( UpperCAmelCase_ : str , UpperCAmelCase_ : Tuple , UpperCAmelCase_ : List[str] ): """simple docstring""" a :Optional[Any] = tmp_path / '''cache''' a :List[Any] = {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''} a :List[Any] = features.copy() if features else default_expected_features a :Optional[Any] = ( Features({feature: Value(UpperCAmelCase_ ) for feature, dtype in features.items()} ) if features is not None else None ) a :int = ParquetDatasetReader({'''train''': parquet_path} , features=UpperCAmelCase_ , cache_dir=UpperCAmelCase_ ).read() _check_parquet_datasetdict(UpperCAmelCase_ , UpperCAmelCase_ ) @pytest.mark.parametrize('''split''' , [None, NamedSplit('''train''' ), '''train''', '''test'''] ) def __lowerCamelCase ( UpperCAmelCase_ : Union[str, Any] , UpperCAmelCase_ : Dict , UpperCAmelCase_ : Optional[Any] ): """simple docstring""" if split: a :Union[str, Any] = {split: parquet_path} else: a :Any = '''train''' a :int = {'''train''': parquet_path, '''test''': parquet_path} a :List[str] = tmp_path / '''cache''' a :List[Any] = {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''} a :Union[str, Any] = ParquetDatasetReader(UpperCAmelCase_ , cache_dir=UpperCAmelCase_ ).read() _check_parquet_datasetdict(UpperCAmelCase_ , UpperCAmelCase_ , splits=list(path.keys() ) ) assert all(dataset[split].split == split for split in path.keys() ) def __lowerCamelCase ( UpperCAmelCase_ : Any , UpperCAmelCase_ : List[Any] ): """simple docstring""" a :int = ParquetDatasetWriter(UpperCAmelCase_ , tmp_path / '''foo.parquet''' ) assert writer.write() > 0 a :Optional[int] = pq.ParquetFile(tmp_path / '''foo.parquet''' ) a :Union[str, Any] = pf.read() assert dataset.data.table == output_table def __lowerCamelCase ( UpperCAmelCase_ : str , UpperCAmelCase_ : Dict ): """simple docstring""" a :str = str(shared_datadir / '''test_image_rgb.jpg''' ) a :List[Any] = {'''image''': [image_path]} a :List[str] = Features({'''image''': Image()} ) a :Optional[Any] = Dataset.from_dict(UpperCAmelCase_ , features=UpperCAmelCase_ ) a :Any = ParquetDatasetWriter(UpperCAmelCase_ , tmp_path / '''foo.parquet''' ) assert writer.write() > 0 a :Any = Dataset.from_parquet(str(tmp_path / '''foo.parquet''' ) ) assert dataset.features == reloaded_dataset.features a :Tuple = ParquetDatasetReader(str(tmp_path / '''foo.parquet''' ) , streaming=UpperCAmelCase_ ).read() assert dataset.features == reloaded_iterable_dataset.features @pytest.mark.parametrize( '''feature, expected''' , [ (Features({'''foo''': Value('''int32''' )} ), None), (Features({'''image''': Image(), '''foo''': Value('''int32''' )} ), config.PARQUET_ROW_GROUP_SIZE_FOR_IMAGE_DATASETS), (Features({'''nested''': Sequence(Audio() )} ), config.PARQUET_ROW_GROUP_SIZE_FOR_AUDIO_DATASETS), ] , ) def __lowerCamelCase ( UpperCAmelCase_ : int , UpperCAmelCase_ : Dict ): """simple docstring""" assert get_writer_batch_size(UpperCAmelCase_ ) == expected
281
import math def __lowerCamelCase ( UpperCAmelCase_ : float , UpperCAmelCase_ : float ): """simple docstring""" return math.pow(UpperCAmelCase_ , 2 ) - a def __lowerCamelCase ( UpperCAmelCase_ : float ): """simple docstring""" return 2 * x def __lowerCamelCase ( UpperCAmelCase_ : float ): """simple docstring""" a :int = 2.0 while start <= a: a :int = math.pow(UpperCAmelCase_ , 2 ) return start def __lowerCamelCase ( UpperCAmelCase_ : float , UpperCAmelCase_ : int = 9999 , UpperCAmelCase_ : float = 0.00000000000001 ): """simple docstring""" if a < 0: raise ValueError('''math domain error''' ) a :List[Any] = get_initial_point(UpperCAmelCase_ ) for _ in range(UpperCAmelCase_ ): a :Optional[int] = value a :int = value - fx(UpperCAmelCase_ , UpperCAmelCase_ ) / fx_derivative(UpperCAmelCase_ ) if abs(prev_value - value ) < tolerance: return value return value if __name__ == "__main__": from doctest import testmod testmod()
281
1
"""simple docstring""" def _lowerCamelCase ( _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase , ): '''simple docstring''' __lowerCAmelCase = [redshift, radiation_density, matter_density, dark_energy] if any(p < 0 for p in parameters ): raise ValueError("All input parameters must be positive" ) if any(p > 1 for p in parameters[1:4] ): raise ValueError("Relative densities cannot be greater than one" ) else: __lowerCAmelCase = 1 - (matter_density + radiation_density + dark_energy) __lowerCAmelCase = ( radiation_density * (redshift + 1) ** 4 + matter_density * (redshift + 1) ** 3 + curvature * (redshift + 1) ** 2 + dark_energy ) __lowerCAmelCase = hubble_constant * e_a ** (1 / 2) return hubble if __name__ == "__main__": import doctest # run doctest doctest.testmod() # demo LCDM approximation A : Tuple = 0.3 print( hubble_parameter( hubble_constant=68.3, radiation_density=1e-4, matter_density=matter_density, dark_energy=1 - matter_density, redshift=0, ) )
57
from __future__ import annotations from collections.abc import Callable from typing import Generic, TypeVar snake_case_ = TypeVar('''T''') snake_case_ = TypeVar('''U''') class SCREAMING_SNAKE_CASE__ (Generic[T, U] ): def __init__( self , a , a): lowercase__ : List[Any] = key lowercase__ : List[Any] = val lowercase__ : DoubleLinkedListNode[T, U] | None = None lowercase__ : DoubleLinkedListNode[T, U] | None = None def __repr__( self): return ( f"""Node: key: {self.key}, val: {self.val}, """ f"""has next: {bool(self.next)}, has prev: {bool(self.prev)}""" ) class SCREAMING_SNAKE_CASE__ (Generic[T, U] ): def __init__( self): lowercase__ : DoubleLinkedListNode[T, U] = DoubleLinkedListNode(a , a) lowercase__ : DoubleLinkedListNode[T, U] = DoubleLinkedListNode(a , a) lowercase__ , lowercase__ : Union[str, Any] = self.rear, self.head def __repr__( self): lowercase__ : Any = ['DoubleLinkedList'] lowercase__ : List[str] = self.head while node.next is not None: rep.append(str(a)) lowercase__ : Tuple = node.next rep.append(str(self.rear)) return ",\n ".join(a) def snake_case_ ( self , a): lowercase__ : Optional[Any] = self.rear.prev # All nodes other than self.head are guaranteed to have non-None previous assert previous is not None lowercase__ : Dict = node lowercase__ : int = previous lowercase__ : Union[str, Any] = node lowercase__ : Optional[int] = self.rear def snake_case_ ( self , a): if node.prev is None or node.next is None: return None lowercase__ : Union[str, Any] = node.next lowercase__ : Tuple = node.prev lowercase__ : Union[str, Any] = None lowercase__ : List[Any] = None return node class SCREAMING_SNAKE_CASE__ (Generic[T, U] ): __lowerCamelCase : dict[Callable[[T], U], LRUCache[T, U]] = {} def __init__( self , a): lowercase__ : DoubleLinkedList[T, U] = DoubleLinkedList() lowercase__ : Optional[Any] = capacity lowercase__ : Union[str, Any] = 0 lowercase__ : Tuple = 0 lowercase__ : int = 0 lowercase__ : dict[T, DoubleLinkedListNode[T, U]] = {} def __repr__( self): return ( f"""CacheInfo(hits={self.hits}, misses={self.miss}, """ f"""capacity={self.capacity}, current size={self.num_keys})""" ) def __contains__( self , a): return key in self.cache def snake_case_ ( self , a): # Note: pythonic interface would throw KeyError rather than return None if key in self.cache: self.hits += 1 lowercase__ : DoubleLinkedListNode[T, U] = self.cache[key] lowercase__ : str = self.list.remove(self.cache[key]) assert node == value_node # node is guaranteed not None because it is in self.cache assert node is not None self.list.add(a) return node.val self.miss += 1 return None def snake_case_ ( self , a , a): if key not in self.cache: if self.num_keys >= self.capacity: # delete first node (oldest) when over capacity lowercase__ : Optional[int] = self.list.head.next # guaranteed to have a non-None first node when num_keys > 0 # explain to type checker via assertions assert first_node is not None assert first_node.key is not None assert ( self.list.remove(a) is not None ) # node guaranteed to be in list assert node.key is not None del self.cache[first_node.key] self.num_keys -= 1 lowercase__ : Optional[Any] = DoubleLinkedListNode(a , a) self.list.add(self.cache[key]) self.num_keys += 1 else: # bump node to the end of the list, update value lowercase__ : Any = self.list.remove(self.cache[key]) assert node is not None # node guaranteed to be in list lowercase__ : Union[str, Any] = value self.list.add(a) @classmethod def snake_case_ ( cls , a = 128): def cache_decorator_inner(a) -> Callable[..., U]: def cache_decorator_wrapper(*a) -> U: if func not in cls.decorator_function_to_instance_map: lowercase__ : Dict = LRUCache(a) lowercase__ : str = cls.decorator_function_to_instance_map[func].get(args[0]) if result is None: lowercase__ : str = func(*a) cls.decorator_function_to_instance_map[func].put(args[0] , a) return result def cache_info() -> LRUCache[T, U]: return cls.decorator_function_to_instance_map[func] setattr(a , 'cache_info' , a) # noqa: B010 return cache_decorator_wrapper return cache_decorator_inner if __name__ == "__main__": import doctest doctest.testmod()
214
0
"""simple docstring""" from PIL import Image def _lowerCAmelCase ( UpperCAmelCase__ : Image, UpperCAmelCase__ : float ) ->Image: def brightness(UpperCAmelCase__ : int ) -> float: return 1_2_8 + level + (c - 1_2_8) if not -255.0 <= level <= 255.0: raise ValueError("""level must be between -255.0 (black) and 255.0 (white)""" ) return img.point(UpperCAmelCase__ ) if __name__ == "__main__": # Load image with Image.open('''image_data/lena.jpg''') as img: # Change brightness to 100 A_ = change_brightness(img, 100) brigt_img.save('''image_data/lena_brightness.png''', format='''png''')
367
"""simple docstring""" import warnings from ..trainer import Trainer from ..utils import logging A_ = logging.get_logger(__name__) class __SCREAMING_SNAKE_CASE ( UpperCamelCase ): def __init__( self : Optional[int] , snake_case : List[str]=None , **snake_case : Any ): '''simple docstring''' warnings.warn( """`SageMakerTrainer` is deprecated and will be removed in v5 of Transformers. You can use `Trainer` """ """instead.""" , snake_case , ) super().__init__(args=snake_case , **snake_case )
296
0
import random from typing import Any def UpperCAmelCase_( a__ ): """simple docstring""" for _ in range(len(a__ ) ): SCREAMING_SNAKE_CASE : str = random.randint(0 , len(a__ ) - 1 ) SCREAMING_SNAKE_CASE : int = random.randint(0 , len(a__ ) - 1 ) SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE : Any = data[b], data[a] return data if __name__ == "__main__": a__ : List[Any] = [0, 1, 2, 3, 4, 5, 6, 7] a__ : Tuple = ['''python''', '''says''', '''hello''', '''!'''] print('''Fisher-Yates Shuffle:''') print('''List''', integers, strings) print('''FY Shuffle''', fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
313
import logging from pathlib import Path import numpy as np import pytorch_lightning as pl import torch from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint from pytorch_lightning.utilities import rank_zero_only from utils_rag import save_json def UpperCAmelCase_( a__ ): """simple docstring""" SCREAMING_SNAKE_CASE : Optional[Any] = filter(lambda a__ : p.requires_grad , model.parameters() ) SCREAMING_SNAKE_CASE : List[Any] = sum([np.prod(p.size() ) for p in model_parameters] ) return params a__ : Any = logging.getLogger(__name__) def UpperCAmelCase_( a__ , a__ ): """simple docstring""" if metric == "rouge2": SCREAMING_SNAKE_CASE : str = '''{val_avg_rouge2:.4f}-{step_count}''' elif metric == "bleu": SCREAMING_SNAKE_CASE : List[Any] = '''{val_avg_bleu:.4f}-{step_count}''' elif metric == "em": SCREAMING_SNAKE_CASE : int = '''{val_avg_em:.4f}-{step_count}''' elif metric == "loss": SCREAMING_SNAKE_CASE : int = '''{val_avg_loss:.4f}-{step_count}''' else: raise NotImplementedError( F"""seq2seq callbacks only support rouge2 and bleu, got {metric}, You can make your own by adding to this""" ''' function.''' ) SCREAMING_SNAKE_CASE : Dict = ModelCheckpoint( dirpath=a__ , filename=a__ , monitor=F"""val_{metric}""" , mode='''max''' , save_top_k=1 , every_n_epochs=1 , ) return checkpoint_callback def UpperCAmelCase_( a__ , a__ ): """simple docstring""" return EarlyStopping( monitor=F"""val_{metric}""" , mode='''min''' if '''loss''' in metric else '''max''' , patience=a__ , verbose=a__ , ) class a_ ( pl.Callback ): """simple docstring""" def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase ) ->Dict: SCREAMING_SNAKE_CASE : List[str] = {F"""lr_group_{i}""": param['''lr'''] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups )} pl_module.logger.log_metrics(_lowerCamelCase ) @rank_zero_only def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase=True ) ->None: logger.info(F"""***** {type_path} results at step {trainer.global_step:05d} *****""" ) SCREAMING_SNAKE_CASE : Optional[int] = trainer.callback_metrics trainer.logger.log_metrics({k: v for k, v in metrics.items() if k not in ['''log''', '''progress_bar''', '''preds''']} ) # Log results SCREAMING_SNAKE_CASE : List[str] = Path(pl_module.hparams.output_dir ) if type_path == "test": SCREAMING_SNAKE_CASE : Any = od / '''test_results.txt''' SCREAMING_SNAKE_CASE : Optional[int] = od / '''test_generations.txt''' else: # this never gets hit. I prefer not to save intermediate generations, and results are in metrics.json # If people want this it will be easy enough to add back. SCREAMING_SNAKE_CASE : str = od / F"""{type_path}_results/{trainer.global_step:05d}.txt""" SCREAMING_SNAKE_CASE : Tuple = od / F"""{type_path}_generations/{trainer.global_step:05d}.txt""" results_file.parent.mkdir(exist_ok=_lowerCamelCase ) generations_file.parent.mkdir(exist_ok=_lowerCamelCase ) with open(_lowerCamelCase , '''a+''' ) as writer: for key in sorted(_lowerCamelCase ): if key in ["log", "progress_bar", "preds"]: continue SCREAMING_SNAKE_CASE : Tuple = metrics[key] if isinstance(_lowerCamelCase , torch.Tensor ): SCREAMING_SNAKE_CASE : List[Any] = val.item() SCREAMING_SNAKE_CASE : Tuple = F"""{key}: {val:.6f}\n""" writer.write(_lowerCamelCase ) if not save_generations: return if "preds" in metrics: SCREAMING_SNAKE_CASE : Optional[Any] = '''\n'''.join(metrics['''preds'''] ) generations_file.open('''w+''' ).write(_lowerCamelCase ) @rank_zero_only def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase ) ->Dict: try: SCREAMING_SNAKE_CASE : Any = pl_module.model.model.num_parameters() except AttributeError: SCREAMING_SNAKE_CASE : Optional[int] = pl_module.model.num_parameters() SCREAMING_SNAKE_CASE : int = count_trainable_parameters(_lowerCamelCase ) # mp stands for million parameters trainer.logger.log_metrics({'''n_params''': npars, '''mp''': npars / 1e6, '''grad_mp''': n_trainable_pars / 1e6} ) @rank_zero_only def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase ) ->List[Any]: save_json(pl_module.metrics , pl_module.metrics_save_path ) return self._write_logs(_lowerCamelCase , _lowerCamelCase , '''test''' ) @rank_zero_only def __lowerCAmelCase ( self , _lowerCamelCase , _lowerCamelCase ) ->Tuple: save_json(pl_module.metrics , pl_module.metrics_save_path ) # Uncommenting this will save val generations # return self._write_logs(trainer, pl_module, "valid")
313
1
from __future__ import annotations def _lowerCAmelCase ( __lowerCAmelCase ) -> bool: """simple docstring""" snake_case__ : Any = str(__lowerCAmelCase ) return n == n[::-1] def _lowerCAmelCase ( __lowerCAmelCase = 1000000 ) -> List[Any]: """simple docstring""" snake_case__ : Union[str, Any] = 0 for i in range(1 , __lowerCAmelCase ): if is_palindrome(__lowerCAmelCase ) and is_palindrome(bin(__lowerCAmelCase ).split('''b''' )[1] ): total += i return total if __name__ == "__main__": print(solution(int(str(input().strip()))))
44
from __future__ import annotations import random # Maximum size of the population. Bigger could be faster but is more memory expensive. A__ = 200 # Number of elements selected in every generation of evolution. The selection takes # place from best to worst of that generation and must be smaller than N_POPULATION. A__ = 50 # Probability that an element of a generation can mutate, changing one of its genes. # This will guarantee that all genes will be used during evolution. A__ = 0.4 # Just a seed to improve randomness required by the algorithm. random.seed(random.randint(0, 1000)) def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase ) -> tuple[str, float]: """simple docstring""" snake_case__ : List[Any] = len([g for position, g in enumerate(__lowerCAmelCase ) if g == main_target[position]] ) return (item, float(__lowerCAmelCase )) def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase ) -> tuple[str, str]: """simple docstring""" snake_case__ : Tuple = random.randint(0 , len(__lowerCAmelCase ) - 1 ) snake_case__ : Optional[Any] = parent_a[:random_slice] + parent_a[random_slice:] snake_case__ : Any = parent_a[:random_slice] + parent_a[random_slice:] return (child_a, child_a) def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase ) -> str: """simple docstring""" snake_case__ : Dict = list(__lowerCAmelCase ) if random.uniform(0 , 1 ) < MUTATION_PROBABILITY: snake_case__ : List[str] = random.choice(__lowerCAmelCase ) return "".join(__lowerCAmelCase ) def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , ) -> list[str]: """simple docstring""" snake_case__ : Dict = [] # Generate more children proportionally to the fitness score. snake_case__ : List[str] = int(parent_a[1] * 100 ) + 1 snake_case__ : Optional[int] = 10 if child_n >= 10 else child_n for _ in range(__lowerCAmelCase ): snake_case__ : List[str] = population_score[random.randint(0 , __lowerCAmelCase )][0] snake_case__ , snake_case__ : Union[str, Any] = crossover(parent_a[0] , __lowerCAmelCase ) # Append new string to the population list. pop.append(mutate(__lowerCAmelCase , __lowerCAmelCase ) ) pop.append(mutate(__lowerCAmelCase , __lowerCAmelCase ) ) return pop def _lowerCAmelCase ( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase = True ) -> tuple[int, int, str]: """simple docstring""" if N_POPULATION < N_SELECTED: snake_case__ : List[str] = f"""{N_POPULATION} must be bigger than {N_SELECTED}""" raise ValueError(__lowerCAmelCase ) # Verify that the target contains no genes besides the ones inside genes variable. snake_case__ : List[Any] = sorted({c for c in target if c not in genes} ) if not_in_genes_list: snake_case__ : List[str] = f"""{not_in_genes_list} is not in genes list, evolution cannot converge""" raise ValueError(__lowerCAmelCase ) # Generate random starting population. snake_case__ : Tuple = [] for _ in range(__lowerCAmelCase ): population.append(''''''.join([random.choice(__lowerCAmelCase ) for i in range(len(__lowerCAmelCase ) )] ) ) # Just some logs to know what the algorithms is doing. snake_case__ , snake_case__ : Union[str, Any] = 0, 0 # This loop will end when we find a perfect match for our target. while True: generation += 1 total_population += len(__lowerCAmelCase ) # Random population created. Now it's time to evaluate. # Adding a bit of concurrency can make everything faster, # # import concurrent.futures # population_score: list[tuple[str, float]] = [] # with concurrent.futures.ThreadPoolExecutor( # max_workers=NUM_WORKERS) as executor: # futures = {executor.submit(evaluate, item) for item in population} # concurrent.futures.wait(futures) # population_score = [item.result() for item in futures] # # but with a simple algorithm like this, it will probably be slower. # We just need to call evaluate for every item inside the population. snake_case__ : str = [evaluate(__lowerCAmelCase , __lowerCAmelCase ) for item in population] # Check if there is a matching evolution. snake_case__ : str = sorted(__lowerCAmelCase , key=lambda __lowerCAmelCase : x[1] , reverse=__lowerCAmelCase ) if population_score[0][0] == target: return (generation, total_population, population_score[0][0]) # Print the best result every 10 generation. # Just to know that the algorithm is working. if debug and generation % 10 == 0: print( f"""\nGeneration: {generation}""" f"""\nTotal Population:{total_population}""" f"""\nBest score: {population_score[0][1]}""" f"""\nBest string: {population_score[0][0]}""" ) # Flush the old population, keeping some of the best evolutions. # Keeping this avoid regression of evolution. snake_case__ : Optional[Any] = population[: int(N_POPULATION / 3 )] population.clear() population.extend(__lowerCAmelCase ) # Normalize population score to be between 0 and 1. snake_case__ : Dict = [ (item, score / len(__lowerCAmelCase )) for item, score in population_score ] # This is selection for i in range(__lowerCAmelCase ): population.extend(select(population_score[int(__lowerCAmelCase )] , __lowerCAmelCase , __lowerCAmelCase ) ) # Check if the population has already reached the maximum value and if so, # break the cycle. If this check is disabled, the algorithm will take # forever to compute large strings, but will also calculate small strings in # a far fewer generations. if len(__lowerCAmelCase ) > N_POPULATION: break if __name__ == "__main__": A__ = ( '''This is a genetic algorithm to evaluate, combine, evolve, and mutate a string!''' ) A__ = list( ''' ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm''' '''nopqrstuvwxyz.,;!?+-*#@^\'èéòà€ù=)(&%$£/\\''' ) A__ , A__ , A__ = basic(target_str, genes_list) print( f"""\nGeneration: {generation}\nTotal Population: {population}\nTarget: {target}""" )
44
1
import argparse import os import torch from transformers import FlavaImageCodebook, FlavaImageCodebookConfig def _a ( a :Optional[Any] , a :int , a :List[str] , a :List[str] ) -> Tuple: a = s.rsplit(a , a ) return new.join(a ) def _a ( a :Any ) -> List[Any]: # encoder.embeddings are double copied in original FLAVA return sum(param.float().sum() if '''encoder.embeddings''' not in key else 0 for key, param in state_dict.items() ) def _a ( a :Any ) -> List[Any]: a = {} a = ['''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: a = key.replace(F"""{group_key}.""" , F"""{group_key}.group.""" ) if "res_path" in key: a = key.replace('''res_path.''' , '''res_path.path.''' ) if key.endswith('''.w''' ): a = rreplace(a , '''.w''' , '''.weight''' , 1 ) if key.endswith('''.b''' ): a = rreplace(a , '''.b''' , '''.bias''' , 1 ) a = value.float() return upgrade @torch.no_grad() def _a ( a :Union[str, Any] , a :Optional[Any] , a :Optional[int]=None , a :str=True ) -> Tuple: from dall_e import Encoder a = Encoder() if os.path.exists(a ): a = torch.load(a ) else: a = torch.hub.load_state_dict_from_url(a ) if isinstance(a , a ): a = ckpt.state_dict() encoder.load_state_dict(a ) if config_path is not None: a = FlavaImageCodebookConfig.from_pretrained(a ) else: a = FlavaImageCodebookConfig() a = FlavaImageCodebook(a ).eval() a = encoder.state_dict() a = upgrade_state_dict(a ) hf_model.load_state_dict(a ) a = hf_model.state_dict() a = count_parameters(a ) a = count_parameters(a ) assert torch.allclose(a , a , atol=1e-3 ) if save_checkpoint: hf_model.save_pretrained(a ) else: return hf_state_dict if __name__ == "__main__": UpperCAmelCase__ = 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") UpperCAmelCase__ = parser.parse_args() convert_dalle_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
0
'''simple docstring''' import argparse import json import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation def __A ( lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE : str = 3_84 SCREAMING_SNAKE_CASE : Union[str, Any] = 7 if "tiny" in model_name: SCREAMING_SNAKE_CASE : List[str] = 96 SCREAMING_SNAKE_CASE : List[str] = (2, 2, 6, 2) SCREAMING_SNAKE_CASE : List[Any] = (3, 6, 12, 24) elif "small" in model_name: SCREAMING_SNAKE_CASE : Any = 96 SCREAMING_SNAKE_CASE : List[str] = (2, 2, 18, 2) SCREAMING_SNAKE_CASE : int = (3, 6, 12, 24) elif "base" in model_name: SCREAMING_SNAKE_CASE : int = 1_28 SCREAMING_SNAKE_CASE : Any = (2, 2, 18, 2) SCREAMING_SNAKE_CASE : int = (4, 8, 16, 32) SCREAMING_SNAKE_CASE : Optional[Any] = 12 SCREAMING_SNAKE_CASE : str = 5_12 elif "large" in model_name: SCREAMING_SNAKE_CASE : Tuple = 1_92 SCREAMING_SNAKE_CASE : Tuple = (2, 2, 18, 2) SCREAMING_SNAKE_CASE : List[str] = (6, 12, 24, 48) SCREAMING_SNAKE_CASE : Tuple = 12 SCREAMING_SNAKE_CASE : Union[str, Any] = 7_68 # set label information SCREAMING_SNAKE_CASE : List[str] = 1_50 SCREAMING_SNAKE_CASE : Optional[Any] = """huggingface/label-files""" SCREAMING_SNAKE_CASE : List[str] = """ade20k-id2label.json""" SCREAMING_SNAKE_CASE : Optional[int] = json.load(open(hf_hub_download(lowerCamelCase_ , lowerCamelCase_ , repo_type="""dataset""" ) , """r""" ) ) SCREAMING_SNAKE_CASE : str = {int(lowerCamelCase_ ): v for k, v in idalabel.items()} SCREAMING_SNAKE_CASE : int = {v: k for k, v in idalabel.items()} SCREAMING_SNAKE_CASE : Optional[Any] = SwinConfig( embed_dim=lowerCamelCase_ , depths=lowerCamelCase_ , num_heads=lowerCamelCase_ , window_size=lowerCamelCase_ , out_features=["""stage1""", """stage2""", """stage3""", """stage4"""] , ) SCREAMING_SNAKE_CASE : List[str] = UperNetConfig( backbone_config=lowerCamelCase_ , auxiliary_in_channels=lowerCamelCase_ , num_labels=lowerCamelCase_ , idalabel=lowerCamelCase_ , labelaid=lowerCamelCase_ , ) return config def __A ( lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE : List[str] = [] # fmt: off # stem rename_keys.append(("""backbone.patch_embed.projection.weight""", """backbone.embeddings.patch_embeddings.projection.weight""") ) rename_keys.append(("""backbone.patch_embed.projection.bias""", """backbone.embeddings.patch_embeddings.projection.bias""") ) rename_keys.append(("""backbone.patch_embed.norm.weight""", """backbone.embeddings.norm.weight""") ) rename_keys.append(("""backbone.patch_embed.norm.bias""", """backbone.embeddings.norm.bias""") ) # stages for i in range(len(config.backbone_config.depths ) ): for j in range(config.backbone_config.depths[i] ): rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.norm1.weight''', f'''backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.norm1.bias''', f'''backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table''', f'''backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index''', f'''backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight''', f'''backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias''', f'''backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.norm2.weight''', f'''backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.norm2.bias''', f'''backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight''', f'''backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias''', f'''backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight''', f'''backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight''') ) rename_keys.append((f'''backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias''', f'''backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias''') ) if i < 3: rename_keys.append((f'''backbone.stages.{i}.downsample.reduction.weight''', f'''backbone.encoder.layers.{i}.downsample.reduction.weight''') ) rename_keys.append((f'''backbone.stages.{i}.downsample.norm.weight''', f'''backbone.encoder.layers.{i}.downsample.norm.weight''') ) rename_keys.append((f'''backbone.stages.{i}.downsample.norm.bias''', f'''backbone.encoder.layers.{i}.downsample.norm.bias''') ) rename_keys.append((f'''backbone.norm{i}.weight''', f'''backbone.hidden_states_norms.stage{i+1}.weight''') ) rename_keys.append((f'''backbone.norm{i}.bias''', f'''backbone.hidden_states_norms.stage{i+1}.bias''') ) # decode head rename_keys.extend( [ ("""decode_head.conv_seg.weight""", """decode_head.classifier.weight"""), ("""decode_head.conv_seg.bias""", """decode_head.classifier.bias"""), ("""auxiliary_head.conv_seg.weight""", """auxiliary_head.classifier.weight"""), ("""auxiliary_head.conv_seg.bias""", """auxiliary_head.classifier.bias"""), ] ) # fmt: on return rename_keys def __A ( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE : int = dct.pop(lowerCamelCase_ ) SCREAMING_SNAKE_CASE : List[Any] = val def __A ( lowerCamelCase_ , lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE : Optional[Any] = [int(backbone_config.embed_dim * 2**i ) for i in range(len(backbone_config.depths ) )] for i in range(len(backbone_config.depths ) ): SCREAMING_SNAKE_CASE : Dict = num_features[i] for j in range(backbone_config.depths[i] ): # fmt: off # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias) SCREAMING_SNAKE_CASE : Union[str, Any] = state_dict.pop(f'''backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight''' ) SCREAMING_SNAKE_CASE : Union[str, Any] = state_dict.pop(f'''backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias''' ) # next, add query, keys and values (in that order) to the state dict SCREAMING_SNAKE_CASE : int = in_proj_weight[:dim, :] SCREAMING_SNAKE_CASE : Optional[int] = in_proj_bias[: dim] SCREAMING_SNAKE_CASE : Union[str, Any] = in_proj_weight[ dim : dim * 2, : ] SCREAMING_SNAKE_CASE : Any = in_proj_bias[ dim : dim * 2 ] SCREAMING_SNAKE_CASE : List[Any] = in_proj_weight[ -dim :, : ] SCREAMING_SNAKE_CASE : str = in_proj_bias[-dim :] # fmt: on def __A ( lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE : Tuple = x.shape SCREAMING_SNAKE_CASE : Any = x.reshape(lowerCamelCase_ , 4 , in_channel // 4 ) SCREAMING_SNAKE_CASE : Any = x[:, [0, 2, 1, 3], :].transpose(1 , 2 ).reshape(lowerCamelCase_ , lowerCamelCase_ ) return x def __A ( lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE, SCREAMING_SNAKE_CASE : Dict = x.shape SCREAMING_SNAKE_CASE : Dict = x.reshape(lowerCamelCase_ , in_channel // 4 , 4 ) SCREAMING_SNAKE_CASE : str = x[:, :, [0, 2, 1, 3]].transpose(1 , 2 ).reshape(lowerCamelCase_ , lowerCamelCase_ ) return x def __A ( lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE : str = x.shape[0] SCREAMING_SNAKE_CASE : List[str] = x.reshape(4 , in_channel // 4 ) SCREAMING_SNAKE_CASE : str = x[[0, 2, 1, 3], :].transpose(0 , 1 ).reshape(lowerCamelCase_ ) return x def __A ( lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE : Tuple = x.shape[0] SCREAMING_SNAKE_CASE : Optional[int] = x.reshape(in_channel // 4 , 4 ) SCREAMING_SNAKE_CASE : str = x[:, [0, 2, 1, 3]].transpose(0 , 1 ).reshape(lowerCamelCase_ ) return x def __A ( lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ): """simple docstring""" SCREAMING_SNAKE_CASE : Dict = { """upernet-swin-tiny""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth""", """upernet-swin-small""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth""", """upernet-swin-base""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth""", """upernet-swin-large""": """https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth""", } SCREAMING_SNAKE_CASE : List[str] = model_name_to_url[model_name] SCREAMING_SNAKE_CASE : Optional[int] = torch.hub.load_state_dict_from_url(lowerCamelCase_ , map_location="""cpu""" , file_name=lowerCamelCase_ )[ """state_dict""" ] for name, param in state_dict.items(): print(lowerCamelCase_ , param.shape ) SCREAMING_SNAKE_CASE : Dict = get_upernet_config(lowerCamelCase_ ) SCREAMING_SNAKE_CASE : Union[str, Any] = UperNetForSemanticSegmentation(lowerCamelCase_ ) model.eval() # replace "bn" => "batch_norm" for key in state_dict.copy().keys(): SCREAMING_SNAKE_CASE : Union[str, Any] = state_dict.pop(lowerCamelCase_ ) if "bn" in key: SCREAMING_SNAKE_CASE : List[str] = key.replace("""bn""" , """batch_norm""" ) SCREAMING_SNAKE_CASE : Optional[Any] = val # rename keys SCREAMING_SNAKE_CASE : Union[str, Any] = create_rename_keys(lowerCamelCase_ ) for src, dest in rename_keys: rename_key(lowerCamelCase_ , lowerCamelCase_ , lowerCamelCase_ ) read_in_q_k_v(lowerCamelCase_ , config.backbone_config ) # fix downsample parameters for key, value in state_dict.items(): if "downsample" in key: if "reduction" in key: SCREAMING_SNAKE_CASE : Tuple = reverse_correct_unfold_reduction_order(lowerCamelCase_ ) if "norm" in key: SCREAMING_SNAKE_CASE : Optional[int] = reverse_correct_unfold_norm_order(lowerCamelCase_ ) model.load_state_dict(lowerCamelCase_ ) # verify on image SCREAMING_SNAKE_CASE : Optional[int] = """https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg""" SCREAMING_SNAKE_CASE : Tuple = Image.open(requests.get(lowerCamelCase_ , stream=lowerCamelCase_ ).raw ).convert("""RGB""" ) SCREAMING_SNAKE_CASE : Optional[int] = SegformerImageProcessor() SCREAMING_SNAKE_CASE : str = processor(lowerCamelCase_ , return_tensors="""pt""" ).pixel_values with torch.no_grad(): SCREAMING_SNAKE_CASE : List[str] = model(lowerCamelCase_ ) SCREAMING_SNAKE_CASE : Dict = outputs.logits print(logits.shape ) print("""First values of logits:""" , logits[0, 0, :3, :3] ) # assert values if model_name == "upernet-swin-tiny": SCREAMING_SNAKE_CASE : Optional[Any] = torch.tensor( [[-7.5_958, -7.5_958, -7.4_302], [-7.5_958, -7.5_958, -7.4_302], [-7.4_797, -7.4_797, -7.3_068]] ) elif model_name == "upernet-swin-small": SCREAMING_SNAKE_CASE : Optional[Any] = torch.tensor( [[-7.1_921, -7.1_921, -6.9_532], [-7.1_921, -7.1_921, -6.9_532], [-7.0_908, -7.0_908, -6.8_534]] ) elif model_name == "upernet-swin-base": SCREAMING_SNAKE_CASE : str = torch.tensor( [[-6.5_851, -6.5_851, -6.4_330], [-6.5_851, -6.5_851, -6.4_330], [-6.4_763, -6.4_763, -6.3_254]] ) elif model_name == "upernet-swin-large": SCREAMING_SNAKE_CASE : str = torch.tensor( [[-7.5_297, -7.5_297, -7.3_802], [-7.5_297, -7.5_297, -7.3_802], [-7.4_044, -7.4_044, -7.2_586]] ) print("""Logits:""" , outputs.logits[0, 0, :3, :3] ) assert torch.allclose(outputs.logits[0, 0, :3, :3] , lowerCamelCase_ , atol=1E-4 ) print("""Looks ok!""" ) if pytorch_dump_folder_path is not None: print(f'''Saving model {model_name} to {pytorch_dump_folder_path}''' ) model.save_pretrained(lowerCamelCase_ ) print(f'''Saving processor to {pytorch_dump_folder_path}''' ) processor.save_pretrained(lowerCamelCase_ ) if push_to_hub: print(f'''Pushing model and processor for {model_name} to hub''' ) model.push_to_hub(f'''openmmlab/{model_name}''' ) processor.push_to_hub(f'''openmmlab/{model_name}''' ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( """--model_name""", default="""upernet-swin-tiny""", type=str, choices=[f'''upernet-swin-{size}''' for size in ["""tiny""", """small""", """base""", """large"""]], help="""Name of the Swin + UperNet model you'd like to convert.""", ) parser.add_argument( """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory.""" ) parser.add_argument( """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub.""" ) __UpperCAmelCase = parser.parse_args() convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
323
0
def _UpperCAmelCase ( SCREAMING_SNAKE_CASE__ : int ): if n == 1 or not isinstance(_UpperCamelCase , _UpperCamelCase ): return 0 elif n == 2: return 1 else: __UpperCamelCase =[0, 1] for i in range(2 , n + 1 ): sequence.append(sequence[i - 1] + sequence[i - 2] ) return sequence[n] def _UpperCAmelCase ( SCREAMING_SNAKE_CASE__ : int ): __UpperCamelCase =0 __UpperCamelCase =2 while digits < n: index += 1 __UpperCamelCase =len(str(fibonacci(_UpperCamelCase ) ) ) return index def _UpperCAmelCase ( SCREAMING_SNAKE_CASE__ : int = 10_00 ): return fibonacci_digits_index(_UpperCamelCase ) if __name__ == "__main__": print(solution(int(str(input()).strip())))
359
import pprint import requests _A = 'https://zenquotes.io/api' def _UpperCAmelCase ( ): return requests.get(API_ENDPOINT_URL + '/today' ).json() def _UpperCAmelCase ( ): return requests.get(API_ENDPOINT_URL + '/random' ).json() if __name__ == "__main__": _A = random_quotes() pprint.pprint(response)
117
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 ConditionalDetrImageProcessor class __A ( unittest.TestCase ): '''simple docstring''' def __init__( self , __lowerCAmelCase , __lowerCAmelCase=7 , __lowerCAmelCase=3 , __lowerCAmelCase=3_0 , __lowerCAmelCase=4_0_0 , __lowerCAmelCase=True , __lowerCAmelCase=None , __lowerCAmelCase=True , __lowerCAmelCase=[0.5, 0.5, 0.5] , __lowerCAmelCase=[0.5, 0.5, 0.5] , __lowerCAmelCase=True , __lowerCAmelCase=1 / 2_5_5 , __lowerCAmelCase=True , ): '''simple docstring''' lowerCamelCase__ = size if size is not None else {'''shortest_edge''': 1_8, '''longest_edge''': 1_3_3_3} lowerCamelCase__ = parent lowerCamelCase__ = batch_size lowerCamelCase__ = num_channels lowerCamelCase__ = min_resolution lowerCamelCase__ = max_resolution lowerCamelCase__ = do_resize lowerCamelCase__ = size lowerCamelCase__ = do_normalize lowerCamelCase__ = image_mean lowerCamelCase__ = image_std lowerCamelCase__ = do_rescale lowerCamelCase__ = rescale_factor lowerCamelCase__ = do_pad def __lowerCamelCase ( self ): '''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 __lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase=False ): '''simple docstring''' if not batched: lowerCamelCase__ = image_inputs[0] if isinstance(__lowerCAmelCase , Image.Image ): lowerCamelCase__ , lowerCamelCase__ = image.size else: lowerCamelCase__ , lowerCamelCase__ = image.shape[1], image.shape[2] if w < h: lowerCamelCase__ = int(self.size['''shortest_edge'''] * h / w ) lowerCamelCase__ = self.size['''shortest_edge'''] elif w > h: lowerCamelCase__ = self.size['''shortest_edge'''] lowerCamelCase__ = int(self.size['''shortest_edge'''] * w / h ) else: lowerCamelCase__ = self.size['''shortest_edge'''] lowerCamelCase__ = self.size['''shortest_edge'''] else: lowerCamelCase__ = [] for image in image_inputs: lowerCamelCase__ , lowerCamelCase__ = self.get_expected_values([image] ) expected_values.append((expected_height, expected_width) ) lowerCamelCase__ = max(__lowerCAmelCase , key=lambda __lowerCAmelCase : item[0] )[0] lowerCamelCase__ = max(__lowerCAmelCase , key=lambda __lowerCAmelCase : item[1] )[1] return expected_height, expected_width @require_torch @require_vision class __A ( lowerCAmelCase , unittest.TestCase ): '''simple docstring''' lowerCAmelCase_ = ConditionalDetrImageProcessor if is_vision_available() else None def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = ConditionalDetrImageProcessingTester(self ) @property def __lowerCamelCase ( self ): '''simple docstring''' return self.image_processor_tester.prepare_image_processor_dict() def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.image_processing_class(**self.image_processor_dict ) self.assertTrue(hasattr(__lowerCAmelCase , '''image_mean''' ) ) self.assertTrue(hasattr(__lowerCAmelCase , '''image_std''' ) ) self.assertTrue(hasattr(__lowerCAmelCase , '''do_normalize''' ) ) self.assertTrue(hasattr(__lowerCAmelCase , '''do_resize''' ) ) self.assertTrue(hasattr(__lowerCAmelCase , '''size''' ) ) def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = 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 , __lowerCAmelCase ) lowerCamelCase__ = self.image_processing_class.from_dict( self.image_processor_dict , size=4_2 , max_size=8_4 , pad_and_return_pixel_mask=__lowerCAmelCase ) self.assertEqual(image_processor.size , {'''shortest_edge''': 4_2, '''longest_edge''': 8_4} ) self.assertEqual(image_processor.do_pad , __lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' pass def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.image_processing_class(**self.image_processor_dict ) # create random PIL images lowerCamelCase__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=__lowerCAmelCase ) for image in image_inputs: self.assertIsInstance(__lowerCAmelCase , Image.Image ) # Test not batched input lowerCamelCase__ = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values lowerCamelCase__ , lowerCamelCase__ = self.image_processor_tester.get_expected_values(__lowerCAmelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched lowerCamelCase__ , lowerCamelCase__ = self.image_processor_tester.get_expected_values(__lowerCAmelCase , batched=__lowerCAmelCase ) lowerCamelCase__ = image_processing(__lowerCAmelCase , 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 ): '''simple docstring''' lowerCamelCase__ = self.image_processing_class(**self.image_processor_dict ) # create random numpy tensors lowerCamelCase__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=__lowerCAmelCase , numpify=__lowerCAmelCase ) for image in image_inputs: self.assertIsInstance(__lowerCAmelCase , np.ndarray ) # Test not batched input lowerCamelCase__ = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values lowerCamelCase__ , lowerCamelCase__ = self.image_processor_tester.get_expected_values(__lowerCAmelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched lowerCamelCase__ = image_processing(__lowerCAmelCase , return_tensors='''pt''' ).pixel_values lowerCamelCase__ , lowerCamelCase__ = self.image_processor_tester.get_expected_values(__lowerCAmelCase , batched=__lowerCAmelCase ) self.assertEqual( encoded_images.shape , ( self.image_processor_tester.batch_size, self.image_processor_tester.num_channels, expected_height, expected_width, ) , ) def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.image_processing_class(**self.image_processor_dict ) # create random PyTorch tensors lowerCamelCase__ = prepare_image_inputs(self.image_processor_tester , equal_resolution=__lowerCAmelCase , torchify=__lowerCAmelCase ) for image in image_inputs: self.assertIsInstance(__lowerCAmelCase , torch.Tensor ) # Test not batched input lowerCamelCase__ = image_processing(image_inputs[0] , return_tensors='''pt''' ).pixel_values lowerCamelCase__ , lowerCamelCase__ = self.image_processor_tester.get_expected_values(__lowerCAmelCase ) self.assertEqual( encoded_images.shape , (1, self.image_processor_tester.num_channels, expected_height, expected_width) , ) # Test batched lowerCamelCase__ = image_processing(__lowerCAmelCase , return_tensors='''pt''' ).pixel_values lowerCamelCase__ , lowerCamelCase__ = self.image_processor_tester.get_expected_values(__lowerCAmelCase , batched=__lowerCAmelCase ) 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 ): '''simple docstring''' lowerCamelCase__ = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) with open('''./tests/fixtures/tests_samples/COCO/coco_annotations.txt''' , '''r''' ) as f: lowerCamelCase__ = json.loads(f.read() ) lowerCamelCase__ = {'''image_id''': 3_9_7_6_9, '''annotations''': target} # encode them lowerCamelCase__ = ConditionalDetrImageProcessor.from_pretrained('''microsoft/conditional-detr-resnet-50''' ) lowerCamelCase__ = image_processing(images=__lowerCAmelCase , annotations=__lowerCAmelCase , return_tensors='''pt''' ) # verify pixel values lowerCamelCase__ = torch.Size([1, 3, 8_0_0, 1_0_6_6] ) self.assertEqual(encoding['''pixel_values'''].shape , __lowerCAmelCase ) lowerCamelCase__ = torch.tensor([0.2796, 0.3138, 0.3481] ) self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3] , __lowerCAmelCase , atol=1E-4 ) ) # verify area lowerCamelCase__ = torch.tensor([5887.9600, 1_1250.2061, 48_9353.8438, 83_7122.7500, 14_7967.5156, 16_5732.3438] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area'''] , __lowerCAmelCase ) ) # verify boxes lowerCamelCase__ = torch.Size([6, 4] ) self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape , __lowerCAmelCase ) lowerCamelCase__ = torch.tensor([0.5503, 0.2765, 0.0604, 0.2215] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0] , __lowerCAmelCase , atol=1E-3 ) ) # verify image_id lowerCamelCase__ = torch.tensor([3_9_7_6_9] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id'''] , __lowerCAmelCase ) ) # verify is_crowd lowerCamelCase__ = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd'''] , __lowerCAmelCase ) ) # verify class_labels lowerCamelCase__ = torch.tensor([7_5, 7_5, 6_3, 6_5, 1_7, 1_7] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels'''] , __lowerCAmelCase ) ) # verify orig_size lowerCamelCase__ = torch.tensor([4_8_0, 6_4_0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size'''] , __lowerCAmelCase ) ) # verify size lowerCamelCase__ = torch.tensor([8_0_0, 1_0_6_6] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size'''] , __lowerCAmelCase ) ) @slow def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' ) with open('''./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt''' , '''r''' ) as f: lowerCamelCase__ = json.loads(f.read() ) lowerCamelCase__ = {'''file_name''': '''000000039769.png''', '''image_id''': 3_9_7_6_9, '''segments_info''': target} lowerCamelCase__ = pathlib.Path('''./tests/fixtures/tests_samples/COCO/coco_panoptic''' ) # encode them lowerCamelCase__ = ConditionalDetrImageProcessor(format='''coco_panoptic''' ) lowerCamelCase__ = image_processing(images=__lowerCAmelCase , annotations=__lowerCAmelCase , masks_path=__lowerCAmelCase , return_tensors='''pt''' ) # verify pixel values lowerCamelCase__ = torch.Size([1, 3, 8_0_0, 1_0_6_6] ) self.assertEqual(encoding['''pixel_values'''].shape , __lowerCAmelCase ) lowerCamelCase__ = torch.tensor([0.2796, 0.3138, 0.3481] ) self.assertTrue(torch.allclose(encoding['''pixel_values'''][0, 0, 0, :3] , __lowerCAmelCase , atol=1E-4 ) ) # verify area lowerCamelCase__ = torch.tensor([14_7979.6875, 16_5527.0469, 48_4638.5938, 1_1292.9375, 5879.6562, 7634.1147] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''area'''] , __lowerCAmelCase ) ) # verify boxes lowerCamelCase__ = torch.Size([6, 4] ) self.assertEqual(encoding['''labels'''][0]['''boxes'''].shape , __lowerCAmelCase ) lowerCamelCase__ = torch.tensor([0.2625, 0.5437, 0.4688, 0.8625] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''boxes'''][0] , __lowerCAmelCase , atol=1E-3 ) ) # verify image_id lowerCamelCase__ = torch.tensor([3_9_7_6_9] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''image_id'''] , __lowerCAmelCase ) ) # verify is_crowd lowerCamelCase__ = torch.tensor([0, 0, 0, 0, 0, 0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''iscrowd'''] , __lowerCAmelCase ) ) # verify class_labels lowerCamelCase__ = torch.tensor([1_7, 1_7, 6_3, 7_5, 7_5, 9_3] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''class_labels'''] , __lowerCAmelCase ) ) # verify masks lowerCamelCase__ = 8_2_2_8_7_3 self.assertEqual(encoding['''labels'''][0]['''masks'''].sum().item() , __lowerCAmelCase ) # verify orig_size lowerCamelCase__ = torch.tensor([4_8_0, 6_4_0] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''orig_size'''] , __lowerCAmelCase ) ) # verify size lowerCamelCase__ = torch.tensor([8_0_0, 1_0_6_6] ) self.assertTrue(torch.allclose(encoding['''labels'''][0]['''size'''] , __lowerCAmelCase ) )
209
import torch from diffusers import UnCLIPScheduler from .test_schedulers import SchedulerCommonTest class __A ( lowerCAmelCase ): '''simple docstring''' lowerCAmelCase_ = (UnCLIPScheduler,) def __lowerCamelCase ( self , **__lowerCAmelCase ): '''simple docstring''' lowerCamelCase__ = { '''num_train_timesteps''': 1_0_0_0, '''variance_type''': '''fixed_small_log''', '''clip_sample''': True, '''clip_sample_range''': 1.0, '''prediction_type''': '''epsilon''', } config.update(**__lowerCAmelCase ) return config def __lowerCamelCase ( self ): '''simple docstring''' for timesteps in [1, 5, 1_0_0, 1_0_0_0]: self.check_over_configs(num_train_timesteps=__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' for variance in ["fixed_small_log", "learned_range"]: self.check_over_configs(variance_type=__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' for clip_sample in [True, False]: self.check_over_configs(clip_sample=__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' for clip_sample_range in [1, 5, 1_0, 2_0]: self.check_over_configs(clip_sample_range=__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' for prediction_type in ["epsilon", "sample"]: self.check_over_configs(prediction_type=__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' for time_step in [0, 5_0_0, 9_9_9]: for prev_timestep in [None, 5, 1_0_0, 2_5_0, 5_0_0, 7_5_0]: if prev_timestep is not None and prev_timestep >= time_step: continue self.check_over_forward(time_step=__lowerCAmelCase , prev_timestep=__lowerCAmelCase ) def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.scheduler_classes[0] lowerCamelCase__ = self.get_scheduler_config(variance_type='''fixed_small_log''' ) lowerCamelCase__ = scheduler_class(**__lowerCAmelCase ) assert torch.sum(torch.abs(scheduler._get_variance(0 ) - 1.0000E-10 ) ) < 1E-5 assert torch.sum(torch.abs(scheduler._get_variance(4_8_7 ) - 0.054_9625 ) ) < 1E-5 assert torch.sum(torch.abs(scheduler._get_variance(9_9_9 ) - 0.999_4987 ) ) < 1E-5 def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.scheduler_classes[0] lowerCamelCase__ = self.get_scheduler_config(variance_type='''learned_range''' ) lowerCamelCase__ = scheduler_class(**__lowerCAmelCase ) lowerCamelCase__ = 0.5 assert scheduler._get_variance(1 , predicted_variance=__lowerCAmelCase ) - -10.171_2790 < 1E-5 assert scheduler._get_variance(4_8_7 , predicted_variance=__lowerCAmelCase ) - -5.799_8052 < 1E-5 assert scheduler._get_variance(9_9_9 , predicted_variance=__lowerCAmelCase ) - -0.001_0011 < 1E-5 def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.scheduler_classes[0] lowerCamelCase__ = self.get_scheduler_config() lowerCamelCase__ = scheduler_class(**__lowerCAmelCase ) lowerCamelCase__ = scheduler.timesteps lowerCamelCase__ = self.dummy_model() lowerCamelCase__ = self.dummy_sample_deter lowerCamelCase__ = torch.manual_seed(0 ) for i, t in enumerate(__lowerCAmelCase ): # 1. predict noise residual lowerCamelCase__ = model(__lowerCAmelCase , __lowerCAmelCase ) # 2. predict previous mean of sample x_t-1 lowerCamelCase__ = scheduler.step(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , generator=__lowerCAmelCase ).prev_sample lowerCamelCase__ = pred_prev_sample lowerCamelCase__ = torch.sum(torch.abs(__lowerCAmelCase ) ) lowerCamelCase__ = torch.mean(torch.abs(__lowerCAmelCase ) ) assert abs(result_sum.item() - 252.268_2495 ) < 1E-2 assert abs(result_mean.item() - 0.328_4743 ) < 1E-3 def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = self.scheduler_classes[0] lowerCamelCase__ = self.get_scheduler_config() lowerCamelCase__ = scheduler_class(**__lowerCAmelCase ) scheduler.set_timesteps(2_5 ) lowerCamelCase__ = scheduler.timesteps lowerCamelCase__ = self.dummy_model() lowerCamelCase__ = self.dummy_sample_deter lowerCamelCase__ = torch.manual_seed(0 ) for i, t in enumerate(__lowerCAmelCase ): # 1. predict noise residual lowerCamelCase__ = model(__lowerCAmelCase , __lowerCAmelCase ) if i + 1 == timesteps.shape[0]: lowerCamelCase__ = None else: lowerCamelCase__ = timesteps[i + 1] # 2. predict previous mean of sample x_t-1 lowerCamelCase__ = scheduler.step( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , prev_timestep=__lowerCAmelCase , generator=__lowerCAmelCase ).prev_sample lowerCamelCase__ = pred_prev_sample lowerCamelCase__ = torch.sum(torch.abs(__lowerCAmelCase ) ) lowerCamelCase__ = torch.mean(torch.abs(__lowerCAmelCase ) ) assert abs(result_sum.item() - 258.204_4983 ) < 1E-2 assert abs(result_mean.item() - 0.336_2038 ) < 1E-3 def __lowerCamelCase ( self ): '''simple docstring''' pass def __lowerCamelCase ( self ): '''simple docstring''' pass
209
1
import importlib import json import os from collections import OrderedDict from typing import Dict, Optional, Union # Build the list of all image processors from ...configuration_utils import PretrainedConfig from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code from ...image_processing_utils import ImageProcessingMixin from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging from .auto_factory import _LazyAutoMapping from .configuration_auto import ( CONFIG_MAPPING_NAMES, AutoConfig, model_type_to_module_name, replace_list_option_in_docstrings, ) _SCREAMING_SNAKE_CASE = logging.get_logger(__name__) _SCREAMING_SNAKE_CASE = OrderedDict( [ ('align', 'EfficientNetImageProcessor'), ('beit', 'BeitImageProcessor'), ('bit', 'BitImageProcessor'), ('blip', 'BlipImageProcessor'), ('blip-2', 'BlipImageProcessor'), ('bridgetower', 'BridgeTowerImageProcessor'), ('chinese_clip', 'ChineseCLIPImageProcessor'), ('clip', 'CLIPImageProcessor'), ('clipseg', 'ViTImageProcessor'), ('conditional_detr', 'ConditionalDetrImageProcessor'), ('convnext', 'ConvNextImageProcessor'), ('convnextv2', 'ConvNextImageProcessor'), ('cvt', 'ConvNextImageProcessor'), ('data2vec-vision', 'BeitImageProcessor'), ('deformable_detr', 'DeformableDetrImageProcessor'), ('deit', 'DeiTImageProcessor'), ('deta', 'DetaImageProcessor'), ('detr', 'DetrImageProcessor'), ('dinat', 'ViTImageProcessor'), ('donut-swin', 'DonutImageProcessor'), ('dpt', 'DPTImageProcessor'), ('efficientformer', 'EfficientFormerImageProcessor'), ('efficientnet', 'EfficientNetImageProcessor'), ('flava', 'FlavaImageProcessor'), ('focalnet', 'BitImageProcessor'), ('git', 'CLIPImageProcessor'), ('glpn', 'GLPNImageProcessor'), ('groupvit', 'CLIPImageProcessor'), ('imagegpt', 'ImageGPTImageProcessor'), ('instructblip', 'BlipImageProcessor'), ('layoutlmv2', 'LayoutLMv2ImageProcessor'), ('layoutlmv3', 'LayoutLMv3ImageProcessor'), ('levit', 'LevitImageProcessor'), ('mask2former', 'Mask2FormerImageProcessor'), ('maskformer', 'MaskFormerImageProcessor'), ('mgp-str', 'ViTImageProcessor'), ('mobilenet_v1', 'MobileNetV1ImageProcessor'), ('mobilenet_v2', 'MobileNetV2ImageProcessor'), ('mobilevit', 'MobileViTImageProcessor'), ('mobilevit', 'MobileViTImageProcessor'), ('mobilevitv2', 'MobileViTImageProcessor'), ('nat', 'ViTImageProcessor'), ('oneformer', 'OneFormerImageProcessor'), ('owlvit', 'OwlViTImageProcessor'), ('perceiver', 'PerceiverImageProcessor'), ('pix2struct', 'Pix2StructImageProcessor'), ('poolformer', 'PoolFormerImageProcessor'), ('regnet', 'ConvNextImageProcessor'), ('resnet', 'ConvNextImageProcessor'), ('sam', 'SamImageProcessor'), ('segformer', 'SegformerImageProcessor'), ('swiftformer', 'ViTImageProcessor'), ('swin', 'ViTImageProcessor'), ('swin2sr', 'Swin2SRImageProcessor'), ('swinv2', 'ViTImageProcessor'), ('table-transformer', 'DetrImageProcessor'), ('timesformer', 'VideoMAEImageProcessor'), ('tvlt', 'TvltImageProcessor'), ('upernet', 'SegformerImageProcessor'), ('van', 'ConvNextImageProcessor'), ('videomae', 'VideoMAEImageProcessor'), ('vilt', 'ViltImageProcessor'), ('vit', 'ViTImageProcessor'), ('vit_hybrid', 'ViTHybridImageProcessor'), ('vit_mae', 'ViTImageProcessor'), ('vit_msn', 'ViTImageProcessor'), ('xclip', 'CLIPImageProcessor'), ('yolos', 'YolosImageProcessor'), ] ) _SCREAMING_SNAKE_CASE = _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES) def snake_case ( snake_case__ :str) -> Dict: for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items(): if class_name in extractors: _A = model_type_to_module_name(snake_case__) _A = importlib.import_module(F'''.{module_name}''' , """transformers.models""") try: return getattr(snake_case__ , snake_case__) except AttributeError: continue for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items(): if getattr(snake_case__ , """__name__""" , snake_case__) == class_name: return extractor # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main # init and we return the proper dummy to get an appropriate error message. _A = importlib.import_module("""transformers""") if hasattr(snake_case__ , snake_case__): return getattr(snake_case__ , snake_case__) return None def snake_case ( snake_case__ :Union[str, os.PathLike] , snake_case__ :Optional[Union[str, os.PathLike]] = None , snake_case__ :bool = False , snake_case__ :bool = False , snake_case__ :Optional[Dict[str, str]] = None , snake_case__ :Optional[Union[bool, str]] = None , snake_case__ :Optional[str] = None , snake_case__ :bool = False , **snake_case__ :List[Any] , ) -> Any: _A = get_file_from_repo( snake_case__ , snake_case__ , cache_dir=snake_case__ , force_download=snake_case__ , resume_download=snake_case__ , proxies=snake_case__ , use_auth_token=snake_case__ , revision=snake_case__ , local_files_only=snake_case__ , ) if resolved_config_file is None: logger.info( """Could not locate the image processor configuration file, will try to use the model config instead.""") return {} with open(snake_case__ , encoding="""utf-8""") as reader: return json.load(snake_case__) class a : """simple docstring""" def __init__( self ) -> List[str]: raise EnvironmentError( """AutoImageProcessor is designed to be instantiated """ """using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.""" ) @classmethod @replace_list_option_in_docstrings(lowerCAmelCase_ ) def UpperCAmelCase ( cls , lowerCAmelCase_ , **lowerCAmelCase_ ) -> Union[str, Any]: _A = kwargs.pop("""config""" , lowerCAmelCase_ ) _A = kwargs.pop("""trust_remote_code""" , lowerCAmelCase_ ) _A = True _A , _A = ImageProcessingMixin.get_image_processor_dict(lowerCAmelCase_ , **lowerCAmelCase_ ) _A = config_dict.get("""image_processor_type""" , lowerCAmelCase_ ) _A = None if "AutoImageProcessor" in config_dict.get("""auto_map""" , {} ): _A = config_dict["""auto_map"""]["""AutoImageProcessor"""] # If we still don't have the image processor class, check if we're loading from a previous feature extractor config # and if so, infer the image processor class from there. if image_processor_class is None and image_processor_auto_map is None: _A = config_dict.pop("""feature_extractor_type""" , lowerCAmelCase_ ) if feature_extractor_class is not None: logger.warning( """Could not find image processor class in the image processor config or the model config. Loading""" """ based on pattern matching with the model's feature extractor configuration.""" ) _A = feature_extractor_class.replace("""FeatureExtractor""" , """ImageProcessor""" ) if "AutoFeatureExtractor" in config_dict.get("""auto_map""" , {} ): _A = config_dict["""auto_map"""]["""AutoFeatureExtractor"""] _A = feature_extractor_auto_map.replace("""FeatureExtractor""" , """ImageProcessor""" ) logger.warning( """Could not find image processor auto map in the image processor config or the model config.""" """ Loading based on pattern matching with the model's feature extractor configuration.""" ) # If we don't find the image processor class in the image processor config, let's try the model config. if image_processor_class is None and image_processor_auto_map is None: if not isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): _A = AutoConfig.from_pretrained(lowerCAmelCase_ , **lowerCAmelCase_ ) # It could be in `config.image_processor_type`` _A = getattr(lowerCAmelCase_ , """image_processor_type""" , lowerCAmelCase_ ) if hasattr(lowerCAmelCase_ , """auto_map""" ) and "AutoImageProcessor" in config.auto_map: _A = config.auto_map["""AutoImageProcessor"""] if image_processor_class is not None: _A = image_processor_class_from_name(lowerCAmelCase_ ) _A = image_processor_auto_map is not None _A = image_processor_class is not None or type(lowerCAmelCase_ ) in IMAGE_PROCESSOR_MAPPING _A = resolve_trust_remote_code( lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) if has_remote_code and trust_remote_code: _A = get_class_from_dynamic_module( lowerCAmelCase_ , lowerCAmelCase_ , **lowerCAmelCase_ ) _A = kwargs.pop("""code_revision""" , lowerCAmelCase_ ) if os.path.isdir(lowerCAmelCase_ ): image_processor_class.register_for_auto_class() return image_processor_class.from_dict(lowerCAmelCase_ , **lowerCAmelCase_ ) elif image_processor_class is not None: return image_processor_class.from_dict(lowerCAmelCase_ , **lowerCAmelCase_ ) # Last try: we use the IMAGE_PROCESSOR_MAPPING. elif type(lowerCAmelCase_ ) in IMAGE_PROCESSOR_MAPPING: _A = IMAGE_PROCESSOR_MAPPING[type(lowerCAmelCase_ )] return image_processor_class.from_dict(lowerCAmelCase_ , **lowerCAmelCase_ ) raise ValueError( F'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a ''' F'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following ''' F'''`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys() )}''' ) @staticmethod def UpperCAmelCase ( lowerCAmelCase_ , lowerCAmelCase_ ) -> Dict: IMAGE_PROCESSOR_MAPPING.register(lowerCAmelCase_ , lowerCAmelCase_ )
81
import cva import numpy as np class a : """simple docstring""" def __init__( self , lowerCAmelCase_ , lowerCAmelCase_ ) -> Any: if k in (0.04, 0.06): _A = k _A = window_size else: raise ValueError("""invalid k value""" ) def __str__( self ) -> str: return str(self.k ) def UpperCAmelCase ( self , lowerCAmelCase_ ) -> tuple[cva.Mat, list[list[int]]]: _A = cva.imread(lowerCAmelCase_ , 0 ) _A , _A = img.shape _A = [] _A = img.copy() _A = cva.cvtColor(lowerCAmelCase_ , cva.COLOR_GRAY2RGB ) _A , _A = np.gradient(lowerCAmelCase_ ) _A = dx**2 _A = dy**2 _A = dx * dy _A = 0.04 _A = self.window_size // 2 for y in range(lowerCAmelCase_ , h - offset ): for x in range(lowerCAmelCase_ , w - offset ): _A = ixx[ y - offset : y + offset + 1, x - offset : x + offset + 1 ].sum() _A = iyy[ y - offset : y + offset + 1, x - offset : x + offset + 1 ].sum() _A = ixy[ y - offset : y + offset + 1, x - offset : x + offset + 1 ].sum() _A = (wxx * wyy) - (wxy**2) _A = wxx + wyy _A = det - k * (trace**2) # Can change the value if r > 0.5: corner_list.append([x, y, r] ) color_img.itemset((y, x, 0) , 0 ) color_img.itemset((y, x, 1) , 0 ) color_img.itemset((y, x, 2) , 2_55 ) return color_img, corner_list if __name__ == "__main__": _SCREAMING_SNAKE_CASE = HarrisCorner(0.04, 3) _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE = edge_detect.detect('path_to_image') cva.imwrite('detect.png', color_img)
81
1
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 _lowercase : '''simple docstring''' def __init__( self , snake_case__ , snake_case__=13 , snake_case__=64 , snake_case__=2 , snake_case__=3 , snake_case__=True , snake_case__=True , snake_case__=32 , snake_case__=5 , snake_case__=4 , snake_case__=37 , snake_case__="gelu" , snake_case__=0.1 , snake_case__=0.1 , snake_case__=10 , snake_case__=0.02 , snake_case__=[1, 16, 4, 4] , snake_case__=None , ): '''simple docstring''' UpperCamelCase_ = parent UpperCamelCase_ = batch_size UpperCamelCase_ = image_size UpperCamelCase_ = patch_size UpperCamelCase_ = num_channels UpperCamelCase_ = is_training UpperCamelCase_ = use_labels UpperCamelCase_ = hidden_size UpperCamelCase_ = num_hidden_layers UpperCamelCase_ = num_attention_heads UpperCamelCase_ = intermediate_size UpperCamelCase_ = hidden_act UpperCamelCase_ = hidden_dropout_prob UpperCamelCase_ = attention_probs_dropout_prob UpperCamelCase_ = type_sequence_label_size UpperCamelCase_ = initializer_range UpperCamelCase_ = scope UpperCamelCase_ = 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_ = (self.image_size // 32) ** 2 UpperCamelCase_ = num_patches + 1 def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] ) UpperCamelCase_ = None if self.use_labels: UpperCamelCase_ = ids_tensor([self.batch_size] , self.type_sequence_label_size ) UpperCamelCase_ = self.get_config() return config, pixel_values, labels def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = { "global_padding": "same", "layer_type": "bottleneck", "depths": [3, 4, 9], "out_features": ["stage1", "stage2", "stage3"], "embedding_dynamic_padding": True, "hidden_sizes": [4, 8, 16, 32], "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=snake_case__ , initializer_range=self.initializer_range , backbone_featmap_shape=self.backbone_featmap_shape , backbone_config=snake_case__ , ) def _lowerCamelCase ( self , snake_case__ , snake_case__ , snake_case__ ): '''simple docstring''' UpperCamelCase_ = ViTHybridModel(config=snake_case__ ) model.to(snake_case__ ) model.eval() UpperCamelCase_ = model(snake_case__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _lowerCamelCase ( self , snake_case__ , snake_case__ , snake_case__ ): '''simple docstring''' UpperCamelCase_ = self.type_sequence_label_size UpperCamelCase_ = ViTHybridForImageClassification(snake_case__ ) model.to(snake_case__ ) model.eval() UpperCamelCase_ = model(snake_case__ , labels=snake_case__ ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = self.prepare_config_and_inputs() UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ = config_and_inputs UpperCamelCase_ = {"pixel_values": pixel_values} return config, inputs_dict @require_torch class _lowercase (a_ , a_ , unittest.TestCase ): '''simple docstring''' lowercase__ = (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else () lowercase__ = ( {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification} if is_torch_available() else {} ) lowercase__ = False lowercase__ = False lowercase__ = False def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = ViTHybridModelTester(self ) UpperCamelCase_ = ConfigTester(self , config_class=snake_case__ , has_text_modality=snake_case__ , hidden_size=37 ) def _lowerCamelCase ( self ): '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason="ViT does not use inputs_embeds" ) def _lowerCamelCase ( self ): '''simple docstring''' pass def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(snake_case__ ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) UpperCamelCase_ = model.get_output_embeddings() self.assertTrue(x is None or isinstance(snake_case__ , nn.Linear ) ) def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: UpperCamelCase_ = model_class(snake_case__ ) UpperCamelCase_ = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic UpperCamelCase_ = [*signature.parameters.keys()] UpperCamelCase_ = ["pixel_values"] self.assertListEqual(arg_names[:1] , snake_case__ ) def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*snake_case__ ) def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_image_classification(*snake_case__ ) def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ , UpperCamelCase_ = self.model_tester.prepare_config_and_inputs_for_common() UpperCamelCase_ = _config_zero_init(snake_case__ ) for model_class in self.all_model_classes: UpperCamelCase_ = model_class(config=snake_case__ ) # Skip the check for the backbone for name, module in model.named_modules(): if module.__class__.__name__ == "ViTHybridPatchEmbeddings": UpperCamelCase_ = [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 _lowerCamelCase ( self ): '''simple docstring''' for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: UpperCamelCase_ = ViTHybridModel.from_pretrained(snake_case__ ) self.assertIsNotNone(snake_case__ ) def _lowerCAmelCase (): UpperCamelCase_ = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png") return image @require_torch @require_vision class _lowercase (unittest.TestCase ): '''simple docstring''' @cached_property def _lowerCamelCase ( self ): '''simple docstring''' return ( ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ) if is_vision_available() else None ) @slow def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to( snake_case__ ) UpperCamelCase_ = self.default_image_processor UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(images=snake_case__ , return_tensors="pt" ).to(snake_case__ ) # forward pass with torch.no_grad(): UpperCamelCase_ = model(**snake_case__ ) # verify the logits UpperCamelCase_ = torch.Size((1, 1000) ) self.assertEqual(outputs.logits.shape , snake_case__ ) UpperCamelCase_ = torch.tensor([-1.9_090, -0.4_993, -0.2_389] ).to(snake_case__ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , snake_case__ , atol=1e-4 ) ) @slow @require_accelerate def _lowerCamelCase ( self ): '''simple docstring''' UpperCamelCase_ = ViTHybridImageProcessor.from_pretrained("google/vit-hybrid-base-bit-384" ) UpperCamelCase_ = ViTHybridForImageClassification.from_pretrained("google/vit-hybrid-base-bit-384" , device_map="auto" ) UpperCamelCase_ = prepare_img() UpperCamelCase_ = image_processor(images=snake_case__ , return_tensors="pt" ) UpperCamelCase_ = model(**snake_case__ ) UpperCamelCase_ = outputs.logits # model predicts one of the 1000 ImageNet classes UpperCamelCase_ = logits.argmax(-1 ).item() self.assertTrue(model.config.idalabel[predicted_class_idx] , "tabby, tabby cat" )
128
import argparse from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline if __name__ == "__main__": UpperCAmelCase : Dict =argparse.ArgumentParser() parser.add_argument("""--dump_path""", default=None, type=str, required=True, help="""Path to the output model.""") parser.add_argument( """--txt2img_unclip""", default="""kakaobrain/karlo-v1-alpha""", type=str, required=False, help="""The pretrained txt2img unclip.""", ) UpperCAmelCase : Optional[int] =parser.parse_args() UpperCAmelCase : List[Any] =UnCLIPPipeline.from_pretrained(args.txtaimg_unclip) UpperCAmelCase : List[str] =CLIPImageProcessor() UpperCAmelCase : Optional[int] =CLIPVisionModelWithProjection.from_pretrained("""openai/clip-vit-large-patch14""") UpperCAmelCase : Any =UnCLIPImageVariationPipeline( decoder=txtaimg.decoder, text_encoder=txtaimg.text_encoder, tokenizer=txtaimg.tokenizer, text_proj=txtaimg.text_proj, feature_extractor=feature_extractor, image_encoder=image_encoder, super_res_first=txtaimg.super_res_first, super_res_last=txtaimg.super_res_last, decoder_scheduler=txtaimg.decoder_scheduler, super_res_scheduler=txtaimg.super_res_scheduler, ) imgaimg.save_pretrained(args.dump_path)
128
1
import datasets from .nmt_bleu import compute_bleu # From: https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py lowerCAmelCase_ = '''\ @INPROCEEDINGS{Papineni02bleu:a, author = {Kishore Papineni and Salim Roukos and Todd Ward and Wei-jing Zhu}, title = {BLEU: a Method for Automatic Evaluation of Machine Translation}, booktitle = {}, year = {2002}, pages = {311--318} } @inproceedings{lin-och-2004-orange, title = "{ORANGE}: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation", author = "Lin, Chin-Yew and Och, Franz Josef", booktitle = "{COLING} 2004: Proceedings of the 20th International Conference on Computational Linguistics", month = "aug 23{--}aug 27", year = "2004", address = "Geneva, Switzerland", publisher = "COLING", url = "https://www.aclweb.org/anthology/C04-1072", pages = "501--507", } ''' lowerCAmelCase_ = '''\ BLEU (bilingual evaluation understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another. Quality is considered to be the correspondence between a machine\'s output and that of a human: "the closer a machine translation is to a professional human translation, the better it is" – this is the central idea behind BLEU. BLEU was one of the first metrics to claim a high correlation with human judgements of quality, and remains one of the most popular automated and inexpensive metrics. Scores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations. Those scores are then averaged over the whole corpus to reach an estimate of the translation\'s overall quality. Intelligibility or grammatical correctness are not taken into account[citation needed]. BLEU\'s output is always a number between 0 and 1. This value indicates how similar the candidate text is to the reference texts, with values closer to 1 representing more similar texts. Few human translations will attain a score of 1, since this would indicate that the candidate is identical to one of the reference translations. For this reason, it is not necessary to attain a score of 1. Because there are more opportunities to match, adding additional reference translations will increase the BLEU score. ''' lowerCAmelCase_ = ''' Computes BLEU score of translated segments against one or more references. Args: predictions: list of translations to score. Each translation should be tokenized into a list of tokens. references: list of lists of references for each translation. Each reference should be tokenized into a list of tokens. max_order: Maximum n-gram order to use when computing BLEU score. smooth: Whether or not to apply Lin et al. 2004 smoothing. Returns: \'bleu\': bleu score, \'precisions\': geometric mean of n-gram precisions, \'brevity_penalty\': brevity penalty, \'length_ratio\': ratio of lengths, \'translation_length\': translation_length, \'reference_length\': reference_length Examples: >>> predictions = [ ... ["hello", "there", "general", "kenobi"], # tokenized prediction of the first sample ... ["foo", "bar", "foobar"] # tokenized prediction of the second sample ... ] >>> references = [ ... [["hello", "there", "general", "kenobi"], ["hello", "there", "!"]], # tokenized references for the first sample (2 references) ... [["foo", "bar", "foobar"]] # tokenized references for the second sample (1 reference) ... ] >>> bleu = datasets.load_metric("bleu") >>> results = bleu.compute(predictions=predictions, references=references) >>> print(results["bleu"]) 1.0 ''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION, _KWARGS_DESCRIPTION ) class __lowerCAmelCase ( datasets.Metric ): def lowerCamelCase (self ) -> Optional[int]: '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { '''predictions''': datasets.Sequence(datasets.Value('''string''' , id='''token''' ) , id='''sequence''' ), '''references''': datasets.Sequence( datasets.Sequence(datasets.Value('''string''' , id='''token''' ) , id='''sequence''' ) , id='''references''' ), } ) , codebase_urls=['''https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py'''] , reference_urls=[ '''https://en.wikipedia.org/wiki/BLEU''', '''https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213''', ] , ) def lowerCamelCase (self , __magic_name__ , __magic_name__ , __magic_name__=4 , __magic_name__=False ) -> Dict: '''simple docstring''' snake_case_ : List[Any] = compute_bleu( reference_corpus=__magic_name__ , translation_corpus=__magic_name__ , max_order=__magic_name__ , smooth=__magic_name__ ) (snake_case_) : Union[str, Any] = score return { "bleu": bleu, "precisions": precisions, "brevity_penalty": bp, "length_ratio": ratio, "translation_length": translation_length, "reference_length": reference_length, }
370
from ...configuration_utils import PretrainedConfig from ...utils import logging lowerCAmelCase_ = logging.get_logger(__name__) lowerCAmelCase_ = { '''microsoft/biogpt''': '''https://huggingface.co/microsoft/biogpt/resolve/main/config.json''', # See all BioGPT models at https://huggingface.co/models?filter=biogpt } class __lowerCAmelCase ( _a ): lowerCamelCase_ : Any = '''biogpt''' def __init__(self , __magic_name__=4_2384 , __magic_name__=1024 , __magic_name__=24 , __magic_name__=16 , __magic_name__=4096 , __magic_name__="gelu" , __magic_name__=0.1 , __magic_name__=0.1 , __magic_name__=1024 , __magic_name__=0.02 , __magic_name__=1e-12 , __magic_name__=True , __magic_name__=True , __magic_name__=0.0 , __magic_name__=0.0 , __magic_name__=1 , __magic_name__=0 , __magic_name__=2 , **__magic_name__ , ) -> List[str]: '''simple docstring''' snake_case_ : List[str] = vocab_size snake_case_ : Dict = max_position_embeddings snake_case_ : Optional[int] = hidden_size snake_case_ : List[Any] = num_hidden_layers snake_case_ : List[str] = num_attention_heads snake_case_ : int = intermediate_size snake_case_ : List[Any] = hidden_act snake_case_ : List[Any] = hidden_dropout_prob snake_case_ : Optional[int] = attention_probs_dropout_prob snake_case_ : Optional[int] = initializer_range snake_case_ : Optional[int] = layer_norm_eps snake_case_ : str = scale_embedding snake_case_ : Optional[Any] = use_cache snake_case_ : Optional[Any] = layerdrop snake_case_ : Optional[Any] = activation_dropout super().__init__(pad_token_id=__magic_name__ , bos_token_id=__magic_name__ , eos_token_id=__magic_name__ , **__magic_name__ )
279
0
'''simple docstring''' from random import randint from tempfile import TemporaryFile import numpy as np def _lowerCAmelCase ( _UpperCamelCase : Tuple , _UpperCamelCase : Optional[Any] , _UpperCamelCase : Dict ) -> Tuple: """simple docstring""" _SCREAMING_SNAKE_CASE =0 if start < end: _SCREAMING_SNAKE_CASE =randint(_UpperCamelCase , _UpperCamelCase ) _SCREAMING_SNAKE_CASE =a[end] _SCREAMING_SNAKE_CASE =a[pivot] _SCREAMING_SNAKE_CASE =temp _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE =_in_place_partition(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) count += _in_place_quick_sort(_UpperCamelCase , _UpperCamelCase , p - 1 ) count += _in_place_quick_sort(_UpperCamelCase , p + 1 , _UpperCamelCase ) return count def _lowerCAmelCase ( _UpperCamelCase : List[str] , _UpperCamelCase : Union[str, Any] , _UpperCamelCase : Tuple ) -> Dict: """simple docstring""" _SCREAMING_SNAKE_CASE =0 _SCREAMING_SNAKE_CASE =randint(_UpperCamelCase , _UpperCamelCase ) _SCREAMING_SNAKE_CASE =a[end] _SCREAMING_SNAKE_CASE =a[pivot] _SCREAMING_SNAKE_CASE =temp _SCREAMING_SNAKE_CASE =start - 1 for index in range(_UpperCamelCase , _UpperCamelCase ): count += 1 if a[index] < a[end]: # check if current val is less than pivot value _SCREAMING_SNAKE_CASE =new_pivot_index + 1 _SCREAMING_SNAKE_CASE =a[new_pivot_index] _SCREAMING_SNAKE_CASE =a[index] _SCREAMING_SNAKE_CASE =temp _SCREAMING_SNAKE_CASE =a[new_pivot_index + 1] _SCREAMING_SNAKE_CASE =a[end] _SCREAMING_SNAKE_CASE =temp return new_pivot_index + 1, count lowerCamelCase : str = TemporaryFile() lowerCamelCase : Dict = 1_0_0 # 1000 elements are to be sorted lowerCamelCase , lowerCamelCase : int = 0, 1 # mean and standard deviation lowerCamelCase : List[str] = np.random.normal(mu, sigma, p) np.save(outfile, X) print("The array is") print(X) outfile.seek(0) # using the same array lowerCamelCase : Tuple = np.load(outfile) lowerCamelCase : Dict = len(M) - 1 lowerCamelCase : Tuple = _in_place_quick_sort(M, 0, r) print( "No of Comparisons for 100 elements selected from a standard normal distribution" "is :" ) print(z)
47
import re from filelock import FileLock try: import nltk lowerCamelCase__ : str = True except (ImportError, ModuleNotFoundError): lowerCamelCase__ : Union[str, Any] = False if NLTK_AVAILABLE: with FileLock('.lock') as lock: nltk.download('punkt', quiet=True) def UpperCAmelCase_ ( __UpperCAmelCase : str ) -> str: re.sub('<n>' , '' , __UpperCAmelCase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(__UpperCAmelCase ) )
225
0
'''simple docstring''' import random def a ( lowerCamelCase__ ): '''simple docstring''' A_ : Tuple = num - 1 A_ : str = 0 while s % 2 == 0: A_ : Tuple = s // 2 t += 1 for _ in range(5 ): A_ : List[str] = random.randrange(2 , num - 1 ) A_ : Union[str, Any] = pow(_UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ) if v != 1: A_ : Union[str, Any] = 0 while v != (num - 1): if i == t - 1: return False else: A_ : Dict = i + 1 A_ : List[Any] = (v**2) % num return True def a ( lowerCamelCase__ ): '''simple docstring''' if num < 2: return False A_ : Optional[int] = [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 1_01, 1_03, 1_07, 1_09, 1_13, 1_27, 1_31, 1_37, 1_39, 1_49, 1_51, 1_57, 1_63, 1_67, 1_73, 1_79, 1_81, 1_91, 1_93, 1_97, 1_99, 2_11, 2_23, 2_27, 2_29, 2_33, 2_39, 2_41, 2_51, 2_57, 2_63, 2_69, 2_71, 2_77, 2_81, 2_83, 2_93, 3_07, 3_11, 3_13, 3_17, 3_31, 3_37, 3_47, 3_49, 3_53, 3_59, 3_67, 3_73, 3_79, 3_83, 3_89, 3_97, 4_01, 4_09, 4_19, 4_21, 4_31, 4_33, 4_39, 4_43, 4_49, 4_57, 4_61, 4_63, 4_67, 4_79, 4_87, 4_91, 4_99, 5_03, 5_09, 5_21, 5_23, 5_41, 5_47, 5_57, 5_63, 5_69, 5_71, 5_77, 5_87, 5_93, 5_99, 6_01, 6_07, 6_13, 6_17, 6_19, 6_31, 6_41, 6_43, 6_47, 6_53, 6_59, 6_61, 6_73, 6_77, 6_83, 6_91, 7_01, 7_09, 7_19, 7_27, 7_33, 7_39, 7_43, 7_51, 7_57, 7_61, 7_69, 7_73, 7_87, 7_97, 8_09, 8_11, 8_21, 8_23, 8_27, 8_29, 8_39, 8_53, 8_57, 8_59, 8_63, 8_77, 8_81, 8_83, 8_87, 9_07, 9_11, 9_19, 9_29, 9_37, 9_41, 9_47, 9_53, 9_67, 9_71, 9_77, 9_83, 9_91, 9_97, ] if num in low_primes: return True for prime in low_primes: if (num % prime) == 0: return False return rabin_miller(_UpperCAmelCase ) def a ( lowerCamelCase__ = 10_24 ): '''simple docstring''' while True: A_ : Optional[int] = random.randrange(2 ** (keysize - 1) , 2 ** (keysize) ) if is_prime_low_num(_UpperCAmelCase ): return num if __name__ == "__main__": lowerCamelCase :Optional[int] = generate_large_prime() print(('''Prime number:''', num)) print(('''is_prime_low_num:''', is_prime_low_num(num)))
350
'''simple docstring''' from typing import TYPE_CHECKING from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available lowerCamelCase :Dict = {'''configuration_mmbt''': ['''MMBTConfig''']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase :str = ['''MMBTForClassification''', '''MMBTModel''', '''ModalEmbeddings'''] if TYPE_CHECKING: from .configuration_mmbt import MMBTConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_mmbt import MMBTForClassification, MMBTModel, ModalEmbeddings else: import sys lowerCamelCase :Tuple = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
135
0
import math def _SCREAMING_SNAKE_CASE ( _lowerCamelCase : Optional[Any] , _lowerCamelCase : str) -> float: '''simple docstring''' if ( not isinstance(__snake_case , (int, float)) or power_factor < -1 or power_factor > 1 ): raise ValueError("power_factor must be a valid float value between -1 and 1.") return apparent_power * power_factor def _SCREAMING_SNAKE_CASE ( _lowerCamelCase : Tuple , _lowerCamelCase : Dict) -> float: '''simple docstring''' if ( not isinstance(__snake_case , (int, float)) or power_factor < -1 or power_factor > 1 ): raise ValueError("power_factor must be a valid float value between -1 and 1.") return apparent_power * math.sqrt(1 - power_factor**2) if __name__ == "__main__": import doctest doctest.testmod()
232
def lowerCAmelCase__(__snake_case ) -> str: '''simple docstring''' return "".join(chr(ord(__snake_case ) - 32 ) if '''a''' <= char <= '''z''' else char for char in word ) if __name__ == "__main__": from doctest import testmod testmod()
209
0
'''simple docstring''' import json import os import re import unittest from transformers import CodeGenTokenizer, CodeGenTokenizerFast from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class UpperCAmelCase_ ( _a , unittest.TestCase ): """simple docstring""" lowercase = CodeGenTokenizer lowercase = CodeGenTokenizerFast lowercase = True lowercase = {"add_prefix_space": True} lowercase = False def lowerCamelCase ( self : int ): super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt snake_case__ : Union[str, Any] = [ """l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """\u0120""", """\u0120l""", """\u0120n""", """\u0120lo""", """\u0120low""", """er""", """\u0120lowest""", """\u0120newer""", """\u0120wider""", """<unk>""", """<|endoftext|>""", ] snake_case__ : Union[str, Any] = dict(zip(snake_case_ , range(len(snake_case_ ) ) ) ) snake_case__ : Optional[Any] = ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""] snake_case__ : Optional[Any] = {"""unk_token""": """<unk>"""} snake_case__ : Optional[int] = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) snake_case__ : Optional[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(snake_case_ ) + """\n""" ) with open(self.merges_file , """w""" , encoding="""utf-8""" ) as fp: fp.write("""\n""".join(snake_case_ ) ) def lowerCamelCase ( self : Optional[int] , **snake_case_ : int ): kwargs.update(self.special_tokens_map ) return CodeGenTokenizer.from_pretrained(self.tmpdirname , **snake_case_ ) def lowerCamelCase ( self : Dict , **snake_case_ : List[str] ): kwargs.update(self.special_tokens_map ) return CodeGenTokenizerFast.from_pretrained(self.tmpdirname , **snake_case_ ) def lowerCamelCase ( self : Dict , snake_case_ : List[Any] ): snake_case__ : int = """lower newer""" snake_case__ : int = """lower newer""" return input_text, output_text def lowerCamelCase ( self : List[Any] ): snake_case__ : Optional[int] = CodeGenTokenizer(self.vocab_file , self.merges_file , **self.special_tokens_map ) snake_case__ : Optional[int] = """lower newer""" snake_case__ : Tuple = ["""\u0120low""", """er""", """\u0120""", """n""", """e""", """w""", """er"""] snake_case__ : Optional[int] = tokenizer.tokenize(snake_case_ , add_prefix_space=snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) snake_case__ : Dict = tokens + [tokenizer.unk_token] snake_case__ : List[str] = [14, 15, 10, 9, 3, 2, 15, 19] self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_ ) , snake_case_ ) def lowerCamelCase ( self : int ): if not self.test_rust_tokenizer: return snake_case__ : str = self.get_tokenizer() snake_case__ : List[str] = self.get_rust_tokenizer(add_prefix_space=snake_case_ ) snake_case__ : List[str] = """lower newer""" # Testing tokenization snake_case__ : Dict = tokenizer.tokenize(snake_case_ , add_prefix_space=snake_case_ ) snake_case__ : Dict = rust_tokenizer.tokenize(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) # Testing conversion to ids without special tokens snake_case__ : Union[str, Any] = tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ , add_prefix_space=snake_case_ ) snake_case__ : Tuple = rust_tokenizer.encode(snake_case_ , add_special_tokens=snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) # Testing conversion to ids with special tokens snake_case__ : Optional[Any] = self.get_rust_tokenizer(add_prefix_space=snake_case_ ) snake_case__ : Tuple = tokenizer.encode(snake_case_ , add_prefix_space=snake_case_ ) snake_case__ : Optional[Any] = rust_tokenizer.encode(snake_case_ ) self.assertListEqual(snake_case_ , snake_case_ ) # Testing the unknown token snake_case__ : List[Any] = tokens + [rust_tokenizer.unk_token] snake_case__ : Union[str, Any] = [14, 15, 10, 9, 3, 2, 15, 19] self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(snake_case_ ) , snake_case_ ) def lowerCamelCase ( self : Union[str, Any] , *snake_case_ : Union[str, Any] , **snake_case_ : Union[str, Any] ): # It's very difficult to mix/test pretokenization with byte-level # And get both CodeGen and Roberta to work at the same time (mostly an issue of adding a space before the string) pass def lowerCamelCase ( self : Union[str, Any] , snake_case_ : str=15 ): for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ): snake_case__ : Dict = self.rust_tokenizer_class.from_pretrained(snake_case_ , **snake_case_ ) # Simple input snake_case__ : Tuple = """This is a simple input""" snake_case__ : Tuple = ["""This is a simple input 1""", """This is a simple input 2"""] snake_case__ : Tuple = ("""This is a simple input""", """This is a pair""") snake_case__ : Any = [ ("""This is a simple input 1""", """This is a simple input 2"""), ("""This is a simple pair 1""", """This is a simple pair 2"""), ] # Simple input tests self.assertRaises(snake_case_ , tokenizer_r.encode , snake_case_ , max_length=snake_case_ , padding="""max_length""" ) # Simple input self.assertRaises(snake_case_ , tokenizer_r.encode_plus , snake_case_ , max_length=snake_case_ , padding="""max_length""" ) # Simple input self.assertRaises( snake_case_ , tokenizer_r.batch_encode_plus , snake_case_ , max_length=snake_case_ , padding="""max_length""" , ) # Pair input self.assertRaises(snake_case_ , tokenizer_r.encode , snake_case_ , max_length=snake_case_ , padding="""max_length""" ) # Pair input self.assertRaises(snake_case_ , tokenizer_r.encode_plus , snake_case_ , max_length=snake_case_ , padding="""max_length""" ) # Pair input self.assertRaises( snake_case_ , tokenizer_r.batch_encode_plus , snake_case_ , max_length=snake_case_ , padding="""max_length""" , ) def lowerCamelCase ( self : Dict ): snake_case__ : Tuple = CodeGenTokenizer.from_pretrained(self.tmpdirname , pad_token="""<pad>""" ) # Simple input snake_case__ : Optional[int] = """This is a simple input""" snake_case__ : int = ["""This is a simple input looooooooong""", """This is a simple input"""] snake_case__ : Optional[int] = ("""This is a simple input""", """This is a pair""") snake_case__ : int = [ ("""This is a simple input loooooong""", """This is a simple input"""), ("""This is a simple pair loooooong""", """This is a simple pair"""), ] snake_case__ : Dict = tokenizer.pad_token_id snake_case__ : Tuple = tokenizer(snake_case_ , padding="""max_length""" , max_length=30 , return_tensors="""np""" ) snake_case__ : List[Any] = tokenizer(snake_case_ , padding=snake_case_ , truncate=snake_case_ , return_tensors="""np""" ) snake_case__ : Optional[Any] = tokenizer(*snake_case_ , padding="""max_length""" , max_length=60 , return_tensors="""np""" ) snake_case__ : Tuple = tokenizer(snake_case_ , padding=snake_case_ , truncate=snake_case_ , return_tensors="""np""" ) # s # test single string max_length padding self.assertEqual(out_s["""input_ids"""].shape[-1] , 30 ) self.assertTrue(pad_token_id in out_s["""input_ids"""] ) self.assertTrue(0 in out_s["""attention_mask"""] ) # s2 # test automatic padding self.assertEqual(out_sa["""input_ids"""].shape[-1] , 33 ) # long slice doesn't have padding self.assertFalse(pad_token_id in out_sa["""input_ids"""][0] ) self.assertFalse(0 in out_sa["""attention_mask"""][0] ) # short slice does have padding self.assertTrue(pad_token_id in out_sa["""input_ids"""][1] ) self.assertTrue(0 in out_sa["""attention_mask"""][1] ) # p # test single pair max_length padding self.assertEqual(out_p["""input_ids"""].shape[-1] , 60 ) self.assertTrue(pad_token_id in out_p["""input_ids"""] ) self.assertTrue(0 in out_p["""attention_mask"""] ) # p2 # test automatic padding pair self.assertEqual(out_pa["""input_ids"""].shape[-1] , 52 ) # long slice pair doesn't have padding self.assertFalse(pad_token_id in out_pa["""input_ids"""][0] ) self.assertFalse(0 in out_pa["""attention_mask"""][0] ) # short slice pair does have padding self.assertTrue(pad_token_id in out_pa["""input_ids"""][1] ) self.assertTrue(0 in out_pa["""attention_mask"""][1] ) def lowerCamelCase ( self : List[Any] ): snake_case__ : Tuple = """$$$""" snake_case__ : Any = CodeGenTokenizer.from_pretrained(self.tmpdirname , bos_token=snake_case_ , add_bos_token=snake_case_ ) snake_case__ : str = """This is a simple input""" snake_case__ : Dict = ["""This is a simple input 1""", """This is a simple input 2"""] snake_case__ : Optional[int] = tokenizer.bos_token_id snake_case__ : Any = tokenizer(snake_case_ ) snake_case__ : Union[str, Any] = tokenizer(snake_case_ ) self.assertEqual(out_s.input_ids[0] , snake_case_ ) self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids ) ) snake_case__ : Dict = tokenizer.decode(out_s.input_ids ) snake_case__ : Optional[Any] = tokenizer.batch_decode(out_sa.input_ids ) self.assertEqual(decode_s.split()[0] , snake_case_ ) self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa ) ) @slow def lowerCamelCase ( self : Union[str, Any] ): snake_case__ : Optional[int] = CodeGenTokenizer.from_pretrained("""Salesforce/codegen-350M-mono""" ) snake_case__ : Optional[Any] = """\nif len_a > len_b:\n result = a\nelse:\n result = b\n\n\n\n#""" snake_case__ : Dict = """\nif len_a > len_b: result = a\nelse: result = b""" snake_case__ : Any = tokenizer.encode(snake_case_ ) snake_case__ : Any = ["""^#""", re.escape("""<|endoftext|>""" ), """^'''""", """^\"\"\"""", """\n\n\n"""] snake_case__ : List[str] = tokenizer.decode(snake_case_ , truncate_before_pattern=snake_case_ ) self.assertEqual(snake_case_ , snake_case_ ) def lowerCamelCase ( self : Dict ): pass
43
'''simple docstring''' import re from filelock import FileLock try: import nltk __a = True except (ImportError, ModuleNotFoundError): __a = False if NLTK_AVAILABLE: with FileLock(".lock") as lock: nltk.download("punkt", quiet=True) def __snake_case( _lowerCAmelCase ) -> str: re.sub("""<n>""" , """""" , _lowerCAmelCase ) # remove pegasus newline char assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)" return "\n".join(nltk.sent_tokenize(_lowerCAmelCase ) )
43
1
def UpperCAmelCase_ ( __UpperCAmelCase : int ) -> int: if not isinstance(__UpperCAmelCase , __UpperCAmelCase ): raise TypeError('only integers accepted as input' ) else: SCREAMING_SNAKE_CASE_ = str(abs(__UpperCAmelCase ) ) SCREAMING_SNAKE_CASE_ = [list(__UpperCAmelCase ) for char in range(len(__UpperCAmelCase ) )] for index in range(len(__UpperCAmelCase ) ): num_transpositions[index].pop(__UpperCAmelCase ) return max( int(''.join(list(__UpperCAmelCase ) ) ) for transposition in num_transpositions ) if __name__ == "__main__": __import__('doctest').testmod()
225
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available lowerCamelCase__ : str = { 'configuration_mask2former': [ 'MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Mask2FormerConfig', ], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ : int = ['Mask2FormerImageProcessor'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: lowerCamelCase__ : Dict = [ 'MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST', 'Mask2FormerForUniversalSegmentation', 'Mask2FormerModel', 'Mask2FormerPreTrainedModel', ] if TYPE_CHECKING: from .configuration_maskaformer import MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskaFormerConfig try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .image_processing_maskaformer import MaskaFormerImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_maskaformer import ( MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST, MaskaFormerForUniversalSegmentation, MaskaFormerModel, MaskaFormerPreTrainedModel, ) else: import sys lowerCamelCase__ : Tuple = _LazyModule(__name__, globals()['__file__'], _import_structure)
225
1
"""simple docstring""" import argparse import torch from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert from transformers.utils import logging logging.set_verbosity_info() def a_ ( lowerCAmelCase_ : Union[str, Any], lowerCAmelCase_ : str, lowerCAmelCase_ : List[Any] ): __lowerCAmelCase = BertConfig.from_json_file(a__ ) print(F"""Building PyTorch model from configuration: {config}""" ) __lowerCAmelCase = BertForPreTraining(a__ ) # Load weights from tf checkpoint load_tf_weights_in_bert(a__, a__, a__ ) # Save pytorch-model print(F"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict(), a__ ) if __name__ == "__main__": _snake_case : Any = 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( '--bert_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.' ) _snake_case : Union[str, Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
371
from math import factorial class _UpperCAmelCase : """simple docstring""" def __init__( self : Dict , lowerCAmelCase_ : Optional[int] , lowerCAmelCase_ : str ) -> Union[str, Any]: __lowerCAmelCase = real if isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): __lowerCAmelCase = [1] * rank else: __lowerCAmelCase = rank def __repr__( self : Optional[Any] ) -> Tuple: return ( f"""{self.real}+""" f"""{"+".join(str(lowerCAmelCase_ )+"E"+str(n+1 )for n,dual in enumerate(self.duals ) )}""" ) def lowercase ( self : str ) -> Dict: __lowerCAmelCase = self.duals.copy() while cur[-1] == 0: cur.pop(-1 ) return Dual(self.real , lowerCAmelCase_ ) def __add__( self : Union[str, Any] , lowerCAmelCase_ : Tuple ) -> Optional[Any]: if not isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): return Dual(self.real + other , self.duals ) __lowerCAmelCase = self.duals.copy() __lowerCAmelCase = other.duals.copy() if len(lowerCAmelCase_ ) > len(lowerCAmelCase_ ): o_dual.extend([1] * (len(lowerCAmelCase_ ) - len(lowerCAmelCase_ )) ) elif len(lowerCAmelCase_ ) < len(lowerCAmelCase_ ): s_dual.extend([1] * (len(lowerCAmelCase_ ) - len(lowerCAmelCase_ )) ) __lowerCAmelCase = [] for i in range(len(lowerCAmelCase_ ) ): new_duals.append(s_dual[i] + o_dual[i] ) return Dual(self.real + other.real , lowerCAmelCase_ ) a_ = __add__ def __sub__( self : int , lowerCAmelCase_ : Dict ) -> Optional[Any]: return self + other * -1 def __mul__( self : int , lowerCAmelCase_ : Optional[int] ) -> Dict: if not isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): __lowerCAmelCase = [] for i in self.duals: new_duals.append(i * other ) return Dual(self.real * other , lowerCAmelCase_ ) __lowerCAmelCase = [0] * (len(self.duals ) + len(other.duals ) + 1) for i, item in enumerate(self.duals ): for j, jtem in enumerate(other.duals ): new_duals[i + j + 1] += item * jtem for k in range(len(self.duals ) ): new_duals[k] += self.duals[k] * other.real for index in range(len(other.duals ) ): new_duals[index] += other.duals[index] * self.real return Dual(self.real * other.real , lowerCAmelCase_ ) a_ = __mul__ def __truediv__( self : Union[str, Any] , lowerCAmelCase_ : str ) -> Dict: if not isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): __lowerCAmelCase = [] for i in self.duals: new_duals.append(i / other ) return Dual(self.real / other , lowerCAmelCase_ ) raise ValueError def __floordiv__( self : str , lowerCAmelCase_ : List[Any] ) -> Union[str, Any]: if not isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): __lowerCAmelCase = [] for i in self.duals: new_duals.append(i // other ) return Dual(self.real // other , lowerCAmelCase_ ) raise ValueError def __pow__( self : Tuple , lowerCAmelCase_ : Dict ) -> List[str]: if n < 0 or isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): raise ValueError('power must be a positive integer' ) if n == 0: return 1 if n == 1: return self __lowerCAmelCase = self for _ in range(n - 1 ): x *= self return x def a_ ( lowerCAmelCase_ : List[str], lowerCAmelCase_ : Optional[Any], lowerCAmelCase_ : Optional[Any] ): if not callable(lowerCAmelCase_ ): raise ValueError('differentiate() requires a function as input for func' ) if not isinstance(lowerCAmelCase_, (float, int) ): raise ValueError('differentiate() requires a float as input for position' ) if not isinstance(lowerCAmelCase_, lowerCAmelCase_ ): raise ValueError('differentiate() requires an int as input for order' ) __lowerCAmelCase = Dual(lowerCAmelCase_, 1 ) __lowerCAmelCase = func(lowerCAmelCase_ ) if order == 0: return result.real return result.duals[order - 1] * factorial(lowerCAmelCase_ ) if __name__ == "__main__": import doctest doctest.testmod() def a_ ( lowerCAmelCase_ : int ): return y**2 * y**4 print(differentiate(f, 9, 2))
207
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 __snake_case =logging.get_logger(__name__) __snake_case ={ """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 UpperCAmelCase_ ( __lowercase , __lowercase ): lowerCamelCase : Union[str, Any] = '''swin''' lowerCamelCase : Optional[Any] = { '''num_attention_heads''': '''num_heads''', '''num_hidden_layers''': '''num_layers''', } def __init__( self : int , UpperCAmelCase__ : List[Any]=2_2_4 , UpperCAmelCase__ : Any=4 , UpperCAmelCase__ : Dict=3 , UpperCAmelCase__ : Union[str, Any]=9_6 , UpperCAmelCase__ : Any=[2, 2, 6, 2] , UpperCAmelCase__ : List[str]=[3, 6, 1_2, 2_4] , UpperCAmelCase__ : List[Any]=7 , UpperCAmelCase__ : Dict=4.0 , UpperCAmelCase__ : Any=True , UpperCAmelCase__ : Any=0.0 , UpperCAmelCase__ : Any=0.0 , UpperCAmelCase__ : Union[str, Any]=0.1 , UpperCAmelCase__ : Dict="gelu" , UpperCAmelCase__ : Optional[Any]=False , UpperCAmelCase__ : int=0.02 , UpperCAmelCase__ : Optional[Any]=1E-5 , UpperCAmelCase__ : List[str]=3_2 , UpperCAmelCase__ : Dict=None , UpperCAmelCase__ : Dict=None , **UpperCAmelCase__ : Dict , ) -> int: super().__init__(**UpperCAmelCase__ ) lowerCAmelCase = image_size lowerCAmelCase = patch_size lowerCAmelCase = num_channels lowerCAmelCase = embed_dim lowerCAmelCase = depths lowerCAmelCase = len(UpperCAmelCase__ ) 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(UpperCAmelCase__ ) - 1) ) lowerCAmelCase = ['stem'] + [F'''stage{idx}''' for idx in range(1 , len(UpperCAmelCase__ ) + 1 )] lowerCAmelCase , lowerCAmelCase = get_aligned_output_features_output_indices( out_features=UpperCAmelCase__ , out_indices=UpperCAmelCase__ , stage_names=self.stage_names ) class UpperCAmelCase_ ( __lowercase ): lowerCamelCase : Dict = version.parse('''1.11''' ) @property def __UpperCAmelCase ( self : Dict ) -> Mapping[str, Mapping[int, str]]: return OrderedDict( [ ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}), ] ) @property def __UpperCAmelCase ( self : Dict ) -> float: return 1E-4
4
def UpperCamelCase ( _A ): """simple docstring""" if not all(x.isalpha() for x in string ): raise ValueError("""String must only contain alphabetic characters.""" ) __magic_name__ : int = sorted(string.lower() ) return len(_A ) == len(set(_A ) ) if __name__ == "__main__": __magic_name__: Dict = input("Enter a string ").strip() __magic_name__: Union[str, Any] = is_isogram(input_str) print(F"""{input_str} is {'an' if isogram else 'not an'} isogram.""")
342
0
from __future__ import annotations def snake_case_ ( snake_case , snake_case , snake_case , snake_case ) -> List[str]: # noqa: E741 while r - l > 1: lowercase__: Optional[Any] = (l + r) // 2 if v[m] >= key: lowercase__: Optional[Any] = m else: lowercase__: Optional[int] = m # noqa: E741 return r def snake_case_ ( snake_case ) -> Optional[int]: if len(__lowerCAmelCase ) == 0: return 0 lowercase__: Union[str, Any] = [0] * len(__lowerCAmelCase ) lowercase__: Tuple = 1 lowercase__: Optional[Any] = v[0] for i in range(1 , len(__lowerCAmelCase ) ): if v[i] < tail[0]: lowercase__: Union[str, Any] = v[i] elif v[i] > tail[length - 1]: lowercase__: Tuple = v[i] length += 1 else: lowercase__: List[str] = v[i] return length if __name__ == "__main__": import doctest doctest.testmod()
371
from typing import Dict from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available from transformers.testing_utils import ( TestCasePlus, execute_subprocess_async, get_torch_dist_unique_port, require_torch_multi_gpu, require_torch_neuroncore, ) from transformers.training_args import ParallelMode from transformers.utils import logging __lowerCAmelCase = logging.get_logger(__name__) if is_torch_available(): import torch from torch import nn from torch.utils.data import Dataset from transformers import Trainer class __a ( __UpperCamelCase ): def __init__( self , lowerCAmelCase__ = 101 ) -> Any: '''simple docstring''' lowercase__: Any = length def __len__( self ) -> List[Any]: '''simple docstring''' return self.length def __getitem__( self , lowerCAmelCase__ ) -> int: '''simple docstring''' return i class __a : def __call__( self , lowerCAmelCase__ ) -> List[str]: '''simple docstring''' return {"input_ids": torch.tensor(lowerCAmelCase__ ), "labels": torch.tensor(lowerCAmelCase__ )} class __a ( nn.Module ): def __init__( self ) -> Tuple: '''simple docstring''' super().__init__() # Add some (unused) params otherwise DDP will complain. lowercase__: List[str] = nn.Linear(120 , 80 ) def SCREAMING_SNAKE_CASE__ ( self , lowerCAmelCase__ , lowerCAmelCase__=None ) -> int: '''simple docstring''' if labels is not None: return torch.tensor(0.0 , device=input_ids.device ), input_ids else: return input_ids class __a ( __UpperCamelCase ): @require_torch_neuroncore def SCREAMING_SNAKE_CASE__ ( self ) -> Tuple: '''simple docstring''' lowercase__: int = F'--nproc_per_node=2\n --master_port={get_torch_dist_unique_port()}\n {self.test_file_dir}/test_trainer_distributed.py\n '.split() lowercase__: Tuple = self.get_auto_remove_tmp_dir() lowercase__: Optional[int] = F'--output_dir {output_dir}'.split() lowercase__: int = ['torchrun'] + distributed_args + args execute_subprocess_async(lowerCAmelCase__ , env=self.get_env() ) # successful return here == success - any errors would have caused an error in the sub-call class __a ( __UpperCamelCase ): @require_torch_multi_gpu def SCREAMING_SNAKE_CASE__ ( self ) -> Any: '''simple docstring''' lowercase__: List[str] = F'--nproc_per_node={torch.cuda.device_count()}\n --master_port={get_torch_dist_unique_port()}\n {self.test_file_dir}/test_trainer_distributed.py\n '.split() lowercase__: Tuple = self.get_auto_remove_tmp_dir() lowercase__: List[str] = F'--output_dir {output_dir}'.split() lowercase__: int = ['torchrun'] + distributed_args + args execute_subprocess_async(lowerCAmelCase__ , env=self.get_env() ) # successful return here == success - any errors would have caused an error in the sub-call if __name__ == "__main__": # The script below is meant to be run under torch.distributed, on a machine with multiple GPUs: # # PYTHONPATH="src" python -m torch.distributed.run --nproc_per_node 2 --output_dir output_dir ./tests/test_trainer_distributed.py __lowerCAmelCase = HfArgumentParser((TrainingArguments,)) __lowerCAmelCase = parser.parse_args_into_dataclasses()[0] logger.warning( F'''Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, ''' F'''distributed training: {training_args.parallel_mode != ParallelMode.NOT_DISTRIBUTED}''' ) # Essentially, what we want to verify in the distributed case is that we get all samples back, # in the right order. (this is crucial for prediction for instance) for dataset_length in [1_01, 40, 7]: __lowerCAmelCase = DummyDataset(dataset_length) def snake_case_ ( snake_case ) -> Dict: lowercase__: str = list(range(len(snake_case ) ) ) lowercase__: Tuple = p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential if not success and training_args.local_rank == 0: logger.warning( 'Predictions and/or labels do not match expected results:\n - predictions: ' f'{p.predictions.tolist()}\n - labels: {p.label_ids.tolist()}\n - expected: {sequential}' ) return {"success": success} __lowerCAmelCase = Trainer( model=DummyModel(), args=training_args, data_collator=DummyDataCollator(), eval_dataset=dataset, compute_metrics=compute_metrics, ) __lowerCAmelCase = trainer.evaluate() logger.info(metrics) if metrics["eval_success"] is not True: logger.error(metrics) exit(1) __lowerCAmelCase = trainer.predict(dataset) logger.info(p.metrics) if p.metrics["test_success"] is not True: logger.error(p.metrics) exit(1) __lowerCAmelCase = 2 __lowerCAmelCase = trainer.evaluate() logger.info(metrics) if metrics["eval_success"] is not True: logger.error(metrics) exit(1) __lowerCAmelCase = trainer.predict(dataset) logger.info(p.metrics) if p.metrics["test_success"] is not True: logger.error(p.metrics) exit(1) __lowerCAmelCase = None
288
0
"""simple docstring""" from __future__ import annotations import math def UpperCamelCase ( _lowerCAmelCase : int, _lowerCAmelCase : int, _lowerCAmelCase : bool, _lowerCAmelCase : list[int], _lowerCAmelCase : float ) -> int: if depth < 0: raise ValueError("""Depth cannot be less than 0""" ) if not scores: raise ValueError("""Scores cannot be empty""" ) if depth == height: return scores[node_index] return ( max( minimax(depth + 1, node_index * 2, _lowerCAmelCase, _lowerCAmelCase, _lowerCAmelCase ), minimax(depth + 1, node_index * 2 + 1, _lowerCAmelCase, _lowerCAmelCase, _lowerCAmelCase ), ) if is_max else min( minimax(depth + 1, node_index * 2, _lowerCAmelCase, _lowerCAmelCase, _lowerCAmelCase ), minimax(depth + 1, node_index * 2 + 1, _lowerCAmelCase, _lowerCAmelCase, _lowerCAmelCase ), ) ) def UpperCamelCase ( ) -> None: _UpperCAmelCase : Optional[Any] = [90, 23, 6, 33, 21, 65, 123, 34423] _UpperCAmelCase : Optional[int] = math.log(len(_lowerCAmelCase ), 2 ) print(f'''Optimal value : {minimax(0, 0, _lowerCAmelCase, _lowerCAmelCase, _lowerCAmelCase )}''' ) if __name__ == "__main__": import doctest doctest.testmod() main()
246
"""simple docstring""" from typing import List, Optional, Union import numpy as np import PIL import torch from PIL import Image from ...models import UNetaDConditionModel, VQModel from ...pipelines import DiffusionPipeline from ...pipelines.pipeline_utils import ImagePipelineOutput from ...schedulers import DDPMScheduler from ...utils import ( is_accelerate_available, is_accelerate_version, logging, randn_tensor, replace_example_docstring, ) lowerCamelCase__ : Any = logging.get_logger(__name__) # pylint: disable=invalid-name lowerCamelCase__ : Union[str, Any] = ''' Examples: ```py >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline >>> from diffusers.utils import load_image >>> import torch >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained( ... "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16 ... ) >>> pipe_prior.to("cuda") >>> prompt = "A red cartoon frog, 4k" >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False) >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained( ... "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16 ... ) >>> pipe.to("cuda") >>> init_image = load_image( ... "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" ... "/kandinsky/frog.png" ... ) >>> image = pipe( ... image=init_image, ... image_embeds=image_emb, ... negative_image_embeds=zero_image_emb, ... height=768, ... width=768, ... num_inference_steps=100, ... strength=0.2, ... ).images >>> image[0].save("red_frog.png") ``` ''' def UpperCamelCase ( _lowerCAmelCase : int, _lowerCAmelCase : List[Any], _lowerCAmelCase : Optional[Any]=8 ) -> Union[str, Any]: _UpperCAmelCase : Dict = height // scale_factor**2 if height % scale_factor**2 != 0: new_height += 1 _UpperCAmelCase : Tuple = width // scale_factor**2 if width % scale_factor**2 != 0: new_width += 1 return new_height * scale_factor, new_width * scale_factor def UpperCamelCase ( _lowerCAmelCase : Union[str, Any], _lowerCAmelCase : Any=512, _lowerCAmelCase : Optional[Any]=512 ) -> Optional[Any]: _UpperCAmelCase : Optional[int] = pil_image.resize((w, h), resample=Image.BICUBIC, reducing_gap=1 ) _UpperCAmelCase : List[Any] = np.array(pil_image.convert("""RGB""" ) ) _UpperCAmelCase : str = arr.astype(np.floataa ) / 127.5 - 1 _UpperCAmelCase : Dict = np.transpose(_lowerCAmelCase, [2, 0, 1] ) _UpperCAmelCase : Union[str, Any] = torch.from_numpy(_lowerCAmelCase ).unsqueeze(0 ) return image class _UpperCAmelCase ( __a): def __init__( self , _A , _A , _A , ) -> int: '''simple docstring''' super().__init__() self.register_modules( unet=_A , scheduler=_A , movq=_A , ) _UpperCAmelCase : Optional[Any] = 2 ** (len(self.movq.config.block_out_channels ) - 1) def __snake_case ( self , _A , _A , _A ) -> List[Any]: '''simple docstring''' _UpperCAmelCase : int = min(int(num_inference_steps * strength ) , _A ) _UpperCAmelCase : Dict = max(num_inference_steps - init_timestep , 0 ) _UpperCAmelCase : Tuple = self.scheduler.timesteps[t_start:] return timesteps, num_inference_steps - t_start def __snake_case ( self , _A , _A , _A , _A , _A , _A , _A=None ) -> List[Any]: '''simple docstring''' if not isinstance(_A , (torch.Tensor, PIL.Image.Image, list) ): raise ValueError( f'''`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(_A )}''' ) _UpperCAmelCase : Any = image.to(device=_A , dtype=_A ) _UpperCAmelCase : Optional[int] = batch_size * num_images_per_prompt if image.shape[1] == 4: _UpperCAmelCase : Dict = image else: if isinstance(_A , _A ) and len(_A ) != batch_size: raise ValueError( f'''You have passed a list of generators of length {len(_A )}, but requested an effective batch''' f''' size of {batch_size}. Make sure the batch size matches the length of the generators.''' ) elif isinstance(_A , _A ): _UpperCAmelCase : Any = [ self.movq.encode(image[i : i + 1] ).latent_dist.sample(generator[i] ) for i in range(_A ) ] _UpperCAmelCase : List[Any] = torch.cat(_A , dim=0 ) else: _UpperCAmelCase : str = self.movq.encode(_A ).latent_dist.sample(_A ) _UpperCAmelCase : Any = self.movq.config.scaling_factor * init_latents _UpperCAmelCase : List[Any] = torch.cat([init_latents] , dim=0 ) _UpperCAmelCase : Union[str, Any] = init_latents.shape _UpperCAmelCase : List[Any] = randn_tensor(_A , generator=_A , device=_A , dtype=_A ) # get latents _UpperCAmelCase : Optional[int] = self.scheduler.add_noise(_A , _A , _A ) _UpperCAmelCase : Optional[int] = init_latents return latents def __snake_case ( self , _A=0 ) -> Optional[Any]: '''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 : Tuple = [ self.unet, self.movq, ] for cpu_offloaded_model in models: if cpu_offloaded_model is not None: cpu_offload(_A , _A ) def __snake_case ( self , _A=0 ) -> int: '''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 : int = 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 : Any = None for cpu_offloaded_model in [self.unet, self.movq]: _UpperCAmelCase , _UpperCAmelCase : Tuple = cpu_offload_with_hook(_A , _A , prev_module_hook=_A ) # We'll offload the last model manually. _UpperCAmelCase : Optional[int] = hook @property # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device def __snake_case ( self ) -> List[str]: '''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 , _A , _A , _A , _A = 5_12 , _A = 5_12 , _A = 1_00 , _A = 4.0 , _A = 0.3 , _A = 1 , _A = None , _A = "pil" , _A = True , ) -> Any: '''simple docstring''' _UpperCAmelCase : Union[str, Any] = self._execution_device _UpperCAmelCase : List[str] = guidance_scale > 1.0 if isinstance(_A , _A ): _UpperCAmelCase : Dict = torch.cat(_A , dim=0 ) _UpperCAmelCase : Any = image_embeds.shape[0] if isinstance(_A , _A ): _UpperCAmelCase : Any = torch.cat(_A , dim=0 ) if do_classifier_free_guidance: _UpperCAmelCase : str = image_embeds.repeat_interleave(_A , dim=0 ) _UpperCAmelCase : Optional[int] = negative_image_embeds.repeat_interleave(_A , dim=0 ) _UpperCAmelCase : str = torch.cat([negative_image_embeds, image_embeds] , dim=0 ).to(dtype=self.unet.dtype , device=_A ) if not isinstance(_A , _A ): _UpperCAmelCase : str = [image] if not all(isinstance(_A , (PIL.Image.Image, torch.Tensor) ) for i in image ): raise ValueError( f'''Input is in incorrect format: {[type(_A ) for i in image]}. Currently, we only support PIL image and pytorch tensor''' ) _UpperCAmelCase : Union[str, Any] = torch.cat([prepare_image(_A , _A , _A ) for i in image] , dim=0 ) _UpperCAmelCase : List[Any] = image.to(dtype=image_embeds.dtype , device=_A ) _UpperCAmelCase : int = self.movq.encode(_A )["""latents"""] _UpperCAmelCase : Dict = latents.repeat_interleave(_A , dim=0 ) self.scheduler.set_timesteps(_A , device=_A ) _UpperCAmelCase , _UpperCAmelCase : Any = self.get_timesteps(_A , _A , _A ) _UpperCAmelCase : Dict = timesteps[:1].repeat(batch_size * num_images_per_prompt ) _UpperCAmelCase , _UpperCAmelCase : str = downscale_height_and_width(_A , _A , self.movq_scale_factor ) _UpperCAmelCase : List[Any] = self.prepare_latents( _A , _A , _A , _A , image_embeds.dtype , _A , _A ) for i, t in enumerate(self.progress_bar(_A ) ): # expand the latents if we are doing classifier free guidance _UpperCAmelCase : Union[str, Any] = torch.cat([latents] * 2 ) if do_classifier_free_guidance else latents _UpperCAmelCase : Union[str, Any] = {"""image_embeds""": image_embeds} _UpperCAmelCase : 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 : Any = noise_pred.split(latents.shape[1] , dim=1 ) _UpperCAmelCase , _UpperCAmelCase : Any = noise_pred.chunk(2 ) _UpperCAmelCase , _UpperCAmelCase : Union[str, Any] = variance_pred.chunk(2 ) _UpperCAmelCase : List[str] = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) _UpperCAmelCase : Optional[int] = 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 : Dict = noise_pred.split(latents.shape[1] , dim=1 ) # compute the previous noisy sample x_t -> x_t-1 _UpperCAmelCase : List[Any] = self.scheduler.step( _A , _A , _A , generator=_A , )[0] # post-processing _UpperCAmelCase : Optional[int] = 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 : Any = image * 0.5 + 0.5 _UpperCAmelCase : Dict = image.clamp(0 , 1 ) _UpperCAmelCase : str = image.cpu().permute(0 , 2 , 3 , 1 ).float().numpy() if output_type == "pil": _UpperCAmelCase : List[str] = self.numpy_to_pil(_A ) if not return_dict: return (image,) return ImagePipelineOutput(images=_A )
246
1
'''simple docstring''' def SCREAMING_SNAKE_CASE_ () -> int: for n in range(1 , 1000000 ): yield n * (n + 1) // 2 def SCREAMING_SNAKE_CASE_ (UpperCamelCase ) -> List[Any]: lowerCamelCase__ : Tuple = 1 lowerCamelCase__ : Union[str, Any] = 2 while i * i <= n: lowerCamelCase__ : List[str] = 0 while n % i == 0: n //= i multiplicity += 1 divisors_count *= multiplicity + 1 i += 1 if n > 1: divisors_count *= 2 return divisors_count def SCREAMING_SNAKE_CASE_ () -> Any: return next(i for i in triangle_number_generator() if count_divisors(UpperCamelCase ) > 500 ) if __name__ == "__main__": print(solution())
129
'''simple docstring''' from torch import nn def SCREAMING_SNAKE_CASE_ (UpperCamelCase ) -> Dict: if act_fn in ["swish", "silu"]: return nn.SiLU() elif act_fn == "mish": return nn.Mish() elif act_fn == "gelu": return nn.GELU() else: raise ValueError(f'''Unsupported activation function: {act_fn}''' )
129
1
"""simple docstring""" import copy from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict from packaging import version from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging from ..auto.configuration_auto import AutoConfig if TYPE_CHECKING: from ... import PreTrainedTokenizerBase, TensorType UpperCAmelCase__ = logging.get_logger(__name__) class lowerCAmelCase__ ( A_ ): __a = """vision-encoder-decoder""" __a = True def __init__( self : Dict , **_lowerCamelCase : Dict ): super().__init__(**_lowerCamelCase ) if "encoder" not in kwargs or "decoder" not in kwargs: raise ValueError( f'''A configuraton of type {self.model_type} cannot be instantiated because ''' f'''not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}''' ) _snake_case = kwargs.pop('''encoder''' ) _snake_case = encoder_config.pop('''model_type''' ) _snake_case = kwargs.pop('''decoder''' ) _snake_case = decoder_config.pop('''model_type''' ) _snake_case = AutoConfig.for_model(_lowerCamelCase , **_lowerCamelCase ) _snake_case = AutoConfig.for_model(_lowerCamelCase , **_lowerCamelCase ) _snake_case = True @classmethod def lowercase ( cls : Tuple , _lowerCamelCase : PretrainedConfig , _lowerCamelCase : PretrainedConfig , **_lowerCamelCase : Dict ): logger.info('''Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config''' ) _snake_case = True _snake_case = True return cls(encoder=encoder_config.to_dict() , decoder=decoder_config.to_dict() , **_lowerCamelCase ) def lowercase ( self : Dict ): _snake_case = copy.deepcopy(self.__dict__ ) _snake_case = self.encoder.to_dict() _snake_case = self.decoder.to_dict() _snake_case = self.__class__.model_type return output class lowerCAmelCase__ ( A_ ): __a = version.parse("""1.11""" ) @property def lowercase ( self : str ): return OrderedDict( [ ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}), ] ) @property def lowercase ( self : List[Any] ): return 1e-4 @property def lowercase ( self : Optional[Any] ): return OrderedDict({'''last_hidden_state''': {0: '''batch''', 1: '''encoder_sequence'''}} ) class lowerCAmelCase__ ( A_ ): @property def lowercase ( self : Dict ): _snake_case = OrderedDict() _snake_case = {0: '''batch''', 1: '''past_decoder_sequence + sequence'''} _snake_case = {0: '''batch''', 1: '''past_decoder_sequence + sequence'''} _snake_case = {0: '''batch''', 1: '''encoder_sequence'''} return common_inputs def lowercase ( self : str , _lowerCamelCase : "PreTrainedTokenizerBase" , _lowerCamelCase : int = -1 , _lowerCamelCase : int = -1 , _lowerCamelCase : bool = False , _lowerCamelCase : Optional["TensorType"] = None , ): import torch _snake_case = OrderedDict() _snake_case = super().generate_dummy_inputs( _lowerCamelCase , batch_size=_lowerCamelCase , seq_length=_lowerCamelCase , is_pair=_lowerCamelCase , framework=_lowerCamelCase ) _snake_case , _snake_case = dummy_input['''input_ids'''].shape _snake_case = (batch, encoder_sequence, self._config.encoder_hidden_size) _snake_case = dummy_input.pop('''input_ids''' ) _snake_case = dummy_input.pop('''attention_mask''' ) _snake_case = torch.zeros(_lowerCamelCase ) return common_inputs class lowerCAmelCase__ ( A_ ): @property def lowercase ( self : Optional[int] ): pass def lowercase ( self : List[Any] , _lowerCamelCase : PretrainedConfig ): return VisionEncoderDecoderEncoderOnnxConfig(_lowerCamelCase ) def lowercase ( self : Any , _lowerCamelCase : PretrainedConfig , _lowerCamelCase : PretrainedConfig , _lowerCamelCase : str = "default" ): _snake_case = encoder_config.hidden_size return VisionEncoderDecoderDecoderOnnxConfig(_lowerCamelCase , _lowerCamelCase )
288
"""simple docstring""" import os from shutil import copyfile from typing import List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging UpperCAmelCase__ = logging.get_logger(__name__) UpperCAmelCase__ = {'vocab_file': 'sentencepiece.model'} UpperCAmelCase__ = { 'vocab_file': { 'google/rembert': 'https://huggingface.co/google/rembert/resolve/main/sentencepiece.model', }, } UpperCAmelCase__ = { 'google/rembert': 256, } class lowerCAmelCase__ ( A_ ): __a = VOCAB_FILES_NAMES __a = PRETRAINED_VOCAB_FILES_MAP __a = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES def __init__( self : Union[str, Any] , _lowerCamelCase : Any , _lowerCamelCase : Union[str, Any]=False , _lowerCamelCase : Any=True , _lowerCamelCase : Optional[Any]=True , _lowerCamelCase : int="[CLS]" , _lowerCamelCase : Optional[int]="[SEP]" , _lowerCamelCase : Optional[int]="[UNK]" , _lowerCamelCase : Optional[Any]="[SEP]" , _lowerCamelCase : str="[PAD]" , _lowerCamelCase : List[Any]="[CLS]" , _lowerCamelCase : Any="[MASK]" , **_lowerCamelCase : Optional[int] , ): super().__init__( do_lower_case=_lowerCamelCase , remove_space=_lowerCamelCase , keep_accents=_lowerCamelCase , bos_token=_lowerCamelCase , eos_token=_lowerCamelCase , unk_token=_lowerCamelCase , sep_token=_lowerCamelCase , pad_token=_lowerCamelCase , cls_token=_lowerCamelCase , mask_token=_lowerCamelCase , **_lowerCamelCase , ) _snake_case = do_lower_case _snake_case = remove_space _snake_case = keep_accents _snake_case = vocab_file _snake_case = spm.SentencePieceProcessor() self.sp_model.Load(_lowerCamelCase ) @property def lowercase ( self : int ): return len(self.sp_model ) def lowercase ( self : Any ): _snake_case = {self.convert_ids_to_tokens(_lowerCamelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : List[str] ): _snake_case = self.__dict__.copy() _snake_case = None return state def __setstate__( self : List[str] , _lowerCamelCase : Tuple ): _snake_case = d _snake_case = spm.SentencePieceProcessor() self.sp_model.Load(self.vocab_file ) def lowercase ( self : str , _lowerCamelCase : List[str] , _lowerCamelCase : Tuple=False ): _snake_case = self.sp_model.EncodeAsPieces(_lowerCamelCase ) return pieces def lowercase ( self : str , _lowerCamelCase : str ): return self.sp_model.PieceToId(_lowerCamelCase ) def lowercase ( self : List[str] , _lowerCamelCase : int ): return self.sp_model.IdToPiece(_lowerCamelCase ) def lowercase ( self : Union[str, Any] , _lowerCamelCase : Any ): _snake_case = self.sp_model.decode_pieces(_lowerCamelCase ) return out_string def lowercase ( self : Optional[Any] , _lowerCamelCase : List[int] , _lowerCamelCase : Optional[List[int]] = None ): _snake_case = [self.sep_token_id] _snake_case = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def lowercase ( self : Tuple , _lowerCamelCase : List[int] , _lowerCamelCase : Optional[List[int]] = None , _lowerCamelCase : 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 x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a] if token_ids_a is not None: return [1] + ([0] * len(_lowerCamelCase )) + [1] + ([0] * len(_lowerCamelCase )) + [1] return [1] + ([0] * len(_lowerCamelCase )) + [1] def lowercase ( self : Optional[int] , _lowerCamelCase : List[int] , _lowerCamelCase : Optional[List[int]] = None ): _snake_case = [self.sep_token_id] _snake_case = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] def lowercase ( self : List[str] , _lowerCamelCase : str , _lowerCamelCase : Optional[str] = None ): if not os.path.isdir(_lowerCamelCase ): logger.error('''Vocabulary path ({}) should be a directory'''.format(_lowerCamelCase ) ) return _snake_case = os.path.join( _lowerCamelCase , (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(_lowerCamelCase ): copyfile(self.vocab_file , _lowerCamelCase ) return (out_vocab_file,)
288
1
from math import pi def A ( a_ ,a_ ) -> float: return 2 * pi * radius * (angle / 360) if __name__ == "__main__": print(arc_length(90, 10))
245
from .constants import ( MODEL_NAME, OPTIMIZER_NAME, RNG_STATE_NAME, SAFE_WEIGHTS_INDEX_NAME, SAFE_WEIGHTS_NAME, SCALER_NAME, SCHEDULER_NAME, TORCH_LAUNCH_PARAMS, WEIGHTS_INDEX_NAME, WEIGHTS_NAME, ) from .dataclasses import ( BnbQuantizationConfig, ComputeEnvironment, CustomDtype, DeepSpeedPlugin, DistributedDataParallelKwargs, DistributedType, DynamoBackend, FPaRecipeKwargs, FullyShardedDataParallelPlugin, GradientAccumulationPlugin, GradScalerKwargs, InitProcessGroupKwargs, KwargsHandler, LoggerType, MegatronLMPlugin, PrecisionType, ProjectConfiguration, RNGType, SageMakerDistributedType, TensorInformation, TorchDynamoPlugin, ) from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env from .imports import ( get_ccl_version, is_abit_bnb_available, is_abit_bnb_available, is_aim_available, is_bfaa_available, is_bnb_available, is_botoa_available, is_ccl_available, is_comet_ml_available, is_datasets_available, is_deepspeed_available, is_fpa_available, is_ipex_available, is_megatron_lm_available, is_mlflow_available, is_mps_available, is_npu_available, is_rich_available, is_safetensors_available, is_sagemaker_available, is_tensorboard_available, is_tpu_available, is_transformers_available, is_wandb_available, is_xpu_available, ) from .modeling import ( check_device_map, check_tied_parameters_in_config, check_tied_parameters_on_same_device, compute_module_sizes, convert_file_size_to_int, dtype_byte_size, find_tied_parameters, get_balanced_memory, get_max_layer_size, get_max_memory, get_mixed_precision_context_manager, id_tensor_storage, infer_auto_device_map, load_checkpoint_in_model, load_offloaded_weights, load_state_dict, named_module_tensors, retie_parameters, set_module_tensor_to_device, shard_checkpoint, ) from .offload import ( OffloadedWeightsLoader, PrefixedDataset, extract_submodules_state_dict, load_offloaded_weight, offload_state_dict, offload_weight, save_offload_index, ) from .operations import ( broadcast, broadcast_object_list, concatenate, convert_outputs_to_fpaa, convert_to_fpaa, find_batch_size, find_device, gather, gather_object, get_data_structure, honor_type, initialize_tensors, is_namedtuple, is_tensor_information, is_torch_tensor, listify, pad_across_processes, recursively_apply, reduce, send_to_device, slice_tensors, ) from .versions import compare_versions, is_torch_version if is_deepspeed_available(): from .deepspeed import ( DeepSpeedEngineWrapper, DeepSpeedOptimizerWrapper, DeepSpeedSchedulerWrapper, DummyOptim, DummyScheduler, HfDeepSpeedConfig, ) from .bnb import has_abit_bnb_layers, load_and_quantize_model from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer from .launch import ( PrepareForLaunch, _filter_args, prepare_deepspeed_cmd_env, prepare_multi_gpu_env, prepare_sagemager_args_inputs, prepare_simple_launcher_cmd_env, prepare_tpu, ) from .megatron_lm import ( AbstractTrainStep, BertTrainStep, GPTTrainStep, MegatronEngine, MegatronLMDummyDataLoader, MegatronLMDummyScheduler, MegatronLMOptimizerWrapper, MegatronLMSchedulerWrapper, TaTrainStep, avg_losses_across_data_parallel_group, gather_across_data_parallel_groups, ) from .megatron_lm import initialize as megatron_lm_initialize from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader from .megatron_lm import prepare_model as megatron_lm_prepare_model from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler from .memory import find_executable_batch_size, release_memory from .other import ( extract_model_from_parallel, get_pretty_name, is_port_in_use, merge_dicts, patch_environment, save, wait_for_everyone, write_basic_config, ) from .random import set_seed, synchronize_rng_state, synchronize_rng_states from .torch_xla import install_xla from .tqdm import tqdm from .transformer_engine import convert_model, has_transformer_engine_layers
245
1
"""simple docstring""" import argparse import os import torch from diffusers import ( CMStochasticIterativeScheduler, ConsistencyModelPipeline, UNetaDModel, ) UpperCamelCase : Tuple = { "sample_size": 3_2, "in_channels": 3, "out_channels": 3, "layers_per_block": 2, "num_class_embeds": 1_0_0_0, "block_out_channels": [3_2, 6_4], "attention_head_dim": 8, "down_block_types": [ "ResnetDownsampleBlock2D", "AttnDownBlock2D", ], "up_block_types": [ "AttnUpBlock2D", "ResnetUpsampleBlock2D", ], "resnet_time_scale_shift": "scale_shift", "upsample_type": "resnet", "downsample_type": "resnet", } UpperCamelCase : List[Any] = { "sample_size": 6_4, "in_channels": 3, "out_channels": 3, "layers_per_block": 3, "num_class_embeds": 1_0_0_0, "block_out_channels": [1_9_2, 1_9_2 * 2, 1_9_2 * 3, 1_9_2 * 4], "attention_head_dim": 6_4, "down_block_types": [ "ResnetDownsampleBlock2D", "AttnDownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D", ], "up_block_types": [ "AttnUpBlock2D", "AttnUpBlock2D", "AttnUpBlock2D", "ResnetUpsampleBlock2D", ], "resnet_time_scale_shift": "scale_shift", "upsample_type": "resnet", "downsample_type": "resnet", } UpperCamelCase : Any = { "sample_size": 2_5_6, "in_channels": 3, "out_channels": 3, "layers_per_block": 2, "num_class_embeds": None, "block_out_channels": [2_5_6, 2_5_6, 2_5_6 * 2, 2_5_6 * 2, 2_5_6 * 4, 2_5_6 * 4], "attention_head_dim": 6_4, "down_block_types": [ "ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D", "AttnDownBlock2D", "AttnDownBlock2D", "AttnDownBlock2D", ], "up_block_types": [ "AttnUpBlock2D", "AttnUpBlock2D", "AttnUpBlock2D", "ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D", ], "resnet_time_scale_shift": "default", "upsample_type": "resnet", "downsample_type": "resnet", } UpperCamelCase : str = { "num_train_timesteps": 4_0, "sigma_min": 0.0_02, "sigma_max": 80.0, } UpperCamelCase : Union[str, Any] = { "num_train_timesteps": 2_0_1, "sigma_min": 0.0_02, "sigma_max": 80.0, } UpperCamelCase : Any = { "num_train_timesteps": 1_5_1, "sigma_min": 0.0_02, "sigma_max": 80.0, } def A ( snake_case :Dict ) -> int: if isinstance(snake_case , snake_case ): 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 argparse.ArgumentTypeError('boolean value expected' ) def A ( snake_case :List[str] , snake_case :List[Any] , snake_case :Dict , snake_case :List[str] , snake_case :Any=False ) -> Optional[Any]: __UpperCamelCase = checkpoint[f'{old_prefix}.in_layers.0.weight'] __UpperCamelCase = checkpoint[f'{old_prefix}.in_layers.0.bias'] __UpperCamelCase = checkpoint[f'{old_prefix}.in_layers.2.weight'] __UpperCamelCase = checkpoint[f'{old_prefix}.in_layers.2.bias'] __UpperCamelCase = checkpoint[f'{old_prefix}.emb_layers.1.weight'] __UpperCamelCase = checkpoint[f'{old_prefix}.emb_layers.1.bias'] __UpperCamelCase = checkpoint[f'{old_prefix}.out_layers.0.weight'] __UpperCamelCase = checkpoint[f'{old_prefix}.out_layers.0.bias'] __UpperCamelCase = checkpoint[f'{old_prefix}.out_layers.3.weight'] __UpperCamelCase = checkpoint[f'{old_prefix}.out_layers.3.bias'] if has_skip: __UpperCamelCase = checkpoint[f'{old_prefix}.skip_connection.weight'] __UpperCamelCase = checkpoint[f'{old_prefix}.skip_connection.bias'] return new_checkpoint def A ( snake_case :Union[str, Any] , snake_case :str , snake_case :List[str] , snake_case :List[Any] , snake_case :Union[str, Any]=None ) -> List[str]: __UpperCamelCase , __UpperCamelCase , __UpperCamelCase = checkpoint[f'{old_prefix}.qkv.weight'].chunk(3 , dim=0 ) __UpperCamelCase , __UpperCamelCase , __UpperCamelCase = checkpoint[f'{old_prefix}.qkv.bias'].chunk(3 , dim=0 ) __UpperCamelCase = checkpoint[f'{old_prefix}.norm.weight'] __UpperCamelCase = checkpoint[f'{old_prefix}.norm.bias'] __UpperCamelCase = weight_q.squeeze(-1 ).squeeze(-1 ) __UpperCamelCase = bias_q.squeeze(-1 ).squeeze(-1 ) __UpperCamelCase = weight_k.squeeze(-1 ).squeeze(-1 ) __UpperCamelCase = bias_k.squeeze(-1 ).squeeze(-1 ) __UpperCamelCase = weight_v.squeeze(-1 ).squeeze(-1 ) __UpperCamelCase = bias_v.squeeze(-1 ).squeeze(-1 ) __UpperCamelCase = ( checkpoint[f'{old_prefix}.proj_out.weight'].squeeze(-1 ).squeeze(-1 ) ) __UpperCamelCase = checkpoint[f'{old_prefix}.proj_out.bias'].squeeze(-1 ).squeeze(-1 ) return new_checkpoint def A ( snake_case :str , snake_case :List[Any] ) -> Tuple: __UpperCamelCase = torch.load(snake_case , map_location='cpu' ) __UpperCamelCase = {} __UpperCamelCase = checkpoint['time_embed.0.weight'] __UpperCamelCase = checkpoint['time_embed.0.bias'] __UpperCamelCase = checkpoint['time_embed.2.weight'] __UpperCamelCase = checkpoint['time_embed.2.bias'] if unet_config["num_class_embeds"] is not None: __UpperCamelCase = checkpoint['label_emb.weight'] __UpperCamelCase = checkpoint['input_blocks.0.0.weight'] __UpperCamelCase = checkpoint['input_blocks.0.0.bias'] __UpperCamelCase = unet_config['down_block_types'] __UpperCamelCase = unet_config['layers_per_block'] __UpperCamelCase = unet_config['attention_head_dim'] __UpperCamelCase = unet_config['block_out_channels'] __UpperCamelCase = 1 __UpperCamelCase = channels_list[0] for i, layer_type in enumerate(snake_case ): __UpperCamelCase = channels_list[i] __UpperCamelCase = current_channels != prev_channels if layer_type == "ResnetDownsampleBlock2D": for j in range(snake_case ): __UpperCamelCase = f'down_blocks.{i}.resnets.{j}' __UpperCamelCase = f'input_blocks.{current_layer}.0' __UpperCamelCase = True if j == 0 and downsample_block_has_skip else False __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case , has_skip=snake_case ) current_layer += 1 elif layer_type == "AttnDownBlock2D": for j in range(snake_case ): __UpperCamelCase = f'down_blocks.{i}.resnets.{j}' __UpperCamelCase = f'input_blocks.{current_layer}.0' __UpperCamelCase = True if j == 0 and downsample_block_has_skip else False __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case , has_skip=snake_case ) __UpperCamelCase = f'down_blocks.{i}.attentions.{j}' __UpperCamelCase = f'input_blocks.{current_layer}.1' __UpperCamelCase = convert_attention( snake_case , snake_case , snake_case , snake_case , snake_case ) current_layer += 1 if i != len(snake_case ) - 1: __UpperCamelCase = f'down_blocks.{i}.downsamplers.0' __UpperCamelCase = f'input_blocks.{current_layer}.0' __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case ) current_layer += 1 __UpperCamelCase = current_channels # hardcoded the mid-block for now __UpperCamelCase = 'mid_block.resnets.0' __UpperCamelCase = 'middle_block.0' __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case ) __UpperCamelCase = 'mid_block.attentions.0' __UpperCamelCase = 'middle_block.1' __UpperCamelCase = convert_attention(snake_case , snake_case , snake_case , snake_case , snake_case ) __UpperCamelCase = 'mid_block.resnets.1' __UpperCamelCase = 'middle_block.2' __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case ) __UpperCamelCase = 0 __UpperCamelCase = unet_config['up_block_types'] for i, layer_type in enumerate(snake_case ): if layer_type == "ResnetUpsampleBlock2D": for j in range(layers_per_block + 1 ): __UpperCamelCase = f'up_blocks.{i}.resnets.{j}' __UpperCamelCase = f'output_blocks.{current_layer}.0' __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case , has_skip=snake_case ) current_layer += 1 if i != len(snake_case ) - 1: __UpperCamelCase = f'up_blocks.{i}.upsamplers.0' __UpperCamelCase = f'output_blocks.{current_layer-1}.1' __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case ) elif layer_type == "AttnUpBlock2D": for j in range(layers_per_block + 1 ): __UpperCamelCase = f'up_blocks.{i}.resnets.{j}' __UpperCamelCase = f'output_blocks.{current_layer}.0' __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case , has_skip=snake_case ) __UpperCamelCase = f'up_blocks.{i}.attentions.{j}' __UpperCamelCase = f'output_blocks.{current_layer}.1' __UpperCamelCase = convert_attention( snake_case , snake_case , snake_case , snake_case , snake_case ) current_layer += 1 if i != len(snake_case ) - 1: __UpperCamelCase = f'up_blocks.{i}.upsamplers.0' __UpperCamelCase = f'output_blocks.{current_layer-1}.2' __UpperCamelCase = convert_resnet(snake_case , snake_case , snake_case , snake_case ) __UpperCamelCase = checkpoint['out.0.weight'] __UpperCamelCase = checkpoint['out.0.bias'] __UpperCamelCase = checkpoint['out.2.weight'] __UpperCamelCase = checkpoint['out.2.bias'] return new_checkpoint if __name__ == "__main__": UpperCamelCase : List[str] = argparse.ArgumentParser() parser.add_argument("--unet_path", default=None, type=str, required=True, help="Path to the unet.pt to convert.") parser.add_argument( "--dump_path", default=None, type=str, required=True, help="Path to output the converted UNet model." ) parser.add_argument("--class_cond", default=True, type=str, help="Whether the model is class-conditional.") UpperCamelCase : Dict = parser.parse_args() UpperCamelCase : List[Any] = strabool(args.class_cond) UpperCamelCase : List[str] = os.path.basename(args.unet_path) print(f'''Checkpoint: {ckpt_name}''') # Get U-Net config if "imagenet64" in ckpt_name: UpperCamelCase : Optional[int] = IMAGENET_64_UNET_CONFIG elif "256" in ckpt_name and (("bedroom" in ckpt_name) or ("cat" in ckpt_name)): UpperCamelCase : int = LSUN_256_UNET_CONFIG elif "test" in ckpt_name: UpperCamelCase : int = TEST_UNET_CONFIG else: raise ValueError(f'''Checkpoint type {ckpt_name} is not currently supported.''') if not args.class_cond: UpperCamelCase : Optional[int] = None UpperCamelCase : Dict = con_pt_to_diffuser(args.unet_path, unet_config) UpperCamelCase : List[Any] = UNetaDModel(**unet_config) image_unet.load_state_dict(converted_unet_ckpt) # Get scheduler config if "cd" in ckpt_name or "test" in ckpt_name: UpperCamelCase : str = CD_SCHEDULER_CONFIG elif "ct" in ckpt_name and "imagenet64" in ckpt_name: UpperCamelCase : int = CT_IMAGENET_64_SCHEDULER_CONFIG elif "ct" in ckpt_name and "256" in ckpt_name and (("bedroom" in ckpt_name) or ("cat" in ckpt_name)): UpperCamelCase : Union[str, Any] = CT_LSUN_256_SCHEDULER_CONFIG else: raise ValueError(f'''Checkpoint type {ckpt_name} is not currently supported.''') UpperCamelCase : Optional[Any] = CMStochasticIterativeScheduler(**scheduler_config) UpperCamelCase : Tuple = ConsistencyModelPipeline(unet=image_unet, scheduler=cm_scheduler) consistency_model.save_pretrained(args.dump_path)
316
"""simple docstring""" def A ( snake_case :list[int] , snake_case :int ) -> bool: __UpperCamelCase = len(snake_case ) __UpperCamelCase = [[False] * (required_sum + 1) for _ in range(arr_len + 1 )] # for each arr value, a sum of zero(0) can be formed by not taking any element # hence True/1 for i in range(arr_len + 1 ): __UpperCamelCase = True # sum is not zero and set is empty then false for i in range(1 , required_sum + 1 ): __UpperCamelCase = False for i in range(1 , arr_len + 1 ): for j in range(1 , required_sum + 1 ): if arr[i - 1] > j: __UpperCamelCase = subset[i - 1][j] if arr[i - 1] <= j: __UpperCamelCase = subset[i - 1][j] or subset[i - 1][j - arr[i - 1]] return subset[arr_len][required_sum] if __name__ == "__main__": import doctest doctest.testmod()
316
1
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging lowercase__ : List[str] = logging.get_logger(__name__) lowercase__ : int = { # See all MEGATRON_BERT models at https://huggingface.co/models?filter=bert } class _UpperCAmelCase ( lowerCAmelCase__): _lowerCAmelCase : Any = """megatron-bert""" def __init__( self : Optional[Any] , lowercase_ : int=29056 , lowercase_ : Dict=1024 , lowercase_ : Union[str, Any]=24 , lowercase_ : List[str]=16 , lowercase_ : List[str]=4096 , lowercase_ : str="gelu" , lowercase_ : Optional[int]=0.1 , lowercase_ : Optional[Any]=0.1 , lowercase_ : List[Any]=512 , lowercase_ : List[str]=2 , lowercase_ : Union[str, Any]=0.02 , lowercase_ : Dict=1E-12 , lowercase_ : Dict=0 , lowercase_ : Dict="absolute" , lowercase_ : Union[str, Any]=True , **lowercase_ : Optional[int] , ): super().__init__(pad_token_id=lowercase_ , **lowercase_ ) snake_case_ : Any = vocab_size snake_case_ : List[Any] = hidden_size snake_case_ : Optional[int] = num_hidden_layers snake_case_ : List[Any] = num_attention_heads snake_case_ : Dict = hidden_act snake_case_ : List[Any] = intermediate_size snake_case_ : str = hidden_dropout_prob snake_case_ : Optional[int] = attention_probs_dropout_prob snake_case_ : str = max_position_embeddings snake_case_ : List[Any] = type_vocab_size snake_case_ : List[Any] = initializer_range snake_case_ : str = layer_norm_eps snake_case_ : Tuple = position_embedding_type snake_case_ : str = use_cache
369
"""simple docstring""" def __lowercase ( _a = 4_000_000 ): snake_case_ : Dict = [] snake_case_, snake_case_ : List[str] = 0, 1 while b <= n: if b % 2 == 0: even_fibs.append(_a ) snake_case_, snake_case_ : str = b, a + b return sum(_a ) if __name__ == "__main__": print(f'{solution() = }')
155
0
"""simple docstring""" import argparse import json import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import ConvNextConfig, SegformerImageProcessor, UperNetConfig, UperNetForSemanticSegmentation def _snake_case ( lowercase__ : List[Any] ) -> str: '''simple docstring''' lowerCAmelCase_ :Dict = 3_8_4 if "tiny" in model_name: lowerCAmelCase_ :Optional[int] = [3, 3, 9, 3] lowerCAmelCase_ :Tuple = [9_6, 1_9_2, 3_8_4, 7_6_8] if "small" in model_name: lowerCAmelCase_ :Optional[Any] = [3, 3, 2_7, 3] lowerCAmelCase_ :int = [9_6, 1_9_2, 3_8_4, 7_6_8] if "base" in model_name: lowerCAmelCase_ :Union[str, Any] = [3, 3, 2_7, 3] lowerCAmelCase_ :str = [1_2_8, 2_5_6, 5_1_2, 1_0_2_4] lowerCAmelCase_ :Optional[int] = 5_1_2 if "large" in model_name: lowerCAmelCase_ :Union[str, Any] = [3, 3, 2_7, 3] lowerCAmelCase_ :List[str] = [1_9_2, 3_8_4, 7_6_8, 1_5_3_6] lowerCAmelCase_ :Union[str, Any] = 7_6_8 if "xlarge" in model_name: lowerCAmelCase_ :Optional[Any] = [3, 3, 2_7, 3] lowerCAmelCase_ :str = [2_5_6, 5_1_2, 1_0_2_4, 2_0_4_8] lowerCAmelCase_ :List[Any] = 1_0_2_4 # set label information lowerCAmelCase_ :Union[str, Any] = 1_5_0 lowerCAmelCase_ :List[str] = 'huggingface/label-files' lowerCAmelCase_ :Optional[int] = 'ade20k-id2label.json' lowerCAmelCase_ :List[Any] = json.load(open(hf_hub_download(UpperCAmelCase_ , UpperCAmelCase_ , repo_type="""dataset""" ) , """r""" ) ) lowerCAmelCase_ :Any = {int(UpperCAmelCase_ ): v for k, v in idalabel.items()} lowerCAmelCase_ :Union[str, Any] = {v: k for k, v in idalabel.items()} lowerCAmelCase_ :Any = ConvNextConfig( depths=UpperCAmelCase_ , hidden_sizes=UpperCAmelCase_ , out_features=["""stage1""", """stage2""", """stage3""", """stage4"""] ) lowerCAmelCase_ :Any = UperNetConfig( backbone_config=UpperCAmelCase_ , auxiliary_in_channels=UpperCAmelCase_ , num_labels=UpperCAmelCase_ , idalabel=UpperCAmelCase_ , labelaid=UpperCAmelCase_ , ) return config def _snake_case ( lowercase__ : Tuple ) -> str: '''simple docstring''' lowerCAmelCase_ :Dict = [] # fmt: off # stem rename_keys.append(("""backbone.downsample_layers.0.0.weight""", """backbone.embeddings.patch_embeddings.weight""") ) rename_keys.append(("""backbone.downsample_layers.0.0.bias""", """backbone.embeddings.patch_embeddings.bias""") ) rename_keys.append(("""backbone.downsample_layers.0.1.weight""", """backbone.embeddings.layernorm.weight""") ) rename_keys.append(("""backbone.downsample_layers.0.1.bias""", """backbone.embeddings.layernorm.bias""") ) # stages for i in range(len(config.backbone_config.depths ) ): for j in range(config.backbone_config.depths[i] ): rename_keys.append((f"""backbone.stages.{i}.{j}.gamma""", f"""backbone.encoder.stages.{i}.layers.{j}.layer_scale_parameter""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.depthwise_conv.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.dwconv.weight""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.depthwise_conv.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.dwconv.bias""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.norm.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.layernorm.weight""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.norm.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.layernorm.bias""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv1.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv1.weight""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv1.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv1.bias""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv2.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv2.weight""") ) rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv2.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv2.bias""") ) if i > 0: rename_keys.append((f"""backbone.downsample_layers.{i}.0.weight""", f"""backbone.encoder.stages.{i}.downsampling_layer.0.weight""") ) rename_keys.append((f"""backbone.downsample_layers.{i}.0.bias""", f"""backbone.encoder.stages.{i}.downsampling_layer.0.bias""") ) rename_keys.append((f"""backbone.downsample_layers.{i}.1.weight""", f"""backbone.encoder.stages.{i}.downsampling_layer.1.weight""") ) rename_keys.append((f"""backbone.downsample_layers.{i}.1.bias""", f"""backbone.encoder.stages.{i}.downsampling_layer.1.bias""") ) rename_keys.append((f"""backbone.norm{i}.weight""", f"""backbone.hidden_states_norms.stage{i+1}.weight""") ) rename_keys.append((f"""backbone.norm{i}.bias""", f"""backbone.hidden_states_norms.stage{i+1}.bias""") ) # decode head rename_keys.extend( [ ("""decode_head.conv_seg.weight""", """decode_head.classifier.weight"""), ("""decode_head.conv_seg.bias""", """decode_head.classifier.bias"""), ("""auxiliary_head.conv_seg.weight""", """auxiliary_head.classifier.weight"""), ("""auxiliary_head.conv_seg.bias""", """auxiliary_head.classifier.bias"""), ] ) # fmt: on return rename_keys def _snake_case ( lowercase__ : Optional[Any] , lowercase__ : int , lowercase__ : int ) -> Optional[int]: '''simple docstring''' lowerCAmelCase_ :List[str] = dct.pop(UpperCAmelCase_ ) lowerCAmelCase_ :Any = val def _snake_case ( lowercase__ : Any , lowercase__ : Optional[Any] , lowercase__ : List[Any] ) -> Optional[Any]: '''simple docstring''' lowerCAmelCase_ :List[Any] = { 'upernet-convnext-tiny': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth', 'upernet-convnext-small': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth', 'upernet-convnext-base': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth', 'upernet-convnext-large': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth', 'upernet-convnext-xlarge': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth', } lowerCAmelCase_ :List[Any] = model_name_to_url[model_name] lowerCAmelCase_ :Any = torch.hub.load_state_dict_from_url(UpperCAmelCase_ , map_location="""cpu""" )['state_dict'] lowerCAmelCase_ :Tuple = get_upernet_config(UpperCAmelCase_ ) lowerCAmelCase_ :Optional[int] = UperNetForSemanticSegmentation(UpperCAmelCase_ ) model.eval() # replace "bn" => "batch_norm" for key in state_dict.copy().keys(): lowerCAmelCase_ :str = state_dict.pop(UpperCAmelCase_ ) if "bn" in key: lowerCAmelCase_ :Union[str, Any] = key.replace("""bn""" , """batch_norm""" ) lowerCAmelCase_ :Union[str, Any] = val # rename keys lowerCAmelCase_ :Optional[int] = create_rename_keys(UpperCAmelCase_ ) for src, dest in rename_keys: rename_key(UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ ) model.load_state_dict(UpperCAmelCase_ ) # verify on image lowerCAmelCase_ :Union[str, Any] = 'https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg' lowerCAmelCase_ :Optional[Any] = Image.open(requests.get(UpperCAmelCase_ , stream=UpperCAmelCase_ ).raw ).convert("""RGB""" ) lowerCAmelCase_ :Tuple = SegformerImageProcessor() lowerCAmelCase_ :Tuple = processor(UpperCAmelCase_ , return_tensors="""pt""" ).pixel_values with torch.no_grad(): lowerCAmelCase_ :Dict = model(UpperCAmelCase_ ) if model_name == "upernet-convnext-tiny": lowerCAmelCase_ :Optional[int] = torch.tensor( [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]] ) elif model_name == "upernet-convnext-small": lowerCAmelCase_ :List[str] = torch.tensor( [[-8.8236, -8.8236, -8.6771], [-8.8236, -8.8236, -8.6771], [-8.7638, -8.7638, -8.6240]] ) elif model_name == "upernet-convnext-base": lowerCAmelCase_ :Dict = torch.tensor( [[-8.8558, -8.8558, -8.6905], [-8.8558, -8.8558, -8.6905], [-8.7669, -8.7669, -8.6021]] ) elif model_name == "upernet-convnext-large": lowerCAmelCase_ :str = torch.tensor( [[-8.6660, -8.6660, -8.6210], [-8.6660, -8.6660, -8.6210], [-8.6310, -8.6310, -8.5964]] ) elif model_name == "upernet-convnext-xlarge": lowerCAmelCase_ :Optional[int] = torch.tensor( [[-8.4980, -8.4980, -8.3977], [-8.4980, -8.4980, -8.3977], [-8.4379, -8.4379, -8.3412]] ) print("""Logits:""" , outputs.logits[0, 0, :3, :3] ) assert torch.allclose(outputs.logits[0, 0, :3, :3] , UpperCAmelCase_ , atol=1E-4 ) print("""Looks ok!""" ) if pytorch_dump_folder_path is not None: print(f"""Saving model {model_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(UpperCAmelCase_ ) print(f"""Saving processor to {pytorch_dump_folder_path}""" ) processor.save_pretrained(UpperCAmelCase_ ) if push_to_hub: print(f"""Pushing model and processor for {model_name} to hub""" ) model.push_to_hub(f"""openmmlab/{model_name}""" ) processor.push_to_hub(f"""openmmlab/{model_name}""" ) if __name__ == "__main__": __UpperCAmelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '--model_name', default='upernet-convnext-tiny', type=str, choices=[F"""upernet-convnext-{size}""" for size in ['tiny', 'small', 'base', 'large', 'xlarge']], help='Name of the ConvNext UperNet model you\'d like to convert.', ) parser.add_argument( '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.' ) parser.add_argument( '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.' ) __UpperCAmelCase = parser.parse_args() convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
84
'''simple docstring''' import numpy as np from cva import destroyAllWindows, imread, imshow, waitKey class UpperCAmelCase_ : """simple docstring""" def __init__( self , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) -> int: if dst_width < 0 or dst_height < 0: raise ValueError('Destination width/height should be > 0' ) __lowerCamelCase : Dict = img __lowerCamelCase : Any = img.shape[1] __lowerCamelCase : Optional[int] = img.shape[0] __lowerCamelCase : Dict = dst_width __lowerCamelCase : str = dst_height __lowerCamelCase : Dict = self.src_w / self.dst_w __lowerCamelCase : List[Any] = self.src_h / self.dst_h __lowerCamelCase : Optional[int] = ( np.ones((self.dst_h, self.dst_w, 3) , np.uinta ) * 2_55 ) def lowercase_ ( self ) -> List[Any]: for i in range(self.dst_h ): for j in range(self.dst_w ): __lowerCamelCase : Union[str, Any] = self.img[self.get_y(SCREAMING_SNAKE_CASE_ )][self.get_x(SCREAMING_SNAKE_CASE_ )] def lowercase_ ( self , SCREAMING_SNAKE_CASE_ ) -> int: return int(self.ratio_x * x ) def lowercase_ ( self , SCREAMING_SNAKE_CASE_ ) -> int: return int(self.ratio_y * y ) if __name__ == "__main__": A__ , A__ : Optional[Any] = 800, 600 A__ : List[str] = imread("""image_data/lena.jpg""", 1) A__ : List[Any] = NearestNeighbour(im, dst_w, dst_h) n.process() imshow( f'''Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}''', n.output ) waitKey(0) destroyAllWindows()
185
0
'''simple docstring''' import functools import operator from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase__ : Any = logging.get_logger(__name__) UpperCamelCase__ : List[Any] = { 'microsoft/unispeech-large-1500h-cv': ( 'https://huggingface.co/microsoft/unispeech-large-1500h-cv/resolve/main/config.json' ), # See all UniSpeech models at https://huggingface.co/models?filter=unispeech } class _lowerCAmelCase ( __A ): """simple docstring""" lowerCamelCase = '''unispeech''' def __init__( self , _lowerCamelCase=32 , _lowerCamelCase=768 , _lowerCamelCase=12 , _lowerCamelCase=12 , _lowerCamelCase=3072 , _lowerCamelCase="gelu" , _lowerCamelCase=0.1 , _lowerCamelCase=0.1 , _lowerCamelCase=0.1 , _lowerCamelCase=0.0 , _lowerCamelCase=0.0 , _lowerCamelCase=0.1 , _lowerCamelCase=0.1 , _lowerCamelCase=0.02 , _lowerCamelCase=1e-5 , _lowerCamelCase="group" , _lowerCamelCase="gelu" , _lowerCamelCase=(512, 512, 512, 512, 512, 512, 512) , _lowerCamelCase=(5, 2, 2, 2, 2, 2, 2) , _lowerCamelCase=(10, 3, 3, 3, 3, 2, 2) , _lowerCamelCase=False , _lowerCamelCase=128 , _lowerCamelCase=16 , _lowerCamelCase=False , _lowerCamelCase=True , _lowerCamelCase=0.05 , _lowerCamelCase=10 , _lowerCamelCase=2 , _lowerCamelCase=0.0 , _lowerCamelCase=10 , _lowerCamelCase=0 , _lowerCamelCase=320 , _lowerCamelCase=2 , _lowerCamelCase=0.1 , _lowerCamelCase=100 , _lowerCamelCase=256 , _lowerCamelCase=256 , _lowerCamelCase=0.1 , _lowerCamelCase="mean" , _lowerCamelCase=False , _lowerCamelCase=False , _lowerCamelCase=256 , _lowerCamelCase=80 , _lowerCamelCase=0 , _lowerCamelCase=1 , _lowerCamelCase=2 , _lowerCamelCase=0.5 , **_lowerCamelCase , ) -> Tuple: super().__init__(**_lowerCamelCase , pad_token_id=_lowerCamelCase , bos_token_id=_lowerCamelCase , eos_token_id=_lowerCamelCase ) A_ : Tuple = hidden_size A_ : int = feat_extract_norm A_ : str = feat_extract_activation A_ : List[str] = list(_lowerCamelCase ) A_ : int = list(_lowerCamelCase ) A_ : Optional[int] = list(_lowerCamelCase ) A_ : List[str] = conv_bias A_ : List[str] = num_conv_pos_embeddings A_ : Dict = num_conv_pos_embedding_groups A_ : Optional[int] = len(self.conv_dim ) A_ : Any = num_hidden_layers A_ : Optional[int] = intermediate_size A_ : Any = hidden_act A_ : int = num_attention_heads A_ : Optional[int] = hidden_dropout A_ : Optional[Any] = attention_dropout A_ : Union[str, Any] = activation_dropout A_ : int = feat_proj_dropout A_ : Dict = final_dropout A_ : Union[str, Any] = layerdrop A_ : int = layer_norm_eps A_ : List[str] = initializer_range A_ : Tuple = num_ctc_classes A_ : Tuple = vocab_size A_ : Dict = do_stable_layer_norm A_ : str = use_weighted_layer_sum A_ : str = classifier_proj_size if ( (len(self.conv_stride ) != self.num_feat_extract_layers) or (len(self.conv_kernel ) != self.num_feat_extract_layers) or (len(self.conv_dim ) != self.num_feat_extract_layers) ): raise ValueError( """Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` ==""" """ `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) =""" F" {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`," F" `len(config.conv_kernel) = {len(self.conv_kernel )}`." ) # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779 A_ : List[str] = apply_spec_augment A_ : Tuple = mask_time_prob A_ : int = mask_time_length A_ : Optional[int] = mask_time_min_masks A_ : Union[str, Any] = mask_feature_prob A_ : Dict = mask_feature_length A_ : str = mask_feature_min_masks # parameters for pretraining with codevector quantized representations A_ : Optional[Any] = num_codevectors_per_group A_ : Any = num_codevector_groups A_ : Tuple = contrastive_logits_temperature A_ : Any = feat_quantizer_dropout A_ : List[Any] = num_negatives A_ : Optional[Any] = codevector_dim A_ : List[Any] = proj_codevector_dim A_ : List[str] = diversity_loss_weight # ctc loss A_ : Union[str, Any] = ctc_loss_reduction A_ : Tuple = ctc_zero_infinity # pretraining loss A_ : List[Any] = replace_prob @property def UpperCAmelCase_ ( self ) -> int: return functools.reduce(operator.mul , self.conv_stride , 1 )
164
'''simple docstring''' 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 UpperCamelCase__ : List[Any] = logging.get_logger(__name__) class _lowerCAmelCase ( __A ): """simple docstring""" lowerCamelCase = ['''input_values''', '''attention_mask'''] def __init__( self , _lowerCamelCase = 1 , _lowerCamelCase = 1_6000 , _lowerCamelCase = 0.0 , _lowerCamelCase = False , _lowerCamelCase = 80 , _lowerCamelCase = 16 , _lowerCamelCase = 64 , _lowerCamelCase = "hann_window" , _lowerCamelCase = 1.0 , _lowerCamelCase = 80 , _lowerCamelCase = 7600 , _lowerCamelCase = 1e-10 , _lowerCamelCase = 2 , _lowerCamelCase = True , **_lowerCamelCase , ) -> List[Any]: super().__init__(feature_size=_lowerCamelCase , sampling_rate=_lowerCamelCase , padding_value=_lowerCamelCase , **_lowerCamelCase ) A_ : List[Any] = do_normalize A_ : Union[str, Any] = return_attention_mask A_ : Tuple = num_mel_bins A_ : List[str] = hop_length A_ : int = win_length A_ : Optional[int] = win_function A_ : List[Any] = frame_signal_scale A_ : str = fmin A_ : Optional[Any] = fmax A_ : Any = mel_floor A_ : Any = reduction_factor A_ : Tuple = win_length * sampling_rate // 1000 A_ : Dict = hop_length * sampling_rate // 1000 A_ : Dict = optimal_fft_length(self.sample_size ) A_ : str = (self.n_fft // 2) + 1 A_ : int = window_function(window_length=self.sample_size , name=self.win_function , periodic=_lowerCamelCase ) A_ : Optional[int] = 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""" , _lowerCamelCase , ) if reduction_factor != 2.0: warnings.warn( """The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers""" , _lowerCamelCase , ) @staticmethod # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm def UpperCAmelCase_ ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase = 0.0 ) -> List[np.ndarray]: if attention_mask is not None: A_ : Dict = np.array(_lowerCamelCase , np.intaa ) A_ : Dict = [] for vector, length in zip(_lowerCamelCase , attention_mask.sum(-1 ) ): A_ : Optional[int] = (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7 ) if length < normed_slice.shape[0]: A_ : Any = padding_value normed_input_values.append(_lowerCamelCase ) else: A_ : List[str] = [(x - x.mean()) / np.sqrt(x.var() + 1e-7 ) for x in input_values] return normed_input_values def UpperCAmelCase_ ( self , _lowerCamelCase , ) -> np.ndarray: A_ : int = spectrogram( _lowerCamelCase , 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 , _lowerCamelCase = None , _lowerCamelCase = None , _lowerCamelCase = False , _lowerCamelCase = None , _lowerCamelCase = False , _lowerCamelCase = None , _lowerCamelCase = None , _lowerCamelCase = None , _lowerCamelCase = None , **_lowerCamelCase , ) -> BatchFeature: 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: A_ : Dict = self._process_audio( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , **_lowerCamelCase , ) else: A_ : Optional[int] = None if audio_target is not None: A_ : Union[str, Any] = self._process_audio( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , **_lowerCamelCase , ) if inputs is None: return inputs_target else: A_ : Optional[int] = inputs_target["""input_values"""] A_ : Tuple = inputs_target.get("""attention_mask""" ) if decoder_attention_mask is not None: A_ : int = decoder_attention_mask return inputs def UpperCAmelCase_ ( self , _lowerCamelCase , _lowerCamelCase = False , _lowerCamelCase = False , _lowerCamelCase = None , _lowerCamelCase = False , _lowerCamelCase = None , _lowerCamelCase = None , _lowerCamelCase = None , **_lowerCamelCase , ) -> BatchFeature: A_ : Optional[int] = isinstance(_lowerCamelCase , 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}" ) A_ : List[str] = is_batched_numpy or ( isinstance(_lowerCamelCase , (list, tuple) ) and (isinstance(speech[0] , (np.ndarray, tuple, list) )) ) if is_batched: A_ : Union[str, Any] = [np.asarray(_lowerCamelCase , dtype=np.floataa ) for speech in speech] elif not is_batched and not isinstance(_lowerCamelCase , np.ndarray ): A_ : List[str] = np.asarray(_lowerCamelCase , dtype=np.floataa ) elif isinstance(_lowerCamelCase , np.ndarray ) and speech.dtype is np.dtype(np.floataa ): A_ : Optional[Any] = speech.astype(np.floataa ) # always return batch if not is_batched: A_ : int = [speech] # needed to make pad() work on spectrogram inputs A_ : List[Any] = self.feature_size # convert into correct format for padding if is_target: A_ : Tuple = [self._extract_mel_features(_lowerCamelCase ) for waveform in speech] A_ : Tuple = BatchFeature({"""input_values""": features} ) A_ : Dict = self.num_mel_bins else: A_ : Union[str, Any] = BatchFeature({"""input_values""": speech} ) A_ : Tuple = self.pad( _lowerCamelCase , padding=_lowerCamelCase , max_length=_lowerCamelCase , truncation=_lowerCamelCase , pad_to_multiple_of=_lowerCamelCase , return_attention_mask=_lowerCamelCase , **_lowerCamelCase , ) A_ : Union[str, Any] = feature_size_hack # convert input values to correct format A_ : str = padded_inputs["""input_values"""] if not isinstance(input_values[0] , np.ndarray ): A_ : str = [np.asarray(_lowerCamelCase , dtype=np.floataa ) for array in input_values] elif ( not isinstance(_lowerCamelCase , np.ndarray ) and isinstance(input_values[0] , np.ndarray ) and input_values[0].dtype is np.dtype(np.floataa ) ): A_ : Tuple = [array.astype(np.floataa ) for array in input_values] elif isinstance(_lowerCamelCase , np.ndarray ) and input_values.dtype is np.dtype(np.floataa ): A_ : List[Any] = input_values.astype(np.floataa ) # convert attention_mask to correct format A_ : Any = padded_inputs.get("""attention_mask""" ) if attention_mask is not None: A_ : str = [np.asarray(_lowerCamelCase , dtype=np.intaa ) for array in attention_mask] # zero-mean and unit-variance normalization if not is_target and self.do_normalize: A_ : Any = ( attention_mask if self._get_padding_strategies(_lowerCamelCase , max_length=_lowerCamelCase ) is not PaddingStrategy.DO_NOT_PAD else None ) A_ : Any = self.zero_mean_unit_var_norm( padded_inputs["""input_values"""] , attention_mask=_lowerCamelCase , padding_value=self.padding_value ) if return_tensors is not None: A_ : Dict = padded_inputs.convert_to_tensors(_lowerCamelCase ) return padded_inputs def UpperCAmelCase_ ( self ) -> Dict[str, Any]: A_ : List[Any] = super().to_dict() # Don't serialize these as they are derived from the other properties. A_ : Optional[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
164
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_dpt import DPTImageProcessor lowercase__ = logging.get_logger(__name__) class lowerCAmelCase__ ( lowercase ): '''simple docstring''' def __init__( self , *lowercase , **lowercase ): warnings.warn( 'The class DPTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please' ' use DPTImageProcessor instead.' , lowercase , ) super().__init__(*lowercase , **lowercase )
96
from datetime import datetime as dt import os from github import Github A__ : List[str] = [ '''good first issue''', '''good second issue''', '''good difficult issue''', '''feature request''', '''new model''', '''wip''', ] def UpperCamelCase( ): lowerCAmelCase_ : Union[str, Any] = Github(os.environ['''GITHUB_TOKEN'''] ) lowerCAmelCase_ : Tuple = g.get_repo('''huggingface/transformers''' ) lowerCAmelCase_ : int = repo.get_issues(state='''open''' ) for issue in open_issues: lowerCAmelCase_ : Optional[Any] = sorted([comment for comment in issue.get_comments()] ,key=lambda __UpperCamelCase : i.created_at ,reverse=__UpperCamelCase ) lowerCAmelCase_ : Tuple = comments[0] if len(__UpperCamelCase ) > 0 else None if ( last_comment is not None and last_comment.user.login == "github-actions[bot]" and (dt.utcnow() - issue.updated_at).days > 7 and (dt.utcnow() - issue.created_at).days >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # print(f"Would close issue {issue.number} since it has been 7 days of inactivity since bot mention.") issue.edit(state='''closed''' ) elif ( (dt.utcnow() - issue.updated_at).days > 23 and (dt.utcnow() - issue.created_at).days >= 30 and not any(label.name.lower() in LABELS_TO_EXEMPT for label in issue.get_labels() ) ): # print(f"Would add stale comment to {issue.number}") issue.create_comment( '''This issue has been automatically marked as stale because it has not had ''' '''recent activity. If you think this still needs to be addressed ''' '''please comment on this thread.\n\nPlease note that issues that do not follow the ''' '''[contributing guidelines](https://github.com/huggingface/transformers/blob/main/CONTRIBUTING.md) ''' '''are likely to be ignored.''' ) if __name__ == "__main__": main()
103
0
from typing import Any def _UpperCamelCase ( UpperCamelCase_ : list ) -> list[Any]: """simple docstring""" if not input_list: return [] lowerCAmelCase__ = [input_list.count(UpperCamelCase_ ) for value in input_list] lowerCAmelCase__ = max(UpperCamelCase_ ) # Gets the maximum count in the input list. # Gets values of modes return sorted({input_list[i] for i, value in enumerate(UpperCamelCase_ ) if value == y} ) if __name__ == "__main__": import doctest doctest.testmod()
122
import argparse import os import sys from unittest.mock import patch import pytorch_lightning as pl import timeout_decorator import torch from distillation import SummarizationDistiller, distill_main from finetune import SummarizationModule, main from transformers import MarianMTModel from transformers.file_utils import cached_path from transformers.testing_utils import TestCasePlus, require_torch_gpu, slow from utils import load_json __snake_case : Tuple = """sshleifer/mar_enro_6_3_student""" class __SCREAMING_SNAKE_CASE ( __lowercase): def UpperCamelCase__ ( self ): """simple docstring""" super().setUp() lowerCAmelCase__ = cached_path( 'https://cdn-datasets.huggingface.co/translation/wmt_en_ro-tr40k-va0.5k-te0.5k.tar.gz' , extract_compressed_file=_UpperCamelCase , ) lowerCAmelCase__ = F"{data_cached}/wmt_en_ro-tr40k-va0.5k-te0.5k" @slow @require_torch_gpu def UpperCamelCase__ ( self ): """simple docstring""" MarianMTModel.from_pretrained(_UpperCamelCase ) @slow @require_torch_gpu def UpperCamelCase__ ( self ): """simple docstring""" lowerCAmelCase__ = { '$MAX_LEN': 64, '$BS': 64, '$GAS': 1, '$ENRO_DIR': self.data_dir, 'facebook/mbart-large-cc25': MARIAN_MODEL, # "val_check_interval=0.25": "val_check_interval=1.0", '--learning_rate=3e-5': '--learning_rate 3e-4', '--num_train_epochs 6': '--num_train_epochs 1', } # Clean up bash script lowerCAmelCase__ = (self.test_file_dir / 'train_mbart_cc25_enro.sh').open().read().split('finetune.py' )[1].strip() lowerCAmelCase__ = bash_script.replace('\\\n' , '' ).strip().replace('"$@"' , '' ) for k, v in env_vars_to_replace.items(): lowerCAmelCase__ = bash_script.replace(_UpperCamelCase , str(_UpperCamelCase ) ) lowerCAmelCase__ = self.get_auto_remove_tmp_dir() # bash_script = bash_script.replace("--fp16 ", "") lowerCAmelCase__ = F"\n --output_dir {output_dir}\n --tokenizer_name Helsinki-NLP/opus-mt-en-ro\n --sortish_sampler\n --do_predict\n --gpus 1\n --freeze_encoder\n --n_train 40000\n --n_val 500\n --n_test 500\n --fp16_opt_level O1\n --num_sanity_val_steps 0\n --eval_beams 2\n ".split() # XXX: args.gpus > 1 : handle multi_gpu in the future lowerCAmelCase__ = ['finetune.py'] + bash_script.split() + args with patch.object(_UpperCamelCase , 'argv' , _UpperCamelCase ): lowerCAmelCase__ = argparse.ArgumentParser() lowerCAmelCase__ = pl.Trainer.add_argparse_args(_UpperCamelCase ) lowerCAmelCase__ = SummarizationModule.add_model_specific_args(_UpperCamelCase , os.getcwd() ) lowerCAmelCase__ = parser.parse_args() lowerCAmelCase__ = main(_UpperCamelCase ) # Check metrics lowerCAmelCase__ = load_json(model.metrics_save_path ) lowerCAmelCase__ = metrics['val'][0] lowerCAmelCase__ = metrics['val'][-1] self.assertEqual(len(metrics['val'] ) , (args.max_epochs / args.val_check_interval) ) assert isinstance(last_step_stats[F"val_avg_{model.val_metric}"] , _UpperCamelCase ) self.assertGreater(last_step_stats['val_avg_gen_time'] , 0.01 ) # model hanging on generate. Maybe bad config was saved. (XXX: old comment/assert?) self.assertLessEqual(last_step_stats['val_avg_gen_time'] , 1.0 ) # test learning requirements: # 1. BLEU improves over the course of training by more than 2 pts self.assertGreater(last_step_stats['val_avg_bleu'] - first_step_stats['val_avg_bleu'] , 2 ) # 2. BLEU finishes above 17 self.assertGreater(last_step_stats['val_avg_bleu'] , 17 ) # 3. test BLEU and val BLEU within ~1.1 pt. self.assertLess(abs(metrics['val'][-1]['val_avg_bleu'] - metrics['test'][-1]['test_avg_bleu'] ) , 1.1 ) # check lightning ckpt can be loaded and has a reasonable statedict lowerCAmelCase__ = os.listdir(_UpperCamelCase ) lowerCAmelCase__ = [x for x in contents if x.endswith('.ckpt' )][0] lowerCAmelCase__ = os.path.join(args.output_dir , _UpperCamelCase ) lowerCAmelCase__ = torch.load(_UpperCamelCase , map_location='cpu' ) lowerCAmelCase__ = 'model.model.decoder.layers.0.encoder_attn_layer_norm.weight' assert expected_key in ckpt["state_dict"] assert ckpt["state_dict"]["model.model.decoder.layers.0.encoder_attn_layer_norm.weight"].dtype == torch.floataa # TODO: turn on args.do_predict when PL bug fixed. if args.do_predict: lowerCAmelCase__ = {os.path.basename(_UpperCamelCase ) for p in contents} assert "test_generations.txt" in contents assert "test_results.txt" in contents # assert len(metrics["val"]) == desired_n_evals assert len(metrics['test'] ) == 1 class __SCREAMING_SNAKE_CASE ( __lowercase): @timeout_decorator.timeout(6_00 ) @slow @require_torch_gpu def UpperCamelCase__ ( self ): """simple docstring""" lowerCAmelCase__ = F"{self.test_file_dir_str}/test_data/wmt_en_ro" lowerCAmelCase__ = { '--fp16_opt_level=O1': '', '$MAX_LEN': 1_28, '$BS': 16, '$GAS': 1, '$ENRO_DIR': data_dir, '$m': 'sshleifer/student_marian_en_ro_6_1', 'val_check_interval=0.25': 'val_check_interval=1.0', } # Clean up bash script lowerCAmelCase__ = ( (self.test_file_dir / 'distil_marian_no_teacher.sh').open().read().split('distillation.py' )[1].strip() ) lowerCAmelCase__ = bash_script.replace('\\\n' , '' ).strip().replace('"$@"' , '' ) lowerCAmelCase__ = bash_script.replace('--fp16 ' , ' ' ) for k, v in env_vars_to_replace.items(): lowerCAmelCase__ = bash_script.replace(_UpperCamelCase , str(_UpperCamelCase ) ) lowerCAmelCase__ = self.get_auto_remove_tmp_dir() lowerCAmelCase__ = bash_script.replace('--fp16' , '' ) lowerCAmelCase__ = 6 lowerCAmelCase__ = ( ['distillation.py'] + bash_script.split() + [ F"--output_dir={output_dir}", '--gpus=1', '--learning_rate=1e-3', F"--num_train_epochs={epochs}", '--warmup_steps=10', '--val_check_interval=1.0', '--do_predict', ] ) with patch.object(_UpperCamelCase , 'argv' , _UpperCamelCase ): lowerCAmelCase__ = argparse.ArgumentParser() lowerCAmelCase__ = pl.Trainer.add_argparse_args(_UpperCamelCase ) lowerCAmelCase__ = SummarizationDistiller.add_model_specific_args(_UpperCamelCase , os.getcwd() ) lowerCAmelCase__ = parser.parse_args() # assert args.gpus == gpus THIS BREAKS for multi_gpu lowerCAmelCase__ = distill_main(_UpperCamelCase ) # Check metrics lowerCAmelCase__ = load_json(model.metrics_save_path ) lowerCAmelCase__ = metrics['val'][0] lowerCAmelCase__ = metrics['val'][-1] assert len(metrics['val'] ) >= (args.max_epochs / args.val_check_interval) # +1 accounts for val_sanity_check assert last_step_stats["val_avg_gen_time"] >= 0.01 assert first_step_stats["val_avg_bleu"] < last_step_stats["val_avg_bleu"] # model learned nothing assert 1.0 >= last_step_stats["val_avg_gen_time"] # model hanging on generate. Maybe bad config was saved. assert isinstance(last_step_stats[F"val_avg_{model.val_metric}"] , _UpperCamelCase ) # check lightning ckpt can be loaded and has a reasonable statedict lowerCAmelCase__ = os.listdir(_UpperCamelCase ) lowerCAmelCase__ = [x for x in contents if x.endswith('.ckpt' )][0] lowerCAmelCase__ = os.path.join(args.output_dir , _UpperCamelCase ) lowerCAmelCase__ = torch.load(_UpperCamelCase , map_location='cpu' ) lowerCAmelCase__ = 'model.model.decoder.layers.0.encoder_attn_layer_norm.weight' assert expected_key in ckpt["state_dict"] assert ckpt["state_dict"]["model.model.decoder.layers.0.encoder_attn_layer_norm.weight"].dtype == torch.floataa # TODO: turn on args.do_predict when PL bug fixed. if args.do_predict: lowerCAmelCase__ = {os.path.basename(_UpperCamelCase ) for p in contents} assert "test_generations.txt" in contents assert "test_results.txt" in contents # assert len(metrics["val"]) == desired_n_evals assert len(metrics['test'] ) == 1
122
1
"""simple docstring""" import unittest from transformers import ( MODEL_FOR_OBJECT_DETECTION_MAPPING, AutoFeatureExtractor, AutoModelForObjectDetection, ObjectDetectionPipeline, is_vision_available, pipeline, ) from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_pytesseract, require_tf, require_timm, require_torch, require_vision, slow, ) from .test_pipelines_common import ANY if is_vision_available(): from PIL import Image else: class snake_case : @staticmethod def lowercase_ ( *UpperCamelCase__ : Optional[Any] , **UpperCamelCase__ : Tuple)-> List[str]: '''simple docstring''' pass @is_pipeline_test @require_vision @require_timm @require_torch class snake_case ( unittest.TestCase ): SCREAMING_SNAKE_CASE_ : Any = MODEL_FOR_OBJECT_DETECTION_MAPPING def lowercase_ ( self : Dict , UpperCamelCase__ : Optional[int] , UpperCamelCase__ : Tuple , UpperCamelCase__ : Union[str, Any])-> List[Any]: '''simple docstring''' __lowerCAmelCase: Optional[Any] = ObjectDetectionPipeline(model=A_ , image_processor=A_) return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"] def lowercase_ ( self : int , UpperCamelCase__ : Any , UpperCamelCase__ : Union[str, Any])-> Optional[int]: '''simple docstring''' __lowerCAmelCase: Dict = object_detector("./tests/fixtures/tests_samples/COCO/000000039769.png" , threshold=0.0) self.assertGreater(len(A_) , 0) for detected_object in outputs: self.assertEqual( A_ , { "score": ANY(A_), "label": ANY(A_), "box": {"xmin": ANY(A_), "ymin": ANY(A_), "xmax": ANY(A_), "ymax": ANY(A_)}, } , ) import datasets __lowerCAmelCase: Dict = datasets.load_dataset("hf-internal-testing/fixtures_image_utils" , "image" , split="test") __lowerCAmelCase: str = [ Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"), "http://images.cocodataset.org/val2017/000000039769.jpg", # RGBA dataset[0]["file"], # LA dataset[1]["file"], # L dataset[2]["file"], ] __lowerCAmelCase: List[Any] = object_detector(A_ , threshold=0.0) self.assertEqual(len(A_) , len(A_)) for outputs in batch_outputs: self.assertGreater(len(A_) , 0) for detected_object in outputs: self.assertEqual( A_ , { "score": ANY(A_), "label": ANY(A_), "box": {"xmin": ANY(A_), "ymin": ANY(A_), "xmax": ANY(A_), "ymax": ANY(A_)}, } , ) @require_tf @unittest.skip("Object detection not implemented in TF") def lowercase_ ( self : str)-> str: '''simple docstring''' pass @require_torch def lowercase_ ( self : List[Any])-> Union[str, Any]: '''simple docstring''' __lowerCAmelCase: Optional[int] = "hf-internal-testing/tiny-detr-mobilenetsv3" __lowerCAmelCase: Dict = AutoModelForObjectDetection.from_pretrained(A_) __lowerCAmelCase: Optional[int] = AutoFeatureExtractor.from_pretrained(A_) __lowerCAmelCase: Any = ObjectDetectionPipeline(model=A_ , feature_extractor=A_) __lowerCAmelCase: int = object_detector("http://images.cocodataset.org/val2017/000000039769.jpg" , threshold=0.0) self.assertEqual( nested_simplify(A_ , decimals=4) , [ {"score": 0.3376, "label": "LABEL_0", "box": {"xmin": 1_5_9, "ymin": 1_2_0, "xmax": 4_8_0, "ymax": 3_5_9}}, {"score": 0.3376, "label": "LABEL_0", "box": {"xmin": 1_5_9, "ymin": 1_2_0, "xmax": 4_8_0, "ymax": 3_5_9}}, ] , ) __lowerCAmelCase: Union[str, Any] = object_detector( [ "http://images.cocodataset.org/val2017/000000039769.jpg", "http://images.cocodataset.org/val2017/000000039769.jpg", ] , threshold=0.0 , ) self.assertEqual( nested_simplify(A_ , decimals=4) , [ [ {"score": 0.3376, "label": "LABEL_0", "box": {"xmin": 1_5_9, "ymin": 1_2_0, "xmax": 4_8_0, "ymax": 3_5_9}}, {"score": 0.3376, "label": "LABEL_0", "box": {"xmin": 1_5_9, "ymin": 1_2_0, "xmax": 4_8_0, "ymax": 3_5_9}}, ], [ {"score": 0.3376, "label": "LABEL_0", "box": {"xmin": 1_5_9, "ymin": 1_2_0, "xmax": 4_8_0, "ymax": 3_5_9}}, {"score": 0.3376, "label": "LABEL_0", "box": {"xmin": 1_5_9, "ymin": 1_2_0, "xmax": 4_8_0, "ymax": 3_5_9}}, ], ] , ) @require_torch @slow def lowercase_ ( self : Optional[Any])-> int: '''simple docstring''' __lowerCAmelCase: Optional[int] = "facebook/detr-resnet-50" __lowerCAmelCase: Union[str, Any] = AutoModelForObjectDetection.from_pretrained(A_) __lowerCAmelCase: List[str] = AutoFeatureExtractor.from_pretrained(A_) __lowerCAmelCase: int = ObjectDetectionPipeline(model=A_ , feature_extractor=A_) __lowerCAmelCase: Dict = object_detector("http://images.cocodataset.org/val2017/000000039769.jpg") self.assertEqual( nested_simplify(A_ , decimals=4) , [ {"score": 0.9982, "label": "remote", "box": {"xmin": 4_0, "ymin": 7_0, "xmax": 1_7_5, "ymax": 1_1_7}}, {"score": 0.9960, "label": "remote", "box": {"xmin": 3_3_3, "ymin": 7_2, "xmax": 3_6_8, "ymax": 1_8_7}}, {"score": 0.9955, "label": "couch", "box": {"xmin": 0, "ymin": 1, "xmax": 6_3_9, "ymax": 4_7_3}}, {"score": 0.9988, "label": "cat", "box": {"xmin": 1_3, "ymin": 5_2, "xmax": 3_1_4, "ymax": 4_7_0}}, {"score": 0.9987, "label": "cat", "box": {"xmin": 3_4_5, "ymin": 2_3, "xmax": 6_4_0, "ymax": 3_6_8}}, ] , ) __lowerCAmelCase: List[str] = object_detector( [ "http://images.cocodataset.org/val2017/000000039769.jpg", "http://images.cocodataset.org/val2017/000000039769.jpg", ]) self.assertEqual( nested_simplify(A_ , decimals=4) , [ [ {"score": 0.9982, "label": "remote", "box": {"xmin": 4_0, "ymin": 7_0, "xmax": 1_7_5, "ymax": 1_1_7}}, {"score": 0.9960, "label": "remote", "box": {"xmin": 3_3_3, "ymin": 7_2, "xmax": 3_6_8, "ymax": 1_8_7}}, {"score": 0.9955, "label": "couch", "box": {"xmin": 0, "ymin": 1, "xmax": 6_3_9, "ymax": 4_7_3}}, {"score": 0.9988, "label": "cat", "box": {"xmin": 1_3, "ymin": 5_2, "xmax": 3_1_4, "ymax": 4_7_0}}, {"score": 0.9987, "label": "cat", "box": {"xmin": 3_4_5, "ymin": 2_3, "xmax": 6_4_0, "ymax": 3_6_8}}, ], [ {"score": 0.9982, "label": "remote", "box": {"xmin": 4_0, "ymin": 7_0, "xmax": 1_7_5, "ymax": 1_1_7}}, {"score": 0.9960, "label": "remote", "box": {"xmin": 3_3_3, "ymin": 7_2, "xmax": 3_6_8, "ymax": 1_8_7}}, {"score": 0.9955, "label": "couch", "box": {"xmin": 0, "ymin": 1, "xmax": 6_3_9, "ymax": 4_7_3}}, {"score": 0.9988, "label": "cat", "box": {"xmin": 1_3, "ymin": 5_2, "xmax": 3_1_4, "ymax": 4_7_0}}, {"score": 0.9987, "label": "cat", "box": {"xmin": 3_4_5, "ymin": 2_3, "xmax": 6_4_0, "ymax": 3_6_8}}, ], ] , ) @require_torch @slow def lowercase_ ( self : str)-> Optional[int]: '''simple docstring''' __lowerCAmelCase: Union[str, Any] = "facebook/detr-resnet-50" __lowerCAmelCase: Dict = pipeline("object-detection" , model=A_) __lowerCAmelCase: Tuple = object_detector("http://images.cocodataset.org/val2017/000000039769.jpg") self.assertEqual( nested_simplify(A_ , decimals=4) , [ {"score": 0.9982, "label": "remote", "box": {"xmin": 4_0, "ymin": 7_0, "xmax": 1_7_5, "ymax": 1_1_7}}, {"score": 0.9960, "label": "remote", "box": {"xmin": 3_3_3, "ymin": 7_2, "xmax": 3_6_8, "ymax": 1_8_7}}, {"score": 0.9955, "label": "couch", "box": {"xmin": 0, "ymin": 1, "xmax": 6_3_9, "ymax": 4_7_3}}, {"score": 0.9988, "label": "cat", "box": {"xmin": 1_3, "ymin": 5_2, "xmax": 3_1_4, "ymax": 4_7_0}}, {"score": 0.9987, "label": "cat", "box": {"xmin": 3_4_5, "ymin": 2_3, "xmax": 6_4_0, "ymax": 3_6_8}}, ] , ) __lowerCAmelCase: Union[str, Any] = object_detector( [ "http://images.cocodataset.org/val2017/000000039769.jpg", "http://images.cocodataset.org/val2017/000000039769.jpg", ]) self.assertEqual( nested_simplify(A_ , decimals=4) , [ [ {"score": 0.9982, "label": "remote", "box": {"xmin": 4_0, "ymin": 7_0, "xmax": 1_7_5, "ymax": 1_1_7}}, {"score": 0.9960, "label": "remote", "box": {"xmin": 3_3_3, "ymin": 7_2, "xmax": 3_6_8, "ymax": 1_8_7}}, {"score": 0.9955, "label": "couch", "box": {"xmin": 0, "ymin": 1, "xmax": 6_3_9, "ymax": 4_7_3}}, {"score": 0.9988, "label": "cat", "box": {"xmin": 1_3, "ymin": 5_2, "xmax": 3_1_4, "ymax": 4_7_0}}, {"score": 0.9987, "label": "cat", "box": {"xmin": 3_4_5, "ymin": 2_3, "xmax": 6_4_0, "ymax": 3_6_8}}, ], [ {"score": 0.9982, "label": "remote", "box": {"xmin": 4_0, "ymin": 7_0, "xmax": 1_7_5, "ymax": 1_1_7}}, {"score": 0.9960, "label": "remote", "box": {"xmin": 3_3_3, "ymin": 7_2, "xmax": 3_6_8, "ymax": 1_8_7}}, {"score": 0.9955, "label": "couch", "box": {"xmin": 0, "ymin": 1, "xmax": 6_3_9, "ymax": 4_7_3}}, {"score": 0.9988, "label": "cat", "box": {"xmin": 1_3, "ymin": 5_2, "xmax": 3_1_4, "ymax": 4_7_0}}, {"score": 0.9987, "label": "cat", "box": {"xmin": 3_4_5, "ymin": 2_3, "xmax": 6_4_0, "ymax": 3_6_8}}, ], ] , ) @require_torch @slow def lowercase_ ( self : List[str])-> Optional[Any]: '''simple docstring''' __lowerCAmelCase: Optional[Any] = 0.9985 __lowerCAmelCase: Union[str, Any] = "facebook/detr-resnet-50" __lowerCAmelCase: str = pipeline("object-detection" , model=A_) __lowerCAmelCase: List[str] = object_detector("http://images.cocodataset.org/val2017/000000039769.jpg" , threshold=A_) self.assertEqual( nested_simplify(A_ , decimals=4) , [ {"score": 0.9988, "label": "cat", "box": {"xmin": 1_3, "ymin": 5_2, "xmax": 3_1_4, "ymax": 4_7_0}}, {"score": 0.9987, "label": "cat", "box": {"xmin": 3_4_5, "ymin": 2_3, "xmax": 6_4_0, "ymax": 3_6_8}}, ] , ) @require_torch @require_pytesseract @slow def lowercase_ ( self : List[str])-> int: '''simple docstring''' __lowerCAmelCase: Dict = "Narsil/layoutlmv3-finetuned-funsd" __lowerCAmelCase: int = 0.9993 __lowerCAmelCase: str = pipeline("object-detection" , model=A_ , threshold=A_) __lowerCAmelCase: List[str] = object_detector( "https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png") self.assertEqual( nested_simplify(A_ , decimals=4) , [ {"score": 0.9993, "label": "I-ANSWER", "box": {"xmin": 2_9_4, "ymin": 2_5_4, "xmax": 3_4_3, "ymax": 2_6_4}}, {"score": 0.9993, "label": "I-ANSWER", "box": {"xmin": 2_9_4, "ymin": 2_5_4, "xmax": 3_4_3, "ymax": 2_6_4}}, ] , )
217
import os def _A ( ) -> Tuple: """simple docstring""" with open(os.path.dirname(_lowercase ) + '/p022_names.txt' ) as file: __UpperCamelCase = str(file.readlines()[0] ) __UpperCamelCase = names.replace('"' , '' ).split(',' ) names.sort() __UpperCamelCase = 0 __UpperCamelCase = 0 for i, name in enumerate(_lowercase ): for letter in name: name_score += ord(_lowercase ) - 64 total_score += (i + 1) * name_score __UpperCamelCase = 0 return total_score if __name__ == "__main__": print(solution())
310
0
import math from dataclasses import dataclass from typing import Optional, Tuple, Union import numpy as np import torch from ..configuration_utils import ConfigMixin, register_to_config from ..utils import BaseOutput, randn_tensor from .scheduling_utils import SchedulerMixin @dataclass # Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->UnCLIP class _UpperCamelCase ( A ): '''simple docstring''' lowerCAmelCase__ = 42 lowerCAmelCase__ = None def _A ( _lowerCAmelCase , _lowerCAmelCase=0.9_99 , _lowerCAmelCase="cosine" , ): """simple docstring""" if alpha_transform_type == "cosine": def alpha_bar_fn(_lowerCAmelCase ): return math.cos((t + 0.0_08) / 1.0_08 * math.pi / 2 ) ** 2 elif alpha_transform_type == "exp": def alpha_bar_fn(_lowerCAmelCase ): return math.exp(t * -12.0 ) else: raise ValueError(f"""Unsupported alpha_tranform_type: {alpha_transform_type}""" ) __lowercase =[] for i in range(_lowerCAmelCase ): __lowercase =i / num_diffusion_timesteps __lowercase =(i + 1) / num_diffusion_timesteps betas.append(min(1 - alpha_bar_fn(_lowerCAmelCase ) / alpha_bar_fn(_lowerCAmelCase ) , _lowerCAmelCase ) ) return torch.tensor(_lowerCAmelCase , dtype=torch.floataa ) class _UpperCamelCase ( A , A ): '''simple docstring''' @register_to_config def __init__( self : Dict , _lowerCAmelCase : int = 1_0_0_0 , _lowerCAmelCase : str = "fixed_small_log" , _lowerCAmelCase : bool = True , _lowerCAmelCase : Optional[float] = 1.0 , _lowerCAmelCase : str = "epsilon" , _lowerCAmelCase : str = "squaredcos_cap_v2" , ): '''simple docstring''' if beta_schedule != "squaredcos_cap_v2": raise ValueError('UnCLIPScheduler only supports `beta_schedule`: \'squaredcos_cap_v2\'') __lowercase =betas_for_alpha_bar(_lowerCAmelCase) __lowercase =1.0 - self.betas __lowercase =torch.cumprod(self.alphas , dim=0) __lowercase =torch.tensor(1.0) # standard deviation of the initial noise distribution __lowercase =1.0 # setable values __lowercase =None __lowercase =torch.from_numpy(np.arange(0 , _lowerCAmelCase)[::-1].copy()) __lowercase =variance_type def __lowerCamelCase ( self : int , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : Optional[int] = None): '''simple docstring''' return sample def __lowerCamelCase ( self : Union[str, Any] , _lowerCAmelCase : int , _lowerCAmelCase : Union[str, torch.device] = None): '''simple docstring''' __lowercase =num_inference_steps __lowercase =(self.config.num_train_timesteps - 1) / (self.num_inference_steps - 1) __lowercase =(np.arange(0 , _lowerCAmelCase) * step_ratio).round()[::-1].copy().astype(np.intaa) __lowercase =torch.from_numpy(_lowerCAmelCase).to(_lowerCAmelCase) def __lowerCamelCase ( self : Tuple , _lowerCAmelCase : Optional[int] , _lowerCAmelCase : List[Any]=None , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : int=None): '''simple docstring''' if prev_timestep is None: __lowercase =t - 1 __lowercase =self.alphas_cumprod[t] __lowercase =self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one __lowercase =1 - alpha_prod_t __lowercase =1 - alpha_prod_t_prev if prev_timestep == t - 1: __lowercase =self.betas[t] else: __lowercase =1 - alpha_prod_t / alpha_prod_t_prev # For t > 0, compute predicted variance βt (see formula (6) and (7) from https://arxiv.org/pdf/2006.11239.pdf) # and sample from it to get previous sample # x_{t-1} ~ N(pred_prev_sample, variance) == add variance to pred_sample __lowercase =beta_prod_t_prev / beta_prod_t * beta if variance_type is None: __lowercase =self.config.variance_type # hacks - were probably added for training stability if variance_type == "fixed_small_log": __lowercase =torch.log(torch.clamp(_lowerCAmelCase , min=1e-20)) __lowercase =torch.exp(0.5 * variance) elif variance_type == "learned_range": # NOTE difference with DDPM scheduler __lowercase =variance.log() __lowercase =beta.log() __lowercase =(predicted_variance + 1) / 2 __lowercase =frac * max_log + (1 - frac) * min_log return variance def __lowerCamelCase ( self : Any , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : int , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : Optional[int] = None , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : bool = True , ): '''simple docstring''' __lowercase =timestep if model_output.shape[1] == sample.shape[1] * 2 and self.variance_type == "learned_range": __lowercase , __lowercase =torch.split(_lowerCAmelCase , sample.shape[1] , dim=1) else: __lowercase =None # 1. compute alphas, betas if prev_timestep is None: __lowercase =t - 1 __lowercase =self.alphas_cumprod[t] __lowercase =self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.one __lowercase =1 - alpha_prod_t __lowercase =1 - alpha_prod_t_prev if prev_timestep == t - 1: __lowercase =self.betas[t] __lowercase =self.alphas[t] else: __lowercase =1 - alpha_prod_t / alpha_prod_t_prev __lowercase =1 - beta # 2. compute predicted original sample from predicted noise also called # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf if self.config.prediction_type == "epsilon": __lowercase =(sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5 elif self.config.prediction_type == "sample": __lowercase =model_output else: raise ValueError( f"""prediction_type given as {self.config.prediction_type} must be one of `epsilon` or `sample`""" ' for the UnCLIPScheduler.') # 3. Clip "predicted x_0" if self.config.clip_sample: __lowercase =torch.clamp( _lowerCAmelCase , -self.config.clip_sample_range , self.config.clip_sample_range) # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf __lowercase =(alpha_prod_t_prev ** 0.5 * beta) / beta_prod_t __lowercase =alpha ** 0.5 * beta_prod_t_prev / beta_prod_t # 5. Compute predicted previous sample µ_t # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf __lowercase =pred_original_sample_coeff * pred_original_sample + current_sample_coeff * sample # 6. Add noise __lowercase =0 if t > 0: __lowercase =randn_tensor( model_output.shape , dtype=model_output.dtype , generator=_lowerCAmelCase , device=model_output.device) __lowercase =self._get_variance( _lowerCAmelCase , predicted_variance=_lowerCAmelCase , prev_timestep=_lowerCAmelCase , ) if self.variance_type == "fixed_small_log": __lowercase =variance elif self.variance_type == "learned_range": __lowercase =(0.5 * variance).exp() else: raise ValueError( f"""variance_type given as {self.variance_type} must be one of `fixed_small_log` or `learned_range`""" ' for the UnCLIPScheduler.') __lowercase =variance * variance_noise __lowercase =pred_prev_sample + variance if not return_dict: return (pred_prev_sample,) return UnCLIPSchedulerOutput(prev_sample=_lowerCAmelCase , pred_original_sample=_lowerCAmelCase) def __lowerCamelCase ( self : Tuple , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : torch.FloatTensor , _lowerCAmelCase : torch.IntTensor , ): '''simple docstring''' __lowercase =self.alphas_cumprod.to(device=original_samples.device , dtype=original_samples.dtype) __lowercase =timesteps.to(original_samples.device) __lowercase =alphas_cumprod[timesteps] ** 0.5 __lowercase =sqrt_alpha_prod.flatten() while len(sqrt_alpha_prod.shape) < len(original_samples.shape): __lowercase =sqrt_alpha_prod.unsqueeze(-1) __lowercase =(1 - alphas_cumprod[timesteps]) ** 0.5 __lowercase =sqrt_one_minus_alpha_prod.flatten() while len(sqrt_one_minus_alpha_prod.shape) < len(original_samples.shape): __lowercase =sqrt_one_minus_alpha_prod.unsqueeze(-1) __lowercase =sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise return noisy_samples
367
'''simple docstring''' import warnings from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding class _UpperCamelCase ( A ): '''simple docstring''' lowerCAmelCase__ = ["""image_processor""", """tokenizer"""] lowerCAmelCase__ = """CLIPImageProcessor""" lowerCAmelCase__ = ("""CLIPTokenizer""", """CLIPTokenizerFast""") def __init__( self : List[Any] , _lowerCAmelCase : Union[str, Any]=None , _lowerCAmelCase : Optional[Any]=None , **_lowerCAmelCase : str): '''simple docstring''' __lowercase =None if "feature_extractor" in kwargs: warnings.warn( 'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`' ' instead.' , _lowerCAmelCase , ) __lowercase =kwargs.pop('feature_extractor') __lowercase =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__(_lowerCAmelCase , _lowerCAmelCase) def __call__( self : List[Any] , _lowerCAmelCase : Optional[Any]=None , _lowerCAmelCase : Dict=None , _lowerCAmelCase : str=None , **_lowerCAmelCase : Union[str, Any]): '''simple docstring''' if text is None and images is None: raise ValueError('You have to specify either text or images. Both cannot be none.') if text is not None: __lowercase =self.tokenizer(_lowerCAmelCase , return_tensors=_lowerCAmelCase , **_lowerCAmelCase) if images is not None: __lowercase =self.image_processor(_lowerCAmelCase , return_tensors=_lowerCAmelCase , **_lowerCAmelCase) if text is not None and images is not None: __lowercase =image_features.pixel_values return encoding elif text is not None: return encoding else: return BatchEncoding(data=dict(**_lowerCAmelCase) , tensor_type=_lowerCAmelCase) def __lowerCamelCase ( self : Tuple , *_lowerCAmelCase : str , **_lowerCAmelCase : int): '''simple docstring''' return self.tokenizer.batch_decode(*_lowerCAmelCase , **_lowerCAmelCase) def __lowerCamelCase ( self : List[str] , *_lowerCAmelCase : Dict , **_lowerCAmelCase : Union[str, Any]): '''simple docstring''' return self.tokenizer.decode(*_lowerCAmelCase , **_lowerCAmelCase) @property def __lowerCamelCase ( self : Optional[int]): '''simple docstring''' __lowercase =self.tokenizer.model_input_names __lowercase =self.image_processor.model_input_names return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names)) @property def __lowerCamelCase ( self : List[Any]): '''simple docstring''' warnings.warn( '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.' , _lowerCAmelCase , ) return self.image_processor_class @property def __lowerCamelCase ( self : Optional[Any]): '''simple docstring''' warnings.warn( '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.' , _lowerCAmelCase , ) return self.image_processor
48
0
"""simple docstring""" import argparse import json import os import fairseq import torch from fairseq.data import Dictionary from transformers import ( UniSpeechConfig, UniSpeechForCTC, UniSpeechForPreTraining, WavaVecaFeatureExtractor, WavaVecaPhonemeCTCTokenizer, WavaVecaProcessor, logging, ) logging.set_verbosity_info() lowercase__ = logging.get_logger(__name__) lowercase__ = { """post_extract_proj""": """feature_projection.projection""", """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""", """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""", """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""", """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""", """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""", """self_attn_layer_norm""": """encoder.layers.*.layer_norm""", """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""", """fc2""": """encoder.layers.*.feed_forward.output_dense""", """final_layer_norm""": """encoder.layers.*.final_layer_norm""", """encoder.layer_norm""": """encoder.layer_norm""", """w2v_model.layer_norm""": """feature_projection.layer_norm""", """quantizer.weight_proj""": """quantizer.weight_proj""", """quantizer.vars""": """quantizer.codevectors""", """project_q""": """project_q""", """final_proj""": """project_hid""", """w2v_encoder.proj""": """ctc_proj""", """mask_emb""": """masked_spec_embed""", } lowercase__ = [ """ctc_proj""", """quantizer.weight_proj""", """quantizer.codevectors""", """project_q""", """project_hid""", ] def _snake_case ( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ): for attribute in key.split('.' ): if is_finetuned: if attribute in ["quantizer", "project_q", "project_hid"]: # those layers are only relevant for pretraining and should be dropped return if attribute == "ctc_proj": # we should rename `ctc_proj` to `lm_head` for fine-tuned phoneme models _lowerCamelCase : List[str] = """lm_head""" _lowerCamelCase : Optional[int] = getattr(lowerCAmelCase__ , lowerCAmelCase__ ) if weight_type is not None: _lowerCamelCase : Optional[Any] = getattr(lowerCAmelCase__ , lowerCAmelCase__ ).shape else: _lowerCamelCase : int = hf_pointer.shape assert hf_shape == value.shape, ( f'''Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be''' f''' {value.shape} for {full_name}''' ) if weight_type == "weight": _lowerCamelCase : str = value elif weight_type == "weight_g": _lowerCamelCase : Any = value elif weight_type == "weight_v": _lowerCamelCase : List[Any] = value elif weight_type == "bias": _lowerCamelCase : List[str] = value else: _lowerCamelCase : Optional[Any] = value logger.info(f'''{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}.''' ) def _snake_case ( lowercase__ , lowercase__ , lowercase__ ): _lowerCamelCase : List[Any] = [] _lowerCamelCase : Tuple = fairseq_model.state_dict() _lowerCamelCase : Optional[Any] = hf_model.unispeech.feature_extractor for name, value in fairseq_dict.items(): _lowerCamelCase : Any = False if "conv_layers" in name: load_conv_layer( lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , hf_model.config.feat_extract_norm == 'group' , ) _lowerCamelCase : str = True else: for key, mapped_key in MAPPING.items(): _lowerCamelCase : Tuple = """unispeech.""" + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key if key in name or key.split('w2v_model.' )[-1] == name.split('.' )[0]: _lowerCamelCase : List[Any] = True if "*" in mapped_key: _lowerCamelCase : Optional[int] = name.split(lowerCAmelCase__ )[0].split('.' )[-2] _lowerCamelCase : str = mapped_key.replace('*' , lowerCAmelCase__ ) if "weight_g" in name: _lowerCamelCase : Optional[int] = """weight_g""" elif "weight_v" in name: _lowerCamelCase : Tuple = """weight_v""" elif "bias" in name: _lowerCamelCase : str = """bias""" elif "weight" in name: # TODO: don't match quantizer.weight_proj _lowerCamelCase : Union[str, Any] = """weight""" else: _lowerCamelCase : int = None set_recursively(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ) continue if not is_used: unused_weights.append(lowerCAmelCase__ ) logger.warning(f'''Unused weights: {unused_weights}''' ) def _snake_case ( lowercase__ , lowercase__ , lowercase__ , lowercase__ , lowercase__ ): _lowerCamelCase : Any = full_name.split('conv_layers.' )[-1] _lowerCamelCase : Union[str, Any] = name.split('.' ) _lowerCamelCase : Optional[Any] = int(items[0] ) _lowerCamelCase : Tuple = 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 : int = value logger.info(f'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, ( f'''{full_name} has size {value.shape}, but''' f''' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.''' ) _lowerCamelCase : Any = value logger.info(f'''Feat extract conv layer {layer_id} was initialized from {full_name}.''' ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, ( f'''{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was''' " found." ) _lowerCamelCase : Any = value logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, ( f'''{full_name} has size {value.shape}, but''' f''' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.''' ) _lowerCamelCase : str = value logger.info(f'''Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.''' ) else: unused_weights.append(lowerCAmelCase__ ) @torch.no_grad() def _snake_case ( lowercase__ , lowercase__ , lowercase__=None , lowercase__=None , lowercase__=True ): if config_path is not None: _lowerCamelCase : Any = UniSpeechConfig.from_pretrained(lowerCAmelCase__ ) else: _lowerCamelCase : Union[str, Any] = UniSpeechConfig() if is_finetuned: if dict_path: _lowerCamelCase : List[str] = Dictionary.load_from_json(lowerCAmelCase__ ) # important change bos & pad token id since CTC symbol is <pad> and # not <s> as in fairseq _lowerCamelCase : str = target_dict.pad_index _lowerCamelCase : Optional[int] = target_dict.bos_index _lowerCamelCase : Union[str, Any] = target_dict.eos_index _lowerCamelCase : List[Any] = len(target_dict.symbols ) _lowerCamelCase : Tuple = os.path.join(lowerCAmelCase__ , 'vocab.json' ) if not os.path.isdir(lowerCAmelCase__ ): logger.error('--pytorch_dump_folder_path ({}) should be a directory'.format(lowerCAmelCase__ ) ) return os.makedirs(lowerCAmelCase__ , exist_ok=lowerCAmelCase__ ) _lowerCamelCase : Tuple = target_dict.indices # fairseq has the <pad> and <s> switched _lowerCamelCase : Tuple = 42 _lowerCamelCase : Optional[int] = 43 with open(lowerCAmelCase__ , 'w' , encoding='utf-8' ) as vocab_handle: json.dump(lowerCAmelCase__ , lowerCAmelCase__ ) _lowerCamelCase : Union[str, Any] = WavaVecaPhonemeCTCTokenizer( lowerCAmelCase__ , unk_token=target_dict.unk_word , pad_token=target_dict.pad_word , bos_token=target_dict.bos_word , eos_token=target_dict.eos_word , word_delimiter_token='|' , do_lower_case=lowerCAmelCase__ , ) _lowerCamelCase : List[str] = True if config.feat_extract_norm == """layer""" else False _lowerCamelCase : str = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=16000 , padding_value=0 , do_normalize=lowerCAmelCase__ , return_attention_mask=lowerCAmelCase__ , ) _lowerCamelCase : Tuple = WavaVecaProcessor(feature_extractor=lowerCAmelCase__ , tokenizer=lowerCAmelCase__ ) processor.save_pretrained(lowerCAmelCase__ ) _lowerCamelCase : Optional[int] = UniSpeechForCTC(lowerCAmelCase__ ) else: _lowerCamelCase : Optional[int] = UniSpeechForPreTraining(lowerCAmelCase__ ) if is_finetuned: _lowerCamelCase : List[str] = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={'data': '/'.join(dict_path.split('/' )[:-1] ), 'w2v_path': checkpoint_path} ) else: _lowerCamelCase : List[Any] = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] ) _lowerCamelCase : Optional[Any] = model[0].eval() recursively_load_weights(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ) hf_unispeech.save_pretrained(lowerCAmelCase__ ) if __name__ == "__main__": lowercase__ = argparse.ArgumentParser() parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""") parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""") parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""") parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""") parser.add_argument( """--not_finetuned""", action="""store_true""", help="""Whether the model to convert is a fine-tuned model or not""" ) lowercase__ = parser.parse_args() convert_unispeech_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned )
96
'''simple docstring''' _UpperCamelCase = ''' # Transformers 설치 방법 ! pip install transformers datasets # 마지막 릴리스 대신 소스에서 설치하려면, 위 명령을 주석으로 바꾸고 아래 명령을 해제하세요. # ! pip install git+https://github.com/huggingface/transformers.git ''' _UpperCamelCase = [{'''type''': '''code''', '''content''': INSTALL_CONTENT}] _UpperCamelCase = { '''{processor_class}''': '''FakeProcessorClass''', '''{model_class}''': '''FakeModelClass''', '''{object_class}''': '''FakeObjectClass''', }
254
0
import argparse import gc import json import os import shutil import warnings import torch from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer try: from transformers import LlamaTokenizerFast except ImportError as e: warnings.warn(e) warnings.warn( """The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion""" ) lowerCamelCase_ = None lowerCamelCase_ = { "7B": 1_1_0_0_8, "13B": 1_3_8_2_4, "30B": 1_7_9_2_0, "65B": 2_2_0_1_6, "70B": 2_8_6_7_2, } lowerCamelCase_ = { "7B": 1, "7Bf": 1, "13B": 2, "13Bf": 2, "30B": 4, "65B": 8, "70B": 8, "70Bf": 8, } def lowerCamelCase ( a_ , a_=1 , a_=256 ) -> List[str]: return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3 ) ) + multiple_of - 1) // multiple_of) def lowerCamelCase ( a_ ) -> List[Any]: with open(__lowerCAmelCase , 'r' ) as f: return json.load(__lowerCAmelCase ) def lowerCamelCase ( a_ , a_ ) -> List[str]: with open(__lowerCAmelCase , 'w' ) as f: json.dump(__lowerCAmelCase , __lowerCAmelCase ) def lowerCamelCase ( a_ , a_ , a_ , a_=True ) -> Optional[Any]: os.makedirs(__lowerCAmelCase , exist_ok=__lowerCAmelCase ) lowerCAmelCase_ = os.path.join(__lowerCAmelCase , 'tmp' ) os.makedirs(__lowerCAmelCase , exist_ok=__lowerCAmelCase ) lowerCAmelCase_ = read_json(os.path.join(__lowerCAmelCase , 'params.json' ) ) lowerCAmelCase_ = NUM_SHARDS[model_size] lowerCAmelCase_ = params["""n_layers"""] lowerCAmelCase_ = params["""n_heads"""] lowerCAmelCase_ = n_heads // num_shards lowerCAmelCase_ = params["""dim"""] lowerCAmelCase_ = dim // n_heads lowerCAmelCase_ = 10_000.0 lowerCAmelCase_ = 1.0 / (base ** (torch.arange(0 , __lowerCAmelCase , 2 ).float() / dims_per_head)) if "n_kv_heads" in params: lowerCAmelCase_ = params["""n_kv_heads"""] # for GQA / MQA lowerCAmelCase_ = n_heads_per_shard // num_key_value_heads lowerCAmelCase_ = dim // num_key_value_heads else: # compatibility with other checkpoints lowerCAmelCase_ = n_heads lowerCAmelCase_ = n_heads_per_shard lowerCAmelCase_ = dim # permute for sliced rotary def permute(a_ , a_=n_heads , a_=dim , a_=dim ): return w.view(__lowerCAmelCase , dima // n_heads // 2 , 2 , __lowerCAmelCase ).transpose(1 , 2 ).reshape(__lowerCAmelCase , __lowerCAmelCase ) print(F'''Fetching all parameters from the checkpoint at {input_base_path}.''' ) # Load weights if model_size == "7B": # Not sharded # (The sharded implementation would also work, but this is simpler.) lowerCAmelCase_ = torch.load(os.path.join(__lowerCAmelCase , 'consolidated.00.pth' ) , map_location='cpu' ) else: # Sharded lowerCAmelCase_ = [ torch.load(os.path.join(__lowerCAmelCase , F'''consolidated.{i:02d}.pth''' ) , map_location='cpu' ) for i in range(__lowerCAmelCase ) ] lowerCAmelCase_ = 0 lowerCAmelCase_ = {"""weight_map""": {}} for layer_i in range(__lowerCAmelCase ): lowerCAmelCase_ = F'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin''' if model_size == "7B": # Unsharded lowerCAmelCase_ = { F'''model.layers.{layer_i}.self_attn.q_proj.weight''': permute( loaded[F'''layers.{layer_i}.attention.wq.weight'''] ), F'''model.layers.{layer_i}.self_attn.k_proj.weight''': permute( loaded[F'''layers.{layer_i}.attention.wk.weight'''] ), F'''model.layers.{layer_i}.self_attn.v_proj.weight''': loaded[F'''layers.{layer_i}.attention.wv.weight'''], F'''model.layers.{layer_i}.self_attn.o_proj.weight''': loaded[F'''layers.{layer_i}.attention.wo.weight'''], F'''model.layers.{layer_i}.mlp.gate_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w1.weight'''], F'''model.layers.{layer_i}.mlp.down_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w2.weight'''], F'''model.layers.{layer_i}.mlp.up_proj.weight''': loaded[F'''layers.{layer_i}.feed_forward.w3.weight'''], F'''model.layers.{layer_i}.input_layernorm.weight''': loaded[F'''layers.{layer_i}.attention_norm.weight'''], F'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[F'''layers.{layer_i}.ffn_norm.weight'''], } else: # Sharded # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned. lowerCAmelCase_ = { F'''model.layers.{layer_i}.input_layernorm.weight''': loaded[0][ F'''layers.{layer_i}.attention_norm.weight''' ].clone(), F'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[0][ F'''layers.{layer_i}.ffn_norm.weight''' ].clone(), } lowerCAmelCase_ = permute( torch.cat( [ loaded[i][F'''layers.{layer_i}.attention.wq.weight'''].view(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) for i in range(__lowerCAmelCase ) ] , dim=0 , ).reshape(__lowerCAmelCase , __lowerCAmelCase ) ) lowerCAmelCase_ = permute( torch.cat( [ loaded[i][F'''layers.{layer_i}.attention.wk.weight'''].view( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) for i in range(__lowerCAmelCase ) ] , dim=0 , ).reshape(__lowerCAmelCase , __lowerCAmelCase ) , __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase , ) lowerCAmelCase_ = torch.cat( [ loaded[i][F'''layers.{layer_i}.attention.wv.weight'''].view( __lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) for i in range(__lowerCAmelCase ) ] , dim=0 , ).reshape(__lowerCAmelCase , __lowerCAmelCase ) lowerCAmelCase_ = torch.cat( [loaded[i][F'''layers.{layer_i}.attention.wo.weight'''] for i in range(__lowerCAmelCase )] , dim=1 ) lowerCAmelCase_ = torch.cat( [loaded[i][F'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(__lowerCAmelCase )] , dim=0 ) lowerCAmelCase_ = torch.cat( [loaded[i][F'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(__lowerCAmelCase )] , dim=1 ) lowerCAmelCase_ = torch.cat( [loaded[i][F'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(__lowerCAmelCase )] , dim=0 ) lowerCAmelCase_ = inv_freq for k, v in state_dict.items(): lowerCAmelCase_ = filename param_count += v.numel() torch.save(__lowerCAmelCase , os.path.join(__lowerCAmelCase , __lowerCAmelCase ) ) lowerCAmelCase_ = F'''pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin''' if model_size == "7B": # Unsharded lowerCAmelCase_ = { """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""], """model.norm.weight""": loaded["""norm.weight"""], """lm_head.weight""": loaded["""output.weight"""], } else: lowerCAmelCase_ = { """model.norm.weight""": loaded[0]["""norm.weight"""], """model.embed_tokens.weight""": torch.cat( [loaded[i]['tok_embeddings.weight'] for i in range(__lowerCAmelCase )] , dim=1 ), """lm_head.weight""": torch.cat([loaded[i]['output.weight'] for i in range(__lowerCAmelCase )] , dim=0 ), } for k, v in state_dict.items(): lowerCAmelCase_ = filename param_count += v.numel() torch.save(__lowerCAmelCase , os.path.join(__lowerCAmelCase , __lowerCAmelCase ) ) # Write configs lowerCAmelCase_ = {"""total_size""": param_count * 2} write_json(__lowerCAmelCase , os.path.join(__lowerCAmelCase , 'pytorch_model.bin.index.json' ) ) lowerCAmelCase_ = params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1 lowerCAmelCase_ = params["""multiple_of"""] if """multiple_of""" in params else 256 lowerCAmelCase_ = LlamaConfig( hidden_size=__lowerCAmelCase , intermediate_size=compute_intermediate_size(__lowerCAmelCase , __lowerCAmelCase , __lowerCAmelCase ) , num_attention_heads=params['n_heads'] , num_hidden_layers=params['n_layers'] , rms_norm_eps=params['norm_eps'] , num_key_value_heads=__lowerCAmelCase , ) config.save_pretrained(__lowerCAmelCase ) # Make space so we can load the model properly now. del state_dict del loaded gc.collect() print('Loading the checkpoint in a Llama model.' ) lowerCAmelCase_ = LlamaForCausalLM.from_pretrained(__lowerCAmelCase , torch_dtype=torch.floataa , low_cpu_mem_usage=__lowerCAmelCase ) # Avoid saving this as part of the config. del model.config._name_or_path print('Saving in the Transformers format.' ) model.save_pretrained(__lowerCAmelCase , safe_serialization=__lowerCAmelCase ) shutil.rmtree(__lowerCAmelCase ) def lowerCamelCase ( a_ , a_ ) -> List[str]: # Initialize the tokenizer based on the `spm` model lowerCAmelCase_ = LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast print(F'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.''' ) lowerCAmelCase_ = tokenizer_class(__lowerCAmelCase ) tokenizer.save_pretrained(__lowerCAmelCase ) def lowerCamelCase ( ) -> Any: lowerCAmelCase_ = argparse.ArgumentParser() parser.add_argument( '--input_dir' , help='Location of LLaMA weights, which contains tokenizer.model and model folders' , ) parser.add_argument( '--model_size' , choices=['7B', '7Bf', '13B', '13Bf', '30B', '65B', '70B', '70Bf', 'tokenizer_only'] , ) parser.add_argument( '--output_dir' , help='Location to write HF model and tokenizer' , ) parser.add_argument('--safe_serialization' , type=__lowerCAmelCase , help='Whether or not to save using `safetensors`.' ) lowerCAmelCase_ = parser.parse_args() if args.model_size != "tokenizer_only": write_model( model_path=args.output_dir , input_base_path=os.path.join(args.input_dir , args.model_size ) , model_size=args.model_size , safe_serialization=args.safe_serialization , ) lowerCAmelCase_ = os.path.join(args.input_dir , 'tokenizer.model' ) write_tokenizer(args.output_dir , __lowerCAmelCase ) if __name__ == "__main__": main()
361
def lowerCamelCase ( a_ ) -> "list[int]": if upper_limit < 0: raise ValueError('Limit for the Catalan sequence must be ≥ 0' ) lowerCAmelCase_ = [0] * (upper_limit + 1) # Base case: C(0) = C(1) = 1 lowerCAmelCase_ = 1 if upper_limit > 0: lowerCAmelCase_ = 1 # Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i for i in range(2 , upper_limit + 1 ): for j in range(a_ ): catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1] return catalan_list if __name__ == "__main__": print("""\n********* Catalan Numbers Using Dynamic Programming ************\n""") print("""\n*** Enter -1 at any time to quit ***""") print("""\nEnter the upper limit (≥ 0) for the Catalan number sequence: """, end="""""") try: while True: lowerCamelCase_ = int(input().strip()) if N < 0: print("""\n********* Goodbye!! ************""") break else: print(f'''The Catalan numbers from 0 through {N} are:''') print(catalan_numbers(N)) print("""Try another upper limit for the sequence: """, end="""""") except (NameError, ValueError): print("""\n********* Invalid input, goodbye! ************\n""") import doctest doctest.testmod()
14
0
'''simple docstring''' import argparse from pathlib import Path import requests import torch from PIL import Image from transformers import ( RobertaTokenizer, TrOCRConfig, TrOCRForCausalLM, TrOCRProcessor, VisionEncoderDecoderModel, ViTConfig, ViTImageProcessor, ViTModel, ) from transformers.utils import logging logging.set_verbosity_info() _UpperCamelCase = logging.get_logger(__name__) def a_ ( _lowerCAmelCase ,_lowerCAmelCase ) -> Optional[Any]: __lowerCamelCase : int = [] for i in range(encoder_config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append( (F'encoder.deit.blocks.{i}.norm1.weight', F'encoder.encoder.layer.{i}.layernorm_before.weight') ) rename_keys.append((F'encoder.deit.blocks.{i}.norm1.bias', F'encoder.encoder.layer.{i}.layernorm_before.bias') ) rename_keys.append( (F'encoder.deit.blocks.{i}.attn.proj.weight', F'encoder.encoder.layer.{i}.attention.output.dense.weight') ) rename_keys.append( (F'encoder.deit.blocks.{i}.attn.proj.bias', F'encoder.encoder.layer.{i}.attention.output.dense.bias') ) rename_keys.append( (F'encoder.deit.blocks.{i}.norm2.weight', F'encoder.encoder.layer.{i}.layernorm_after.weight') ) rename_keys.append((F'encoder.deit.blocks.{i}.norm2.bias', F'encoder.encoder.layer.{i}.layernorm_after.bias') ) rename_keys.append( (F'encoder.deit.blocks.{i}.mlp.fc1.weight', F'encoder.encoder.layer.{i}.intermediate.dense.weight') ) rename_keys.append( (F'encoder.deit.blocks.{i}.mlp.fc1.bias', F'encoder.encoder.layer.{i}.intermediate.dense.bias') ) rename_keys.append( (F'encoder.deit.blocks.{i}.mlp.fc2.weight', F'encoder.encoder.layer.{i}.output.dense.weight') ) rename_keys.append((F'encoder.deit.blocks.{i}.mlp.fc2.bias', F'encoder.encoder.layer.{i}.output.dense.bias') ) # cls token, position embeddings and patch embeddings of encoder rename_keys.extend( [ ('encoder.deit.cls_token', 'encoder.embeddings.cls_token'), ('encoder.deit.pos_embed', 'encoder.embeddings.position_embeddings'), ('encoder.deit.patch_embed.proj.weight', 'encoder.embeddings.patch_embeddings.projection.weight'), ('encoder.deit.patch_embed.proj.bias', 'encoder.embeddings.patch_embeddings.projection.bias'), ('encoder.deit.norm.weight', 'encoder.layernorm.weight'), ('encoder.deit.norm.bias', 'encoder.layernorm.bias'), ] ) return rename_keys def a_ ( _lowerCAmelCase ,_lowerCAmelCase ) -> List[Any]: for i in range(encoder_config.num_hidden_layers ): # queries, keys and values (only weights, no biases) __lowerCamelCase : Union[str, Any] = state_dict.pop(F'encoder.deit.blocks.{i}.attn.qkv.weight' ) __lowerCamelCase : List[str] = in_proj_weight[ : encoder_config.hidden_size, : ] __lowerCamelCase : Dict = in_proj_weight[ encoder_config.hidden_size : encoder_config.hidden_size * 2, : ] __lowerCamelCase : str = in_proj_weight[ -encoder_config.hidden_size :, : ] def a_ ( _lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase ) -> str: __lowerCamelCase : Dict = dct.pop(_lowerCAmelCase ) __lowerCamelCase : Any = val def a_ ( _lowerCAmelCase ) -> List[str]: if "handwritten" in checkpoint_url: __lowerCamelCase : Dict = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' # industry # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-12.jpg" # have # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02-10.jpg" # let # url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg" # # url = "https://fki.tic.heia-fr.ch/static/img/a01-122.jpg" elif "printed" in checkpoint_url or "stage1" in checkpoint_url: __lowerCamelCase : Optional[Any] = 'https://www.researchgate.net/profile/Dinh-Sang/publication/338099565/figure/fig8/AS:840413229350922@1577381536857/An-receipt-example-in-the-SROIE-2019-dataset_Q640.jpg' __lowerCamelCase : Optional[int] = Image.open(requests.get(_lowerCAmelCase ,stream=_lowerCAmelCase ).raw ).convert('RGB' ) return im @torch.no_grad() def a_ ( _lowerCAmelCase ,_lowerCAmelCase ) -> Tuple: __lowerCamelCase : List[Any] = ViTConfig(image_size=384 ,qkv_bias=_lowerCAmelCase ) __lowerCamelCase : Optional[Any] = TrOCRConfig() # size of the architecture if "base" in checkpoint_url: __lowerCamelCase : str = 768 elif "large" in checkpoint_url: # use ViT-large encoder __lowerCamelCase : Tuple = 1024 __lowerCamelCase : List[str] = 4096 __lowerCamelCase : str = 24 __lowerCamelCase : int = 16 __lowerCamelCase : Optional[Any] = 1024 else: raise ValueError('Should either find \'base\' or \'large\' in checkpoint URL' ) # the large-printed + stage1 checkpoints uses sinusoidal position embeddings, no layernorm afterwards if "large-printed" in checkpoint_url or "stage1" in checkpoint_url: __lowerCamelCase : Any = False __lowerCamelCase : Union[str, Any] = 'relu' __lowerCamelCase : int = 1024 __lowerCamelCase : Optional[Any] = True __lowerCamelCase : Any = False __lowerCamelCase : Any = False # load HuggingFace model __lowerCamelCase : List[str] = ViTModel(_lowerCAmelCase ,add_pooling_layer=_lowerCAmelCase ) __lowerCamelCase : Optional[int] = TrOCRForCausalLM(_lowerCAmelCase ) __lowerCamelCase : List[str] = VisionEncoderDecoderModel(encoder=_lowerCAmelCase ,decoder=_lowerCAmelCase ) model.eval() # load state_dict of original model, rename some keys __lowerCamelCase : Union[str, Any] = torch.hub.load_state_dict_from_url(_lowerCAmelCase ,map_location='cpu' ,check_hash=_lowerCAmelCase )['model'] __lowerCamelCase : List[str] = create_rename_keys(_lowerCAmelCase ,_lowerCAmelCase ) for src, dest in rename_keys: rename_key(_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase ) read_in_q_k_v(_lowerCAmelCase ,_lowerCAmelCase ) # remove parameters we don't need del state_dict["encoder.deit.head.weight"] del state_dict["encoder.deit.head.bias"] del state_dict["decoder.version"] # add prefix to decoder keys for key, val in state_dict.copy().items(): __lowerCamelCase : Union[str, Any] = state_dict.pop(_lowerCAmelCase ) if key.startswith('decoder' ) and "output_projection" not in key: __lowerCamelCase : Dict = val else: __lowerCamelCase : Dict = val # load state dict model.load_state_dict(_lowerCAmelCase ) # Check outputs on an image __lowerCamelCase : List[str] = ViTImageProcessor(size=encoder_config.image_size ) __lowerCamelCase : List[Any] = RobertaTokenizer.from_pretrained('roberta-large' ) __lowerCamelCase : int = TrOCRProcessor(_lowerCAmelCase ,_lowerCAmelCase ) __lowerCamelCase : Tuple = processor(images=prepare_img(_lowerCAmelCase ) ,return_tensors='pt' ).pixel_values # verify logits __lowerCamelCase : List[Any] = torch.tensor([[model.config.decoder.decoder_start_token_id]] ) __lowerCamelCase : str = model(pixel_values=_lowerCAmelCase ,decoder_input_ids=_lowerCAmelCase ) __lowerCamelCase : str = outputs.logits __lowerCamelCase : Optional[Any] = torch.Size([1, 1, 50265] ) if "trocr-base-handwritten" in checkpoint_url: __lowerCamelCase : List[str] = torch.tensor( [-1.4502, -4.6683, -0.5347, -2.9291, 9.1435, -3.0571, 8.9764, 1.7560, 8.7358, -1.5311] ) elif "trocr-large-handwritten" in checkpoint_url: __lowerCamelCase : Dict = torch.tensor( [-2.6437, -1.3129, -2.2596, -5.3455, 6.3539, 1.7604, 5.4991, 1.4702, 5.6113, 2.0170] ) elif "trocr-base-printed" in checkpoint_url: __lowerCamelCase : Dict = torch.tensor( [-5.6816, -5.8388, 1.1398, -6.9034, 6.8505, -2.4393, 1.2284, -1.0232, -1.9661, -3.9210] ) elif "trocr-large-printed" in checkpoint_url: __lowerCamelCase : str = torch.tensor( [-6.0162, -7.0959, 4.4155, -5.1063, 7.0468, -3.1631, 2.6466, -0.3081, -0.8106, -1.7535] ) if "stage1" not in checkpoint_url: assert logits.shape == expected_shape, "Shape of logits not as expected" assert torch.allclose(logits[0, 0, :10] ,_lowerCAmelCase ,atol=1E-3 ), "First elements of logits not as expected" Path(_lowerCAmelCase ).mkdir(exist_ok=_lowerCAmelCase ) print(F'Saving model to {pytorch_dump_folder_path}' ) model.save_pretrained(_lowerCAmelCase ) print(F'Saving processor to {pytorch_dump_folder_path}' ) processor.save_pretrained(_lowerCAmelCase ) if __name__ == "__main__": _UpperCamelCase = argparse.ArgumentParser() parser.add_argument( '--checkpoint_url', default='https://layoutlm.blob.core.windows.net/trocr/model_zoo/fairseq/trocr-base-handwritten.pt', 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.' ) _UpperCamelCase = parser.parse_args() convert_tr_ocr_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)
208
'''simple docstring''' from collections.abc import Sequence def a_ ( _lowerCAmelCase ,_lowerCAmelCase ) -> float: return sum(c * (x**i) for i, c in enumerate(_lowerCAmelCase ) ) def a_ ( _lowerCAmelCase ,_lowerCAmelCase ) -> float: __lowerCamelCase : Any = 0.0 for coeff in reversed(_lowerCAmelCase ): __lowerCamelCase : Tuple = result * x + coeff return result if __name__ == "__main__": _UpperCamelCase = (0.0, 0.0, 5.0, 9.3, 7.0) _UpperCamelCase = 1_0.0 print(evaluate_poly(poly, x)) print(horner(poly, x))
208
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_poolformer import PoolFormerImageProcessor __magic_name__ : Tuple = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE_ ( lowercase__ ): """simple docstring""" def __init__( self , *lowerCAmelCase__ , **lowerCAmelCase__): warnings.warn( """The class PoolFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.""" """ Please use PoolFormerImageProcessor instead.""" , lowercase_ , ) super().__init__(*lowercase_ , **lowercase_)
351
"""simple docstring""" import os import tempfile import unittest from transformers import NezhaConfig, is_torch_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( MODEL_FOR_PRETRAINING_MAPPING, NezhaForMaskedLM, NezhaForMultipleChoice, NezhaForNextSentencePrediction, NezhaForPreTraining, NezhaForQuestionAnswering, NezhaForSequenceClassification, NezhaForTokenClassification, NezhaModel, ) from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST class SCREAMING_SNAKE_CASE_ : """simple docstring""" def __init__( self , lowerCAmelCase__ , lowerCAmelCase__=1_3 , lowerCAmelCase__=7 , lowerCAmelCase__=True , lowerCAmelCase__=True , lowerCAmelCase__=True , lowerCAmelCase__=True , lowerCAmelCase__=9_9 , lowerCAmelCase__=3_2 , lowerCAmelCase__=5 , lowerCAmelCase__=4 , lowerCAmelCase__=3_7 , lowerCAmelCase__="gelu" , lowerCAmelCase__=0.1 , lowerCAmelCase__=0.1 , lowerCAmelCase__=1_2_8 , lowerCAmelCase__=3_2 , lowerCAmelCase__=1_6 , lowerCAmelCase__=2 , lowerCAmelCase__=0.02 , lowerCAmelCase__=3 , lowerCAmelCase__=4 , lowerCAmelCase__=None , ): __SCREAMING_SNAKE_CASE = parent __SCREAMING_SNAKE_CASE = batch_size __SCREAMING_SNAKE_CASE = seq_length __SCREAMING_SNAKE_CASE = is_training __SCREAMING_SNAKE_CASE = use_input_mask __SCREAMING_SNAKE_CASE = use_token_type_ids __SCREAMING_SNAKE_CASE = use_labels __SCREAMING_SNAKE_CASE = vocab_size __SCREAMING_SNAKE_CASE = hidden_size __SCREAMING_SNAKE_CASE = num_hidden_layers __SCREAMING_SNAKE_CASE = num_attention_heads __SCREAMING_SNAKE_CASE = intermediate_size __SCREAMING_SNAKE_CASE = hidden_act __SCREAMING_SNAKE_CASE = hidden_dropout_prob __SCREAMING_SNAKE_CASE = attention_probs_dropout_prob __SCREAMING_SNAKE_CASE = max_position_embeddings __SCREAMING_SNAKE_CASE = type_vocab_size __SCREAMING_SNAKE_CASE = type_sequence_label_size __SCREAMING_SNAKE_CASE = initializer_range __SCREAMING_SNAKE_CASE = num_labels __SCREAMING_SNAKE_CASE = num_choices __SCREAMING_SNAKE_CASE = scope def snake_case_ ( self): __SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size) __SCREAMING_SNAKE_CASE = None if self.use_input_mask: __SCREAMING_SNAKE_CASE = random_attention_mask([self.batch_size, self.seq_length]) __SCREAMING_SNAKE_CASE = None if self.use_token_type_ids: __SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size) __SCREAMING_SNAKE_CASE = None __SCREAMING_SNAKE_CASE = None __SCREAMING_SNAKE_CASE = None if self.use_labels: __SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.type_sequence_label_size) __SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , self.num_labels) __SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size] , self.num_choices) __SCREAMING_SNAKE_CASE = self.get_config() return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def snake_case_ ( self): return NezhaConfig( 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=lowerCAmelCase__ , initializer_range=self.initializer_range , ) def snake_case_ ( self): ( ( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) , ) = self.prepare_config_and_inputs() __SCREAMING_SNAKE_CASE = True __SCREAMING_SNAKE_CASE = floats_tensor([self.batch_size, self.seq_length, self.hidden_size]) __SCREAMING_SNAKE_CASE = ids_tensor([self.batch_size, self.seq_length] , vocab_size=2) return ( config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels, encoder_hidden_states, encoder_attention_mask, ) def snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = NezhaModel(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = model(lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , token_type_ids=lowerCAmelCase__) __SCREAMING_SNAKE_CASE = model(lowerCAmelCase__ , token_type_ids=lowerCAmelCase__) __SCREAMING_SNAKE_CASE = 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 snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , ): __SCREAMING_SNAKE_CASE = True __SCREAMING_SNAKE_CASE = NezhaModel(lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = model( lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , encoder_hidden_states=lowerCAmelCase__ , encoder_attention_mask=lowerCAmelCase__ , ) __SCREAMING_SNAKE_CASE = model( lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , encoder_hidden_states=lowerCAmelCase__ , ) __SCREAMING_SNAKE_CASE = model(lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , token_type_ids=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 snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = NezhaForMaskedLM(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = 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 snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = NezhaForNextSentencePrediction(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = model( lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , labels=lowerCAmelCase__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, 2)) def snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = NezhaForPreTraining(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = 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 snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = NezhaForQuestionAnswering(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = 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 snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = self.num_labels __SCREAMING_SNAKE_CASE = NezhaForSequenceClassification(lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = model(lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , labels=lowerCAmelCase__) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels)) def snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = self.num_labels __SCREAMING_SNAKE_CASE = NezhaForTokenClassification(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = 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 snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__): __SCREAMING_SNAKE_CASE = self.num_choices __SCREAMING_SNAKE_CASE = NezhaForMultipleChoice(config=lowerCAmelCase__) model.to(lowerCAmelCase__) model.eval() __SCREAMING_SNAKE_CASE = input_ids.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() __SCREAMING_SNAKE_CASE = token_type_ids.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() __SCREAMING_SNAKE_CASE = input_mask.unsqueeze(1).expand(-1 , self.num_choices , -1).contiguous() __SCREAMING_SNAKE_CASE = model( lowerCAmelCase__ , attention_mask=lowerCAmelCase__ , token_type_ids=lowerCAmelCase__ , labels=lowerCAmelCase__ , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices)) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.prepare_config_and_inputs() ( ( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) , ) = config_and_inputs __SCREAMING_SNAKE_CASE = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask} return config, inputs_dict @require_torch class SCREAMING_SNAKE_CASE_ ( __a , __a , __a , unittest.TestCase ): """simple docstring""" __lowercase : int = ( ( NezhaModel, NezhaForMaskedLM, NezhaForMultipleChoice, NezhaForNextSentencePrediction, NezhaForPreTraining, NezhaForQuestionAnswering, NezhaForSequenceClassification, NezhaForTokenClassification, ) if is_torch_available() else () ) __lowercase : Optional[Any] = ( { '''feature-extraction''': NezhaModel, '''fill-mask''': NezhaForMaskedLM, '''question-answering''': NezhaForQuestionAnswering, '''text-classification''': NezhaForSequenceClassification, '''token-classification''': NezhaForTokenClassification, '''zero-shot''': NezhaForSequenceClassification, } if is_torch_available() else {} ) __lowercase : List[Any] = True def snake_case_ ( self , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__=False): __SCREAMING_SNAKE_CASE = super()._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__ , return_labels=lowerCAmelCase__) if return_labels: if model_class in get_values(lowerCAmelCase__): __SCREAMING_SNAKE_CASE = torch.zeros( (self.model_tester.batch_size, self.model_tester.seq_length) , dtype=torch.long , device=lowerCAmelCase__) __SCREAMING_SNAKE_CASE = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=lowerCAmelCase__) return inputs_dict def snake_case_ ( self): __SCREAMING_SNAKE_CASE = NezhaModelTester(self) __SCREAMING_SNAKE_CASE = ConfigTester(self , config_class=lowerCAmelCase__ , hidden_size=3_7) def snake_case_ ( self): self.config_tester.run_common_tests() def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*lowerCAmelCase__) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_decoder() self.model_tester.create_and_check_model_as_decoder(*lowerCAmelCase__) def snake_case_ ( self): # This regression test was failing with PyTorch < 1.3 ( ( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) ,( __SCREAMING_SNAKE_CASE ) , ) = self.model_tester.prepare_config_and_inputs_for_decoder() __SCREAMING_SNAKE_CASE = None self.model_tester.create_and_check_model_as_decoder( lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , ) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase__) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase__) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_next_sequence_prediction(*lowerCAmelCase__) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase__) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase__) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase__) def snake_case_ ( self): __SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase__) @slow def snake_case_ ( self): for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: __SCREAMING_SNAKE_CASE = NezhaModel.from_pretrained(lowerCAmelCase__) self.assertIsNotNone(lowerCAmelCase__) @slow @require_torch_gpu def snake_case_ ( self): __SCREAMING_SNAKE_CASE ,__SCREAMING_SNAKE_CASE = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: # NezhaForMultipleChoice behaves incorrectly in JIT environments. if model_class == NezhaForMultipleChoice: return __SCREAMING_SNAKE_CASE = True __SCREAMING_SNAKE_CASE = model_class(config=lowerCAmelCase__) __SCREAMING_SNAKE_CASE = self._prepare_for_class(lowerCAmelCase__ , lowerCAmelCase__) __SCREAMING_SNAKE_CASE = torch.jit.trace( lowerCAmelCase__ , (inputs_dict["""input_ids"""].to("""cpu"""), inputs_dict["""attention_mask"""].to("""cpu"""))) with tempfile.TemporaryDirectory() as tmp: torch.jit.save(lowerCAmelCase__ , os.path.join(lowerCAmelCase__ , """bert.pt""")) __SCREAMING_SNAKE_CASE = torch.jit.load(os.path.join(lowerCAmelCase__ , """bert.pt""") , map_location=lowerCAmelCase__) loaded(inputs_dict["""input_ids"""].to(lowerCAmelCase__) , inputs_dict["""attention_mask"""].to(lowerCAmelCase__)) @require_torch class SCREAMING_SNAKE_CASE_ ( unittest.TestCase ): """simple docstring""" @slow def snake_case_ ( self): __SCREAMING_SNAKE_CASE = NezhaModel.from_pretrained("""sijunhe/nezha-cn-base""") __SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]]) __SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 1, 1, 1, 1]]) with torch.no_grad(): __SCREAMING_SNAKE_CASE = model(lowerCAmelCase__ , attention_mask=lowerCAmelCase__)[0] __SCREAMING_SNAKE_CASE = torch.Size((1, 6, 7_6_8)) self.assertEqual(output.shape , lowerCAmelCase__) __SCREAMING_SNAKE_CASE = torch.tensor([[[0.06_85, 0.24_41, 0.11_02], [0.06_00, 0.19_06, 0.13_49], [0.02_21, 0.08_19, 0.05_86]]]) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , lowerCAmelCase__ , atol=1E-4)) @slow def snake_case_ ( self): __SCREAMING_SNAKE_CASE = NezhaForMaskedLM.from_pretrained("""sijunhe/nezha-cn-base""") __SCREAMING_SNAKE_CASE = torch.tensor([[0, 1, 2, 3, 4, 5]]) __SCREAMING_SNAKE_CASE = torch.tensor([[1, 1, 1, 1, 1, 1]]) with torch.no_grad(): __SCREAMING_SNAKE_CASE = model(lowerCAmelCase__ , attention_mask=lowerCAmelCase__)[0] __SCREAMING_SNAKE_CASE = torch.Size((1, 6, 2_1_1_2_8)) self.assertEqual(output.shape , lowerCAmelCase__) __SCREAMING_SNAKE_CASE = torch.tensor( [[-2.79_39, -1.79_02, -2.21_89], [-2.85_85, -1.89_08, -2.37_23], [-2.64_99, -1.77_50, -2.25_58]]) self.assertTrue(torch.allclose(output[:, 1:4, 1:4] , lowerCAmelCase__ , atol=1E-4))
255
0
'''simple docstring''' import numpy as np from cva import destroyAllWindows, imread, imshow, waitKey class a__ : def __init__( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): """simple docstring""" if dst_width < 0 or dst_height < 0: raise ValueError("Destination width/height should be > 0" ) _lowercase : Optional[int] = img _lowercase : Tuple = img.shape[1] _lowercase : Union[str, Any] = img.shape[0] _lowercase : List[Any] = dst_width _lowercase : int = dst_height _lowercase : Any = self.src_w / self.dst_w _lowercase : Any = self.src_h / self.dst_h _lowercase : Optional[Any] = ( np.ones((self.dst_h, self.dst_w, 3) , np.uinta ) * 255 ) def _lowerCamelCase ( self ): """simple docstring""" for i in range(self.dst_h ): for j in range(self.dst_w ): _lowercase : List[str] = self.img[self.get_y(_UpperCamelCase )][self.get_x(_UpperCamelCase )] def _lowerCamelCase ( self , _UpperCamelCase ): """simple docstring""" return int(self.ratio_x * x ) def _lowerCamelCase ( self , _UpperCamelCase ): """simple docstring""" return int(self.ratio_y * y ) if __name__ == "__main__": _snake_case , _snake_case = 800, 600 _snake_case = imread('image_data/lena.jpg', 1) _snake_case = NearestNeighbour(im, dst_w, dst_h) n.process() imshow( F'''Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}''', n.output ) waitKey(0) destroyAllWindows()
250
'''simple docstring''' import copy import inspect import unittest import numpy as np from huggingface_hub import hf_hub_download from transformers import VideoMAEConfig from transformers.models.auto import get_values from transformers.testing_utils import require_torch, require_vision, slow, torch_device from transformers.utils import cached_property, is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from torch import nn from transformers import ( MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEForPreTraining, VideoMAEForVideoClassification, VideoMAEModel, ) from transformers.models.videomae.modeling_videomae import VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from transformers import VideoMAEImageProcessor class a__ : def __init__( self , _UpperCamelCase , _UpperCamelCase=13 , _UpperCamelCase=10 , _UpperCamelCase=3 , _UpperCamelCase=2 , _UpperCamelCase=2 , _UpperCamelCase=2 , _UpperCamelCase=True , _UpperCamelCase=True , _UpperCamelCase=32 , _UpperCamelCase=5 , _UpperCamelCase=4 , _UpperCamelCase=37 , _UpperCamelCase="gelu" , _UpperCamelCase=0.1 , _UpperCamelCase=0.1 , _UpperCamelCase=10 , _UpperCamelCase=0.0_2 , _UpperCamelCase=0.9 , _UpperCamelCase=None , ): """simple docstring""" _lowercase : List[str] = parent _lowercase : Tuple = batch_size _lowercase : Tuple = image_size _lowercase : Any = num_channels _lowercase : Tuple = patch_size _lowercase : Union[str, Any] = tubelet_size _lowercase : str = num_frames _lowercase : Any = is_training _lowercase : Tuple = use_labels _lowercase : List[Any] = hidden_size _lowercase : int = num_hidden_layers _lowercase : Tuple = num_attention_heads _lowercase : int = intermediate_size _lowercase : Optional[int] = hidden_act _lowercase : Union[str, Any] = hidden_dropout_prob _lowercase : Optional[Any] = attention_probs_dropout_prob _lowercase : Optional[Any] = type_sequence_label_size _lowercase : Optional[Any] = initializer_range _lowercase : int = mask_ratio _lowercase : Union[str, Any] = scope # in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame _lowercase : List[str] = (image_size // patch_size) ** 2 _lowercase : Optional[Any] = (num_frames // tubelet_size) * self.num_patches_per_frame # use this variable to define bool_masked_pos _lowercase : str = int(mask_ratio * self.seq_length ) def _lowerCamelCase ( self ): """simple docstring""" _lowercase : Union[str, Any] = floats_tensor( [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size] ) _lowercase : Tuple = None if self.use_labels: _lowercase : Dict = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _lowercase : Optional[Any] = self.get_config() return config, pixel_values, labels def _lowerCamelCase ( self ): """simple docstring""" return VideoMAEConfig( image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , num_frames=self.num_frames , tubelet_size=self.tubelet_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 , is_decoder=_UpperCamelCase , initializer_range=self.initializer_range , ) def _lowerCamelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): """simple docstring""" _lowercase : Dict = VideoMAEModel(config=_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() _lowercase : Dict = model(_UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _lowerCamelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): """simple docstring""" _lowercase : Dict = VideoMAEForPreTraining(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() # important: each video needs to have the same number of masked patches # hence we define a single mask, which we then repeat for each example in the batch _lowercase : Optional[int] = torch.ones((self.num_masks,) ) _lowercase : List[Any] = torch.cat([mask, torch.zeros(self.seq_length - mask.size(0 ) )] ) _lowercase : Tuple = mask.expand(self.batch_size , -1 ).bool() _lowercase : Tuple = model(_UpperCamelCase , _UpperCamelCase ) # model only returns predictions for masked patches _lowercase : Tuple = mask.sum().item() _lowercase : Optional[Any] = 3 * self.tubelet_size * self.patch_size**2 self.parent.assertEqual(result.logits.shape , (self.batch_size, num_masked_patches, decoder_num_labels) ) def _lowerCamelCase ( self ): """simple docstring""" _lowercase : List[Any] = self.prepare_config_and_inputs() _lowercase , _lowercase , _lowercase : List[Any] = config_and_inputs _lowercase : str = {"pixel_values": pixel_values} return config, inputs_dict @require_torch class a__ ( lowerCamelCase_ , lowerCamelCase_ , unittest.TestCase ): _SCREAMING_SNAKE_CASE : List[str] = ( (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else () ) _SCREAMING_SNAKE_CASE : List[Any] = ( {'feature-extraction': VideoMAEModel, 'video-classification': VideoMAEForVideoClassification} if is_torch_available() else {} ) _SCREAMING_SNAKE_CASE : Tuple = False _SCREAMING_SNAKE_CASE : Dict = False _SCREAMING_SNAKE_CASE : Optional[int] = False _SCREAMING_SNAKE_CASE : Optional[Any] = False def _lowerCamelCase ( self ): """simple docstring""" _lowercase : int = VideoMAEModelTester(self ) _lowercase : Union[str, Any] = ConfigTester(self , config_class=_UpperCamelCase , has_text_modality=_UpperCamelCase , hidden_size=37 ) def _lowerCamelCase ( self , _UpperCamelCase , _UpperCamelCase , _UpperCamelCase=False ): """simple docstring""" _lowercase : Any = copy.deepcopy(_UpperCamelCase ) if model_class == VideoMAEForPreTraining: # important: each video needs to have the same number of masked patches # hence we define a single mask, which we then repeat for each example in the batch _lowercase : Union[str, Any] = torch.ones((self.model_tester.num_masks,) ) _lowercase : Dict = torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0 ) )] ) _lowercase : List[str] = mask.expand(self.model_tester.batch_size , -1 ).bool() _lowercase : Any = bool_masked_pos.to(_UpperCamelCase ) if return_labels: if model_class in [ *get_values(_UpperCamelCase ), ]: _lowercase : Any = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=_UpperCamelCase ) return inputs_dict def _lowerCamelCase ( self ): """simple docstring""" self.config_tester.run_common_tests() @unittest.skip(reason="VideoMAE does not use inputs_embeds" ) def _lowerCamelCase ( self ): """simple docstring""" pass def _lowerCamelCase ( self ): """simple docstring""" _lowercase , _lowercase : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[str] = model_class(_UpperCamelCase ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) _lowercase : Any = model.get_output_embeddings() self.assertTrue(x is None or isinstance(_UpperCamelCase , nn.Linear ) ) def _lowerCamelCase ( self ): """simple docstring""" _lowercase , _lowercase : str = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : List[Any] = model_class(_UpperCamelCase ) _lowercase : Any = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _lowercase : str = [*signature.parameters.keys()] _lowercase : List[Any] = ["pixel_values"] self.assertListEqual(arg_names[:1] , _UpperCamelCase ) def _lowerCamelCase ( self ): """simple docstring""" _lowercase : List[str] = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*_UpperCamelCase ) def _lowerCamelCase ( self ): """simple docstring""" _lowercase : int = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*_UpperCamelCase ) @slow def _lowerCamelCase ( self ): """simple docstring""" for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _lowercase : int = VideoMAEModel.from_pretrained(_UpperCamelCase ) self.assertIsNotNone(_UpperCamelCase ) def _lowerCamelCase ( self ): """simple docstring""" if not self.has_attentions: pass else: _lowercase , _lowercase : Tuple = self.model_tester.prepare_config_and_inputs_for_common() _lowercase : Optional[int] = True for model_class in self.all_model_classes: _lowercase : List[str] = self.model_tester.seq_length - self.model_tester.num_masks _lowercase : List[Any] = ( num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length ) _lowercase : int = True _lowercase : str = False _lowercase : Any = True _lowercase : Optional[Any] = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): _lowercase : Union[str, Any] = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) _lowercase : List[str] = outputs.attentions self.assertEqual(len(_UpperCamelCase ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _lowercase : Tuple = True _lowercase : Optional[Any] = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): _lowercase : Dict = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) _lowercase : Tuple = outputs.attentions self.assertEqual(len(_UpperCamelCase ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, seq_len, seq_len] , ) _lowercase : str = len(_UpperCamelCase ) # Check attention is always last and order is fine _lowercase : List[Any] = True _lowercase : List[str] = True _lowercase : Any = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): _lowercase : Optional[int] = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) self.assertEqual(out_len + 1 , len(_UpperCamelCase ) ) _lowercase : Optional[int] = outputs.attentions self.assertEqual(len(_UpperCamelCase ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(self_attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, seq_len, seq_len] , ) def _lowerCamelCase ( self ): """simple docstring""" def check_hidden_states_output(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ): _lowercase : Optional[int] = model_class(_UpperCamelCase ) model.to(_UpperCamelCase ) model.eval() with torch.no_grad(): _lowercase : Tuple = model(**self._prepare_for_class(_UpperCamelCase , _UpperCamelCase ) ) _lowercase : List[str] = outputs.hidden_states _lowercase : List[Any] = self.model_tester.num_hidden_layers + 1 self.assertEqual(len(_UpperCamelCase ) , _UpperCamelCase ) _lowercase : List[str] = self.model_tester.seq_length - self.model_tester.num_masks _lowercase : Optional[Any] = num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [seq_length, self.model_tester.hidden_size] , ) _lowercase , _lowercase : Optional[int] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _lowercase : Dict = True check_hidden_states_output(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _lowercase : List[str] = True check_hidden_states_output(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." ) def _lowerCamelCase ( self ): """simple docstring""" pass def _A ( ) -> Any: _lowercase : Tuple = hf_hub_download( repo_id="hf-internal-testing/spaghetti-video" , filename="eating_spaghetti.npy" , repo_type="dataset" ) _lowercase : int = np.load(snake_case ) return list(snake_case ) @require_torch @require_vision class a__ ( unittest.TestCase ): @cached_property def _lowerCamelCase ( self ): """simple docstring""" return ( VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] , image_std=[0.5, 0.5, 0.5] ) if is_vision_available() else None ) @slow def _lowerCamelCase ( self ): """simple docstring""" _lowercase : Tuple = VideoMAEForVideoClassification.from_pretrained("MCG-NJU/videomae-base-finetuned-kinetics" ).to( _UpperCamelCase ) _lowercase : Dict = self.default_image_processor _lowercase : Optional[Any] = prepare_video() _lowercase : Union[str, Any] = image_processor(_UpperCamelCase , return_tensors="pt" ).to(_UpperCamelCase ) # forward pass with torch.no_grad(): _lowercase : str = model(**_UpperCamelCase ) # verify the logits _lowercase : List[Any] = torch.Size((1, 400) ) self.assertEqual(outputs.logits.shape , _UpperCamelCase ) _lowercase : int = torch.tensor([0.3_6_6_9, -0.0_6_8_8, -0.2_4_2_1] ).to(_UpperCamelCase ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , _UpperCamelCase , atol=1E-4 ) ) @slow def _lowerCamelCase ( self ): """simple docstring""" _lowercase : Union[str, Any] = VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base-short" ).to(_UpperCamelCase ) _lowercase : Dict = self.default_image_processor _lowercase : Optional[Any] = prepare_video() _lowercase : List[Any] = image_processor(_UpperCamelCase , return_tensors="pt" ).to(_UpperCamelCase ) # add boolean mask, indicating which patches to mask _lowercase : int = hf_hub_download(repo_id="hf-internal-testing/bool-masked-pos" , filename="bool_masked_pos.pt" ) _lowercase : Any = torch.load(_UpperCamelCase ) # forward pass with torch.no_grad(): _lowercase : List[Any] = model(**_UpperCamelCase ) # verify the logits _lowercase : Dict = torch.Size([1, 1408, 1536] ) _lowercase : Tuple = torch.tensor( [[0.7_9_9_4, 0.9_6_1_2, 0.8_5_0_8], [0.7_4_0_1, 0.8_9_5_8, 0.8_3_0_2], [0.5_8_6_2, 0.7_4_6_8, 0.7_3_2_5]] , device=_UpperCamelCase ) self.assertEqual(outputs.logits.shape , _UpperCamelCase ) self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] , _UpperCamelCase , atol=1E-4 ) ) # verify the loss (`config.norm_pix_loss` = `True`) _lowercase : Tuple = torch.tensor([0.5_1_4_2] , device=_UpperCamelCase ) self.assertTrue(torch.allclose(outputs.loss , _UpperCamelCase , atol=1E-4 ) ) # verify the loss (`config.norm_pix_loss` = `False`) _lowercase : Dict = VideoMAEForPreTraining.from_pretrained("MCG-NJU/videomae-base-short" , norm_pix_loss=_UpperCamelCase ).to( _UpperCamelCase ) with torch.no_grad(): _lowercase : Optional[int] = model(**_UpperCamelCase ) _lowercase : List[str] = torch.tensor(torch.tensor([0.6_4_6_9] ) , device=_UpperCamelCase ) self.assertTrue(torch.allclose(outputs.loss , _UpperCamelCase , atol=1E-4 ) )
250
1
"""simple docstring""" def lowercase__ ( lowercase_ ) -> None: """simple docstring""" _UpperCamelCase : Optional[Any] = generate_pascal_triangle(lowercase_ ) for row_idx in range(lowercase_ ): # Print left spaces for _ in range(num_rows - row_idx - 1 ): print(end=" " ) # Print row values for col_idx in range(row_idx + 1 ): if col_idx != row_idx: print(triangle[row_idx][col_idx] ,end=" " ) else: print(triangle[row_idx][col_idx] ,end="" ) print() def lowercase__ ( lowercase_ ) -> list[list[int]]: """simple docstring""" if not isinstance(lowercase_ ,lowercase_ ): raise TypeError("The input value of 'num_rows' should be 'int'" ) if num_rows == 0: return [] elif num_rows < 0: raise ValueError( "The input value of 'num_rows' should be greater than or equal to 0" ) _UpperCamelCase : list[list[int]] = [] for current_row_idx in range(lowercase_ ): _UpperCamelCase : Any = populate_current_row(lowercase_ ,lowercase_ ) triangle.append(lowercase_ ) return triangle def lowercase__ ( lowercase_ ,lowercase_ ) -> list[int]: """simple docstring""" _UpperCamelCase : str = [-1] * (current_row_idx + 1) # first and last elements of current row are equal to 1 _UpperCamelCase, _UpperCamelCase : Union[str, Any] = 1, 1 for current_col_idx in range(1 ,lowercase_ ): calculate_current_element( lowercase_ ,lowercase_ ,lowercase_ ,lowercase_ ) return current_row def lowercase__ ( lowercase_ ,lowercase_ ,lowercase_ ,lowercase_ ,) -> None: """simple docstring""" _UpperCamelCase : Tuple = triangle[current_row_idx - 1][current_col_idx - 1] _UpperCamelCase : Union[str, Any] = triangle[current_row_idx - 1][current_col_idx] _UpperCamelCase : str = above_to_left_elt + above_to_right_elt def lowercase__ ( lowercase_ ) -> list[list[int]]: """simple docstring""" if not isinstance(lowercase_ ,lowercase_ ): raise TypeError("The input value of 'num_rows' should be 'int'" ) if num_rows == 0: return [] elif num_rows < 0: raise ValueError( "The input value of 'num_rows' should be greater than or equal to 0" ) _UpperCamelCase : list[list[int]] = [[1]] for row_index in range(1 ,lowercase_ ): _UpperCamelCase : Tuple = [0] + result[-1] + [0] _UpperCamelCase : Union[str, Any] = row_index + 1 # Calculate the number of distinct elements in a row _UpperCamelCase : List[Any] = sum(divmod(lowercase_ ,2 ) ) _UpperCamelCase : Optional[int] = [ temp_row[i - 1] + temp_row[i] for i in range(1 ,distinct_elements + 1 ) ] _UpperCamelCase : Any = row_first_half[: (row_index + 1) // 2] row_second_half.reverse() _UpperCamelCase : int = row_first_half + row_second_half result.append(lowercase_ ) return result def lowercase__ ( ) -> None: """simple docstring""" from collections.abc import Callable from timeit import timeit def benchmark_a_function(lowercase_ ,lowercase_ ) -> None: _UpperCamelCase : int = F'''{func.__name__}({value})''' _UpperCamelCase : Optional[int] = timeit(F'''__main__.{call}''' ,setup="import __main__" ) # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds") print(F'''{call:38} -- {timing:.4f} seconds''' ) for value in range(15 ): # (1, 7, 14): for func in (generate_pascal_triangle, generate_pascal_triangle_optimized): benchmark_a_function(lowercase_ ,lowercase_ ) print() if __name__ == "__main__": import doctest doctest.testmod() benchmark()
310
"""simple docstring""" lowerCamelCase__ = [ [0, 16, 13, 0, 0, 0], [0, 0, 10, 12, 0, 0], [0, 4, 0, 0, 14, 0], [0, 0, 9, 0, 0, 20], [0, 0, 0, 7, 0, 4], [0, 0, 0, 0, 0, 0], ] def lowercase__ ( lowercase_ ,lowercase_ ,lowercase_ ,lowercase_ ) -> Dict: """simple docstring""" _UpperCamelCase : Tuple = [False] * len(lowercase_ ) _UpperCamelCase : Dict = [s] _UpperCamelCase : List[str] = True while queue: _UpperCamelCase : Union[str, Any] = queue.pop(0 ) for ind in range(len(graph[u] ) ): if visited[ind] is False and graph[u][ind] > 0: queue.append(lowercase_ ) _UpperCamelCase : Union[str, Any] = True _UpperCamelCase : List[str] = u return visited[t] def lowercase__ ( lowercase_ ,lowercase_ ,lowercase_ ) -> str: """simple docstring""" _UpperCamelCase : int = [-1] * (len(lowercase_ )) _UpperCamelCase : Optional[int] = 0 _UpperCamelCase : Optional[Any] = [] _UpperCamelCase : str = [i[:] for i in graph] # Record original cut, copy. while bfs(lowercase_ ,lowercase_ ,lowercase_ ,lowercase_ ): _UpperCamelCase : int = float("Inf" ) _UpperCamelCase : Optional[Any] = sink while s != source: # Find the minimum value in select path _UpperCamelCase : List[Any] = min(lowercase_ ,graph[parent[s]][s] ) _UpperCamelCase : Union[str, Any] = parent[s] max_flow += path_flow _UpperCamelCase : Union[str, Any] = sink while v != source: _UpperCamelCase : Optional[Any] = parent[v] graph[u][v] -= path_flow graph[v][u] += path_flow _UpperCamelCase : Dict = parent[v] for i in range(len(lowercase_ ) ): for j in range(len(graph[0] ) ): if graph[i][j] == 0 and temp[i][j] > 0: res.append((i, j) ) return res if __name__ == "__main__": print(mincut(test_graph, source=0, sink=5))
310
1
'''simple docstring''' from manim import * class __UpperCAmelCase ( _lowerCamelCase ): def lowerCamelCase ( self ): """simple docstring""" _snake_case = Rectangle(height=0.5 , width=0.5 ) _snake_case = Rectangle(height=0.46 , width=0.46 ).set_stroke(width=0 ) _snake_case = [mem.copy() for i in range(6 )] _snake_case = [mem.copy() for i in range(6 )] _snake_case = VGroup(*lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0 ) _snake_case = VGroup(*lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0 ) _snake_case = VGroup(lowerCAmelCase_ , lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0 ) _snake_case = Text('CPU' , font_size=24 ) _snake_case = Group(lowerCAmelCase_ , lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0.5 , aligned_edge=lowerCAmelCase_ ) cpu.move_to([-2.5, -0.5, 0] ) self.add(lowerCAmelCase_ ) _snake_case = [mem.copy() for i in range(4 )] _snake_case = VGroup(*lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0 ) _snake_case = Text('GPU' , font_size=24 ) _snake_case = Group(lowerCAmelCase_ , lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0.5 , aligned_edge=lowerCAmelCase_ ) gpu.move_to([-1, -1, 0] ) self.add(lowerCAmelCase_ ) _snake_case = [mem.copy() for i in range(6 )] _snake_case = VGroup(*lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0 ) _snake_case = Text('Model' , font_size=24 ) _snake_case = Group(lowerCAmelCase_ , lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0.5 , aligned_edge=lowerCAmelCase_ ) model.move_to([3, -1.0, 0] ) self.add(lowerCAmelCase_ ) _snake_case = [] for i, rect in enumerate(lowerCAmelCase_ ): rect.set_stroke(lowerCAmelCase_ ) # target = fill.copy().set_fill(YELLOW, opacity=0.7) # target.move_to(rect) # self.add(target) _snake_case = Rectangle(height=0.46 / 4 , width=0.46 / 3 ).set_stroke(width=0.0 ).set_fill(lowerCAmelCase_ , opacity=0.7 ) if i == 0: cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT ) , buff=0.02 , direction=lowerCAmelCase_ ) cpu_target.set_x(cpu_target.get_x() + 0.1 ) elif i == 3: cpu_target.next_to(cpu_targs[0] , direction=lowerCAmelCase_ , buff=0.0 ) else: cpu_target.next_to(cpu_targs[i - 1] , direction=lowerCAmelCase_ , buff=0.0 ) self.add(lowerCAmelCase_ ) cpu_targs.append(lowerCAmelCase_ ) _snake_case = [mem.copy() for i in range(6 )] _snake_case = VGroup(*lowerCAmelCase_ ).arrange(lowerCAmelCase_ , buff=0 ) _snake_case = Text('Loaded Checkpoint' , font_size=24 ) _snake_case = Group(lowerCAmelCase_ , lowerCAmelCase_ ).arrange(lowerCAmelCase_ , aligned_edge=lowerCAmelCase_ , buff=0.4 ) checkpoint.move_to([3, 0.5, 0] ) _snake_case = Square(side_length=2.2 ) key.move_to([-5, 2, 0] ) _snake_case = MarkupText( F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model' , font_size=18 , ) key_text.move_to([-5, 2.4, 0] ) self.add(lowerCAmelCase_ , lowerCAmelCase_ ) _snake_case = MarkupText( F'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint' , font_size=18 , ) blue_text.next_to(lowerCAmelCase_ , DOWN * 2.4 , aligned_edge=key_text.get_left() ) _snake_case = MarkupText( F'Next, a <i><span fgcolor="{BLUE}">second</span></i> model is loaded into memory,\nwith the weights of a <span fgcolor="{BLUE}">single shard</span>.' , font_size=24 , ) step_a.move_to([2, 2, 0] ) self.play(Write(lowerCAmelCase_ ) , Write(lowerCAmelCase_ ) ) self.play(Write(lowerCAmelCase_ , run_time=1 ) , Create(lowerCAmelCase_ , run_time=1 ) ) _snake_case = [] _snake_case = [] for i, rect in enumerate(lowerCAmelCase_ ): _snake_case = fill.copy().set_fill(lowerCAmelCase_ , opacity=0.7 ) target.move_to(lowerCAmelCase_ ) first_animations.append(GrowFromCenter(lowerCAmelCase_ , run_time=1 ) ) _snake_case = target.copy() cpu_target.generate_target() if i < 5: cpu_target.target.move_to(cpu_left_col_base[i + 1] ) else: cpu_target.target.move_to(cpu_right_col_base[i - 5] ) second_animations.append(MoveToTarget(lowerCAmelCase_ , run_time=1.5 ) ) self.play(*lowerCAmelCase_ ) self.play(*lowerCAmelCase_ ) self.wait()
42
'''simple docstring''' import argparse import json import os import fairseq import torch from fairseq.data import Dictionary # Register SEW's fairseq modules from sew_asapp import tasks # noqa: F401 from transformers import ( SEWConfig, SEWForCTC, SEWModel, WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor, logging, ) logging.set_verbosity_info() lowercase : str = logging.get_logger(__name__) lowercase : Union[str, Any] = { "post_extract_proj": "feature_projection", "encoder.pos_conv.0": "encoder.pos_conv_embed.conv", "self_attn.k_proj": "encoder.layers.*.attention.k_proj", "self_attn.v_proj": "encoder.layers.*.attention.v_proj", "self_attn.q_proj": "encoder.layers.*.attention.q_proj", "self_attn.out_proj": "encoder.layers.*.attention.out_proj", "self_attn_layer_norm": "encoder.layers.*.layer_norm", "fc1": "encoder.layers.*.feed_forward.intermediate_dense", "fc2": "encoder.layers.*.feed_forward.output_dense", "final_layer_norm": "encoder.layers.*.final_layer_norm", "encoder.upsample.0": "encoder.upsample.projection", "encoder.layer_norm": "encoder.layer_norm", "w2v_model.layer_norm": "layer_norm", "w2v_encoder.proj": "lm_head", "mask_emb": "masked_spec_embed", } def SCREAMING_SNAKE_CASE__ ( __A , __A , __A , __A , __A ) -> Dict: for attribute in key.split('.' ): _snake_case = getattr(__A , __A ) if weight_type is not None: _snake_case = getattr(__A , __A ).shape else: _snake_case = hf_pointer.shape assert hf_shape == value.shape, ( F'Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be' F' {value.shape} for {full_name}' ) if weight_type == "weight": _snake_case = value elif weight_type == "weight_g": _snake_case = value elif weight_type == "weight_v": _snake_case = value elif weight_type == "bias": _snake_case = value else: _snake_case = value logger.info(F'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.' ) def SCREAMING_SNAKE_CASE__ ( __A , __A , __A ) -> Any: _snake_case = [] _snake_case = fairseq_model.state_dict() _snake_case = hf_model.sew.feature_extractor if is_finetuned else hf_model.feature_extractor for name, value in fairseq_dict.items(): _snake_case = False if "conv_layers" in name: load_conv_layer( __A , __A , __A , __A , hf_model.config.feat_extract_norm == 'group' , ) _snake_case = True else: for key, mapped_key in MAPPING.items(): _snake_case = 'sew.' + mapped_key if (is_finetuned and mapped_key != 'lm_head') else mapped_key if key in name or key.split('w2v_model.' )[-1] == name.split('.' )[0]: _snake_case = True if "*" in mapped_key: _snake_case = name.split(__A )[0].split('.' )[-2] _snake_case = mapped_key.replace('*' , __A ) if "weight_g" in name: _snake_case = 'weight_g' elif "weight_v" in name: _snake_case = 'weight_v' elif "weight" in name: _snake_case = 'weight' elif "bias" in name: _snake_case = 'bias' else: _snake_case = None set_recursively(__A , __A , __A , __A , __A ) continue if not is_used: unused_weights.append(__A ) logger.warning(F'Unused weights: {unused_weights}' ) def SCREAMING_SNAKE_CASE__ ( __A , __A , __A , __A , __A ) -> int: _snake_case = full_name.split('conv_layers.' )[-1] _snake_case = name.split('.' ) _snake_case = int(items[0] ) _snake_case = int(items[1] ) if type_id == 0: if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, ( F'{full_name} has size {value.shape}, but' F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.' ) _snake_case = value logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, ( F'{full_name} has size {value.shape}, but' F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.' ) _snake_case = value logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.' ) elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm): if "bias" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, ( F'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was' " found." ) _snake_case = value logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.' ) elif "weight" in name: assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, ( F'{full_name} has size {value.shape}, but' F' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.' ) _snake_case = value logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.' ) else: unused_weights.append(__A ) def SCREAMING_SNAKE_CASE__ ( __A , __A ) -> str: _snake_case = SEWConfig() if is_finetuned: _snake_case = model.wav_encoder.wav_model.cfg else: _snake_case = model.cfg _snake_case = fs_config.conv_bias _snake_case = eval(fs_config.conv_feature_layers ) _snake_case = [x[0] for x in conv_layers] _snake_case = [x[1] for x in conv_layers] _snake_case = [x[2] for x in conv_layers] _snake_case = 'gelu' _snake_case = 'layer' if fs_config.extractor_mode == 'layer_norm' else 'group' _snake_case = 0.0 _snake_case = fs_config.activation_fn.name _snake_case = fs_config.encoder_embed_dim _snake_case = 0.0_2 _snake_case = fs_config.encoder_ffn_embed_dim _snake_case = 1e-5 _snake_case = fs_config.encoder_layerdrop _snake_case = fs_config.encoder_attention_heads _snake_case = fs_config.conv_pos_groups _snake_case = fs_config.conv_pos _snake_case = len(__A ) _snake_case = fs_config.encoder_layers _snake_case = fs_config.squeeze_factor # take care of any params that are overridden by the Wav2VecCtc model if is_finetuned: _snake_case = model.cfg _snake_case = fs_config.final_dropout _snake_case = fs_config.layerdrop _snake_case = fs_config.activation_dropout _snake_case = fs_config.mask_prob > 0 or fs_config.mask_channel_prob > 0 _snake_case = fs_config.attention_dropout _snake_case = fs_config.dropout_input _snake_case = fs_config.dropout _snake_case = fs_config.mask_channel_length _snake_case = fs_config.mask_channel_prob _snake_case = fs_config.mask_length _snake_case = fs_config.mask_prob _snake_case = 'Wav2Vec2FeatureExtractor' _snake_case = 'Wav2Vec2CTCTokenizer' return config @torch.no_grad() def SCREAMING_SNAKE_CASE__ ( __A , __A , __A=None , __A=None , __A=True ) -> List[str]: if is_finetuned: _snake_case , _snake_case , _snake_case = fairseq.checkpoint_utils.load_model_ensemble_and_task( [checkpoint_path] , arg_overrides={'data': '/'.join(dict_path.split('/' )[:-1] )} ) else: _snake_case , _snake_case , _snake_case = fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path] ) if config_path is not None: _snake_case = SEWConfig.from_pretrained(__A ) else: _snake_case = convert_config(model[0] , __A ) _snake_case = model[0].eval() _snake_case = True if config.feat_extract_norm == 'layer' else False _snake_case = WavaVecaFeatureExtractor( feature_size=1 , sampling_rate=16_000 , padding_value=0 , do_normalize=__A , return_attention_mask=__A , ) if is_finetuned: if dict_path: _snake_case = Dictionary.load(__A ) # important change bos & pad token id since CTC symbol is <pad> and # not <s> as in fairseq _snake_case = target_dict.pad_index _snake_case = target_dict.bos_index _snake_case = target_dict.pad_index _snake_case = target_dict.bos_index _snake_case = target_dict.eos_index _snake_case = len(target_dict.symbols ) _snake_case = os.path.join(__A , 'vocab.json' ) if not os.path.isdir(__A ): logger.error('--pytorch_dump_folder_path ({}) should be a directory'.format(__A ) ) return os.makedirs(__A , exist_ok=__A ) with open(__A , 'w' , encoding='utf-8' ) as vocab_handle: json.dump(target_dict.indices , __A ) _snake_case = WavaVecaCTCTokenizer( __A , unk_token=target_dict.unk_word , pad_token=target_dict.pad_word , bos_token=target_dict.bos_word , eos_token=target_dict.eos_word , word_delimiter_token='|' , do_lower_case=__A , ) _snake_case = WavaVecaProcessor(feature_extractor=__A , tokenizer=__A ) processor.save_pretrained(__A ) _snake_case = SEWForCTC(__A ) else: _snake_case = SEWModel(__A ) feature_extractor.save_pretrained(__A ) recursively_load_weights(__A , __A , __A ) hf_model.save_pretrained(__A ) if __name__ == "__main__": lowercase : 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 fairseq checkpoint") parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model") parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert") parser.add_argument( "--is_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not" ) lowercase : Union[str, Any] = parser.parse_args() convert_sew_checkpoint( args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, args.is_finetuned )
42
1
import enum import shutil import sys _A : Tuple = shutil.get_terminal_size() _A : Union[str, Any] = {'UP': 'A', 'DOWN': 'B', 'RIGHT': 'C', 'LEFT': 'D'} class __SCREAMING_SNAKE_CASE ( enum.Enum ): _UpperCAmelCase : Tuple = 0 _UpperCAmelCase : Union[str, Any] = 1 def _a ( UpperCAmelCase , UpperCAmelCase="" ) -> int: """simple docstring""" sys.stdout.write(str(UpperCAmelCase ) + end ) sys.stdout.flush() def _a ( UpperCAmelCase , UpperCAmelCase , UpperCAmelCase="" ) -> Union[str, Any]: """simple docstring""" forceWrite(f"\u001b[{color}m{content}\u001b[0m" , UpperCAmelCase ) def _a ( ) -> Dict: """simple docstring""" forceWrite('''\r''' ) def _a ( UpperCAmelCase , UpperCAmelCase ) -> Optional[Any]: """simple docstring""" forceWrite(f"\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}" ) def _a ( ) -> Optional[int]: """simple docstring""" forceWrite(''' ''' * TERMINAL_WIDTH ) reset_cursor() def _a ( ) -> str: """simple docstring""" reset_cursor() forceWrite('''-''' * TERMINAL_WIDTH )
361
import math import random def _a ( UpperCAmelCase , UpperCAmelCase = False ) -> float: """simple docstring""" if deriv: return value * (1 - value) return 1 / (1 + math.exp(-value )) # Initial Value _A : Tuple = 0.02 def _a ( UpperCAmelCase , UpperCAmelCase ) -> float: """simple docstring""" lowerCamelCase__ : List[Any] = float(2 * (random.randint(1 , 100 )) - 1 ) for _ in range(UpperCAmelCase ): # Forward propagation lowerCamelCase__ : Optional[int] = sigmoid_function(INITIAL_VALUE * weight ) # How much did we miss? lowerCamelCase__ : int = (expected / 100) - layer_a # Error delta lowerCamelCase__ : Union[str, Any] = layer_1_error * sigmoid_function(UpperCAmelCase , UpperCAmelCase ) # Update weight weight += INITIAL_VALUE * layer_1_delta return layer_a * 100 if __name__ == "__main__": import doctest doctest.testmod() _A : Union[str, Any] = int(input('Expected value: ')) _A : int = int(input('Number of propagations: ')) print(forward_propagation(expected, number_propagations))
265
0
import argparse import json import pickle from pathlib import Path import requests import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import MaskFormerConfig, MaskFormerForInstanceSegmentation, MaskFormerImageProcessor, SwinConfig from transformers.utils import logging logging.set_verbosity_info() lowercase__ :Optional[int] = logging.get_logger(__name__) def UpperCamelCase ( lowerCAmelCase__ ): '''simple docstring''' lowercase = SwinConfig.from_pretrained( '''microsoft/swin-tiny-patch4-window7-224''' , out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4'''] ) lowercase = MaskFormerConfig(backbone_config=lowerCAmelCase__ ) lowercase = '''huggingface/label-files''' if "ade20k-full" in model_name: # this should be ok lowercase = 847 lowercase = '''maskformer-ade20k-full-id2label.json''' elif "ade" in model_name: # this should be ok lowercase = 150 lowercase = '''ade20k-id2label.json''' elif "coco-stuff" in model_name: # this should be ok lowercase = 171 lowercase = '''maskformer-coco-stuff-id2label.json''' elif "coco" in model_name: # TODO lowercase = 133 lowercase = '''coco-panoptic-id2label.json''' elif "cityscapes" in model_name: # this should be ok lowercase = 19 lowercase = '''cityscapes-id2label.json''' elif "vistas" in model_name: # this should be ok lowercase = 65 lowercase = '''mapillary-vistas-id2label.json''' lowercase = json.load(open(hf_hub_download(lowerCAmelCase__ , lowerCAmelCase__ , repo_type='''dataset''' ) , '''r''' ) ) lowercase = {int(lowerCAmelCase__ ): v for k, v in idalabel.items()} return config def UpperCamelCase ( lowerCAmelCase__ ): '''simple docstring''' lowercase = [] # stem # fmt: off rename_keys.append(('''backbone.patch_embed.proj.weight''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.weight''') ) rename_keys.append(('''backbone.patch_embed.proj.bias''', '''model.pixel_level_module.encoder.model.embeddings.patch_embeddings.projection.bias''') ) rename_keys.append(('''backbone.patch_embed.norm.weight''', '''model.pixel_level_module.encoder.model.embeddings.norm.weight''') ) rename_keys.append(('''backbone.patch_embed.norm.bias''', '''model.pixel_level_module.encoder.model.embeddings.norm.bias''') ) # stages for i in range(len(config.backbone_config.depths ) ): for j in range(config.backbone_config.depths[i] ): rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm1.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm1.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.relative_position_bias_table', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.relative_position_index', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.proj.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.attn.proj.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm2.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.norm2.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc1.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc1.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc2.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.weight') ) rename_keys.append((f'backbone.layers.{i}.blocks.{j}.mlp.fc2.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.blocks.{j}.output.dense.bias') ) if i < 3: rename_keys.append((f'backbone.layers.{i}.downsample.reduction.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.reduction.weight') ) rename_keys.append((f'backbone.layers.{i}.downsample.norm.weight', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.weight') ) rename_keys.append((f'backbone.layers.{i}.downsample.norm.bias', f'model.pixel_level_module.encoder.model.encoder.layers.{i}.downsample.norm.bias') ) rename_keys.append((f'backbone.norm{i}.weight', f'model.pixel_level_module.encoder.hidden_states_norms.{i}.weight') ) rename_keys.append((f'backbone.norm{i}.bias', f'model.pixel_level_module.encoder.hidden_states_norms.{i}.bias') ) # FPN rename_keys.append(('''sem_seg_head.layer_4.weight''', '''model.pixel_level_module.decoder.fpn.stem.0.weight''') ) rename_keys.append(('''sem_seg_head.layer_4.norm.weight''', '''model.pixel_level_module.decoder.fpn.stem.1.weight''') ) rename_keys.append(('''sem_seg_head.layer_4.norm.bias''', '''model.pixel_level_module.decoder.fpn.stem.1.bias''') ) for source_index, target_index in zip(range(3 , 0 , -1 ) , range(0 , 3 ) ): rename_keys.append((f'sem_seg_head.adapter_{source_index}.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.0.weight') ) rename_keys.append((f'sem_seg_head.adapter_{source_index}.norm.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.weight') ) rename_keys.append((f'sem_seg_head.adapter_{source_index}.norm.bias', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.proj.1.bias') ) rename_keys.append((f'sem_seg_head.layer_{source_index}.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.0.weight') ) rename_keys.append((f'sem_seg_head.layer_{source_index}.norm.weight', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.weight') ) rename_keys.append((f'sem_seg_head.layer_{source_index}.norm.bias', f'model.pixel_level_module.decoder.fpn.layers.{target_index}.block.1.bias') ) rename_keys.append(('''sem_seg_head.mask_features.weight''', '''model.pixel_level_module.decoder.mask_projection.weight''') ) rename_keys.append(('''sem_seg_head.mask_features.bias''', '''model.pixel_level_module.decoder.mask_projection.bias''') ) # Transformer decoder for idx in range(config.decoder_config.decoder_layers ): # self-attention out projection rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.weight', f'model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.weight') ) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.out_proj.bias', f'model.transformer_module.decoder.layers.{idx}.self_attn.out_proj.bias') ) # cross-attention out projection rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.weight', f'model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.weight') ) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.out_proj.bias', f'model.transformer_module.decoder.layers.{idx}.encoder_attn.out_proj.bias') ) # MLP 1 rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.weight', f'model.transformer_module.decoder.layers.{idx}.fc1.weight') ) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear1.bias', f'model.transformer_module.decoder.layers.{idx}.fc1.bias') ) # MLP 2 rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.weight', f'model.transformer_module.decoder.layers.{idx}.fc2.weight') ) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.linear2.bias', f'model.transformer_module.decoder.layers.{idx}.fc2.bias') ) # layernorm 1 (self-attention layernorm) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.weight', f'model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.weight') ) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm1.bias', f'model.transformer_module.decoder.layers.{idx}.self_attn_layer_norm.bias') ) # layernorm 2 (cross-attention layernorm) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.weight', f'model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.weight') ) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm2.bias', f'model.transformer_module.decoder.layers.{idx}.encoder_attn_layer_norm.bias') ) # layernorm 3 (final layernorm) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.weight', f'model.transformer_module.decoder.layers.{idx}.final_layer_norm.weight') ) rename_keys.append((f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.norm3.bias', f'model.transformer_module.decoder.layers.{idx}.final_layer_norm.bias') ) rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.weight''', '''model.transformer_module.decoder.layernorm.weight''') ) rename_keys.append(('''sem_seg_head.predictor.transformer.decoder.norm.bias''', '''model.transformer_module.decoder.layernorm.bias''') ) # heads on top rename_keys.append(('''sem_seg_head.predictor.query_embed.weight''', '''model.transformer_module.queries_embedder.weight''') ) rename_keys.append(('''sem_seg_head.predictor.input_proj.weight''', '''model.transformer_module.input_projection.weight''') ) rename_keys.append(('''sem_seg_head.predictor.input_proj.bias''', '''model.transformer_module.input_projection.bias''') ) rename_keys.append(('''sem_seg_head.predictor.class_embed.weight''', '''class_predictor.weight''') ) rename_keys.append(('''sem_seg_head.predictor.class_embed.bias''', '''class_predictor.bias''') ) for i in range(3 ): rename_keys.append((f'sem_seg_head.predictor.mask_embed.layers.{i}.weight', f'mask_embedder.{i}.0.weight') ) rename_keys.append((f'sem_seg_head.predictor.mask_embed.layers.{i}.bias', f'mask_embedder.{i}.0.bias') ) # fmt: on return rename_keys def UpperCamelCase ( lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ): '''simple docstring''' lowercase = dct.pop(lowerCAmelCase__ ) lowercase = val def UpperCamelCase ( lowerCAmelCase__ , lowerCAmelCase__ ): '''simple docstring''' lowercase = [int(backbone_config.embed_dim * 2**i ) for i in range(len(backbone_config.depths ) )] for i in range(len(backbone_config.depths ) ): lowercase = num_features[i] for j in range(backbone_config.depths[i] ): # fmt: off # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias) lowercase = state_dict.pop(f'backbone.layers.{i}.blocks.{j}.attn.qkv.weight' ) lowercase = state_dict.pop(f'backbone.layers.{i}.blocks.{j}.attn.qkv.bias' ) # next, add query, keys and values (in that order) to the state dict lowercase = in_proj_weight[:dim, :] lowercase = in_proj_bias[: dim] lowercase = in_proj_weight[ dim : dim * 2, : ] lowercase = in_proj_bias[ dim : dim * 2 ] lowercase = in_proj_weight[ -dim :, : ] lowercase = in_proj_bias[-dim :] # fmt: on def UpperCamelCase ( lowerCAmelCase__ , lowerCAmelCase__ ): '''simple docstring''' # fmt: off lowercase = config.decoder_config.hidden_size for idx in range(config.decoder_config.decoder_layers ): # read in weights + bias of self-attention input projection layer (in the original implementation, this is a single matrix + bias) lowercase = state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_weight' ) lowercase = state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.self_attn.in_proj_bias' ) # next, add query, keys and values (in that order) to the state dict lowercase = in_proj_weight[: hidden_size, :] lowercase = in_proj_bias[:config.hidden_size] lowercase = in_proj_weight[hidden_size : hidden_size * 2, :] lowercase = in_proj_bias[hidden_size : hidden_size * 2] lowercase = in_proj_weight[-hidden_size :, :] lowercase = in_proj_bias[-hidden_size :] # read in weights + bias of cross-attention input projection layer (in the original implementation, this is a single matrix + bias) lowercase = state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_weight' ) lowercase = state_dict.pop(f'sem_seg_head.predictor.transformer.decoder.layers.{idx}.multihead_attn.in_proj_bias' ) # next, add query, keys and values (in that order) to the state dict lowercase = in_proj_weight[: hidden_size, :] lowercase = in_proj_bias[:config.hidden_size] lowercase = in_proj_weight[hidden_size : hidden_size * 2, :] lowercase = in_proj_bias[hidden_size : hidden_size * 2] lowercase = in_proj_weight[-hidden_size :, :] lowercase = in_proj_bias[-hidden_size :] # fmt: on def UpperCamelCase ( ): '''simple docstring''' lowercase = '''http://images.cocodataset.org/val2017/000000039769.jpg''' lowercase = Image.open(requests.get(lowerCAmelCase__ , stream=lowerCAmelCase__ ).raw ) return im @torch.no_grad() def UpperCamelCase ( lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ = False ): '''simple docstring''' lowercase = get_maskformer_config(lowerCAmelCase__ ) # load original state_dict with open(lowerCAmelCase__ , '''rb''' ) as f: lowercase = pickle.load(lowerCAmelCase__ ) lowercase = data['''model'''] # for name, param in state_dict.items(): # print(name, param.shape) # rename keys lowercase = create_rename_keys(lowerCAmelCase__ ) for src, dest in rename_keys: rename_key(lowerCAmelCase__ , lowerCAmelCase__ , lowerCAmelCase__ ) read_in_swin_q_k_v(lowerCAmelCase__ , config.backbone_config ) read_in_decoder_q_k_v(lowerCAmelCase__ , lowerCAmelCase__ ) # update to torch tensors for key, value in state_dict.items(): lowercase = torch.from_numpy(lowerCAmelCase__ ) # load 🤗 model lowercase = MaskFormerForInstanceSegmentation(lowerCAmelCase__ ) model.eval() for name, param in model.named_parameters(): print(lowerCAmelCase__ , param.shape ) lowercase , lowercase = model.load_state_dict(lowerCAmelCase__ , strict=lowerCAmelCase__ ) assert missing_keys == [ "model.pixel_level_module.encoder.model.layernorm.weight", "model.pixel_level_module.encoder.model.layernorm.bias", ] assert len(lowerCAmelCase__ ) == 0, f'Unexpected keys: {unexpected_keys}' # verify results lowercase = prepare_img() if "vistas" in model_name: lowercase = 65 elif "cityscapes" in model_name: lowercase = 6_5535 else: lowercase = 255 lowercase = True if '''ade''' in model_name else False lowercase = MaskFormerImageProcessor(ignore_index=lowerCAmelCase__ , reduce_labels=lowerCAmelCase__ ) lowercase = image_processor(lowerCAmelCase__ , return_tensors='''pt''' ) lowercase = model(**lowerCAmelCase__ ) print('''Logits:''' , outputs.class_queries_logits[0, :3, :3] ) if model_name == "maskformer-swin-tiny-ade": lowercase = torch.tensor( [[3.63_53, -4.47_70, -2.60_65], [0.50_81, -4.23_94, -3.53_43], [2.19_09, -5.03_53, -1.93_23]] ) assert torch.allclose(outputs.class_queries_logits[0, :3, :3] , lowerCAmelCase__ , atol=1E-4 ) print('''Looks ok!''' ) if pytorch_dump_folder_path is not None: print(f'Saving model and image processor to {pytorch_dump_folder_path}' ) Path(lowerCAmelCase__ ).mkdir(exist_ok=lowerCAmelCase__ ) model.save_pretrained(lowerCAmelCase__ ) image_processor.save_pretrained(lowerCAmelCase__ ) if push_to_hub: print('''Pushing model and image processor to the hub...''' ) model.push_to_hub(f'nielsr/{model_name}' ) image_processor.push_to_hub(f'nielsr/{model_name}' ) if __name__ == "__main__": lowercase__ :Optional[int] = argparse.ArgumentParser() # Required parameters parser.add_argument( "--model_name", default="maskformer-swin-tiny-ade", type=str, help=("Name of the MaskFormer model you'd like to convert",), ) parser.add_argument( "--checkpoint_path", default="/Users/nielsrogge/Documents/MaskFormer_checkpoints/MaskFormer-Swin-tiny-ADE20k/model.pkl", type=str, help="Path to the original state dict (.pth file).", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory." ) parser.add_argument( "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub." ) lowercase__ :Optional[Any] = parser.parse_args() convert_maskformer_checkpoint( args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub )
101
import os from pathlib import Path from unittest.mock import patch import pytest import zstandard as zstd from datasets.download.download_config import DownloadConfig from datasets.utils.file_utils import ( OfflineModeIsEnabled, cached_path, fsspec_get, fsspec_head, ftp_get, ftp_head, get_from_cache, http_get, http_head, ) __snake_case :List[str] = '''\ Text data. Second line of data.''' __snake_case :Optional[Any] = '''file''' @pytest.fixture(scope='''session''' ) def __snake_case ( _UpperCAmelCase ): __a = tmp_path_factory.mktemp('''data''' ) / (FILE_PATH + '''.zstd''') __a = bytes(_UpperCAmelCase , '''utf-8''' ) with zstd.open(_UpperCAmelCase , '''wb''' ) as f: f.write(_UpperCAmelCase ) return path @pytest.fixture def __snake_case ( _UpperCAmelCase ): with open(os.path.join(tmpfs.local_root_dir , _UpperCAmelCase ) , '''w''' ) as f: f.write(_UpperCAmelCase ) return FILE_PATH @pytest.mark.parametrize('''compression_format''' , ['''gzip''', '''xz''', '''zstd'''] ) def __snake_case ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): __a = {'''gzip''': gz_file, '''xz''': xz_file, '''zstd''': zstd_path} __a = input_paths[compression_format] __a = tmp_path / '''cache''' __a = DownloadConfig(cache_dir=_UpperCAmelCase , extract_compressed_file=_UpperCAmelCase ) __a = cached_path(_UpperCAmelCase , download_config=_UpperCAmelCase ) with open(_UpperCAmelCase ) as f: __a = f.read() with open(_UpperCAmelCase ) as f: __a = f.read() assert extracted_file_content == expected_file_content @pytest.mark.parametrize('''default_extracted''' , [True, False] ) @pytest.mark.parametrize('''default_cache_dir''' , [True, False] ) def __snake_case ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase ): __a = '''custom_cache''' __a = '''custom_extracted_dir''' __a = tmp_path / '''custom_extracted_path''' if default_extracted: __a = ('''downloads''' if default_cache_dir else custom_cache_dir, '''extracted''') else: monkeypatch.setattr('''datasets.config.EXTRACTED_DATASETS_DIR''' , _UpperCAmelCase ) monkeypatch.setattr('''datasets.config.EXTRACTED_DATASETS_PATH''' , str(_UpperCAmelCase ) ) __a = custom_extracted_path.parts[-2:] if default_cache_dir else (custom_cache_dir, custom_extracted_dir) __a = xz_file __a = ( DownloadConfig(extract_compressed_file=_UpperCAmelCase ) if default_cache_dir else DownloadConfig(cache_dir=tmp_path / custom_cache_dir , extract_compressed_file=_UpperCAmelCase ) ) __a = cached_path(_UpperCAmelCase , download_config=_UpperCAmelCase ) assert Path(_UpperCAmelCase ).parent.parts[-2:] == expected def __snake_case ( _UpperCAmelCase ): # absolute path __a = str(Path(_UpperCAmelCase ).resolve() ) assert cached_path(_UpperCAmelCase ) == text_file # relative path __a = str(Path(_UpperCAmelCase ).resolve().relative_to(Path(os.getcwd() ) ) ) assert cached_path(_UpperCAmelCase ) == text_file def __snake_case ( _UpperCAmelCase ): # absolute path __a = str(tmp_path.resolve() / '''__missing_file__.txt''' ) with pytest.raises(_UpperCAmelCase ): cached_path(_UpperCAmelCase ) # relative path __a = '''./__missing_file__.txt''' with pytest.raises(_UpperCAmelCase ): cached_path(_UpperCAmelCase ) def __snake_case ( _UpperCAmelCase ): __a = get_from_cache(f'tmp://{tmpfs_file}' ) with open(_UpperCAmelCase ) as f: __a = f.read() assert output_file_content == FILE_CONTENT @patch('''datasets.config.HF_DATASETS_OFFLINE''' , _UpperCAmelCase ) def __snake_case ( ): with pytest.raises(_UpperCAmelCase ): cached_path('''https://huggingface.co''' ) @patch('''datasets.config.HF_DATASETS_OFFLINE''' , _UpperCAmelCase ) def __snake_case ( _UpperCAmelCase ): __a = tmp_path_factory.mktemp('''data''' ) / '''file.html''' with pytest.raises(_UpperCAmelCase ): http_get('''https://huggingface.co''' , temp_file=_UpperCAmelCase ) with pytest.raises(_UpperCAmelCase ): http_head('''https://huggingface.co''' ) @patch('''datasets.config.HF_DATASETS_OFFLINE''' , _UpperCAmelCase ) def __snake_case ( _UpperCAmelCase ): __a = tmp_path_factory.mktemp('''data''' ) / '''file.html''' with pytest.raises(_UpperCAmelCase ): ftp_get('''ftp://huggingface.co''' , temp_file=_UpperCAmelCase ) with pytest.raises(_UpperCAmelCase ): ftp_head('''ftp://huggingface.co''' ) @patch('''datasets.config.HF_DATASETS_OFFLINE''' , _UpperCAmelCase ) def __snake_case ( _UpperCAmelCase ): __a = tmp_path_factory.mktemp('''data''' ) / '''file.html''' with pytest.raises(_UpperCAmelCase ): fsspec_get('''s3://huggingface.co''' , temp_file=_UpperCAmelCase ) with pytest.raises(_UpperCAmelCase ): fsspec_head('''s3://huggingface.co''' )
49
0
'''simple docstring''' import argparse import json from pathlib import Path import requests import timm import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel from transformers.utils import logging logging.set_verbosity_info() UpperCamelCase = logging.get_logger(__name__) def SCREAMING_SNAKE_CASE( __lowercase , __lowercase=False ) -> int: A: Tuple = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((F"""blocks.{i}.norm1.weight""", F"""vit.encoder.layer.{i}.layernorm_before.weight""") ) rename_keys.append((F"""blocks.{i}.norm1.bias""", F"""vit.encoder.layer.{i}.layernorm_before.bias""") ) rename_keys.append((F"""blocks.{i}.attn.proj.weight""", F"""vit.encoder.layer.{i}.attention.output.dense.weight""") ) rename_keys.append((F"""blocks.{i}.attn.proj.bias""", F"""vit.encoder.layer.{i}.attention.output.dense.bias""") ) rename_keys.append((F"""blocks.{i}.norm2.weight""", F"""vit.encoder.layer.{i}.layernorm_after.weight""") ) rename_keys.append((F"""blocks.{i}.norm2.bias""", F"""vit.encoder.layer.{i}.layernorm_after.bias""") ) rename_keys.append((F"""blocks.{i}.mlp.fc1.weight""", F"""vit.encoder.layer.{i}.intermediate.dense.weight""") ) rename_keys.append((F"""blocks.{i}.mlp.fc1.bias""", F"""vit.encoder.layer.{i}.intermediate.dense.bias""") ) rename_keys.append((F"""blocks.{i}.mlp.fc2.weight""", F"""vit.encoder.layer.{i}.output.dense.weight""") ) rename_keys.append((F"""blocks.{i}.mlp.fc2.bias""", F"""vit.encoder.layer.{i}.output.dense.bias""") ) # projection layer + position embeddings rename_keys.extend( [ ('''cls_token''', '''vit.embeddings.cls_token'''), ('''patch_embed.proj.weight''', '''vit.embeddings.patch_embeddings.projection.weight'''), ('''patch_embed.proj.bias''', '''vit.embeddings.patch_embeddings.projection.bias'''), ('''pos_embed''', '''vit.embeddings.position_embeddings'''), ] ) if base_model: # layernorm + pooler rename_keys.extend( [ ('''norm.weight''', '''layernorm.weight'''), ('''norm.bias''', '''layernorm.bias'''), ('''pre_logits.fc.weight''', '''pooler.dense.weight'''), ('''pre_logits.fc.bias''', '''pooler.dense.bias'''), ] ) # if just the base model, we should remove "vit" from all keys that start with "vit" A: int = [(pair[0], pair[1][4:]) if pair[1].startswith('''vit''' ) else pair for pair in rename_keys] else: # layernorm + classification head rename_keys.extend( [ ('''norm.weight''', '''vit.layernorm.weight'''), ('''norm.bias''', '''vit.layernorm.bias'''), ('''head.weight''', '''classifier.weight'''), ('''head.bias''', '''classifier.bias'''), ] ) return rename_keys def SCREAMING_SNAKE_CASE( __lowercase , __lowercase , __lowercase=False ) -> Dict: for i in range(config.num_hidden_layers ): if base_model: A: str = '''''' else: A: Union[str, Any] = '''vit.''' # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) A: Tuple = state_dict.pop(F"""blocks.{i}.attn.qkv.weight""" ) A: Any = state_dict.pop(F"""blocks.{i}.attn.qkv.bias""" ) # next, add query, keys and values (in that order) to the state dict A: str = in_proj_weight[ : config.hidden_size, : ] A: List[str] = in_proj_bias[: config.hidden_size] A: List[str] = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] A: Optional[Any] = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] A: Union[str, Any] = in_proj_weight[ -config.hidden_size :, : ] A: List[Any] = in_proj_bias[-config.hidden_size :] def SCREAMING_SNAKE_CASE( __lowercase ) -> List[Any]: A: Tuple = ['''head.weight''', '''head.bias'''] for k in ignore_keys: state_dict.pop(__lowercase , __lowercase ) def SCREAMING_SNAKE_CASE( __lowercase , __lowercase , __lowercase ) -> Dict: A: int = dct.pop(__lowercase ) A: List[str] = val def SCREAMING_SNAKE_CASE( ) -> str: A: Union[str, Any] = '''http://images.cocodataset.org/val2017/000000039769.jpg''' A: List[str] = Image.open(requests.get(__lowercase , stream=__lowercase ).raw ) return im @torch.no_grad() def SCREAMING_SNAKE_CASE( __lowercase , __lowercase ) -> Tuple: A: Optional[int] = ViTConfig() A: Union[str, Any] = False # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size if vit_name[-5:] == "in21k": A: Optional[int] = True A: Dict = int(vit_name[-1_2:-1_0] ) A: int = int(vit_name[-9:-6] ) else: A: int = 1_0_0_0 A: Union[str, Any] = '''huggingface/label-files''' A: List[str] = '''imagenet-1k-id2label.json''' A: Optional[Any] = json.load(open(hf_hub_download(__lowercase , __lowercase , repo_type='''dataset''' ) , '''r''' ) ) A: Any = {int(__lowercase ): v for k, v in idalabel.items()} A: Union[str, Any] = idalabel A: str = {v: k for k, v in idalabel.items()} A: str = int(vit_name[-6:-4] ) A: Optional[int] = int(vit_name[-3:] ) # size of the architecture if "deit" in vit_name: if vit_name[9:].startswith('''tiny''' ): A: Any = 1_9_2 A: List[Any] = 7_6_8 A: List[str] = 1_2 A: Union[str, Any] = 3 elif vit_name[9:].startswith('''small''' ): A: str = 3_8_4 A: int = 1_5_3_6 A: int = 1_2 A: Any = 6 else: pass else: if vit_name[4:].startswith('''small''' ): A: Any = 7_6_8 A: List[Any] = 2_3_0_4 A: Any = 8 A: Tuple = 8 elif vit_name[4:].startswith('''base''' ): pass elif vit_name[4:].startswith('''large''' ): A: List[Any] = 1_0_2_4 A: Any = 4_0_9_6 A: Optional[int] = 2_4 A: Any = 1_6 elif vit_name[4:].startswith('''huge''' ): A: List[str] = 1_2_8_0 A: str = 5_1_2_0 A: Optional[int] = 3_2 A: int = 1_6 # load original model from timm A: List[str] = timm.create_model(__lowercase , pretrained=__lowercase ) timm_model.eval() # load state_dict of original model, remove and rename some keys A: Any = timm_model.state_dict() if base_model: remove_classification_head_(__lowercase ) A: Optional[Any] = create_rename_keys(__lowercase , __lowercase ) for src, dest in rename_keys: rename_key(__lowercase , __lowercase , __lowercase ) read_in_q_k_v(__lowercase , __lowercase , __lowercase ) # load HuggingFace model if vit_name[-5:] == "in21k": A: Optional[int] = ViTModel(__lowercase ).eval() else: A: Any = ViTForImageClassification(__lowercase ).eval() model.load_state_dict(__lowercase ) # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor if "deit" in vit_name: A: int = DeiTImageProcessor(size=config.image_size ) else: A: List[Any] = ViTImageProcessor(size=config.image_size ) A: str = image_processor(images=prepare_img() , return_tensors='''pt''' ) A: Optional[int] = encoding['''pixel_values'''] A: Dict = model(__lowercase ) if base_model: A: Dict = timm_model.forward_features(__lowercase ) assert timm_pooled_output.shape == outputs.pooler_output.shape assert torch.allclose(__lowercase , outputs.pooler_output , atol=1E-3 ) else: A: Tuple = timm_model(__lowercase ) assert timm_logits.shape == outputs.logits.shape assert torch.allclose(__lowercase , outputs.logits , atol=1E-3 ) Path(__lowercase ).mkdir(exist_ok=__lowercase ) print(F"""Saving model {vit_name} to {pytorch_dump_folder_path}""" ) model.save_pretrained(__lowercase ) print(F"""Saving image processor to {pytorch_dump_folder_path}""" ) image_processor.save_pretrained(__lowercase ) if __name__ == "__main__": UpperCamelCase = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--vit_name''', default='''vit_base_patch16_224''', type=str, help='''Name of the ViT timm model you\'d like to convert.''', ) parser.add_argument( '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.''' ) UpperCamelCase = parser.parse_args() convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)
369
'''simple docstring''' class lowerCAmelCase_ : '''simple docstring''' def __init__( self : Any , SCREAMING_SNAKE_CASE_ : str , SCREAMING_SNAKE_CASE_ : Optional[int] , SCREAMING_SNAKE_CASE_ : List[str] ) -> int: '''simple docstring''' A: Tuple = None A: Dict = None A: Optional[int] = graph self._normalize_graph(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) A: str = len(SCREAMING_SNAKE_CASE_ ) A: Optional[Any] = None def _snake_case ( self : Tuple , SCREAMING_SNAKE_CASE_ : Optional[int] , SCREAMING_SNAKE_CASE_ : Dict ) -> str: '''simple docstring''' if sources is int: A: Union[str, Any] = [sources] if sinks is int: A: Tuple = [sinks] if len(SCREAMING_SNAKE_CASE_ ) == 0 or len(SCREAMING_SNAKE_CASE_ ) == 0: return A: List[str] = sources[0] A: Optional[int] = sinks[0] # make fake vertex if there are more # than one source or sink if len(SCREAMING_SNAKE_CASE_ ) > 1 or len(SCREAMING_SNAKE_CASE_ ) > 1: A: Any = 0 for i in sources: max_input_flow += sum(self.graph[i] ) A: Dict = len(self.graph ) + 1 for room in self.graph: room.insert(0 , 0 ) self.graph.insert(0 , [0] * size ) for i in sources: A: Optional[Any] = max_input_flow A: Optional[Any] = 0 A: str = len(self.graph ) + 1 for room in self.graph: room.append(0 ) self.graph.append([0] * size ) for i in sinks: A: Optional[Any] = max_input_flow A: str = size - 1 def _snake_case ( self : List[Any] ) -> Union[str, Any]: '''simple docstring''' if self.maximum_flow_algorithm is None: raise Exception('''You need to set maximum flow algorithm before.''' ) if self.source_index is None or self.sink_index is None: return 0 self.maximum_flow_algorithm.execute() return self.maximum_flow_algorithm.getMaximumFlow() def _snake_case ( self : Tuple , SCREAMING_SNAKE_CASE_ : Union[str, Any] ) -> Tuple: '''simple docstring''' A: Optional[Any] = algorithm(self ) class lowerCAmelCase_ : '''simple docstring''' def __init__( self : int , SCREAMING_SNAKE_CASE_ : List[Any] ) -> Optional[Any]: '''simple docstring''' A: str = flow_network A: List[str] = flow_network.verticesCount A: Dict = flow_network.sourceIndex A: Any = flow_network.sinkIndex # it's just a reference, so you shouldn't change # it in your algorithms, use deep copy before doing that A: str = flow_network.graph A: str = False def _snake_case ( self : int ) -> Union[str, Any]: '''simple docstring''' if not self.executed: self._algorithm() A: str = True def _snake_case ( self : Tuple ) -> Optional[Any]: '''simple docstring''' pass class lowerCAmelCase_ ( UpperCAmelCase_ ): '''simple docstring''' def __init__( self : List[str] , SCREAMING_SNAKE_CASE_ : List[str] ) -> Optional[int]: '''simple docstring''' super().__init__(SCREAMING_SNAKE_CASE_ ) # use this to save your result A: Any = -1 def _snake_case ( self : List[str] ) -> Optional[Any]: '''simple docstring''' if not self.executed: raise Exception('''You should execute algorithm before using its result!''' ) return self.maximum_flow class lowerCAmelCase_ ( UpperCAmelCase_ ): '''simple docstring''' def __init__( self : int , SCREAMING_SNAKE_CASE_ : Any ) -> Optional[int]: '''simple docstring''' super().__init__(SCREAMING_SNAKE_CASE_ ) A: Optional[int] = [[0] * self.verticies_count for i in range(self.verticies_count )] A: Any = [0] * self.verticies_count A: Optional[Any] = [0] * self.verticies_count def _snake_case ( self : str ) -> Optional[Any]: '''simple docstring''' A: Any = self.verticies_count # push some substance to graph for nextvertex_index, bandwidth in enumerate(self.graph[self.source_index] ): self.preflow[self.source_index][nextvertex_index] += bandwidth self.preflow[nextvertex_index][self.source_index] -= bandwidth self.excesses[nextvertex_index] += bandwidth # Relabel-to-front selection rule A: str = [ i for i in range(self.verticies_count ) if i != self.source_index and i != self.sink_index ] # move through list A: Dict = 0 while i < len(SCREAMING_SNAKE_CASE_ ): A: Any = vertices_list[i] A: str = self.heights[vertex_index] self.process_vertex(SCREAMING_SNAKE_CASE_ ) if self.heights[vertex_index] > previous_height: # if it was relabeled, swap elements # and start from 0 index vertices_list.insert(0 , vertices_list.pop(SCREAMING_SNAKE_CASE_ ) ) A: Tuple = 0 else: i += 1 A: Tuple = sum(self.preflow[self.source_index] ) def _snake_case ( self : int , SCREAMING_SNAKE_CASE_ : List[str] ) -> str: '''simple docstring''' while self.excesses[vertex_index] > 0: for neighbour_index in range(self.verticies_count ): # if it's neighbour and current vertex is higher if ( self.graph[vertex_index][neighbour_index] - self.preflow[vertex_index][neighbour_index] > 0 and self.heights[vertex_index] > self.heights[neighbour_index] ): self.push(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) self.relabel(SCREAMING_SNAKE_CASE_ ) def _snake_case ( self : Union[str, Any] , SCREAMING_SNAKE_CASE_ : Union[str, Any] , SCREAMING_SNAKE_CASE_ : Optional[Any] ) -> int: '''simple docstring''' A: Optional[int] = min( self.excesses[from_index] , self.graph[from_index][to_index] - self.preflow[from_index][to_index] , ) self.preflow[from_index][to_index] += preflow_delta self.preflow[to_index][from_index] -= preflow_delta self.excesses[from_index] -= preflow_delta self.excesses[to_index] += preflow_delta def _snake_case ( self : Optional[int] , SCREAMING_SNAKE_CASE_ : str ) -> int: '''simple docstring''' A: Optional[Any] = None for to_index in range(self.verticies_count ): if ( self.graph[vertex_index][to_index] - self.preflow[vertex_index][to_index] > 0 ) and (min_height is None or self.heights[to_index] < min_height): A: List[Any] = self.heights[to_index] if min_height is not None: A: int = min_height + 1 if __name__ == "__main__": UpperCamelCase = [0] UpperCamelCase = [3] # graph = [ # [0, 0, 4, 6, 0, 0], # [0, 0, 5, 2, 0, 0], # [0, 0, 0, 0, 4, 4], # [0, 0, 0, 0, 6, 6], # [0, 0, 0, 0, 0, 0], # [0, 0, 0, 0, 0, 0], # ] UpperCamelCase = [[0, 7, 0, 0], [0, 0, 6, 0], [0, 0, 0, 8], [9, 0, 0, 0]] # prepare our network UpperCamelCase = FlowNetwork(graph, entrances, exits) # set algorithm flow_network.set_maximum_flow_algorithm(PushRelabelExecutor) # and calculate UpperCamelCase = flow_network.find_maximum_flow() print(f'maximum flow is {maximum_flow}')
334
0
import json from typing import List, Optional, Tuple from tokenizers import normalizers from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_convbert import ConvBertTokenizer UpperCAmelCase__ : Optional[Any] = logging.get_logger(__name__) UpperCAmelCase__ : Dict = {'vocab_file': 'vocab.txt'} UpperCAmelCase__ : List[Any] = { 'vocab_file': { 'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt', 'YituTech/conv-bert-medium-small': ( 'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt' ), 'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt', } } UpperCAmelCase__ : Union[str, Any] = { 'YituTech/conv-bert-base': 512, 'YituTech/conv-bert-medium-small': 512, 'YituTech/conv-bert-small': 512, } UpperCAmelCase__ : Dict = { 'YituTech/conv-bert-base': {'do_lower_case': True}, 'YituTech/conv-bert-medium-small': {'do_lower_case': True}, 'YituTech/conv-bert-small': {'do_lower_case': True}, } class UpperCAmelCase ( SCREAMING_SNAKE_CASE__ ): '''simple docstring''' __UpperCamelCase : Any = VOCAB_FILES_NAMES __UpperCamelCase : Tuple = PRETRAINED_VOCAB_FILES_MAP __UpperCamelCase : str = PRETRAINED_INIT_CONFIGURATION __UpperCamelCase : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCamelCase : int = ConvBertTokenizer def __init__( self : Tuple , lowerCAmelCase_ : int=None , lowerCAmelCase_ : List[Any]=None , lowerCAmelCase_ : Optional[Any]=True , lowerCAmelCase_ : List[Any]="[UNK]" , lowerCAmelCase_ : Optional[Any]="[SEP]" , lowerCAmelCase_ : Optional[Any]="[PAD]" , lowerCAmelCase_ : List[Any]="[CLS]" , lowerCAmelCase_ : Optional[int]="[MASK]" , lowerCAmelCase_ : Any=True , lowerCAmelCase_ : List[str]=None , **lowerCAmelCase_ : List[Any] , ): """simple docstring""" super().__init__( lowerCAmelCase_ , tokenizer_file=lowerCAmelCase_ , do_lower_case=lowerCAmelCase_ , unk_token=lowerCAmelCase_ , sep_token=lowerCAmelCase_ , pad_token=lowerCAmelCase_ , cls_token=lowerCAmelCase_ , mask_token=lowerCAmelCase_ , tokenize_chinese_chars=lowerCAmelCase_ , strip_accents=lowerCAmelCase_ , **lowerCAmelCase_ , ) _A: List[Any] = json.loads(self.backend_tokenizer.normalizer.__getstate__() ) if ( normalizer_state.get('''lowercase''' , lowerCAmelCase_ ) != do_lower_case or normalizer_state.get('''strip_accents''' , lowerCAmelCase_ ) != strip_accents or normalizer_state.get('''handle_chinese_chars''' , lowerCAmelCase_ ) != tokenize_chinese_chars ): _A: List[str] = getattr(lowerCAmelCase_ , normalizer_state.pop('''type''' ) ) _A: List[Any] = do_lower_case _A: Optional[Any] = strip_accents _A: Union[str, Any] = tokenize_chinese_chars _A: Optional[int] = normalizer_class(**lowerCAmelCase_ ) _A: Optional[Any] = do_lower_case def __magic_name__ ( self : str , lowerCAmelCase_ : Tuple , lowerCAmelCase_ : Union[str, Any]=None ): """simple docstring""" _A: Dict = [self.cls_token_id] + token_ids_a + [self.sep_token_id] if token_ids_a: output += token_ids_a + [self.sep_token_id] return output def __magic_name__ ( self : Union[str, Any] , lowerCAmelCase_ : List[int] , lowerCAmelCase_ : Optional[List[int]] = None ): """simple docstring""" _A: Any = [self.sep_token_id] _A: 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 ) * [0] + len(token_ids_a + sep ) * [1] def __magic_name__ ( self : int , lowerCAmelCase_ : str , lowerCAmelCase_ : Optional[str] = None ): """simple docstring""" _A: str = self._tokenizer.model.save(lowerCAmelCase_ , name=lowerCAmelCase_ ) return tuple(lowerCAmelCase_ )
121
import os import pytest import yaml from datasets.features.features import Features, Value from datasets.info import DatasetInfo, DatasetInfosDict @pytest.mark.parametrize( '''files''' , [ ['''full:README.md''', '''dataset_infos.json'''], ['''empty:README.md''', '''dataset_infos.json'''], ['''dataset_infos.json'''], ['''full:README.md'''], ] , ) def lowerCamelCase__ ( a , a ) -> Any: _A: Any = tmp_path_factory.mktemp('''dset_infos_dir''' ) if "full:README.md" in files: with open(dataset_infos_dir / '''README.md''' , '''w''' ) as f: f.write('''---\ndataset_info:\n dataset_size: 42\n---''' ) if "empty:README.md" in files: with open(dataset_infos_dir / '''README.md''' , '''w''' ) as f: f.write('''''' ) # we want to support dataset_infos.json for backward compatibility if "dataset_infos.json" in files: with open(dataset_infos_dir / '''dataset_infos.json''' , '''w''' ) as f: f.write('''{"default": {"dataset_size": 42}}''' ) _A: Optional[int] = DatasetInfosDict.from_directory(a ) assert dataset_infos assert dataset_infos["default"].dataset_size == 42 @pytest.mark.parametrize( '''dataset_info''' , [ DatasetInfo(), DatasetInfo( description='''foo''' , features=Features({'''a''': Value('''int32''' )} ) , builder_name='''builder''' , config_name='''config''' , version='''1.0.0''' , splits=[{'''name''': '''train'''}] , download_size=42 , ), ] , ) def lowerCamelCase__ ( a , a ) -> Any: _A: int = str(a ) dataset_info.write_to_directory(a ) _A: str = DatasetInfo.from_directory(a ) assert dataset_info == reloaded assert os.path.exists(os.path.join(a , '''dataset_info.json''' ) ) def lowerCamelCase__ ( ) -> Any: _A: int = DatasetInfo( description='''foo''' , citation='''bar''' , homepage='''https://foo.bar''' , license='''CC0''' , features=Features({'''a''': Value('''int32''' )} ) , post_processed={} , supervised_keys=() , task_templates=[] , builder_name='''builder''' , config_name='''config''' , version='''1.0.0''' , splits=[{'''name''': '''train''', '''num_examples''': 42}] , download_checksums={} , download_size=13_37 , post_processing_size=4_42 , dataset_size=12_34 , size_in_bytes=13_37 + 4_42 + 12_34 , ) _A: Optional[Any] = dataset_info._to_yaml_dict() assert sorted(a ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML ) for key in DatasetInfo._INCLUDED_INFO_IN_YAML: assert key in dataset_info_yaml_dict assert isinstance(dataset_info_yaml_dict[key] , (list, dict, int, str) ) _A: str = yaml.safe_dump(a ) _A: Optional[int] = yaml.safe_load(a ) assert dataset_info_yaml_dict == reloaded def lowerCamelCase__ ( ) -> int: _A: Union[str, Any] = DatasetInfo() _A: Union[str, Any] = dataset_info._to_yaml_dict() assert dataset_info_yaml_dict == {} @pytest.mark.parametrize( '''dataset_infos_dict''' , [ DatasetInfosDict(), DatasetInfosDict({'''default''': DatasetInfo()} ), DatasetInfosDict({'''my_config_name''': DatasetInfo()} ), DatasetInfosDict( { '''default''': DatasetInfo( description='''foo''' , features=Features({'''a''': Value('''int32''' )} ) , builder_name='''builder''' , config_name='''config''' , version='''1.0.0''' , splits=[{'''name''': '''train'''}] , download_size=42 , ) } ), DatasetInfosDict( { '''v1''': DatasetInfo(dataset_size=42 ), '''v2''': DatasetInfo(dataset_size=13_37 ), } ), ] , ) def lowerCamelCase__ ( a , a ) -> Optional[int]: _A: Optional[int] = str(a ) dataset_infos_dict.write_to_directory(a ) _A: Union[str, Any] = DatasetInfosDict.from_directory(a ) # the config_name of the dataset_infos_dict take over the attribute for config_name, dataset_info in dataset_infos_dict.items(): _A: Optional[Any] = config_name # the yaml representation doesn't include fields like description or citation # so we just test that we can recover what we can from the yaml _A: Any = DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict() ) assert dataset_infos_dict == reloaded if dataset_infos_dict: assert os.path.exists(os.path.join(a , '''README.md''' ) )
121
1
from ...configuration_utils import PretrainedConfig from ...utils import logging lowerCamelCase : Optional[Any] = logging.get_logger(__name__) lowerCamelCase : Tuple = {} class A( UpperCamelCase ): '''simple docstring''' UpperCamelCase = '''llama''' UpperCamelCase = ['''past_key_values'''] def __init__( self : Dict , A_ : List[Any]=32000 , A_ : Tuple=4096 , A_ : List[Any]=11008 , A_ : List[str]=32 , A_ : Optional[Any]=32 , A_ : int=None , A_ : Any="silu" , A_ : Union[str, Any]=2048 , A_ : List[str]=0.02 , A_ : Optional[int]=1E-6 , A_ : List[str]=True , A_ : Optional[int]=0 , A_ : Optional[Any]=1 , A_ : Optional[int]=2 , A_ : int=1 , A_ : Tuple=False , A_ : Tuple=None , **A_ : Optional[int] , ) -> Optional[Any]: """simple docstring""" lowerCamelCase_ = vocab_size lowerCamelCase_ = max_position_embeddings lowerCamelCase_ = hidden_size lowerCamelCase_ = intermediate_size lowerCamelCase_ = num_hidden_layers lowerCamelCase_ = num_attention_heads # for backward compatibility if num_key_value_heads is None: lowerCamelCase_ = num_attention_heads lowerCamelCase_ = num_key_value_heads lowerCamelCase_ = hidden_act lowerCamelCase_ = initializer_range lowerCamelCase_ = rms_norm_eps lowerCamelCase_ = pretraining_tp lowerCamelCase_ = use_cache lowerCamelCase_ = rope_scaling self._rope_scaling_validation() super().__init__( pad_token_id=A_ , bos_token_id=A_ , eos_token_id=A_ , tie_word_embeddings=A_ , **A_ , ) def a__ ( self : Optional[Any] ) -> Any: """simple docstring""" if self.rope_scaling is None: return if not isinstance(self.rope_scaling , A_ ) or len(self.rope_scaling ) != 2: raise ValueError( '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, ' f"""got {self.rope_scaling}""" ) lowerCamelCase_ = self.rope_scaling.get('type' , A_ ) lowerCamelCase_ = self.rope_scaling.get('factor' , A_ ) if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]: raise ValueError( f"""`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}""" ) if rope_scaling_factor is None or not isinstance(A_ , A_ ) or rope_scaling_factor <= 1.0: raise ValueError(f"""`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}""" )
355
from ...configuration_utils import PretrainedConfig from ...utils import logging lowerCamelCase : Optional[Any] = logging.get_logger(__name__) lowerCamelCase : Tuple = { "transfo-xl-wt103": "https://huggingface.co/transfo-xl-wt103/resolve/main/config.json", } class A( UpperCamelCase ): '''simple docstring''' UpperCamelCase = '''transfo-xl''' UpperCamelCase = ['''mems'''] UpperCamelCase = { '''n_token''': '''vocab_size''', '''hidden_size''': '''d_model''', '''num_attention_heads''': '''n_head''', '''num_hidden_layers''': '''n_layer''', } def __init__( self : Any , A_ : Optional[Any]=267735 , A_ : Optional[Any]=[20000, 40000, 200000] , A_ : Union[str, Any]=1024 , A_ : Optional[Any]=1024 , A_ : Optional[int]=16 , A_ : Any=64 , A_ : List[Any]=4096 , A_ : str=4 , A_ : int=False , A_ : List[Any]=18 , A_ : Optional[int]=1600 , A_ : Union[str, Any]=1000 , A_ : Optional[Any]=True , A_ : Optional[int]=True , A_ : List[str]=0 , A_ : int=-1 , A_ : List[Any]=True , A_ : List[Any]=0.1 , A_ : str=0.0 , A_ : Dict=True , A_ : Dict="normal" , A_ : Dict=0.01 , A_ : Optional[Any]=0.01 , A_ : Any=0.02 , A_ : int=1E-5 , A_ : List[str]=0 , **A_ : Optional[Any] , ) -> Optional[int]: """simple docstring""" lowerCamelCase_ = vocab_size lowerCamelCase_ = [] self.cutoffs.extend(A_ ) if proj_share_all_but_first: lowerCamelCase_ = [False] + [True] * len(self.cutoffs ) else: lowerCamelCase_ = [False] + [False] * len(self.cutoffs ) lowerCamelCase_ = d_model lowerCamelCase_ = d_embed lowerCamelCase_ = d_head lowerCamelCase_ = d_inner lowerCamelCase_ = div_val lowerCamelCase_ = pre_lnorm lowerCamelCase_ = n_layer lowerCamelCase_ = n_head lowerCamelCase_ = mem_len lowerCamelCase_ = same_length lowerCamelCase_ = attn_type lowerCamelCase_ = clamp_len lowerCamelCase_ = sample_softmax lowerCamelCase_ = adaptive lowerCamelCase_ = dropout lowerCamelCase_ = dropatt lowerCamelCase_ = untie_r lowerCamelCase_ = init lowerCamelCase_ = init_range lowerCamelCase_ = proj_init_std lowerCamelCase_ = init_std lowerCamelCase_ = layer_norm_epsilon super().__init__(eos_token_id=A_ , **A_ ) @property def a__ ( self : Tuple ) -> Any: """simple docstring""" logger.info(f"""The model {self.model_type} is one of the few models that has no sequence length limit.""" ) return -1 @max_position_embeddings.setter def a__ ( self : Dict , A_ : Optional[int] ) -> List[Any]: """simple docstring""" raise NotImplementedError( f"""The model {self.model_type} is one of the few models that has no sequence length limit.""" )
208
0
'''simple docstring''' import argparse from transformers import ( TapasConfig, TapasForMaskedLM, TapasForQuestionAnswering, TapasForSequenceClassification, TapasModel, TapasTokenizer, load_tf_weights_in_tapas, ) from transformers.utils import logging logging.set_verbosity_info() def UpperCAmelCase_ ( __lowercase : int , __lowercase : Dict , __lowercase : str , __lowercase : Optional[Any] , __lowercase : str ) -> List[str]: '''simple docstring''' _UpperCAmelCase = TapasConfig.from_json_file(__lowercase ) # set absolute/relative position embeddings parameter _UpperCAmelCase = reset_position_index_per_cell # set remaining parameters of TapasConfig as well as the model based on the task if task == "SQA": _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WTQ": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = True # hparam_utils.py hparams _UpperCAmelCase = 0.66_4694 _UpperCAmelCase = 0.20_7951 _UpperCAmelCase = 0.12_1194 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = 0.035_2513 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "WIKISQL_SUPERVISED": # run_task_main.py hparams _UpperCAmelCase = 4 _UpperCAmelCase = False # hparam_utils.py hparams _UpperCAmelCase = 36.4519 _UpperCAmelCase = 0.90_3421 _UpperCAmelCase = 222.088 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 0.76_3141 _UpperCAmelCase = TapasForQuestionAnswering(config=__lowercase ) elif task == "TABFACT": _UpperCAmelCase = TapasForSequenceClassification(config=__lowercase ) elif task == "MLM": _UpperCAmelCase = TapasForMaskedLM(config=__lowercase ) elif task == "INTERMEDIATE_PRETRAINING": _UpperCAmelCase = TapasModel(config=__lowercase ) else: raise ValueError(f'Task {task} not supported.' ) print(f'Building PyTorch model from configuration: {config}' ) # Load weights from tf checkpoint load_tf_weights_in_tapas(__lowercase , __lowercase , __lowercase ) # Save pytorch-model (weights and configuration) print(f'Save PyTorch model to {pytorch_dump_path}' ) model.save_pretrained(__lowercase ) # Save tokenizer files print(f'Save tokenizer files to {pytorch_dump_path}' ) _UpperCAmelCase = TapasTokenizer(vocab_file=tf_checkpoint_path[:-10] + "vocab.txt" , model_max_length=512 ) tokenizer.save_pretrained(__lowercase ) print("Used relative position embeddings:" , model.config.reset_position_index_per_cell ) if __name__ == "__main__": __SCREAMING_SNAKE_CASE :List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--task''', default='''SQA''', type=str, help='''Model task for which to convert a checkpoint. Defaults to SQA.''' ) parser.add_argument( '''--reset_position_index_per_cell''', default=False, action='''store_true''', help='''Whether to use relative position embeddings or not. Defaults to True.''', ) parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--tapas_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained TAPAS 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.''' ) __SCREAMING_SNAKE_CASE :List[str] = parser.parse_args() convert_tf_checkpoint_to_pytorch( args.task, args.reset_position_index_per_cell, args.tf_checkpoint_path, args.tapas_config_file, args.pytorch_dump_path, )
22
"""simple docstring""" import os import time import numpy as np import onnxruntime as ort snake_case_ = """1""" snake_case_ = """0""" snake_case_ = """1""" snake_case_ = ort.SessionOptions() snake_case_ = ort.GraphOptimizationLevel.ORT_DISABLE_ALL print("""Create inference session...""") snake_case_ = ["""TensorrtExecutionProvider""", """CUDAExecutionProvider"""] snake_case_ = ort.InferenceSession("""model.onnx""", sess_options=sess_opt, providers=execution_provider) snake_case_ = ort.RunOptions() snake_case_ = 128 snake_case_ = 1 snake_case_ = np.ones((batch, sequence), dtype=np.intaa) snake_case_ = np.ones((batch, sequence), dtype=np.intaa) snake_case_ = np.ones((batch, sequence), dtype=np.intaa) print("""Warm up phase...""") sess.run( None, { sess.get_inputs()[0].name: input_ids, sess.get_inputs()[1].name: attention_mask, sess.get_inputs()[2].name: token_type_ids, }, run_options=run_opt, ) print("""Start inference...""") snake_case_ = time.time() snake_case_ = 2000 snake_case_ = {} for iter in range(max_iters): snake_case_ = sess.run( None, { sess.get_inputs()[0].name: input_ids, sess.get_inputs()[1].name: attention_mask, sess.get_inputs()[2].name: token_type_ids, }, run_options=run_opt, ) print("""Average Inference Time = {:.3f} ms""".format((time.time() - start_time) * 1000 / max_iters))
78
0
import time from dataclasses import dataclass from multiprocessing import Pool from unittest import TestCase from unittest.mock import patch import multiprocess import numpy as np import pytest from datasets.utils.py_utils import ( NestedDataStructure, asdict, iflatmap_unordered, map_nested, temp_seed, temporary_assignment, zip_dict, ) from .utils import require_tf, require_torch def UpperCamelCase_( snake_case__: List[Any] ) -> Optional[Any]: # picklable for multiprocessing return x.sum() def UpperCamelCase_( snake_case__: str ) -> Optional[Any]: # picklable for multiprocessing return i + 1 @dataclass class lowercase : '''simple docstring''' __SCREAMING_SNAKE_CASE = 42 __SCREAMING_SNAKE_CASE = 42 class lowercase ( _UpperCamelCase ): '''simple docstring''' def UpperCamelCase__ (self ) -> Union[str, Any]: """simple docstring""" UpperCAmelCase__ = {} UpperCAmelCase__ = [] UpperCAmelCase__ = 1 UpperCAmelCase__ = [1, 2] UpperCAmelCase__ = {'a': 1, 'b': 2} UpperCAmelCase__ = {'a': [1, 2], 'b': [3, 4]} UpperCAmelCase__ = {'a': {'1': 1}, 'b': 2} UpperCAmelCase__ = {'a': 1, 'b': 2, 'c': 3, 'd': 4} UpperCAmelCase__ = {} UpperCAmelCase__ = [] UpperCAmelCase__ = 2 UpperCAmelCase__ = [2, 3] UpperCAmelCase__ = {'a': 2, 'b': 3} UpperCAmelCase__ = {'a': [2, 3], 'b': [4, 5]} UpperCAmelCase__ = {'a': {'1': 2}, 'b': 3} UpperCAmelCase__ = {'a': 2, 'b': 3, 'c': 4, 'd': 5} self.assertEqual(map_nested(_a , _a ) , _a ) self.assertEqual(map_nested(_a , _a ) , _a ) self.assertEqual(map_nested(_a , _a ) , _a ) self.assertEqual(map_nested(_a , _a ) , _a ) self.assertEqual(map_nested(_a , _a ) , _a ) self.assertEqual(map_nested(_a , _a ) , _a ) self.assertEqual(map_nested(_a , _a ) , _a ) self.assertEqual(map_nested(_a , _a ) , _a ) UpperCAmelCase__ = 2 self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) self.assertEqual(map_nested(_a , _a , num_proc=_a ) , _a ) UpperCAmelCase__ = {'a': np.eye(2 ), 'b': np.zeros(3 ), 'c': np.ones(2 )} UpperCAmelCase__ = {'a': 2, 'b': 0, 'c': 2} UpperCAmelCase__ = { 'a': np.eye(2 ).astype(_a ), 'b': np.zeros(3 ).astype(_a ), 'c': np.ones(2 ).astype(_a ), } self.assertEqual(map_nested(_a , _a , map_numpy=_a ) , _a ) self.assertEqual( {k: v.tolist() for k, v in map_nested(_a , _a , map_numpy=_a ).items()} , {k: v.tolist() for k, v in expected_map_nested_sna_int.items()} , ) self.assertEqual(map_nested(_a , _a , map_numpy=_a , num_proc=_a ) , _a ) self.assertEqual( {k: v.tolist() for k, v in map_nested(_a , _a , map_numpy=_a , num_proc=_a ).items()} , {k: v.tolist() for k, v in expected_map_nested_sna_int.items()} , ) with self.assertRaises(_a ): # can't pickle a local lambda map_nested(lambda __a : x + 1 , _a , num_proc=_a ) def UpperCamelCase__ (self ) -> Tuple: """simple docstring""" UpperCAmelCase__ = {'a': 1, 'b': 2} UpperCAmelCase__ = {'a': 3, 'b': 4} UpperCAmelCase__ = {'a': 5, 'b': 6} UpperCAmelCase__ = sorted([('a', (1, 3, 5)), ('b', (2, 4, 6))] ) self.assertEqual(sorted(zip_dict(_a , _a , _a ) ) , _a ) def UpperCamelCase__ (self ) -> List[Any]: """simple docstring""" class lowercase : '''simple docstring''' __SCREAMING_SNAKE_CASE = '''bar''' UpperCAmelCase__ = Foo() self.assertEqual(foo.my_attr , 'bar' ) with temporary_assignment(_a , 'my_attr' , 'BAR' ): self.assertEqual(foo.my_attr , 'BAR' ) self.assertEqual(foo.my_attr , 'bar' ) @pytest.mark.parametrize( 'iterable_length, num_proc, expected_num_proc' , [ (1, None, 1), (1, 1, 1), (2, None, 1), (2, 1, 1), (2, 2, 1), (2, 3, 1), (3, 2, 1), (16, 16, 16), (16, 17, 16), (17, 16, 16), ] , ) def UpperCamelCase_( snake_case__: List[str] , snake_case__: str , snake_case__: Dict ) -> Optional[Any]: with patch('datasets.utils.py_utils._single_map_nested' ) as mock_single_map_nested, patch( 'datasets.parallel.parallel.Pool' ) as mock_multiprocessing_pool: UpperCAmelCase__ = {f"{i}": i for i in range(UpperCamelCase__ )} UpperCAmelCase__ = map_nested(lambda snake_case__ : x + 10 , UpperCamelCase__ , num_proc=UpperCamelCase__ , parallel_min_length=16 ) if expected_num_proc == 1: assert mock_single_map_nested.called assert not mock_multiprocessing_pool.called else: assert not mock_single_map_nested.called assert mock_multiprocessing_pool.called assert mock_multiprocessing_pool.call_args[0][0] == expected_num_proc class lowercase ( _UpperCamelCase ): '''simple docstring''' @require_tf def UpperCamelCase__ (self ) -> Tuple: """simple docstring""" import tensorflow as tf from tensorflow.keras import layers UpperCAmelCase__ = layers.Dense(2 ) def gen_random_output(): UpperCAmelCase__ = tf.random.uniform((1, 3) ) return model(_a ).numpy() with temp_seed(42 , set_tensorflow=_a ): UpperCAmelCase__ = gen_random_output() with temp_seed(42 , set_tensorflow=_a ): UpperCAmelCase__ = gen_random_output() UpperCAmelCase__ = gen_random_output() np.testing.assert_equal(_a , _a ) self.assertGreater(np.abs(outa - outa ).sum() , 0 ) @require_torch def UpperCamelCase__ (self ) -> str: """simple docstring""" import torch def gen_random_output(): UpperCAmelCase__ = torch.nn.Linear(3 , 2 ) UpperCAmelCase__ = torch.rand(1 , 3 ) return model(_a ).detach().numpy() with temp_seed(42 , set_pytorch=_a ): UpperCAmelCase__ = gen_random_output() with temp_seed(42 , set_pytorch=_a ): UpperCAmelCase__ = gen_random_output() UpperCAmelCase__ = gen_random_output() np.testing.assert_equal(_a , _a ) self.assertGreater(np.abs(outa - outa ).sum() , 0 ) def UpperCamelCase__ (self ) -> int: """simple docstring""" def gen_random_output(): return np.random.rand(1 , 3 ) with temp_seed(42 ): UpperCAmelCase__ = gen_random_output() with temp_seed(42 ): UpperCAmelCase__ = gen_random_output() UpperCAmelCase__ = gen_random_output() np.testing.assert_equal(_a , _a ) self.assertGreater(np.abs(outa - outa ).sum() , 0 ) @pytest.mark.parametrize('input_data' , [{}] ) def UpperCamelCase_( snake_case__: Any ) -> List[str]: UpperCAmelCase__ = NestedDataStructure(UpperCamelCase__ ).data assert output_data == input_data @pytest.mark.parametrize( 'data, expected_output' , [ ({}, []), ([], []), ('foo', ['foo']), (['foo', 'bar'], ['foo', 'bar']), ([['foo', 'bar']], ['foo', 'bar']), ([[['foo'], ['bar']]], ['foo', 'bar']), ([[['foo'], 'bar']], ['foo', 'bar']), ({'a': 1, 'b': 2}, [1, 2]), ({'a': [1, 2], 'b': [3, 4]}, [1, 2, 3, 4]), ({'a': [[1, 2]], 'b': [[3, 4]]}, [1, 2, 3, 4]), ({'a': [[1, 2]], 'b': [3, 4]}, [1, 2, 3, 4]), ({'a': [[[1], [2]]], 'b': [[[3], [4]]]}, [1, 2, 3, 4]), ({'a': [[[1], [2]]], 'b': [[3, 4]]}, [1, 2, 3, 4]), ({'a': [[[1], [2]]], 'b': [3, 4]}, [1, 2, 3, 4]), ({'a': [[[1], [2]]], 'b': [3, [4]]}, [1, 2, 3, 4]), ({'a': {'1': 1}, 'b': 2}, [1, 2]), ({'a': {'1': [1]}, 'b': 2}, [1, 2]), ({'a': {'1': [1]}, 'b': [2]}, [1, 2]), ] , ) def UpperCamelCase_( snake_case__: int , snake_case__: Dict ) -> str: UpperCAmelCase__ = NestedDataStructure(UpperCamelCase__ ).flatten() assert output == expected_output def UpperCamelCase_( ) -> Optional[int]: UpperCAmelCase__ = A(x=1 , y='foobar' ) UpperCAmelCase__ = {'x': 1, 'y': 'foobar'} assert asdict(UpperCamelCase__ ) == expected_output UpperCAmelCase__ = {'a': {'b': A(x=10 , y='foo' )}, 'c': [A(x=20 , y='bar' )]} UpperCAmelCase__ = {'a': {'b': {'x': 10, 'y': 'foo'}}, 'c': [{'x': 20, 'y': 'bar'}]} assert asdict(UpperCamelCase__ ) == expected_output with pytest.raises(UpperCamelCase__ ): asdict([1, A(x=10 , y='foo' )] ) def UpperCamelCase_( snake_case__: str ) -> Union[str, Any]: return text.split() def UpperCamelCase_( snake_case__: List[Any] ) -> List[Any]: yield (time.time(), content) time.sleep(2 ) yield (time.time(), content) def UpperCamelCase_( ) -> Optional[int]: with Pool(2 ) as pool: UpperCAmelCase__ = list(iflatmap_unordered(UpperCamelCase__ , _split_text , kwargs_iterable=[{'text': 'hello there'}] * 10 ) ) assert out.count('hello' ) == 10 assert out.count('there' ) == 10 assert len(UpperCamelCase__ ) == 20 # check multiprocess from pathos (uses dill for pickling) with multiprocess.Pool(2 ) as pool: UpperCAmelCase__ = list(iflatmap_unordered(UpperCamelCase__ , _split_text , kwargs_iterable=[{'text': 'hello there'}] * 10 ) ) assert out.count('hello' ) == 10 assert out.count('there' ) == 10 assert len(UpperCamelCase__ ) == 20 # check that we get items as fast as possible with Pool(2 ) as pool: UpperCAmelCase__ = [] for yield_time, content in iflatmap_unordered( UpperCamelCase__ , _aseconds_generator_of_aitems_with_timing , kwargs_iterable=[{'content': 'a'}, {'content': 'b'}] ): assert yield_time < time.time() + 0.1, "we should each item directly after it was yielded" out.append(UpperCamelCase__ ) assert out.count('a' ) == 2 assert out.count('b' ) == 2 assert len(UpperCamelCase__ ) == 4
363
from collections import defaultdict from typing import Optional from ..image_utils import load_image from ..utils import ( add_end_docstrings, is_torch_available, logging, requires_backends, ) from .base import PIPELINE_INIT_ARGS, ChunkPipeline if is_torch_available(): import torch from ..models.auto.modeling_auto import MODEL_FOR_MASK_GENERATION_MAPPING _UpperCamelCase = logging.get_logger(__name__) @add_end_docstrings(_UpperCamelCase ) class lowercase ( _UpperCamelCase ): '''simple docstring''' def __init__(self , **__a ) -> Optional[Any]: """simple docstring""" super().__init__(**__a ) requires_backends(self , 'vision' ) requires_backends(self , 'torch' ) if self.framework != "pt": raise ValueError(F"The {self.__class__} is only available in PyTorch." ) self.check_model_type(__a ) def UpperCamelCase__ (self , **__a ) -> List[Any]: """simple docstring""" UpperCAmelCase__ = {} UpperCAmelCase__ = {} UpperCAmelCase__ = {} # preprocess args if "points_per_batch" in kwargs: UpperCAmelCase__ = kwargs['points_per_batch'] if "points_per_crop" in kwargs: UpperCAmelCase__ = kwargs['points_per_crop'] if "crops_n_layers" in kwargs: UpperCAmelCase__ = kwargs['crops_n_layers'] if "crop_overlap_ratio" in kwargs: UpperCAmelCase__ = kwargs['crop_overlap_ratio'] if "crop_n_points_downscale_factor" in kwargs: UpperCAmelCase__ = kwargs['crop_n_points_downscale_factor'] # postprocess args if "pred_iou_thresh" in kwargs: UpperCAmelCase__ = kwargs['pred_iou_thresh'] if "stability_score_offset" in kwargs: UpperCAmelCase__ = kwargs['stability_score_offset'] if "mask_threshold" in kwargs: UpperCAmelCase__ = kwargs['mask_threshold'] if "stability_score_thresh" in kwargs: UpperCAmelCase__ = kwargs['stability_score_thresh'] if "crops_nms_thresh" in kwargs: UpperCAmelCase__ = kwargs['crops_nms_thresh'] if "output_rle_mask" in kwargs: UpperCAmelCase__ = kwargs['output_rle_mask'] if "output_bboxes_mask" in kwargs: UpperCAmelCase__ = kwargs['output_bboxes_mask'] return preprocess_kwargs, forward_params, postprocess_kwargs def __call__(self , __a , *__a , __a=None , __a=None , **__a ) -> List[str]: """simple docstring""" return super().__call__(__a , *__a , num_workers=__a , batch_size=__a , **__a ) def UpperCamelCase__ (self , __a , __a=64 , __a = 0 , __a = 512 / 1500 , __a = 32 , __a = 1 , ) -> Union[str, Any]: """simple docstring""" UpperCAmelCase__ = load_image(__a ) UpperCAmelCase__ = self.image_processor.size['longest_edge'] UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = self.image_processor.generate_crop_boxes( __a , __a , __a , __a , __a , __a ) UpperCAmelCase__ = self.image_processor(images=__a , return_tensors='pt' ) with self.device_placement(): if self.framework == "pt": UpperCAmelCase__ = self.get_inference_context() with inference_context(): UpperCAmelCase__ = self._ensure_tensor_on_device(__a , device=self.device ) UpperCAmelCase__ = self.model.get_image_embeddings(model_inputs.pop('pixel_values' ) ) UpperCAmelCase__ = image_embeddings UpperCAmelCase__ = grid_points.shape[1] UpperCAmelCase__ = points_per_batch if points_per_batch is not None else n_points if points_per_batch <= 0: raise ValueError( 'Cannot have points_per_batch<=0. Must be >=1 to returned batched outputs. ' 'To return all points at once, set points_per_batch to None' ) for i in range(0 , __a , __a ): UpperCAmelCase__ = grid_points[:, i : i + points_per_batch, :, :] UpperCAmelCase__ = input_labels[:, i : i + points_per_batch] UpperCAmelCase__ = i == n_points - points_per_batch yield { "input_points": batched_points, "input_labels": labels, "input_boxes": crop_boxes, "is_last": is_last, **model_inputs, } def UpperCamelCase__ (self , __a , __a=0.88 , __a=0.95 , __a=0 , __a=1 , ) -> Dict: """simple docstring""" UpperCAmelCase__ = model_inputs.pop('input_boxes' ) UpperCAmelCase__ = model_inputs.pop('is_last' ) UpperCAmelCase__ = model_inputs.pop('original_sizes' ).tolist() UpperCAmelCase__ = model_inputs.pop('reshaped_input_sizes' ).tolist() UpperCAmelCase__ = self.model(**__a ) # post processing happens here in order to avoid CPU GPU copies of ALL the masks UpperCAmelCase__ = model_outputs['pred_masks'] UpperCAmelCase__ = self.image_processor.post_process_masks( __a , __a , __a , __a , binarize=__a ) UpperCAmelCase__ = model_outputs['iou_scores'] UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = self.image_processor.filter_masks( masks[0] , iou_scores[0] , original_sizes[0] , input_boxes[0] , __a , __a , __a , __a , ) return { "masks": masks, "is_last": is_last, "boxes": boxes, "iou_scores": iou_scores, } def UpperCamelCase__ (self , __a , __a=False , __a=False , __a=0.7 , ) -> Dict: """simple docstring""" UpperCAmelCase__ = [] UpperCAmelCase__ = [] UpperCAmelCase__ = [] for model_output in model_outputs: all_scores.append(model_output.pop('iou_scores' ) ) all_masks.extend(model_output.pop('masks' ) ) all_boxes.append(model_output.pop('boxes' ) ) UpperCAmelCase__ = torch.cat(__a ) UpperCAmelCase__ = torch.cat(__a ) UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ , UpperCAmelCase__ = self.image_processor.post_process_for_mask_generation( __a , __a , __a , __a ) UpperCAmelCase__ = defaultdict(__a ) for output in model_outputs: for k, v in output.items(): extra[k].append(__a ) UpperCAmelCase__ = {} if output_rle_mask: UpperCAmelCase__ = rle_mask if output_bboxes_mask: UpperCAmelCase__ = bounding_boxes return {"masks": output_masks, "scores": iou_scores, **optional, **extra}
335
0
from __future__ import annotations def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' lowerCamelCase : List[Any] = [] lowerCamelCase , lowerCamelCase : Tuple = input_list[low:mid], input_list[mid : high + 1] while left and right: result.append((left if left[0] <= right[0] else right).pop(0 ) ) lowerCamelCase : Optional[Any] = result + left + right return input_list def lowercase_( SCREAMING_SNAKE_CASE_ ): '''simple docstring''' if len(SCREAMING_SNAKE_CASE_ ) <= 1: return input_list lowerCamelCase : Union[str, Any] = list(SCREAMING_SNAKE_CASE_ ) # iteration for two-way merging lowerCamelCase : List[Any] = 2 while p <= len(SCREAMING_SNAKE_CASE_ ): # getting low, high and middle value for merge-sort of single list for i in range(0 , len(SCREAMING_SNAKE_CASE_ ) , SCREAMING_SNAKE_CASE_ ): lowerCamelCase : Union[str, Any] = i lowerCamelCase : Any = i + p - 1 lowerCamelCase : Optional[int] = (low + high + 1) // 2 lowerCamelCase : Union[str, Any] = merge(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) # final merge of last two parts if p * 2 >= len(SCREAMING_SNAKE_CASE_ ): lowerCamelCase : List[str] = i lowerCamelCase : List[str] = merge(SCREAMING_SNAKE_CASE_ , 0 , SCREAMING_SNAKE_CASE_ , len(SCREAMING_SNAKE_CASE_ ) - 1 ) break p *= 2 return input_list if __name__ == "__main__": _snake_case = input('''Enter numbers separated by a comma:\n''').strip() if user_input == "": _snake_case = [] else: _snake_case = [int(item.strip()) for item in user_input.split(''',''')] print(iter_merge_sort(unsorted))
283
import math from typing import Callable, List, Optional, Union import numpy as np import PIL import torch from PIL import Image from transformers import CLIPTextModel, CLIPTokenizer from diffusers.models import AutoencoderKL, UNetaDConditionModel from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline from diffusers.schedulers import DDIMScheduler, DDPMScheduler, LMSDiscreteScheduler, PNDMScheduler def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_=[] ): '''simple docstring''' lowerCamelCase : Optional[Any] = size[0] - overlap_pixels * 2 lowerCamelCase : int = size[1] - overlap_pixels * 2 for letter in ["l", "r"]: if letter in remove_borders: size_x += overlap_pixels for letter in ["t", "b"]: if letter in remove_borders: size_y += overlap_pixels lowerCamelCase : Tuple = np.ones((size_y, size_x) , dtype=np.uinta ) * 255 lowerCamelCase : List[Any] = np.pad(SCREAMING_SNAKE_CASE_ , mode="linear_ramp" , pad_width=SCREAMING_SNAKE_CASE_ , end_values=0 ) if "l" in remove_borders: lowerCamelCase : Optional[Any] = mask[:, overlap_pixels : mask.shape[1]] if "r" in remove_borders: lowerCamelCase : List[Any] = mask[:, 0 : mask.shape[1] - overlap_pixels] if "t" in remove_borders: lowerCamelCase : List[Any] = mask[overlap_pixels : mask.shape[0], :] if "b" in remove_borders: lowerCamelCase : Tuple = mask[0 : mask.shape[0] - overlap_pixels, :] return mask def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' return max(SCREAMING_SNAKE_CASE_ , min(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) ) def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' return ( clamp(rect[0] , min[0] , max[0] ), clamp(rect[1] , min[1] , max[1] ), clamp(rect[2] , min[0] , max[0] ), clamp(rect[3] , min[1] , max[1] ), ) def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' lowerCamelCase : Optional[Any] = list(SCREAMING_SNAKE_CASE_ ) rect[0] -= overlap rect[1] -= overlap rect[2] += overlap rect[3] += overlap lowerCamelCase : Any = clamp_rect(SCREAMING_SNAKE_CASE_ , [0, 0] , [image_size[0], image_size[1]] ) return rect def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' lowerCamelCase : Dict = Image.new("RGB" , (tile.size[0] + original_slice, tile.size[1]) ) result.paste( original_image.resize((tile.size[0], tile.size[1]) , Image.BICUBIC ).crop( (slice_x, 0, slice_x + original_slice, tile.size[1]) ) , (0, 0) , ) result.paste(SCREAMING_SNAKE_CASE_ , (original_slice, 0) ) return result def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' lowerCamelCase : Union[str, Any] = (original_image_slice * 4, 0, tile.size[0], tile.size[1]) lowerCamelCase : int = tile.crop(SCREAMING_SNAKE_CASE_ ) return tile def lowercase_( SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): '''simple docstring''' lowerCamelCase : int = n % d return n - divisor class UpperCAmelCase_ ( UpperCamelCase ): '''simple docstring''' def __init__( self , __A , __A , __A , __A , __A , __A , __A = 350 , ): """simple docstring""" super().__init__( vae=__A , text_encoder=__A , tokenizer=__A , unet=__A , low_res_scheduler=__A , scheduler=__A , max_noise_level=__A , ) def _snake_case ( self , __A , __A , __A , __A , __A , __A , __A , **__A ): """simple docstring""" torch.manual_seed(0 ) lowerCamelCase : Tuple = ( min(image.size[0] - (tile_size + original_image_slice) , x * tile_size ), min(image.size[1] - (tile_size + original_image_slice) , y * tile_size ), min(image.size[0] , (x + 1) * tile_size ), min(image.size[1] , (y + 1) * tile_size ), ) lowerCamelCase : Union[str, Any] = add_overlap_rect(__A , __A , image.size ) lowerCamelCase : List[str] = image.crop(__A ) lowerCamelCase : Optional[int] = ((crop_rect[0] + ((crop_rect[2] - crop_rect[0]) / 2)) / image.size[0]) * tile.size[0] lowerCamelCase : int = translated_slice_x - (original_image_slice / 2) lowerCamelCase : Optional[Any] = max(0 , __A ) lowerCamelCase : Tuple = squeeze_tile(__A , __A , __A , __A ) lowerCamelCase : Dict = to_input.size lowerCamelCase : Optional[int] = to_input.resize((tile_size, tile_size) , Image.BICUBIC ) lowerCamelCase : Dict = super(__A , self ).__call__(image=__A , **__A ).images[0] lowerCamelCase : Tuple = upscaled_tile.resize((orig_input_size[0] * 4, orig_input_size[1] * 4) , Image.BICUBIC ) lowerCamelCase : Optional[Any] = unsqueeze_tile(__A , __A ) lowerCamelCase : Optional[Any] = upscaled_tile.resize((tile.size[0] * 4, tile.size[1] * 4) , Image.BICUBIC ) lowerCamelCase : int = [] if x == 0: remove_borders.append("l" ) elif crop_rect[2] == image.size[0]: remove_borders.append("r" ) if y == 0: remove_borders.append("t" ) elif crop_rect[3] == image.size[1]: remove_borders.append("b" ) lowerCamelCase : int = Image.fromarray( make_transparency_mask( (upscaled_tile.size[0], upscaled_tile.size[1]) , tile_border * 4 , remove_borders=__A ) , mode="L" , ) final_image.paste( __A , (crop_rect_with_overlap[0] * 4, crop_rect_with_overlap[1] * 4) , __A ) @torch.no_grad() def __call__( self , __A , __A , __A = 75 , __A = 9.0 , __A = 50 , __A = None , __A = 1 , __A = 0.0 , __A = None , __A = None , __A = None , __A = 1 , __A = 128 , __A = 32 , __A = 32 , ): """simple docstring""" lowerCamelCase : Dict = Image.new("RGB" , (image.size[0] * 4, image.size[1] * 4) ) lowerCamelCase : Union[str, Any] = math.ceil(image.size[0] / tile_size ) lowerCamelCase : Dict = math.ceil(image.size[1] / tile_size ) lowerCamelCase : str = tcx * tcy lowerCamelCase : int = 0 for y in range(__A ): for x in range(__A ): self._process_tile( __A , __A , __A , __A , __A , __A , __A , prompt=__A , num_inference_steps=__A , guidance_scale=__A , noise_level=__A , negative_prompt=__A , num_images_per_prompt=__A , eta=__A , generator=__A , latents=__A , ) current_count += 1 if callback is not None: callback({"progress": current_count / total_tile_count, "image": final_image} ) return final_image def lowercase_( ): '''simple docstring''' lowerCamelCase : Dict = "stabilityai/stable-diffusion-x4-upscaler" lowerCamelCase : Union[str, Any] = StableDiffusionTiledUpscalePipeline.from_pretrained(SCREAMING_SNAKE_CASE_ , revision="fp16" , torch_dtype=torch.floataa ) lowerCamelCase : Optional[Any] = pipe.to("cuda" ) lowerCamelCase : List[str] = Image.open("../../docs/source/imgs/diffusers_library.jpg" ) def callback(SCREAMING_SNAKE_CASE_ ): print(f"""progress: {obj['progress']:.4f}""" ) obj["image"].save("diffusers_library_progress.jpg" ) lowerCamelCase : int = pipe(image=SCREAMING_SNAKE_CASE_ , prompt="Black font, white background, vector" , noise_level=40 , callback=SCREAMING_SNAKE_CASE_ ) final_image.save("diffusers_library.jpg" ) if __name__ == "__main__": main()
283
1
'''simple docstring''' import argparse import os import re import torch from flax.traverse_util import flatten_dict from tax import checkpoints from transformers import ( AutoTokenizer, PixaStructConfig, PixaStructForConditionalGeneration, PixaStructImageProcessor, PixaStructProcessor, PixaStructTextConfig, PixaStructVisionConfig, ) def __lowerCamelCase ( __snake_case : Optional[Any] ) -> Optional[Any]: """simple docstring""" A__ : List[str] =checkpoints.load_tax_checkpoint(__snake_case ) A__ : Tuple =flatten_dict(__snake_case ) return flax_params def __lowerCamelCase ( __snake_case : int ) -> Optional[int]: """simple docstring""" A__ : Optional[Any] ={} A__ : int ={ """token_embedder""": """embeddings""", """encoder_norm""": """layernorm""", """kernel""": """weight""", """.out""": """.output""", """scale""": """weight""", """embedders_0.pos_embedding""": """row_embedder.weight""", """embedders_1.pos_embedding""": """column_embedder.weight""", } A__ : Any ={ """query""": """attention.query""", """key""": """attention.key""", """value""": """attention.value""", """output.dense""": """output""", """encoder_decoder_attention.o""": """encoder_decoder_attention.attention.o""", """pre_self_attention_layer_norm""": """self_attention.layer_norm""", """pre_cross_attention_layer_norm""": """encoder_decoder_attention.layer_norm""", """mlp.""": """mlp.DenseReluDense.""", """pre_mlp_layer_norm""": """mlp.layer_norm""", """self_attention.o""": """self_attention.attention.o""", """decoder.embeddings.embedding""": """decoder.embed_tokens.weight""", """decoder.relpos_bias.rel_embedding""": """decoder.layer.0.self_attention.attention.relative_attention_bias.weight""", """decoder.decoder_norm.weight""": """decoder.final_layer_norm.weight""", """decoder.logits_dense.weight""": """decoder.lm_head.weight""", } for key in flax_dict.keys(): if "target" in key: # remove the first prefix from the key A__ : Tuple =""".""".join(key[1:] ) # rename the key for old, new in CONVERSION_MAPPING.items(): A__ : str =new_key.replace(__snake_case, __snake_case ) if "decoder" in new_key: for old, new in DECODER_CONVERSION_MAPPING.items(): A__ : List[str] =new_key.replace(__snake_case, __snake_case ) if "layers" in new_key and "decoder" not in new_key: # use regex to replace the layer number A__ : str =re.sub(r"""layers_(\d+)""", r"""layer.\1""", __snake_case ) A__ : List[Any] =new_key.replace("""encoder""", """encoder.encoder""" ) elif "layers" in new_key and "decoder" in new_key: # use regex to replace the layer number A__ : Dict =re.sub(r"""layers_(\d+)""", r"""layer.\1""", __snake_case ) A__ : List[str] =flax_dict[key] A__ : List[Any] ={} # convert converted_dict into torch format for key in converted_dict.keys(): if ("embed_tokens" not in key) and ("embedder" not in key): A__ : str =torch.from_numpy(converted_dict[key].T ) else: A__ : int =torch.from_numpy(converted_dict[key] ) return converted_torch_dict def __lowerCamelCase ( __snake_case : str, __snake_case : Optional[int], __snake_case : Any=False, __snake_case : Tuple=False ) -> Optional[int]: """simple docstring""" A__ : List[Any] =get_flax_param(__snake_case ) if not use_large: A__ : Optional[int] =PixaStructVisionConfig() A__ : List[str] =PixaStructTextConfig() else: A__ : List[Any] =PixaStructVisionConfig( hidden_size=1_536, d_ff=3_968, num_attention_heads=24, num_hidden_layers=18 ) A__ : Optional[Any] =PixaStructTextConfig(hidden_size=1_536, d_ff=3_968, num_heads=24, num_layers=18 ) A__ : List[str] =PixaStructConfig( vision_config=encoder_config.to_dict(), text_config=decoder_config.to_dict(), is_vqa=__snake_case ) A__ : Dict =PixaStructForConditionalGeneration(__snake_case ) A__ : Union[str, Any] =rename_and_convert_flax_params(__snake_case ) model.load_state_dict(__snake_case ) A__ : Union[str, Any] =AutoTokenizer.from_pretrained("""ybelkada/test-pix2struct-tokenizer""" ) A__ : int =PixaStructImageProcessor() A__ : Union[str, Any] =PixaStructProcessor(image_processor=__snake_case, tokenizer=__snake_case ) if use_large: A__ : Tuple =4_096 A__ : Union[str, Any] =True # mkdir if needed os.makedirs(__snake_case, exist_ok=__snake_case ) model.save_pretrained(__snake_case ) processor.save_pretrained(__snake_case ) print("""Model saved in {}""".format(__snake_case ) ) if __name__ == "__main__": __snake_case : int = argparse.ArgumentParser() parser.add_argument('--t5x_checkpoint_path', default=None, type=str, help='Path to the original T5x checkpoint.') parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.') parser.add_argument('--use_large', action='store_true', help='Use large model.') parser.add_argument('--is_vqa', action='store_true', help='Use large model.') __snake_case : List[str] = parser.parse_args() convert_pixastruct_original_pytorch_checkpoint_to_hf( args.tax_checkpoint_path, args.pytorch_dump_folder_path, args.use_large )
367
'''simple docstring''' from __future__ import annotations from typing import Any class lowerCamelCase : '''simple docstring''' def __init__( self : List[str] , lowerCAmelCase_ : int ) -> None: '''simple docstring''' A__ : Any =num_of_nodes A__ : list[list[int]] =[] A__ : dict[int, int] ={} def lowercase__ ( self : Optional[Any] , lowerCAmelCase_ : int , lowerCAmelCase_ : int , lowerCAmelCase_ : int ) -> None: '''simple docstring''' self.m_edges.append([u_node, v_node, weight] ) def lowercase__ ( self : int , lowerCAmelCase_ : int ) -> int: '''simple docstring''' if self.m_component[u_node] == u_node: return u_node return self.find_component(self.m_component[u_node] ) def lowercase__ ( self : Optional[int] , lowerCAmelCase_ : int ) -> None: '''simple docstring''' if self.m_component[u_node] != u_node: for k in self.m_component: A__ : str =self.find_component(lowerCAmelCase_ ) def lowercase__ ( self : int , lowerCAmelCase_ : list[int] , lowerCAmelCase_ : int , lowerCAmelCase_ : int ) -> None: '''simple docstring''' if component_size[u_node] <= component_size[v_node]: A__ : int =v_node component_size[v_node] += component_size[u_node] self.set_component(lowerCAmelCase_ ) elif component_size[u_node] >= component_size[v_node]: A__ : List[str] =self.find_component(lowerCAmelCase_ ) component_size[u_node] += component_size[v_node] self.set_component(lowerCAmelCase_ ) def lowercase__ ( self : str ) -> None: '''simple docstring''' A__ : Union[str, Any] =[] A__ : List[str] =0 A__ : list[Any] =[-1] * self.m_num_of_nodes # A list of components (initialized to all of the nodes) for node in range(self.m_num_of_nodes ): self.m_component.update({node: node} ) component_size.append(1 ) A__ : List[str] =self.m_num_of_nodes while num_of_components > 1: for edge in self.m_edges: A__ , A__ , A__ : Any =edge A__ : Tuple =self.m_component[u] A__ : Optional[Any] =self.m_component[v] if u_component != v_component: for component in (u_component, v_component): if ( minimum_weight_edge[component] == -1 or minimum_weight_edge[component][2] > w ): A__ : Optional[int] =[u, v, w] for edge in minimum_weight_edge: if isinstance(lowerCAmelCase_ , lowerCAmelCase_ ): A__ , A__ , A__ : Tuple =edge A__ : Any =self.m_component[u] A__ : Optional[Any] =self.m_component[v] if u_component != v_component: mst_weight += w self.union(lowerCAmelCase_ , lowerCAmelCase_ , lowerCAmelCase_ ) print(f"Added edge [{u} - {v}]\nAdded weight: {w}\n" ) num_of_components -= 1 A__ : int =[-1] * self.m_num_of_nodes print(f"The total weight of the minimal spanning tree is: {mst_weight}" ) def __lowerCamelCase ( ) -> None: """simple docstring""" if __name__ == "__main__": import doctest doctest.testmod()
136
0
UpperCamelCase__ = ''' # Installazione di Transformers ! pip install transformers datasets # Per installare dalla fonte invece dell\'ultima versione rilasciata, commenta il comando sopra e # rimuovi la modalità commento al comando seguente. # ! pip install git+https://github.com/huggingface/transformers.git ''' UpperCamelCase__ = [{'''type''': '''code''', '''content''': INSTALL_CONTENT}] UpperCamelCase__ = { '''{processor_class}''': '''FakeProcessorClass''', '''{model_class}''': '''FakeModelClass''', '''{object_class}''': '''FakeObjectClass''', }
92
"""simple docstring""" import argparse import json import os from collections import OrderedDict import numpy as np import tensorflow as tf import torch def _SCREAMING_SNAKE_CASE ( _lowercase : List[Any] ) ->str: '''simple docstring''' a : Union[str, Any] = os.path.join(args.tf_model_dir , "parameters.json" ) a : str = json.loads(open(_lowercase ).read() ) if not params: raise ValueError( F"""It seems that the json file at {parameter_file} is empty. Make sure you have a correct json file.""" ) if not args.output.endswith(".pt" ): a : str = args.output + ".pt" a : Dict = OrderedDict() with tf.device("/CPU:0" ): a : Optional[int] = tf.train.load_checkpoint(args.tf_model_dir ) a : Optional[Any] = reader.get_variable_to_shape_map() for key_name in shapes.keys(): a : Dict = reader.get_tensor(_lowercase ).astype(np.floataa ) if key_name.endswith("/adam_m" ) or key_name.endswith("/adam_v" ): continue if key_name.startswith("pasts/" ): if key_name.startswith("pasts/mlp" ): a : Union[str, Any] = int(key_name[9] ) elif key_name.startswith("pasts/out" ): a : Optional[int] = 8 a : Dict = "model.sqout.%d.weight" % (player * 2) # enter to nn.Sequencial with Tanh, so 2 at a time a : int = vnp.transpose([1, 0] ).copy() # Mesh-Tensorflow is a diagonal matrix a : Dict = torch.tensor(_lowercase ) elif key_name.startswith("model/moe" ): a : List[str] = int(key_name[9:].split("/" )[0] ) if key_name.endswith("/switch_gating/kernel" ): a : str = "model.blocks.%d.feed_forward.mlp.router.classifier.weight" % player a : Tuple = vnp.transpose([1, 0] ).copy() # Mesh-Tensorflow is a diagonal matrix a : List[str] = torch.tensor(_lowercase ) elif key_name.endswith("/softmlp/kernel" ): a : Optional[int] = "model.blocks.%d.feed_forward.soft_bypass_mlp.weight" % player a : Tuple = vnp.transpose([1, 0] ).copy() # Mesh-Tensorflow is a diagonal matrix a : List[Any] = torch.tensor(_lowercase ) elif key_name.endswith("/wo/kernel" ) or key_name.endswith("/wi/kernel" ): a : Any = key_name[-9:-7] for i in range(16 ): a : List[Any] = "model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight" % (player, i, nlayer) a : str = ( vnp[i].transpose([1, 0] ).copy() ) # In Mesh-Tensorflow, it is one array, so it is divided a : Dict = torch.tensor(_lowercase ) elif key_name.startswith("model/mlp" ): a : Union[str, Any] = int(key_name[9:].split("/" )[0] ) if key_name.endswith("/p1/kernel" ): a : str = "model.blocks.%d.feed_forward.mlp.wi.weight" % player a : Dict = vnp.transpose([1, 0] ).copy() # Mesh-Tensorflow is a diagonal matrix a : Optional[int] = torch.tensor(_lowercase ) elif key_name.endswith("/p1/bias" ): a : str = "model.blocks.%d.feed_forward.mlp.wi.bias" % player a : List[Any] = vnp.copy() # same because it is one dimensional a : Tuple = torch.tensor(_lowercase ) elif key_name.endswith("/p2/kernel" ): a : Union[str, Any] = "model.blocks.%d.feed_forward.mlp.wo.weight" % player a : Tuple = vnp.transpose([1, 0] ).copy() # Mesh-Tensorflow is a diagonal matrix a : List[Any] = torch.tensor(_lowercase ) elif key_name.endswith("/p2/bias" ): a : Dict = "model.blocks.%d.feed_forward.mlp.wo.bias" % player a : List[str] = vnp.copy() # same because it is one dimensional a : str = torch.tensor(_lowercase ) elif key_name.startswith("model/ln" ): a : List[str] = int(key_name[8:].split("/" )[0] ) if key_name.endswith("/b" ): a : Optional[Any] = "model.blocks.%d.feed_forward.norm.bias" % player a : Tuple = vnp.copy() # same because it is one dimensional a : int = torch.tensor(_lowercase ) elif key_name.endswith("/g" ): a : Optional[Any] = "model.blocks.%d.feed_forward.norm.weight" % player a : List[str] = vnp.copy() # same because it is one dimensional a : Tuple = torch.tensor(_lowercase ) elif key_name.startswith("model/att" ): a : Optional[Any] = int(key_name[9:].split("/" )[0] ) if key_name.endswith("/qkv/kernel" ): a : Union[str, Any] = vnp.copy() # Compute same dimension as Mesh-tensorflow using einsum a : List[str] = state[:, 0, :, :] a : Dict = state[:, 1, :, :] a : Union[str, Any] = state[:, 2, :, :] a : str = ( state_q.reshape([state_q.shape[0], state_q.shape[1] * state_q.shape[2]] ) .transpose([1, 0] ) .copy() ) # Mesh-Tensorflow is a diagonal matrix a : List[str] = ( state_k.reshape([state_k.shape[0], state_k.shape[1] * state_k.shape[2]] ) .transpose([1, 0] ) .copy() ) # Mesh-Tensorflow is a diagonal matrix a : Dict = ( state_v.reshape([state_v.shape[0], state_v.shape[1] * state_v.shape[2]] ) .transpose([1, 0] ) .copy() ) # Mesh-Tensorflow is a diagonal matrix a : List[Any] = "model.blocks.%d.self_attn.self_attn.q_proj.weight" % player a : Union[str, Any] = torch.tensor(_lowercase ) a : Any = "model.blocks.%d.self_attn.self_attn.k_proj.weight" % player a : List[str] = torch.tensor(_lowercase ) a : Optional[Any] = "model.blocks.%d.self_attn.self_attn.v_proj.weight" % player a : Optional[Any] = torch.tensor(_lowercase ) elif key_name.endswith("/o/kernel" ): a : Any = "model.blocks.%d.self_attn.self_attn.out_proj.weight" % player a : Optional[int] = ( vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]] ).transpose([1, 0] ).copy() ) # Mesh-Tensorflow is a diagonal matrix a : Tuple = torch.tensor(_lowercase ) elif key_name.startswith("model/an" ): a : List[str] = int(key_name[8:].split("/" )[0] ) if key_name.endswith("/b" ): a : Optional[int] = "model.blocks.%d.self_attn.norm.bias" % player a : Union[str, Any] = vnp.copy() # same because it is one dimensional a : List[Any] = torch.tensor(_lowercase ) elif key_name.endswith("/g" ): a : Any = "model.blocks.%d.self_attn.norm.weight" % player a : str = vnp.copy() # same because it is one dimensional a : Any = torch.tensor(_lowercase ) elif ( key_name.startswith("model/wte" ) or key_name.startswith("model/wpe" ) or key_name.startswith("model/ete" ) ): a : Optional[int] = {"wte": "embed_tokens", "wpe": "position_embeddings", "ete": "extra_position_embeddings"}[ key_name[-3:] ] a : Tuple = "model.%s.weight" % nlayer a : Any = vnp.copy() # same in embedded a : Tuple = torch.tensor(_lowercase ) if key_name.startswith("model/wte" ): a : Optional[int] = "lm_head.weight" a : Optional[int] = vnp.copy() # same in embedded a : Optional[int] = torch.tensor(_lowercase ) elif key_name.startswith("model/wob" ): a : Optional[int] = "final_logits_bias" a : Optional[Any] = vnp.copy() # same in embedded a : Optional[int] = state.reshape((1, -1) ) a : List[Any] = torch.tensor(_lowercase ) elif key_name == "model/dense/kernel": a : Optional[int] = "model.last_project.weight" a : Union[str, Any] = vnp.transpose([1, 0] ).copy() # Mesh-Tensorflow is a diagonal matrix a : List[Any] = torch.tensor(_lowercase ) elif key_name == "model/dense_1/bias": a : Dict = "model.last_project.bias" a : Optional[Any] = vnp.copy() # same because it is one dimensional a : Any = torch.tensor(_lowercase ) torch.save(_lowercase , args.output ) if __name__ == "__main__": a : Optional[int] = argparse.ArgumentParser( description='''model converter.''', formatter_class=argparse.ArgumentDefaultsHelpFormatter ) parser.add_argument('''--tf_model_dir''', metavar='''PATH''', type=str, required=True, help='''import model''') parser.add_argument('''--output''', metavar='''PATH''', type=str, required=True, help='''output model''') a : Tuple = parser.parse_args() convert_tf_gptsan_to_pt(args)
105
0
import inspect from typing import Callable, List, Optional, Union import torch from transformers import ( CLIPImageProcessor, CLIPTextModel, CLIPTokenizer, WhisperForConditionalGeneration, WhisperProcessor, ) from diffusers import ( AutoencoderKL, DDIMScheduler, DiffusionPipeline, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel, ) from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker from diffusers.utils import logging lowercase__ :Union[str, Any] = logging.get_logger(__name__) # pylint: disable=invalid-name class lowercase ( SCREAMING_SNAKE_CASE__ ): def __init__( self ,A__ ,A__ ,A__ ,A__ ,A__ ,A__ ,A__ ,A__ ,A__ ,): super().__init__() if safety_checker is None: logger.warning( f'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure' ''' that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered''' ''' results in services or applications open to the public. Both the diffusers team and Hugging Face''' ''' strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling''' ''' it only for use-cases that involve analyzing network behavior or auditing its results. For more''' ''' information, please have a look at https://github.com/huggingface/diffusers/pull/254 .''') self.register_modules( speech_model=A__ ,speech_processor=A__ ,vae=A__ ,text_encoder=A__ ,tokenizer=A__ ,unet=A__ ,scheduler=A__ ,feature_extractor=A__ ,) def A__ ( self ,A__ = "auto"): if slice_size == "auto": lowercase = self.unet.config.attention_head_dim // 2 self.unet.set_attention_slice(A__) def A__ ( self): self.enable_attention_slicing(A__) @torch.no_grad() def __call__( self ,A__ ,A__=1_6_0_0_0 ,A__ = 5_1_2 ,A__ = 5_1_2 ,A__ = 5_0 ,A__ = 7.5 ,A__ = None ,A__ = 1 ,A__ = 0.0 ,A__ = None ,A__ = None ,A__ = "pil" ,A__ = True ,A__ = None ,A__ = 1 ,**A__ ,): lowercase = self.speech_processor.feature_extractor( A__ ,return_tensors='''pt''' ,sampling_rate=A__).input_features.to(self.device) lowercase = self.speech_model.generate(A__ ,max_length=4_8_0_0_0_0) lowercase = self.speech_processor.tokenizer.batch_decode(A__ ,skip_special_tokens=A__ ,normalize=A__)[ 0 ] if isinstance(A__ ,A__): lowercase = 1 elif isinstance(A__ ,A__): lowercase = len(A__) else: raise ValueError(f'`prompt` has to be of type `str` or `list` but is {type(A__)}') 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(A__ ,A__) or callback_steps <= 0) ): raise ValueError( f'`callback_steps` has to be a positive integer but is {callback_steps} of type' f' {type(A__)}.') # get prompt text embeddings lowercase = self.tokenizer( A__ ,padding='''max_length''' ,max_length=self.tokenizer.model_max_length ,return_tensors='''pt''' ,) lowercase = text_inputs.input_ids if text_input_ids.shape[-1] > self.tokenizer.model_max_length: lowercase = 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}') lowercase = text_input_ids[:, : self.tokenizer.model_max_length] lowercase = self.text_encoder(text_input_ids.to(self.device))[0] # duplicate text embeddings for each generation per prompt, using mps friendly method lowercase , lowercase , lowercase = text_embeddings.shape lowercase = text_embeddings.repeat(1 ,A__ ,1) lowercase = text_embeddings.view(bs_embed * num_images_per_prompt ,A__ ,-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. lowercase = guidance_scale > 1.0 # get unconditional embeddings for classifier free guidance if do_classifier_free_guidance: lowercase = 42 if negative_prompt is None: lowercase = [''''''] * 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__): lowercase = [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: lowercase = negative_prompt lowercase = text_input_ids.shape[-1] lowercase = self.tokenizer( A__ ,padding='''max_length''' ,max_length=A__ ,truncation=A__ ,return_tensors='''pt''' ,) lowercase = self.text_encoder(uncond_input.input_ids.to(self.device))[0] # duplicate unconditional embeddings for each generation per prompt, using mps friendly method lowercase = uncond_embeddings.shape[1] lowercase = uncond_embeddings.repeat(1 ,A__ ,1) lowercase = uncond_embeddings.view(batch_size * num_images_per_prompt ,A__ ,-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 lowercase = 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`. lowercase = (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8) lowercase = text_embeddings.dtype if latents is None: if self.device.type == "mps": # randn does not exist on mps lowercase = torch.randn(A__ ,generator=A__ ,device='''cpu''' ,dtype=A__).to( self.device) else: lowercase = torch.randn(A__ ,generator=A__ ,device=self.device ,dtype=A__) else: if latents.shape != latents_shape: raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {latents_shape}') lowercase = latents.to(self.device) # set timesteps self.scheduler.set_timesteps(A__) # Some schedulers like PNDM have timesteps as arrays # It's more optimized to move all timesteps to correct device beforehand lowercase = self.scheduler.timesteps.to(self.device) # scale the initial noise by the standard deviation required by the scheduler lowercase = 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] lowercase = '''eta''' in set(inspect.signature(self.scheduler.step).parameters.keys()) lowercase = {} if accepts_eta: lowercase = eta for i, t in enumerate(self.progress_bar(A__)): # expand the latents if we are doing classifier free guidance lowercase = torch.cat([latents] * 2) if do_classifier_free_guidance else latents lowercase = self.scheduler.scale_model_input(A__ ,A__) # predict the noise residual lowercase = self.unet(A__ ,A__ ,encoder_hidden_states=A__).sample # perform guidance if do_classifier_free_guidance: lowercase , lowercase = noise_pred.chunk(2) lowercase = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) # compute the previous noisy sample x_t -> x_t-1 lowercase = self.scheduler.step(A__ ,A__ ,A__ ,**A__).prev_sample # call the callback, if provided if callback is not None and i % callback_steps == 0: callback(A__ ,A__ ,A__) lowercase = 1 / 0.18215 * latents lowercase = self.vae.decode(A__).sample lowercase = (image / 2 + 0.5).clamp(0 ,1) # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16 lowercase = image.cpu().permute(0 ,2 ,3 ,1).float().numpy() if output_type == "pil": lowercase = self.numpy_to_pil(A__) if not return_dict: return image return StableDiffusionPipelineOutput(images=A__ ,nsfw_content_detected=A__)
97
from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow if is_tf_available(): import numpy as np import tensorflow as tf from transformers import TFXLMRobertaModel @require_tf @require_sentencepiece @require_tokenizers class lowercase ( unittest.TestCase ): @slow def A__ ( self): lowercase = TFXLMRobertaModel.from_pretrained('''jplu/tf-xlm-roberta-base''') lowercase = { '''input_ids''': tf.convert_to_tensor([[0, 2_6_4_6, 1_0_2_6_9, 8_3, 9_9_9_4_2, 2]] ,dtype=tf.intaa), # "My dog is cute" '''attention_mask''': tf.convert_to_tensor([[1, 1, 1, 1, 1, 1]] ,dtype=tf.intaa), } lowercase = model(A__)['''last_hidden_state'''] lowercase = tf.TensorShape((1, 6, 7_6_8)) self.assertEqual(output.shape ,A__) # compare the actual values for a slice. lowercase = tf.convert_to_tensor( [ [ [0.0681762, 0.10894451, 0.06772504], [-0.06423668, 0.02366615, 0.04329344], [-0.06057295, 0.09974135, -0.00070584], ] ] ,dtype=tf.floataa ,) self.assertTrue(np.allclose(output[:, :3, :3].numpy() ,expected_slice.numpy() ,atol=1E-4))
97
1
from __future__ import annotations import time from math import sqrt # 1 for manhattan, 0 for euclidean _snake_case : Union[str, Any] = 0 _snake_case : List[str] = [ [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], # 0 are free path whereas 1's are obstacles [0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], ] _snake_case : List[Any] = [[-1, 0], [0, -1], [1, 0], [0, 1]] # up, left, down, right _snake_case : int = tuple[int, int] class a : """simple docstring""" def __init__( self : int , lowerCamelCase : int , lowerCamelCase : int , lowerCamelCase : int , lowerCamelCase : int , lowerCamelCase : int , lowerCamelCase : Node | None , ) -> None: __snake_case : List[str] = pos_x __snake_case : List[str] = pos_y __snake_case : Dict = (pos_y, pos_x) __snake_case : List[Any] = goal_x __snake_case : Union[str, Any] = goal_y __snake_case : int = g_cost __snake_case : List[Any] = parent __snake_case : Optional[Any] = self.calculate_heuristic() __snake_case : Union[str, Any] = self.g_cost + self.h_cost def __snake_case ( self : Optional[int] ) -> float: __snake_case : Union[str, Any] = self.pos_x - self.goal_x __snake_case : Tuple = self.pos_y - self.goal_y if HEURISTIC == 1: return abs(lowerCamelCase ) + abs(lowerCamelCase ) else: return sqrt(dy**2 + dx**2 ) def __lt__( self : Optional[int] , lowerCamelCase : Node ) -> bool: return self.f_cost < other.f_cost class a : """simple docstring""" def __init__( self : List[Any] , lowerCamelCase : TPosition , lowerCamelCase : TPosition ) -> Optional[Any]: __snake_case : Any = Node(start[1] , start[0] , goal[1] , goal[0] , 0 , lowerCamelCase ) __snake_case : Tuple = Node(goal[1] , goal[0] , goal[1] , goal[0] , 99999 , lowerCamelCase ) __snake_case : str = [self.start] __snake_case : list[Node] = [] __snake_case : int = False def __snake_case ( self : Tuple ) -> list[TPosition]: while self.open_nodes: # Open Nodes are sorted using __lt__ self.open_nodes.sort() __snake_case : Dict = self.open_nodes.pop(0 ) if current_node.pos == self.target.pos: return self.retrace_path(lowerCamelCase ) self.closed_nodes.append(lowerCamelCase ) __snake_case : Tuple = self.get_successors(lowerCamelCase ) for child_node in successors: if child_node in self.closed_nodes: continue if child_node not in self.open_nodes: self.open_nodes.append(lowerCamelCase ) else: # retrieve the best current path __snake_case : Any = self.open_nodes.pop(self.open_nodes.index(lowerCamelCase ) ) if child_node.g_cost < better_node.g_cost: self.open_nodes.append(lowerCamelCase ) else: self.open_nodes.append(lowerCamelCase ) return [self.start.pos] def __snake_case ( self : Optional[Any] , lowerCamelCase : Node ) -> list[Node]: __snake_case : int = [] for action in delta: __snake_case : Tuple = parent.pos_x + action[1] __snake_case : Tuple = parent.pos_y + action[0] if not (0 <= pos_x <= len(grid[0] ) - 1 and 0 <= pos_y <= len(lowerCamelCase ) - 1): continue if grid[pos_y][pos_x] != 0: continue successors.append( Node( lowerCamelCase , lowerCamelCase , self.target.pos_y , self.target.pos_x , parent.g_cost + 1 , lowerCamelCase , ) ) return successors def __snake_case ( self : Optional[Any] , lowerCamelCase : Node | None ) -> list[TPosition]: __snake_case : List[Any] = node __snake_case : Optional[int] = [] while current_node is not None: path.append((current_node.pos_y, current_node.pos_x) ) __snake_case : Tuple = current_node.parent path.reverse() return path class a : """simple docstring""" def __init__( self : Optional[Any] , lowerCamelCase : TPosition , lowerCamelCase : TPosition ) -> None: __snake_case : str = AStar(lowerCamelCase , lowerCamelCase ) __snake_case : int = AStar(lowerCamelCase , lowerCamelCase ) __snake_case : int = False def __snake_case ( self : str ) -> list[TPosition]: while self.fwd_astar.open_nodes or self.bwd_astar.open_nodes: self.fwd_astar.open_nodes.sort() self.bwd_astar.open_nodes.sort() __snake_case : Optional[int] = self.fwd_astar.open_nodes.pop(0 ) __snake_case : str = self.bwd_astar.open_nodes.pop(0 ) if current_bwd_node.pos == current_fwd_node.pos: return self.retrace_bidirectional_path( lowerCamelCase , lowerCamelCase ) self.fwd_astar.closed_nodes.append(lowerCamelCase ) self.bwd_astar.closed_nodes.append(lowerCamelCase ) __snake_case : Optional[Any] = current_bwd_node __snake_case : Any = current_fwd_node __snake_case : int = { self.fwd_astar: self.fwd_astar.get_successors(lowerCamelCase ), self.bwd_astar: self.bwd_astar.get_successors(lowerCamelCase ), } for astar in [self.fwd_astar, self.bwd_astar]: for child_node in successors[astar]: if child_node in astar.closed_nodes: continue if child_node not in astar.open_nodes: astar.open_nodes.append(lowerCamelCase ) else: # retrieve the best current path __snake_case : Optional[int] = astar.open_nodes.pop( astar.open_nodes.index(lowerCamelCase ) ) if child_node.g_cost < better_node.g_cost: astar.open_nodes.append(lowerCamelCase ) else: astar.open_nodes.append(lowerCamelCase ) return [self.fwd_astar.start.pos] def __snake_case ( self : Any , lowerCamelCase : Node , lowerCamelCase : Node ) -> list[TPosition]: __snake_case : Optional[int] = self.fwd_astar.retrace_path(lowerCamelCase ) __snake_case : Optional[Any] = self.bwd_astar.retrace_path(lowerCamelCase ) bwd_path.pop() bwd_path.reverse() __snake_case : int = fwd_path + bwd_path return path if __name__ == "__main__": # all coordinates are given in format [y,x] _snake_case : Dict = (0, 0) _snake_case : Any = (len(grid) - 1, len(grid[0]) - 1) for elem in grid: print(elem) _snake_case : List[Any] = time.time() _snake_case : Dict = AStar(init, goal) _snake_case : Optional[int] = a_star.search() _snake_case : Optional[Any] = time.time() - start_time print(f'''AStar execution time = {end_time:f} seconds''') _snake_case : List[str] = time.time() _snake_case : Any = BidirectionalAStar(init, goal) _snake_case : List[str] = time.time() - bd_start_time print(f'''BidirectionalAStar execution time = {bd_end_time:f} seconds''')
123
import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging _snake_case : List[Any] = logging.get_logger(__name__) _snake_case : List[Any] = "▁" _snake_case : Union[str, Any] = {"vocab_file": "sentencepiece.bpe.model"} _snake_case : Any = { "vocab_file": { "facebook/xglm-564M": "https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model", } } _snake_case : Union[str, Any] = { "facebook/xglm-564M": 2_048, } class a (_lowerCAmelCase ): """simple docstring""" __UpperCAmelCase : Dict = VOCAB_FILES_NAMES __UpperCAmelCase : str = PRETRAINED_VOCAB_FILES_MAP __UpperCAmelCase : int = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES __UpperCAmelCase : Any = ["input_ids", "attention_mask"] def __init__( self : Tuple , lowerCamelCase : Tuple , lowerCamelCase : Optional[int]="<s>" , lowerCamelCase : int="</s>" , lowerCamelCase : Dict="</s>" , lowerCamelCase : Tuple="<s>" , lowerCamelCase : List[str]="<unk>" , lowerCamelCase : str="<pad>" , lowerCamelCase : Optional[Dict[str, Any]] = None , **lowerCamelCase : int , ) -> None: __snake_case : List[str] = {} if sp_model_kwargs is None else sp_model_kwargs # Compatibility with the original tokenizer __snake_case : Tuple = 7 __snake_case : Optional[int] = [F'<madeupword{i}>' for i in range(self.num_madeup_words )] __snake_case : Tuple = kwargs.get("additional_special_tokens" , [] ) kwargs["additional_special_tokens"] += [ word for word in madeup_words if word not in kwargs["additional_special_tokens"] ] super().__init__( bos_token=lowerCamelCase , eos_token=lowerCamelCase , unk_token=lowerCamelCase , sep_token=lowerCamelCase , cls_token=lowerCamelCase , pad_token=lowerCamelCase , sp_model_kwargs=self.sp_model_kwargs , **lowerCamelCase , ) __snake_case : List[Any] = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(lowerCamelCase ) ) __snake_case : List[str] = vocab_file # Original fairseq vocab and spm vocab must be "aligned": # Vocab | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ---- # fairseq | '<s>' | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's' | '▁de' | '-' # spm | '<unk>' | '<s>' | '</s>' | ',' | '.' | '▁' | 's' | '▁de' | '-' | '▁a' # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab __snake_case : Optional[Any] = 1 # Mimic fairseq token-to-id alignment for the first 4 token __snake_case : List[Any] = {"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3} __snake_case : Union[str, Any] = len(self.sp_model ) __snake_case : Union[str, Any] = {F'<madeupword{i}>': sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words )} self.fairseq_tokens_to_ids.update(lowerCamelCase ) __snake_case : Dict = {v: k for k, v in self.fairseq_tokens_to_ids.items()} def __getstate__( self : Dict ) -> List[Any]: __snake_case : Any = self.__dict__.copy() __snake_case : str = None __snake_case : str = self.sp_model.serialized_model_proto() return state def __setstate__( self : Tuple , lowerCamelCase : Union[str, Any] ) -> Optional[Any]: __snake_case : Optional[Any] = d # for backward compatibility if not hasattr(self , "sp_model_kwargs" ): __snake_case : List[str] = {} __snake_case : Tuple = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.LoadFromSerializedProto(self.sp_model_proto ) def __snake_case ( self : List[str] , lowerCamelCase : List[int] , lowerCamelCase : Optional[List[int]] = None ) -> List[int]: if token_ids_a is None: return [self.sep_token_id] + token_ids_a __snake_case : int = [self.sep_token_id] return sep + token_ids_a + sep + sep + token_ids_a def __snake_case ( self : Dict , lowerCamelCase : List[int] , lowerCamelCase : Optional[List[int]] = None , lowerCamelCase : bool = False ) -> List[int]: if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=lowerCamelCase , token_ids_a=lowerCamelCase , already_has_special_tokens=lowerCamelCase ) if token_ids_a is None: return [1] + ([0] * len(lowerCamelCase )) return [1] + ([0] * len(lowerCamelCase )) + [1, 1] + ([0] * len(lowerCamelCase )) def __snake_case ( self : Dict , lowerCamelCase : List[int] , lowerCamelCase : Optional[List[int]] = None ) -> List[int]: __snake_case : str = [self.sep_token_id] if token_ids_a is None: return len(sep + token_ids_a ) * [0] return len(sep + token_ids_a + sep + sep + token_ids_a ) * [0] @property def __snake_case ( self : Any ) -> List[str]: return len(self.sp_model ) + self.fairseq_offset + self.num_madeup_words def __snake_case ( self : Union[str, Any] ) -> Tuple: __snake_case : Optional[int] = {self.convert_ids_to_tokens(lowerCamelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __snake_case ( self : int , lowerCamelCase : str ) -> List[str]: return self.sp_model.encode(lowerCamelCase , out_type=lowerCamelCase ) def __snake_case ( self : Any , lowerCamelCase : Any ) -> Optional[int]: if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] __snake_case : Optional[Any] = self.sp_model.PieceToId(lowerCamelCase ) # Need to return unknown token if the SP model returned 0 return spm_id + self.fairseq_offset if spm_id else self.unk_token_id def __snake_case ( self : Any , lowerCamelCase : int ) -> 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 __snake_case ( self : int , lowerCamelCase : str ) -> Tuple: __snake_case : Optional[Any] = "".join(lowerCamelCase ).replace(lowerCamelCase , " " ).strip() return out_string def __snake_case ( self : List[str] , lowerCamelCase : str , lowerCamelCase : Optional[str] = None ) -> Tuple[str]: if not os.path.isdir(lowerCamelCase ): logger.error(F'Vocabulary path ({save_directory}) should be a directory' ) return __snake_case : str = os.path.join( lowerCamelCase , (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowerCamelCase ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , lowerCamelCase ) elif not os.path.isfile(self.vocab_file ): with open(lowerCamelCase , "wb" ) as fi: __snake_case : Any = self.sp_model.serialized_model_proto() fi.write(lowerCamelCase ) return (out_vocab_file,)
123
1
def __UpperCamelCase ( lowerCAmelCase__ : list[list[int | float]] ): __a : int = len(lowerCAmelCase__ ) __a : Dict = len(matrix[0] ) __a : Union[str, Any] = min(lowerCAmelCase__ , lowerCAmelCase__ ) for row in range(lowerCAmelCase__ ): # Check if diagonal element is not zero if matrix[row][row] != 0: # Eliminate all the elements below the diagonal for col in range(row + 1 , lowerCAmelCase__ ): __a : Dict = matrix[col][row] / matrix[row][row] for i in range(lowerCAmelCase__ , lowerCAmelCase__ ): matrix[col][i] -= multiplier * matrix[row][i] else: # Find a non-zero diagonal element to swap rows __a : Optional[int] = True for i in range(row + 1 , lowerCAmelCase__ ): if matrix[i][row] != 0: __a , __a : Any = matrix[i], matrix[row] __a : Union[str, Any] = False break if reduce: rank -= 1 for i in range(lowerCAmelCase__ ): __a : Optional[Any] = matrix[i][rank] # Reduce the row pointer by one to stay on the same row row -= 1 return rank if __name__ == "__main__": import doctest doctest.testmod()
90
def __UpperCamelCase ( lowerCAmelCase__ : list[list[int | float]] ): __a : int = len(lowerCAmelCase__ ) __a : Dict = len(matrix[0] ) __a : Union[str, Any] = min(lowerCAmelCase__ , lowerCAmelCase__ ) for row in range(lowerCAmelCase__ ): # Check if diagonal element is not zero if matrix[row][row] != 0: # Eliminate all the elements below the diagonal for col in range(row + 1 , lowerCAmelCase__ ): __a : Dict = matrix[col][row] / matrix[row][row] for i in range(lowerCAmelCase__ , lowerCAmelCase__ ): matrix[col][i] -= multiplier * matrix[row][i] else: # Find a non-zero diagonal element to swap rows __a : Optional[int] = True for i in range(row + 1 , lowerCAmelCase__ ): if matrix[i][row] != 0: __a , __a : Any = matrix[i], matrix[row] __a : Union[str, Any] = False break if reduce: rank -= 1 for i in range(lowerCAmelCase__ ): __a : Optional[Any] = matrix[i][rank] # Reduce the row pointer by one to stay on the same row row -= 1 return rank if __name__ == "__main__": import doctest doctest.testmod()
90
1
from ...configuration_utils import PretrainedConfig from ...utils import logging UpperCamelCase = logging.get_logger(__name__) UpperCamelCase = { '''microsoft/cvt-13''': '''https://huggingface.co/microsoft/cvt-13/resolve/main/config.json''', # See all Cvt models at https://huggingface.co/models?filter=cvt } class snake_case_ ( __A ): __A : str = "cvt" def __init__( self : Dict , lowercase_ : int=3 , lowercase_ : Optional[Any]=[7, 3, 3] , lowercase_ : Dict=[4, 2, 2] , lowercase_ : List[Any]=[2, 1, 1] , lowercase_ : Union[str, Any]=[64, 1_92, 3_84] , lowercase_ : Union[str, Any]=[1, 3, 6] , lowercase_ : Optional[Any]=[1, 2, 10] , lowercase_ : Tuple=[4.0, 4.0, 4.0] , lowercase_ : Tuple=[0.0, 0.0, 0.0] , lowercase_ : str=[0.0, 0.0, 0.0] , lowercase_ : Union[str, Any]=[0.0, 0.0, 0.1] , lowercase_ : int=[True, True, True] , lowercase_ : str=[False, False, True] , lowercase_ : Dict=["dw_bn", "dw_bn", "dw_bn"] , lowercase_ : Any=[3, 3, 3] , lowercase_ : Dict=[1, 1, 1] , lowercase_ : Any=[2, 2, 2] , lowercase_ : List[str]=[1, 1, 1] , lowercase_ : Any=[1, 1, 1] , lowercase_ : List[Any]=0.02 , lowercase_ : Optional[int]=1E-12 , **lowercase_ : Any , ) -> List[Any]: super().__init__(**lowercase_ ) lowercase__ : Tuple = num_channels lowercase__ : Optional[Any] = patch_sizes lowercase__ : Optional[int] = patch_stride lowercase__ : Tuple = patch_padding lowercase__ : Dict = embed_dim lowercase__ : str = num_heads lowercase__ : Dict = depth lowercase__ : List[str] = mlp_ratio lowercase__ : Any = attention_drop_rate lowercase__ : Union[str, Any] = drop_rate lowercase__ : Optional[int] = drop_path_rate lowercase__ : Any = qkv_bias lowercase__ : Optional[Any] = cls_token lowercase__ : Optional[Any] = qkv_projection_method lowercase__ : Optional[Any] = kernel_qkv lowercase__ : Optional[int] = padding_kv lowercase__ : Union[str, Any] = stride_kv lowercase__ : str = padding_q lowercase__ : Optional[Any] = stride_q lowercase__ : Tuple = initializer_range lowercase__ : str = layer_norm_eps
87
import shutil import tempfile import unittest from unittest.mock import patch from transformers import ( DefaultFlowCallback, IntervalStrategy, PrinterCallback, ProgressCallback, Trainer, TrainerCallback, TrainingArguments, is_torch_available, ) from transformers.testing_utils import require_torch if is_torch_available(): from transformers.trainer import DEFAULT_CALLBACKS from .test_trainer import RegressionDataset, RegressionModelConfig, RegressionPreTrainedModel class lowerCAmelCase__ ( __lowercase ): def __init__( self : int ) -> Optional[int]: __lowerCamelCase = [] def __A ( self : Any , SCREAMING_SNAKE_CASE__ : List[Any] , SCREAMING_SNAKE_CASE__ : List[Any] , SCREAMING_SNAKE_CASE__ : str , **SCREAMING_SNAKE_CASE__ : List[Any] ) -> Tuple: self.events.append('''on_init_end''' ) def __A ( self : Tuple , SCREAMING_SNAKE_CASE__ : Optional[int] , SCREAMING_SNAKE_CASE__ : Optional[Any] , SCREAMING_SNAKE_CASE__ : Optional[int] , **SCREAMING_SNAKE_CASE__ : Optional[Any] ) -> Any: self.events.append('''on_train_begin''' ) def __A ( self : str , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : Any , SCREAMING_SNAKE_CASE__ : Dict , **SCREAMING_SNAKE_CASE__ : int ) -> Any: self.events.append('''on_train_end''' ) def __A ( self : Union[str, Any] , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : List[Any] , SCREAMING_SNAKE_CASE__ : List[Any] , **SCREAMING_SNAKE_CASE__ : List[Any] ) -> int: self.events.append('''on_epoch_begin''' ) def __A ( self : Optional[Any] , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : Any , SCREAMING_SNAKE_CASE__ : Optional[Any] , **SCREAMING_SNAKE_CASE__ : Tuple ) -> Optional[Any]: self.events.append('''on_epoch_end''' ) def __A ( self : str , SCREAMING_SNAKE_CASE__ : Tuple , SCREAMING_SNAKE_CASE__ : Optional[Any] , SCREAMING_SNAKE_CASE__ : Union[str, Any] , **SCREAMING_SNAKE_CASE__ : str ) -> List[Any]: self.events.append('''on_step_begin''' ) def __A ( self : Any , SCREAMING_SNAKE_CASE__ : List[Any] , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : Any , **SCREAMING_SNAKE_CASE__ : Optional[int] ) -> Tuple: self.events.append('''on_step_end''' ) def __A ( self : int , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : int , **SCREAMING_SNAKE_CASE__ : List[Any] ) -> Union[str, Any]: self.events.append('''on_evaluate''' ) def __A ( self : Union[str, Any] , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : str , **SCREAMING_SNAKE_CASE__ : str ) -> str: self.events.append('''on_predict''' ) def __A ( self : Optional[int] , SCREAMING_SNAKE_CASE__ : int , SCREAMING_SNAKE_CASE__ : List[Any] , SCREAMING_SNAKE_CASE__ : Optional[int] , **SCREAMING_SNAKE_CASE__ : Optional[Any] ) -> Tuple: self.events.append('''on_save''' ) def __A ( self : Optional[int] , SCREAMING_SNAKE_CASE__ : Dict , SCREAMING_SNAKE_CASE__ : Union[str, Any] , SCREAMING_SNAKE_CASE__ : Union[str, Any] , **SCREAMING_SNAKE_CASE__ : List[str] ) -> List[str]: self.events.append('''on_log''' ) def __A ( self : int , SCREAMING_SNAKE_CASE__ : List[Any] , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : List[Any] , **SCREAMING_SNAKE_CASE__ : Optional[int] ) -> str: self.events.append('''on_prediction_step''' ) @require_torch class lowerCAmelCase__ ( unittest.TestCase ): def __A ( self : Union[str, Any] ) -> Optional[Any]: __lowerCamelCase = tempfile.mkdtemp() def __A ( self : int ) -> List[str]: shutil.rmtree(self.output_dir ) def __A ( self : Tuple , SCREAMING_SNAKE_CASE__ : List[Any]=0 , SCREAMING_SNAKE_CASE__ : Any=0 , SCREAMING_SNAKE_CASE__ : List[str]=64 , SCREAMING_SNAKE_CASE__ : Optional[int]=64 , SCREAMING_SNAKE_CASE__ : Optional[int]=None , SCREAMING_SNAKE_CASE__ : Optional[int]=False , **SCREAMING_SNAKE_CASE__ : Optional[Any] ) -> Union[str, Any]: # disable_tqdm in TrainingArguments has a flaky default since it depends on the level of logging. We make sure # its set to False since the tests later on depend on its value. __lowerCamelCase = RegressionDataset(length=SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = RegressionDataset(length=SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = RegressionModelConfig(a=SCREAMING_SNAKE_CASE__ , b=SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = RegressionPreTrainedModel(SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = TrainingArguments(self.output_dir , disable_tqdm=SCREAMING_SNAKE_CASE__ , report_to=[] , **SCREAMING_SNAKE_CASE__ ) return Trainer( SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , train_dataset=SCREAMING_SNAKE_CASE__ , eval_dataset=SCREAMING_SNAKE_CASE__ , callbacks=SCREAMING_SNAKE_CASE__ , ) def __A ( self : List[Any] , SCREAMING_SNAKE_CASE__ : List[str] , SCREAMING_SNAKE_CASE__ : str ) -> Optional[int]: self.assertEqual(len(SCREAMING_SNAKE_CASE__ ) , len(SCREAMING_SNAKE_CASE__ ) ) # Order doesn't matter __lowerCamelCase = sorted(SCREAMING_SNAKE_CASE__ , key=lambda SCREAMING_SNAKE_CASE__ : cb.__name__ if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) else cb.__class__.__name__ ) __lowerCamelCase = sorted(SCREAMING_SNAKE_CASE__ , key=lambda SCREAMING_SNAKE_CASE__ : cb.__name__ if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) else cb.__class__.__name__ ) for cba, cba in zip(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): if isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): self.assertEqual(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) elif isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): self.assertEqual(SCREAMING_SNAKE_CASE__ , cba.__class__ ) elif not isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) and isinstance(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ): self.assertEqual(cba.__class__ , SCREAMING_SNAKE_CASE__ ) else: self.assertEqual(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) def __A ( self : Union[str, Any] , SCREAMING_SNAKE_CASE__ : Optional[int] ) -> Tuple: __lowerCamelCase = ['''on_init_end''', '''on_train_begin'''] __lowerCamelCase = 0 __lowerCamelCase = len(trainer.get_eval_dataloader() ) __lowerCamelCase = ['''on_prediction_step'''] * len(trainer.get_eval_dataloader() ) + ['''on_log''', '''on_evaluate'''] for _ in range(trainer.state.num_train_epochs ): expected_events.append('''on_epoch_begin''' ) for _ in range(SCREAMING_SNAKE_CASE__ ): step += 1 expected_events += ["on_step_begin", "on_step_end"] if step % trainer.args.logging_steps == 0: expected_events.append('''on_log''' ) if trainer.args.evaluation_strategy == IntervalStrategy.STEPS and step % trainer.args.eval_steps == 0: expected_events += evaluation_events.copy() if step % trainer.args.save_steps == 0: expected_events.append('''on_save''' ) expected_events.append('''on_epoch_end''' ) if trainer.args.evaluation_strategy == IntervalStrategy.EPOCH: expected_events += evaluation_events.copy() expected_events += ["on_log", "on_train_end"] return expected_events def __A ( self : Union[str, Any] ) -> int: __lowerCamelCase = self.get_trainer() __lowerCamelCase = DEFAULT_CALLBACKS.copy() + [ProgressCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) # Callbacks passed at init are added to the default callbacks __lowerCamelCase = self.get_trainer(callbacks=[MyTestTrainerCallback] ) expected_callbacks.append(SCREAMING_SNAKE_CASE__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) # TrainingArguments.disable_tqdm controls if use ProgressCallback or PrinterCallback __lowerCamelCase = self.get_trainer(disable_tqdm=SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = DEFAULT_CALLBACKS.copy() + [PrinterCallback] self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) def __A ( self : List[Any] ) -> str: __lowerCamelCase = DEFAULT_CALLBACKS.copy() + [ProgressCallback] __lowerCamelCase = self.get_trainer() # We can add, pop, or remove by class name trainer.remove_callback(SCREAMING_SNAKE_CASE__ ) expected_callbacks.remove(SCREAMING_SNAKE_CASE__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = self.get_trainer() __lowerCamelCase = trainer.pop_callback(SCREAMING_SNAKE_CASE__ ) self.assertEqual(cb.__class__ , SCREAMING_SNAKE_CASE__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) trainer.add_callback(SCREAMING_SNAKE_CASE__ ) expected_callbacks.insert(0 , SCREAMING_SNAKE_CASE__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) # We can also add, pop, or remove by instance __lowerCamelCase = self.get_trainer() __lowerCamelCase = trainer.callback_handler.callbacks[0] trainer.remove_callback(SCREAMING_SNAKE_CASE__ ) expected_callbacks.remove(SCREAMING_SNAKE_CASE__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = self.get_trainer() __lowerCamelCase = trainer.callback_handler.callbacks[0] __lowerCamelCase = trainer.pop_callback(SCREAMING_SNAKE_CASE__ ) self.assertEqual(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) trainer.add_callback(SCREAMING_SNAKE_CASE__ ) expected_callbacks.insert(0 , SCREAMING_SNAKE_CASE__ ) self.check_callbacks_equality(trainer.callback_handler.callbacks , SCREAMING_SNAKE_CASE__ ) def __A ( self : Union[str, Any] ) -> Any: import warnings # XXX: for now ignore scatter_gather warnings in this test since it's not relevant to what's being tested warnings.simplefilter(action='''ignore''' , category=SCREAMING_SNAKE_CASE__ ) __lowerCamelCase = self.get_trainer(callbacks=[MyTestTrainerCallback] ) trainer.train() __lowerCamelCase = trainer.callback_handler.callbacks[-2].events self.assertEqual(SCREAMING_SNAKE_CASE__ , self.get_expected_events(SCREAMING_SNAKE_CASE__ ) ) # Independent log/save/eval __lowerCamelCase = self.get_trainer(callbacks=[MyTestTrainerCallback] , logging_steps=5 ) trainer.train() __lowerCamelCase = trainer.callback_handler.callbacks[-2].events self.assertEqual(SCREAMING_SNAKE_CASE__ , self.get_expected_events(SCREAMING_SNAKE_CASE__ ) ) __lowerCamelCase = self.get_trainer(callbacks=[MyTestTrainerCallback] , save_steps=5 ) trainer.train() __lowerCamelCase = trainer.callback_handler.callbacks[-2].events self.assertEqual(SCREAMING_SNAKE_CASE__ , self.get_expected_events(SCREAMING_SNAKE_CASE__ ) ) __lowerCamelCase = self.get_trainer(callbacks=[MyTestTrainerCallback] , eval_steps=5 , evaluation_strategy='''steps''' ) trainer.train() __lowerCamelCase = trainer.callback_handler.callbacks[-2].events self.assertEqual(SCREAMING_SNAKE_CASE__ , self.get_expected_events(SCREAMING_SNAKE_CASE__ ) ) __lowerCamelCase = self.get_trainer(callbacks=[MyTestTrainerCallback] , evaluation_strategy='''epoch''' ) trainer.train() __lowerCamelCase = trainer.callback_handler.callbacks[-2].events self.assertEqual(SCREAMING_SNAKE_CASE__ , self.get_expected_events(SCREAMING_SNAKE_CASE__ ) ) # A bit of everything __lowerCamelCase = self.get_trainer( callbacks=[MyTestTrainerCallback] , logging_steps=3 , save_steps=10 , eval_steps=5 , evaluation_strategy='''steps''' , ) trainer.train() __lowerCamelCase = trainer.callback_handler.callbacks[-2].events self.assertEqual(SCREAMING_SNAKE_CASE__ , self.get_expected_events(SCREAMING_SNAKE_CASE__ ) ) # warning should be emitted for duplicated callbacks with patch('''transformers.trainer_callback.logger.warning''' ) as warn_mock: __lowerCamelCase = self.get_trainer( callbacks=[MyTestTrainerCallback, MyTestTrainerCallback] , ) assert str(SCREAMING_SNAKE_CASE__ ) in warn_mock.call_args[0][0]
270
0
import copy import os from typing import Union from ...configuration_utils import PretrainedConfig from ...utils import logging __A = logging.get_logger(__name__) __A = { '''microsoft/git-base''': '''https://huggingface.co/microsoft/git-base/resolve/main/config.json''', } class lowercase_ ( _snake_case ): UpperCamelCase_ : Optional[int] = "git_vision_model" def __init__( self : Optional[int] , A__ : Optional[Any]=768 , A__ : Optional[Any]=3072 , A__ : str=12 , A__ : Any=12 , A__ : Tuple=3 , A__ : Optional[int]=224 , A__ : Optional[int]=16 , A__ : Optional[Any]="quick_gelu" , A__ : List[Any]=1e-5 , A__ : str=0.0 , A__ : Optional[Any]=0.02 , **A__ : List[Any] , ) -> Union[str, Any]: super().__init__(**UpperCamelCase__ ) _snake_case = hidden_size _snake_case = intermediate_size _snake_case = num_hidden_layers _snake_case = num_attention_heads _snake_case = num_channels _snake_case = patch_size _snake_case = image_size _snake_case = initializer_range _snake_case = attention_dropout _snake_case = layer_norm_eps _snake_case = hidden_act @classmethod def UpperCamelCase_ ( cls : Union[str, Any] , A__ : List[Any] , **A__ : int ) -> "PretrainedConfig": cls._set_token_in_kwargs(UpperCamelCase__ ) _snake_case, _snake_case = cls.get_config_dict(UpperCamelCase__ , **UpperCamelCase__ ) # get the vision config dict if we are loading from GITConfig if config_dict.get('''model_type''' ) == "git": _snake_case = config_dict['''vision_config'''] if "model_type" in config_dict and hasattr(cls , '''model_type''' ) and config_dict["model_type"] != cls.model_type: logger.warning( f"""You are using a model of type {config_dict['model_type']} to instantiate a model of type """ f"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""" ) return cls.from_dict(UpperCamelCase__ , **UpperCamelCase__ ) class lowercase_ ( _snake_case ): UpperCamelCase_ : Union[str, Any] = "git" def __init__( self : Any , A__ : Any=None , A__ : Dict=30522 , A__ : List[str]=768 , A__ : Union[str, Any]=6 , A__ : Dict=12 , A__ : int=3072 , A__ : Any="gelu" , A__ : List[str]=0.1 , A__ : List[str]=0.1 , A__ : Optional[Any]=1024 , A__ : List[Any]=0.02 , A__ : Optional[Any]=1e-12 , A__ : str=0 , A__ : Optional[Any]="absolute" , A__ : Dict=True , A__ : Tuple=False , A__ : Optional[int]=101 , A__ : List[str]=102 , A__ : List[Any]=None , **A__ : Dict , ) -> Union[str, Any]: super().__init__(bos_token_id=UpperCamelCase__ , eos_token_id=UpperCamelCase__ , pad_token_id=UpperCamelCase__ , **UpperCamelCase__ ) if vision_config is None: _snake_case = {} logger.info('''vision_config is None. initializing the GitVisionConfig with default values.''' ) _snake_case = GitVisionConfig(**UpperCamelCase__ ) _snake_case = vocab_size _snake_case = hidden_size _snake_case = num_hidden_layers _snake_case = num_attention_heads _snake_case = hidden_act _snake_case = intermediate_size _snake_case = hidden_dropout_prob _snake_case = attention_probs_dropout_prob _snake_case = max_position_embeddings _snake_case = initializer_range _snake_case = layer_norm_eps _snake_case = position_embedding_type _snake_case = use_cache _snake_case = tie_word_embeddings _snake_case = num_image_with_embedding _snake_case = bos_token_id _snake_case = eos_token_id def UpperCamelCase_ ( self : List[Any] ) -> Optional[int]: _snake_case = copy.deepcopy(self.__dict__ ) _snake_case = self.vision_config.to_dict() _snake_case = self.__class__.model_type return output
363
import argparse import torch from ...utils import logging from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert logging.set_verbosity_info() def snake_case_(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) -> Optional[Any]: """simple docstring""" _snake_case = AlbertConfig.from_json_file(_UpperCamelCase ) print(F"""Building PyTorch model from configuration: {config}""" ) _snake_case = AlbertForPreTraining(_UpperCamelCase ) # Load weights from tf checkpoint load_tf_weights_in_albert(_UpperCamelCase , _UpperCamelCase , _UpperCamelCase ) # Save pytorch-model print(F"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict() , _UpperCamelCase ) if __name__ == "__main__": __A = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--albert_config_file''', default=None, type=str, required=True, help=( '''The config json file corresponding to the pre-trained ALBERT model. \n''' '''This specifies the model architecture.''' ), ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) __A = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)
278
0
'''simple docstring''' def _lowerCamelCase ( lowercase : list ) -> list: _a = len(__lowercase ) for _ in range(__lowercase ): for i in range(_ % 2 , arr_size - 1 , 2 ): if arr[i + 1] < arr[i]: _a , _a = arr[i + 1], arr[i] return arr if __name__ == "__main__": lowerCAmelCase_ : Union[str, Any] = list(range(10, 0, -1)) print(f"""Original: {arr}. Sorted: {odd_even_transposition(arr)}""")
63
'''simple docstring''' import copy import os from typing import Union from ...configuration_utils import PretrainedConfig from ...utils import logging a__ : List[Any] =logging.get_logger(__name__) a__ : List[Any] ={ '''BAAI/AltCLIP''': '''https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json''', # See all AltCLIP models at https://huggingface.co/models?filter=altclip } class snake_case ( __lowerCamelCase ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple ="altclip_text_model" def __init__( self : str , __A : List[Any]=2_5_0_0_0_2 , __A : Any=1_0_2_4 , __A : int=2_4 , __A : Dict=1_6 , __A : Optional[Any]=4_0_9_6 , __A : Union[str, Any]="gelu" , __A : Dict=0.1 , __A : Dict=0.1 , __A : List[str]=5_1_4 , __A : Optional[int]=1 , __A : int=0.02 , __A : Optional[Any]=0.02 , __A : Optional[Any]=1e-05 , __A : Dict=1 , __A : List[Any]=0 , __A : int=2 , __A : Tuple="absolute" , __A : Optional[Any]=True , __A : Optional[int]=7_6_8 , **__A : List[str] , ): super().__init__(pad_token_id=__A , bos_token_id=__A , eos_token_id=__A , **__A ) __UpperCamelCase = vocab_size __UpperCamelCase = hidden_size __UpperCamelCase = num_hidden_layers __UpperCamelCase = num_attention_heads __UpperCamelCase = hidden_act __UpperCamelCase = intermediate_size __UpperCamelCase = hidden_dropout_prob __UpperCamelCase = attention_probs_dropout_prob __UpperCamelCase = max_position_embeddings __UpperCamelCase = type_vocab_size __UpperCamelCase = initializer_range __UpperCamelCase = initializer_factor __UpperCamelCase = layer_norm_eps __UpperCamelCase = position_embedding_type __UpperCamelCase = use_cache __UpperCamelCase = project_dim class snake_case ( __lowerCamelCase ): """simple docstring""" SCREAMING_SNAKE_CASE_ : Tuple ="altclip_vision_model" def __init__( self : List[Any] , __A : Union[str, Any]=7_6_8 , __A : Optional[int]=3_0_7_2 , __A : Optional[Any]=5_1_2 , __A : Tuple=1_2 , __A : Union[str, Any]=1_2 , __A : Optional[int]=3 , __A : Dict=2_2_4 , __A : Tuple=3_2 , __A : str="quick_gelu" , __A : Dict=1e-5 , __A : Optional[int]=0.0 , __A : List[Any]=0.02 , __A : int=1.0 , **__A : Optional[int] , ): super().__init__(**__A ) __UpperCamelCase = hidden_size __UpperCamelCase = intermediate_size __UpperCamelCase = projection_dim __UpperCamelCase = num_hidden_layers __UpperCamelCase = num_attention_heads __UpperCamelCase = num_channels __UpperCamelCase = patch_size __UpperCamelCase = image_size __UpperCamelCase = initializer_range __UpperCamelCase = initializer_factor __UpperCamelCase = attention_dropout __UpperCamelCase = layer_norm_eps __UpperCamelCase = hidden_act @classmethod def _lowerCamelCase ( cls : Optional[Any] , __A : Union[str, os.PathLike] , **__A : Optional[Any] ): cls._set_token_in_kwargs(__A ) __UpperCamelCase , __UpperCamelCase = cls.get_config_dict(__A , **__A ) # get the vision config dict if we are loading from AltCLIPConfig if config_dict.get('model_type' ) == "altclip": __UpperCamelCase = config_dict['vision_config'] if "model_type" in config_dict and hasattr(cls , 'model_type' ) and config_dict["model_type"] != cls.model_type: logger.warning( f'''You are using a model of type {config_dict['model_type']} to instantiate a model of type ''' f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' ) return cls.from_dict(__A , **__A ) class snake_case ( __lowerCamelCase ): """simple docstring""" SCREAMING_SNAKE_CASE_ : List[str] ="altclip" SCREAMING_SNAKE_CASE_ : Optional[int] =True def __init__( self : Any , __A : List[str]=None , __A : List[Any]=None , __A : List[str]=7_6_8 , __A : List[str]=2.6592 , **__A : Dict ): # If `_config_dict` exist, we use them for the backward compatibility. # We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot # of confusion!). __UpperCamelCase = kwargs.pop('text_config_dict' , __A ) __UpperCamelCase = kwargs.pop('vision_config_dict' , __A ) super().__init__(**__A ) # Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in # `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most # cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`. if text_config_dict is not None: if text_config is None: __UpperCamelCase = {} # This is the complete result when using `text_config_dict`. __UpperCamelCase = AltCLIPTextConfig(**__A ).to_dict() # Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different. for key, value in _text_config_dict.items(): if key in text_config and value != text_config[key] and key not in ["transformers_version"]: # If specified in `text_config_dict` if key in text_config_dict: __UpperCamelCase = ( f'''`{key}` is found in both `text_config_dict` and `text_config` but with different values. ''' f'''The value `text_config_dict["{key}"]` will be used instead.''' ) # If inferred from default argument values (just to be super careful) else: __UpperCamelCase = ( f'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The ''' f'''value `text_config["{key}"]` will be overriden.''' ) logger.warning(__A ) # Update all values in `text_config` with the ones in `_text_config_dict`. text_config.update(_text_config_dict ) if vision_config_dict is not None: if vision_config is None: __UpperCamelCase = {} # This is the complete result when using `vision_config_dict`. __UpperCamelCase = AltCLIPVisionConfig(**__A ).to_dict() # convert keys to string instead of integer if "id2label" in _vision_config_dict: __UpperCamelCase = { str(__A ): value for key, value in _vision_config_dict['id2label'].items() } # Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different. for key, value in _vision_config_dict.items(): if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]: # If specified in `vision_config_dict` if key in vision_config_dict: __UpperCamelCase = ( f'''`{key}` is found in both `vision_config_dict` and `vision_config` but with different ''' f'''values. The value `vision_config_dict["{key}"]` will be used instead.''' ) # If inferred from default argument values (just to be super careful) else: __UpperCamelCase = ( f'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. ''' f'''The value `vision_config["{key}"]` will be overriden.''' ) logger.warning(__A ) # Update all values in `vision_config` with the ones in `_vision_config_dict`. vision_config.update(_vision_config_dict ) if text_config is None: __UpperCamelCase = {} logger.info('`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.' ) if vision_config is None: __UpperCamelCase = {} logger.info('`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.' ) __UpperCamelCase = AltCLIPTextConfig(**__A ) __UpperCamelCase = AltCLIPVisionConfig(**__A ) __UpperCamelCase = projection_dim __UpperCamelCase = logit_scale_init_value __UpperCamelCase = 1.0 @classmethod def _lowerCamelCase ( cls : Union[str, Any] , __A : AltCLIPTextConfig , __A : AltCLIPVisionConfig , **__A : Optional[Any] ): return cls(text_config=text_config.to_dict() , vision_config=vision_config.to_dict() , **__A ) def _lowerCamelCase ( self : List[Any] ): __UpperCamelCase = copy.deepcopy(self.__dict__ ) __UpperCamelCase = self.text_config.to_dict() __UpperCamelCase = self.vision_config.to_dict() __UpperCamelCase = self.__class__.model_type return output
53
0
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) __UpperCAmelCase = { 'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'], 'feature_extraction_whisper': ['WhisperFeatureExtractor'], 'processing_whisper': ['WhisperProcessor'], 'tokenization_whisper': ['WhisperTokenizer'], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = ['WhisperTokenizerFast'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST', 'WhisperForConditionalGeneration', 'WhisperModel', 'WhisperPreTrainedModel', 'WhisperForAudioClassification', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST', 'TFWhisperForConditionalGeneration', 'TFWhisperModel', 'TFWhisperPreTrainedModel', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __UpperCAmelCase = [ 'FlaxWhisperForConditionalGeneration', 'FlaxWhisperModel', 'FlaxWhisperPreTrainedModel', 'FlaxWhisperForAudioClassification', ] if TYPE_CHECKING: from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig from .feature_extraction_whisper import WhisperFeatureExtractor from .processing_whisper import WhisperProcessor from .tokenization_whisper import WhisperTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_whisper_fast import WhisperTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_whisper import ( WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST, WhisperForAudioClassification, WhisperForConditionalGeneration, WhisperModel, WhisperPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_whisper import ( TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST, TFWhisperForConditionalGeneration, TFWhisperModel, TFWhisperPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_whisper import ( FlaxWhisperForAudioClassification, FlaxWhisperForConditionalGeneration, FlaxWhisperModel, FlaxWhisperPreTrainedModel, ) else: import sys __UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
361
import warnings from ...utils import logging from .image_processing_glpn import GLPNImageProcessor __UpperCAmelCase = logging.get_logger(__name__) class __a ( __UpperCamelCase ): def __init__( self : Union[str, Any] , *UpperCAmelCase : Optional[Any] , **UpperCAmelCase : Dict ): warnings.warn( """The class GLPNFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please""" """ use GLPNImageProcessor instead.""" , UpperCAmelCase , ) super().__init__(*UpperCAmelCase , **UpperCAmelCase )
28
0
from collections import OrderedDict from typing import Any, Mapping, Optional from ... import PreTrainedTokenizer, TensorType, is_torch_available from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfigWithPast from ...utils import logging _a = logging.get_logger(__name__) _a = { "EleutherAI/gpt-neo-1.3B": "https://huggingface.co/EleutherAI/gpt-neo-1.3B/resolve/main/config.json", # See all GPTNeo models at https://huggingface.co/models?filter=gpt_neo } class __A ( _UpperCAmelCase ): '''simple docstring''' lowerCAmelCase_ = """gpt_neo""" lowerCAmelCase_ = ["""past_key_values"""] lowerCAmelCase_ = {"""num_attention_heads""": """num_heads""", """num_hidden_layers""": """num_layers"""} def __init__( self , __lowerCAmelCase=5_0_2_5_7 , __lowerCAmelCase=2_0_4_8 , __lowerCAmelCase=2_0_4_8 , __lowerCAmelCase=2_4 , __lowerCAmelCase=[[["global", "local"], 1_2]] , __lowerCAmelCase=1_6 , __lowerCAmelCase=None , __lowerCAmelCase=2_5_6 , __lowerCAmelCase="gelu_new" , __lowerCAmelCase=0.0 , __lowerCAmelCase=0.0 , __lowerCAmelCase=0.0 , __lowerCAmelCase=0.1 , __lowerCAmelCase=1E-5 , __lowerCAmelCase=0.02 , __lowerCAmelCase=True , __lowerCAmelCase=5_0_2_5_6 , __lowerCAmelCase=5_0_2_5_6 , **__lowerCAmelCase , ): '''simple docstring''' lowerCamelCase__ = vocab_size lowerCamelCase__ = max_position_embeddings lowerCamelCase__ = hidden_size lowerCamelCase__ = num_layers lowerCamelCase__ = num_heads lowerCamelCase__ = intermediate_size lowerCamelCase__ = window_size lowerCamelCase__ = activation_function lowerCamelCase__ = resid_dropout lowerCamelCase__ = embed_dropout lowerCamelCase__ = attention_dropout lowerCamelCase__ = classifier_dropout lowerCamelCase__ = layer_norm_epsilon lowerCamelCase__ = initializer_range lowerCamelCase__ = use_cache lowerCamelCase__ = bos_token_id lowerCamelCase__ = eos_token_id lowerCamelCase__ = attention_types lowerCamelCase__ = self.expand_attention_types_params(lowercase_ ) if len(self.attention_layers ) != self.num_layers: raise ValueError( '''Configuration for convolutional module is incorrect. ''' '''It is required that `len(config.attention_layers)` == `config.num_layers` ''' F'but is `len(config.attention_layers) = {len(self.attention_layers )}`, ' F'`config.num_layers = {self.num_layers}`. ' '''`config.attention_layers` is prepared using `config.attention_types`. ''' '''Please verify the value of `config.attention_types` argument.''' ) super().__init__(bos_token_id=lowercase_ , eos_token_id=lowercase_ , **lowercase_ ) @staticmethod def __lowerCamelCase ( __lowerCAmelCase ): '''simple docstring''' lowerCamelCase__ = [] for item in attention_types: for _ in range(item[1] ): attentions.extend(item[0] ) return attentions def lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ,__snake_case ) -> Tuple: '''simple docstring''' import torch lowerCamelCase__ = input.size() lowerCamelCase__ = len(UpperCAmelCase__ ) lowerCamelCase__ = shape[dimension] lowerCamelCase__ = torch.arange(0 ,UpperCAmelCase__ ,UpperCAmelCase__ ) lowerCamelCase__ = torch.div(sizedim - size ,UpperCAmelCase__ ,rounding_mode='''floor''' ) + 1 lowerCamelCase__ = torch.arange(UpperCAmelCase__ ) + low_indices[:min_length][:, None] lowerCamelCase__ = [slice(UpperCAmelCase__ )] * rank lowerCamelCase__ = indices lowerCamelCase__ = input[s] lowerCamelCase__ = list(range(0 ,rank + 1 ) ) perm.append(perm.pop(dimension + 1 ) ) return sliced.permute(UpperCAmelCase__ ) def lowerCAmelCase__(__snake_case ,__snake_case ) -> List[Any]: '''simple docstring''' import torch lowerCamelCase__ = torch.arange(1 ,UpperCAmelCase__ ) lowerCamelCase__ = torch.remainder(UpperCAmelCase__ ,UpperCAmelCase__ ) lowerCamelCase__ = remainders == 0 lowerCamelCase__ = candidates[divisor_indices] lowerCamelCase__ = torch.max(UpperCAmelCase__ ) return largest_divisor, torch.div(UpperCAmelCase__ ,UpperCAmelCase__ ,rounding_mode='''floor''' ) class __A ( _UpperCAmelCase ): '''simple docstring''' @property def __lowerCamelCase ( self ): '''simple docstring''' lowerCamelCase__ = OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}} ) if self.use_past: self.fill_with_past_key_values_(lowercase_ , direction='''inputs''' ) lowerCamelCase__ = {0: """batch""", 1: """past_sequence + sequence"""} else: lowerCamelCase__ = {0: """batch""", 1: """sequence"""} return common_inputs @property def __lowerCamelCase ( self ): '''simple docstring''' return self._config.num_heads def __lowerCamelCase ( self , __lowerCAmelCase , __lowerCAmelCase = -1 , __lowerCAmelCase = -1 , __lowerCAmelCase = False , __lowerCAmelCase = None , ): '''simple docstring''' lowerCamelCase__ = super(lowercase_ , self ).generate_dummy_inputs( lowercase_ , batch_size=lowercase_ , seq_length=lowercase_ , is_pair=lowercase_ , framework=lowercase_ ) # We need to order the input in the way they appears in the forward() lowerCamelCase__ = 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 lowerCamelCase__ = common_inputs["""input_ids"""].shape # Not using the same length for past_key_values lowerCamelCase__ = seqlen + 2 lowerCamelCase__ = ( batch, self.num_attention_heads, past_key_values_length, self._config.hidden_size // self.num_attention_heads, ) lowerCamelCase__ = [ (torch.zeros(lowercase_ ), torch.zeros(lowercase_ )) for _ in range(self.num_layers ) ] lowerCamelCase__ = common_inputs["""attention_mask"""] if self.use_past: lowerCamelCase__ = ordered_inputs["""attention_mask"""].dtype lowerCamelCase__ = torch.cat( [ordered_inputs['''attention_mask'''], torch.ones(lowercase_ , lowercase_ , dtype=lowercase_ )] , dim=1 ) return ordered_inputs @property def __lowerCamelCase ( self ): '''simple docstring''' return 1_3
209
'''simple docstring''' import os from shutil import copyfile from typing import List, Optional, Tuple from ...tokenization_utils import AddedToken from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import is_sentencepiece_available, logging if is_sentencepiece_available(): from .tokenization_albert import AlbertTokenizer else: _lowercase : int = None _lowercase : Union[str, Any] = logging.get_logger(__name__) _lowercase : Tuple = {"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"} _lowercase : Dict = { "vocab_file": { "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/spiece.model", "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/spiece.model", "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model", "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model", "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/spiece.model", "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/spiece.model", "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model", "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model", }, "tokenizer_file": { "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/tokenizer.json", "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/tokenizer.json", "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/tokenizer.json", "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/tokenizer.json", "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/tokenizer.json", "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/tokenizer.json", "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/tokenizer.json", "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/tokenizer.json", }, } _lowercase : int = { "albert-base-v1": 512, "albert-large-v1": 512, "albert-xlarge-v1": 512, "albert-xxlarge-v1": 512, "albert-base-v2": 512, "albert-large-v2": 512, "albert-xlarge-v2": 512, "albert-xxlarge-v2": 512, } _lowercase : Tuple = "▁" class __magic_name__ ( _UpperCAmelCase): UpperCamelCase__ = VOCAB_FILES_NAMES UpperCamelCase__ = PRETRAINED_VOCAB_FILES_MAP UpperCamelCase__ = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES UpperCamelCase__ = AlbertTokenizer def __init__( self : Optional[Any] , lowercase_ : Union[str, Any]=None , lowercase_ : str=None , lowercase_ : Any=True , lowercase_ : Optional[int]=True , lowercase_ : List[str]=False , lowercase_ : Optional[int]="[CLS]" , lowercase_ : Any="[SEP]" , lowercase_ : int="<unk>" , lowercase_ : Any="[SEP]" , lowercase_ : int="<pad>" , lowercase_ : Tuple="[CLS]" , lowercase_ : Dict="[MASK]" , **lowercase_ : Optional[int] , ): # Mask token behave like a normal word, i.e. include the space before it and # is included in the raw text, there should be a match in a non-normalized sentence. lowercase_ : Tuple = ( AddedToken(lowercase_ , lstrip=lowercase_ , rstrip=lowercase_ , normalized=lowercase_ ) if isinstance(lowercase_ , lowercase_ ) else mask_token ) super().__init__( lowercase_ , tokenizer_file=lowercase_ , do_lower_case=lowercase_ , remove_space=lowercase_ , keep_accents=lowercase_ , bos_token=lowercase_ , eos_token=lowercase_ , unk_token=lowercase_ , sep_token=lowercase_ , pad_token=lowercase_ , cls_token=lowercase_ , mask_token=lowercase_ , **lowercase_ , ) lowercase_ : Optional[int] = do_lower_case lowercase_ : Any = remove_space lowercase_ : Dict = keep_accents lowercase_ : Optional[int] = vocab_file lowercase_ : Any = False if not self.vocab_file else True def SCREAMING_SNAKE_CASE_ ( self : Tuple , lowercase_ : List[int] , lowercase_ : Optional[List[int]] = None ): lowercase_ : Tuple = [self.sep_token_id] lowercase_ : str = [self.cls_token_id] if token_ids_a is None: return cls + token_ids_a + sep return cls + token_ids_a + sep + token_ids_a + sep def SCREAMING_SNAKE_CASE_ ( self : Any , lowercase_ : List[int] , lowercase_ : Optional[List[int]] = None ): lowercase_ : Union[str, Any] = [self.sep_token_id] lowercase_ : 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 ) * [0] + len(token_ids_a + sep ) * [1] def SCREAMING_SNAKE_CASE_ ( self : Union[str, Any] , lowercase_ : str , lowercase_ : Optional[str] = None ): if not self.can_save_slow_tokenizer: raise ValueError( """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """ """tokenizer.""" ) if not os.path.isdir(lowercase_ ): logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' ) return lowercase_ : Optional[Any] = os.path.join( lowercase_ , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowercase_ ): copyfile(self.vocab_file , lowercase_ ) return (out_vocab_file,)
239
0
from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available _UpperCAmelCase = { 'configuration_conditional_detr': [ 'CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ConditionalDetrConfig', 'ConditionalDetrOnnxConfig', ] } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCAmelCase = ['ConditionalDetrFeatureExtractor'] _UpperCAmelCase = ['ConditionalDetrImageProcessor'] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _UpperCAmelCase = [ 'CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST', 'ConditionalDetrForObjectDetection', 'ConditionalDetrForSegmentation', 'ConditionalDetrModel', 'ConditionalDetrPreTrainedModel', ] if TYPE_CHECKING: from .configuration_conditional_detr import ( CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, ConditionalDetrConfig, ConditionalDetrOnnxConfig, ) try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .feature_extraction_conditional_detr import ConditionalDetrFeatureExtractor from .image_processing_conditional_detr import ConditionalDetrImageProcessor try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_conditional_detr import ( CONDITIONAL_DETR_PRETRAINED_MODEL_ARCHIVE_LIST, ConditionalDetrForObjectDetection, ConditionalDetrForSegmentation, ConditionalDetrModel, ConditionalDetrPreTrainedModel, ) else: import sys _UpperCAmelCase = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
328
from sklearn.metrics import fa_score, matthews_corrcoef import datasets from .record_evaluation import evaluate as evaluate_record _UpperCAmelCase = '\\n@article{wang2019superglue,\n title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},\n author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},\n journal={arXiv preprint arXiv:1905.00537},\n year={2019}\n}\n' _UpperCAmelCase = '\\nSuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after\nGLUE with a new set of more difficult language understanding tasks, improved\nresources, and a new public leaderboard.\n' _UpperCAmelCase = '\nCompute SuperGLUE evaluation metric associated to each SuperGLUE dataset.\nArgs:\n predictions: list of predictions to score. Depending on the SuperGlUE subset:\n - for \'record\': list of question-answer dictionaries with the following keys:\n - \'idx\': index of the question as specified by the dataset\n - \'prediction_text\': the predicted answer text\n - for \'multirc\': list of question-answer dictionaries with the following keys:\n - \'idx\': index of the question-answer pair as specified by the dataset\n - \'prediction\': the predicted answer label\n - otherwise: list of predicted labels\n references: list of reference labels. Depending on the SuperGLUE subset:\n - for \'record\': list of question-answers dictionaries with the following keys:\n - \'idx\': index of the question as specified by the dataset\n - \'answers\': list of possible answers\n - otherwise: list of reference labels\nReturns: depending on the SuperGLUE subset:\n - for \'record\':\n - \'exact_match\': Exact match between answer and gold answer\n - \'f1\': F1 score\n - for \'multirc\':\n - \'exact_match\': Exact match between answer and gold answer\n - \'f1_m\': Per-question macro-F1 score\n - \'f1_a\': Average F1 score over all answers\n - for \'axb\':\n \'matthews_correlation\': Matthew Correlation\n - for \'cb\':\n - \'accuracy\': Accuracy\n - \'f1\': F1 score\n - for all others:\n - \'accuracy\': Accuracy\nExamples:\n\n >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'copa\') # any of ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]\n >>> predictions = [0, 1]\n >>> references = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0}\n\n >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'cb\')\n >>> predictions = [0, 1]\n >>> references = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'accuracy\': 1.0, \'f1\': 1.0}\n\n >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'record\')\n >>> predictions = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'prediction_text\': \'answer\'}]\n >>> references = [{\'idx\': {\'passage\': 0, \'query\': 0}, \'answers\': [\'answer\', \'another_answer\']}]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact_match\': 1.0, \'f1\': 1.0}\n\n >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'multirc\')\n >>> predictions = [{\'idx\': {\'answer\': 0, \'paragraph\': 0, \'question\': 0}, \'prediction\': 0}, {\'idx\': {\'answer\': 1, \'paragraph\': 2, \'question\': 3}, \'prediction\': 1}]\n >>> references = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'exact_match\': 1.0, \'f1_m\': 1.0, \'f1_a\': 1.0}\n\n >>> super_glue_metric = datasets.load_metric(\'super_glue\', \'axb\')\n >>> references = [0, 1]\n >>> predictions = [0, 1]\n >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n >>> print(results)\n {\'matthews_correlation\': 1.0}\n' def lowerCAmelCase_ ( UpperCamelCase_ , UpperCamelCase_ ) -> Optional[Any]: return float((preds == labels).mean() ) def lowerCAmelCase_ ( UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_="binary" ) -> Tuple: UpperCamelCase_ = simple_accuracy(UpperCamelCase_ , UpperCamelCase_ ) UpperCamelCase_ = float(fa_score(y_true=UpperCamelCase_ , y_pred=UpperCamelCase_ , average=UpperCamelCase_ ) ) return { "accuracy": acc, "f1": fa, } def lowerCAmelCase_ ( UpperCamelCase_ , UpperCamelCase_ ) -> List[Any]: UpperCamelCase_ = {} for id_pred, label in zip(UpperCamelCase_ , UpperCamelCase_ ): UpperCamelCase_ = F'''{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}''' UpperCamelCase_ = id_pred["prediction"] if question_id in question_map: question_map[question_id].append((pred, label) ) else: UpperCamelCase_ = [(pred, label)] UpperCamelCase_ , UpperCamelCase_ = [], [] for question, preds_labels in question_map.items(): UpperCamelCase_ , UpperCamelCase_ = zip(*UpperCamelCase_ ) UpperCamelCase_ = fa_score(y_true=UpperCamelCase_ , y_pred=UpperCamelCase_ , average="macro" ) fas.append(UpperCamelCase_ ) UpperCamelCase_ = int(sum(pred == label for pred, label in preds_labels ) == len(UpperCamelCase_ ) ) ems.append(UpperCamelCase_ ) UpperCamelCase_ = float(sum(UpperCamelCase_ ) / len(UpperCamelCase_ ) ) UpperCamelCase_ = sum(UpperCamelCase_ ) / len(UpperCamelCase_ ) UpperCamelCase_ = float(fa_score(y_true=UpperCamelCase_ , y_pred=[id_pred["prediction"] for id_pred in ids_preds] ) ) return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a} @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class _UpperCamelCase ( datasets.Metric ): def lowercase ( self: Optional[int] ) -> Optional[int]: """simple docstring""" if self.config_name not in [ "boolq", "cb", "copa", "multirc", "record", "rte", "wic", "wsc", "wsc.fixed", "axb", "axg", ]: raise KeyError( "You should supply a configuration name selected in " "[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]" ) return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features(self._get_feature_types() ) , codebase_urls=[] , reference_urls=[] , format="numpy" if not self.config_name == "record" and not self.config_name == "multirc" else None , ) def lowercase ( self: List[Any] ) -> int: """simple docstring""" if self.config_name == "record": return { "predictions": { "idx": { "passage": datasets.Value("int64" ), "query": datasets.Value("int64" ), }, "prediction_text": datasets.Value("string" ), }, "references": { "idx": { "passage": datasets.Value("int64" ), "query": datasets.Value("int64" ), }, "answers": datasets.Sequence(datasets.Value("string" ) ), }, } elif self.config_name == "multirc": return { "predictions": { "idx": { "answer": datasets.Value("int64" ), "paragraph": datasets.Value("int64" ), "question": datasets.Value("int64" ), }, "prediction": datasets.Value("int64" ), }, "references": datasets.Value("int64" ), } else: return { "predictions": datasets.Value("int64" ), "references": datasets.Value("int64" ), } def lowercase ( self: Tuple , _SCREAMING_SNAKE_CASE: Optional[Any] , _SCREAMING_SNAKE_CASE: List[str] ) -> Dict: """simple docstring""" if self.config_name == "axb": return {"matthews_correlation": matthews_corrcoef(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )} elif self.config_name == "cb": return acc_and_fa(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , fa_avg="macro" ) elif self.config_name == "record": UpperCamelCase_ = [ { "qas": [ {"id": ref["idx"]["query"], "answers": [{"text": ans} for ans in ref["answers"]]} for ref in references ] } ] UpperCamelCase_ = {pred["idx"]["query"]: pred["prediction_text"] for pred in predictions} return evaluate_record(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )[0] elif self.config_name == "multirc": return evaluate_multirc(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]: return {"accuracy": simple_accuracy(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE )} else: raise KeyError( "You should supply a configuration name selected in " "[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]" )
328
1
from typing import TYPE_CHECKING from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available from ...utils import OptionalDependencyNotAvailable _snake_case = {"configuration_gpt_neox": ["GPT_NEOX_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTNeoXConfig"]} try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _snake_case = ["GPTNeoXTokenizerFast"] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: _snake_case = [ "GPT_NEOX_PRETRAINED_MODEL_ARCHIVE_LIST", "GPTNeoXForCausalLM", "GPTNeoXForQuestionAnswering", "GPTNeoXForSequenceClassification", "GPTNeoXForTokenClassification", "GPTNeoXLayer", "GPTNeoXModel", "GPTNeoXPreTrainedModel", ] if TYPE_CHECKING: from .configuration_gpt_neox import GPT_NEOX_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTNeoXConfig try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_gpt_neox_fast import GPTNeoXTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_gpt_neox import ( GPT_NEOX_PRETRAINED_MODEL_ARCHIVE_LIST, GPTNeoXForCausalLM, GPTNeoXForQuestionAnswering, GPTNeoXForSequenceClassification, GPTNeoXForTokenClassification, GPTNeoXLayer, GPTNeoXModel, GPTNeoXPreTrainedModel, ) else: import sys _snake_case = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
36
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(_lowerCamelCase , 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 A ( _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' _lowerCAmelCase : List[Any] = _distribute_shards(**_lowerCamelCase ) 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 A ( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' _lowerCAmelCase : Optional[int] = _split_gen_kwargs(_lowerCamelCase , _lowerCamelCase ) 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 A ( _lowerCamelCase , _lowerCamelCase ): '''simple docstring''' if expected is RuntimeError: with pytest.raises(_lowerCamelCase ): _number_of_shards_in_gen_kwargs(_lowerCamelCase ) else: _lowerCAmelCase : Optional[int] = _number_of_shards_in_gen_kwargs(_lowerCamelCase ) assert out == expected
36
1
from collections import OrderedDict from typing import Mapping from ...configuration_utils import PretrainedConfig from ...onnx import OnnxConfig from ...utils import logging UpperCAmelCase_ : int = logging.get_logger(__name__) UpperCAmelCase_ : List[str] = { 'roberta-base': 'https://huggingface.co/roberta-base/resolve/main/config.json', 'roberta-large': 'https://huggingface.co/roberta-large/resolve/main/config.json', 'roberta-large-mnli': 'https://huggingface.co/roberta-large-mnli/resolve/main/config.json', 'distilroberta-base': 'https://huggingface.co/distilroberta-base/resolve/main/config.json', 'roberta-base-openai-detector': 'https://huggingface.co/roberta-base-openai-detector/resolve/main/config.json', 'roberta-large-openai-detector': 'https://huggingface.co/roberta-large-openai-detector/resolve/main/config.json', } class SCREAMING_SNAKE_CASE__ ( lowercase__ ): snake_case__ : Optional[int] = '''roberta''' def __init__( self : str , SCREAMING_SNAKE_CASE__ : int=5_0_2_6_5 , SCREAMING_SNAKE_CASE__ : List[Any]=7_6_8 , SCREAMING_SNAKE_CASE__ : Union[str, Any]=1_2 , SCREAMING_SNAKE_CASE__ : str=1_2 , SCREAMING_SNAKE_CASE__ : Optional[Any]=3_0_7_2 , SCREAMING_SNAKE_CASE__ : Optional[int]="gelu" , SCREAMING_SNAKE_CASE__ : Dict=0.1 , SCREAMING_SNAKE_CASE__ : Dict=0.1 , SCREAMING_SNAKE_CASE__ : int=5_1_2 , SCREAMING_SNAKE_CASE__ : str=2 , SCREAMING_SNAKE_CASE__ : List[Any]=0.02 , SCREAMING_SNAKE_CASE__ : Optional[int]=1E-12 , SCREAMING_SNAKE_CASE__ : Optional[int]=1 , SCREAMING_SNAKE_CASE__ : Optional[Any]=0 , SCREAMING_SNAKE_CASE__ : Optional[Any]=2 , SCREAMING_SNAKE_CASE__ : List[Any]="absolute" , SCREAMING_SNAKE_CASE__ : Any=True , SCREAMING_SNAKE_CASE__ : Optional[Any]=None , **SCREAMING_SNAKE_CASE__ : Any , ) -> Tuple: super().__init__(pad_token_id=SCREAMING_SNAKE_CASE__ , bos_token_id=SCREAMING_SNAKE_CASE__ , eos_token_id=SCREAMING_SNAKE_CASE__ , **SCREAMING_SNAKE_CASE__ ) a_ : Tuple = vocab_size a_ : Optional[int] = hidden_size a_ : Optional[int] = num_hidden_layers a_ : int = num_attention_heads a_ : Any = hidden_act a_ : Any = intermediate_size a_ : Tuple = hidden_dropout_prob a_ : List[str] = attention_probs_dropout_prob a_ : Optional[Any] = max_position_embeddings a_ : Optional[int] = type_vocab_size a_ : Optional[int] = initializer_range a_ : Optional[int] = layer_norm_eps a_ : Optional[int] = position_embedding_type a_ : List[str] = use_cache a_ : List[Any] = classifier_dropout class SCREAMING_SNAKE_CASE__ ( lowercase__ ): @property def SCREAMING_SNAKE_CASE ( self : str ) -> Mapping[str, Mapping[int, str]]: if self.task == "multiple-choice": a_ : str = {0: 'batch', 1: 'choice', 2: 'sequence'} else: a_ : Any = {0: 'batch', 1: 'sequence'} return OrderedDict( [ ('input_ids', dynamic_axis), ('attention_mask', dynamic_axis), ] )
120
def SCREAMING_SNAKE_CASE_ ( __A : int ) -> int: """simple docstring""" if n == 1 or not isinstance(__A , __A ): return 0 elif n == 2: return 1 else: a_ : int = [0, 1] for i in range(2 , n + 1 ): sequence.append(sequence[i - 1] + sequence[i - 2] ) return sequence[n] def SCREAMING_SNAKE_CASE_ ( __A : int ) -> int: """simple docstring""" a_ : Any = 0 a_ : Optional[Any] = 2 while digits < n: index += 1 a_ : List[Any] = len(str(fibonacci(__A ) ) ) return index def SCREAMING_SNAKE_CASE_ ( __A : int = 10_00 ) -> int: """simple docstring""" return fibonacci_digits_index(__A ) if __name__ == "__main__": print(solution(int(str(input()).strip())))
120
1
import json import os import shutil import warnings from argparse import ArgumentParser, Namespace from pathlib import Path from typing import List from ..utils import logging from . import BaseTransformersCLICommand try: from cookiecutter.main import cookiecutter UpperCAmelCase_ = True except ImportError: UpperCAmelCase_ = False UpperCAmelCase_ = logging.get_logger(__name__) # pylint: disable=invalid-name def lowerCAmelCase_ ( __UpperCAmelCase: Union[str, Any] ) -> Optional[Any]: return AddNewModelCommand(args.testing , args.testing_file , path=args.path ) class lowercase__ ( SCREAMING_SNAKE_CASE_ ): '''simple docstring''' @staticmethod def UpperCamelCase__ ( __magic_name__ ) -> List[str]: """simple docstring""" UpperCamelCase__ : Optional[Any] = parser.add_parser('''add-new-model''' ) add_new_model_parser.add_argument('''--testing''', action='''store_true''', help='''If in testing mode.''' ) add_new_model_parser.add_argument('''--testing_file''', type=lowercase_, help='''Configuration file on which to run.''' ) add_new_model_parser.add_argument( '''--path''', type=lowercase_, help='''Path to cookiecutter. Should only be used for testing purposes.''' ) add_new_model_parser.set_defaults(func=lowercase_ ) def __init__( self, __magic_name__, __magic_name__, __magic_name__=None, *__magic_name__ ) -> str: """simple docstring""" UpperCamelCase__ : List[Any] = testing UpperCamelCase__ : List[str] = testing_file UpperCamelCase__ : int = path def UpperCamelCase__ ( self ) -> int: """simple docstring""" warnings.warn( '''The command `transformers-cli add-new-model` is deprecated and will be removed in v5 of Transformers. ''' '''It is not actively maintained anymore, so might give a result that won\'t pass all tests and quality ''' '''checks, you should use `transformers-cli add-new-model-like` instead.''' ) if not _has_cookiecutter: raise ImportError( '''Model creation dependencies are required to use the `add_new_model` command. Install them by running ''' '''the following at the root of your `transformers` clone:\n\n\t$ pip install -e .[modelcreation]\n''' ) # Ensure that there is no other `cookiecutter-template-xxx` directory in the current working directory UpperCamelCase__ : Optional[Any] = [directory for directory in os.listdir() if '''cookiecutter-template-''' == directory[:22]] if len(lowercase_ ) > 0: raise ValueError( '''Several directories starting with `cookiecutter-template-` in current working directory. ''' '''Please clean your directory by removing all folders starting with `cookiecutter-template-` or ''' '''change your working directory.''' ) UpperCamelCase__ : str = ( Path(lowercase_ ).parent.parent.parent.parent if self._path is None else Path(self._path ).parent.parent ) UpperCamelCase__ : List[Any] = path_to_transformer_root / '''templates''' / '''adding_a_new_model''' # Execute cookiecutter if not self._testing: cookiecutter(str(lowercase_ ) ) else: with open(self._testing_file, '''r''' ) as configuration_file: UpperCamelCase__ : int = json.load(lowercase_ ) cookiecutter( str(path_to_cookiecutter if self._path is None else self._path ), no_input=lowercase_, extra_context=lowercase_, ) UpperCamelCase__ : List[str] = [directory for directory in os.listdir() if '''cookiecutter-template-''' in directory[:22]][0] # Retrieve configuration with open(directory + '''/configuration.json''', '''r''' ) as configuration_file: UpperCamelCase__ : Any = json.load(lowercase_ ) UpperCamelCase__ : Optional[int] = configuration['''lowercase_modelname'''] UpperCamelCase__ : Union[str, Any] = configuration['''generate_tensorflow_pytorch_and_flax'''] os.remove(f"{directory}/configuration.json" ) UpperCamelCase__ : Any = '''PyTorch''' in generate_tensorflow_pytorch_and_flax UpperCamelCase__ : Dict = '''TensorFlow''' in generate_tensorflow_pytorch_and_flax UpperCamelCase__ : Optional[int] = '''Flax''' in generate_tensorflow_pytorch_and_flax UpperCamelCase__ : Tuple = f"{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}" os.makedirs(lowercase_, exist_ok=lowercase_ ) os.makedirs(f"{path_to_transformer_root}/tests/models/{lowercase_model_name}", exist_ok=lowercase_ ) # Tests require submodules as they have parent imports with open(f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/__init__.py", '''w''' ): pass shutil.move( f"{directory}/__init__.py", f"{model_dir}/__init__.py", ) shutil.move( f"{directory}/configuration_{lowercase_model_name}.py", f"{model_dir}/configuration_{lowercase_model_name}.py", ) def remove_copy_lines(__magic_name__ ): with open(lowercase_, '''r''' ) as f: UpperCamelCase__ : List[Any] = f.readlines() with open(lowercase_, '''w''' ) as f: for line in lines: if "# Copied from transformers." not in line: f.write(lowercase_ ) if output_pytorch: if not self._testing: remove_copy_lines(f"{directory}/modeling_{lowercase_model_name}.py" ) shutil.move( f"{directory}/modeling_{lowercase_model_name}.py", f"{model_dir}/modeling_{lowercase_model_name}.py", ) shutil.move( f"{directory}/test_modeling_{lowercase_model_name}.py", f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_{lowercase_model_name}.py", ) else: os.remove(f"{directory}/modeling_{lowercase_model_name}.py" ) os.remove(f"{directory}/test_modeling_{lowercase_model_name}.py" ) if output_tensorflow: if not self._testing: remove_copy_lines(f"{directory}/modeling_tf_{lowercase_model_name}.py" ) shutil.move( f"{directory}/modeling_tf_{lowercase_model_name}.py", f"{model_dir}/modeling_tf_{lowercase_model_name}.py", ) shutil.move( f"{directory}/test_modeling_tf_{lowercase_model_name}.py", f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_tf_{lowercase_model_name}.py", ) else: os.remove(f"{directory}/modeling_tf_{lowercase_model_name}.py" ) os.remove(f"{directory}/test_modeling_tf_{lowercase_model_name}.py" ) if output_flax: if not self._testing: remove_copy_lines(f"{directory}/modeling_flax_{lowercase_model_name}.py" ) shutil.move( f"{directory}/modeling_flax_{lowercase_model_name}.py", f"{model_dir}/modeling_flax_{lowercase_model_name}.py", ) shutil.move( f"{directory}/test_modeling_flax_{lowercase_model_name}.py", f"{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_flax_{lowercase_model_name}.py", ) else: os.remove(f"{directory}/modeling_flax_{lowercase_model_name}.py" ) os.remove(f"{directory}/test_modeling_flax_{lowercase_model_name}.py" ) shutil.move( f"{directory}/{lowercase_model_name}.md", f"{path_to_transformer_root}/docs/source/en/model_doc/{lowercase_model_name}.md", ) shutil.move( f"{directory}/tokenization_{lowercase_model_name}.py", f"{model_dir}/tokenization_{lowercase_model_name}.py", ) shutil.move( f"{directory}/tokenization_fast_{lowercase_model_name}.py", f"{model_dir}/tokenization_{lowercase_model_name}_fast.py", ) from os import fdopen, remove from shutil import copymode, move from tempfile import mkstemp def replace(__magic_name__, __magic_name__, __magic_name__ ): # Create temp file UpperCamelCase__ ,UpperCamelCase__ : Tuple = mkstemp() UpperCamelCase__ : int = False with fdopen(lowercase_, '''w''' ) as new_file: with open(lowercase_ ) as old_file: for line in old_file: new_file.write(lowercase_ ) if line_to_copy_below in line: UpperCamelCase__ : Optional[int] = True for line_to_copy in lines_to_copy: new_file.write(lowercase_ ) if not line_found: raise ValueError(f"Line {line_to_copy_below} was not found in file." ) # Copy the file permissions from the old file to the new file copymode(lowercase_, lowercase_ ) # Remove original file remove(lowercase_ ) # Move new file move(lowercase_, lowercase_ ) def skip_units(__magic_name__ ): return ( ("generating PyTorch" in line and not output_pytorch) or ("generating TensorFlow" in line and not output_tensorflow) or ("generating Flax" in line and not output_flax) ) def replace_in_files(__magic_name__ ): with open(lowercase_ ) as datafile: UpperCamelCase__ : Union[str, Any] = [] UpperCamelCase__ : int = False UpperCamelCase__ : Any = False for line in datafile: if "# To replace in: " in line and "##" not in line: UpperCamelCase__ : Any = line.split('''"''' )[1] UpperCamelCase__ : Dict = skip_units(lowercase_ ) elif "# Below: " in line and "##" not in line: UpperCamelCase__ : List[str] = line.split('''"''' )[1] UpperCamelCase__ : int = skip_units(lowercase_ ) elif "# End." in line and "##" not in line: if not skip_file and not skip_snippet: replace(lowercase_, lowercase_, lowercase_ ) UpperCamelCase__ : Tuple = [] elif "# Replace with" in line and "##" not in line: UpperCamelCase__ : Optional[Any] = [] elif "##" not in line: lines_to_copy.append(lowercase_ ) remove(lowercase_ ) replace_in_files(f"{directory}/to_replace_{lowercase_model_name}.py" ) os.rmdir(lowercase_ )
201
"""simple docstring""" class A_ : """simple docstring""" def __init__( self :List[Any] , lowercase_ :int ) -> None: UpperCAmelCase = size UpperCAmelCase = [0] * size UpperCAmelCase = [0] * size @staticmethod def UpperCAmelCase__ ( lowercase_ :int ) -> int: return index | (index + 1) @staticmethod def UpperCAmelCase__ ( lowercase_ :int ) -> int: return (index & (index + 1)) - 1 def UpperCAmelCase__ ( self :Any , lowercase_ :int , lowercase_ :int ) -> None: UpperCAmelCase = value while index < self.size: UpperCAmelCase = self.get_prev(lowercase_ ) + 1 if current_left_border == index: UpperCAmelCase = value else: UpperCAmelCase = max(lowercase_ , lowercase_ , lowercase_ ) UpperCAmelCase = self.get_next(lowercase_ ) def UpperCAmelCase__ ( self :List[str] , lowercase_ :int , lowercase_ :int ) -> int: right -= 1 # Because of right is exclusive UpperCAmelCase = 0 while left <= right: UpperCAmelCase = self.get_prev(lowercase_ ) if left <= current_left: UpperCAmelCase = max(lowercase_ , self.tree[right] ) UpperCAmelCase = current_left else: UpperCAmelCase = max(lowercase_ , self.arr[right] ) right -= 1 return result if __name__ == "__main__": import doctest doctest.testmod()
78
0
from random import randint from tempfile import TemporaryFile import numpy as np def lowerCAmelCase_ ( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase ): __snake_case : str = 0 if start < end: __snake_case : Optional[int] = randint(__lowerCamelCase , __lowerCamelCase ) __snake_case : Tuple = a[end] __snake_case : str = a[pivot] __snake_case : Dict = temp __snake_case , __snake_case : Tuple = _in_place_partition(__lowerCamelCase , __lowerCamelCase , __lowerCamelCase ) count += _in_place_quick_sort(__lowerCamelCase , __lowerCamelCase , p - 1 ) count += _in_place_quick_sort(__lowerCamelCase , p + 1 , __lowerCamelCase ) return count def lowerCAmelCase_ ( __lowerCamelCase , __lowerCamelCase , __lowerCamelCase ): __snake_case : List[str] = 0 __snake_case : str = randint(__lowerCamelCase , __lowerCamelCase ) __snake_case : Union[str, Any] = a[end] __snake_case : Union[str, Any] = a[pivot] __snake_case : Tuple = temp __snake_case : Dict = start - 1 for index in range(__lowerCamelCase , __lowerCamelCase ): count += 1 if a[index] < a[end]: # check if current val is less than pivot value __snake_case : Optional[int] = new_pivot_index + 1 __snake_case : Optional[Any] = a[new_pivot_index] __snake_case : Optional[int] = a[index] __snake_case : Tuple = temp __snake_case : Any = a[new_pivot_index + 1] __snake_case : int = a[end] __snake_case : Dict = temp return new_pivot_index + 1, count _snake_case : Any = TemporaryFile() _snake_case : Dict = 100 # 1000 elements are to be sorted _snake_case , _snake_case : Dict = 0, 1 # mean and standard deviation _snake_case : Optional[int] = np.random.normal(mu, sigma, p) np.save(outfile, X) print("The array is") print(X) outfile.seek(0) # using the same array _snake_case : Optional[int] = np.load(outfile) _snake_case : Tuple = len(M) - 1 _snake_case : Dict = _in_place_quick_sort(M, 0, r) print( "No of Comparisons for 100 elements selected from a standard normal distribution" "is :" ) print(z)
134
import copy from typing import Any, Dict, List, Optional, Union import numpy as np import torch 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 _snake_case : List[Any] = logging.get_logger(__name__) class a (_lowerCAmelCase ): """simple docstring""" __UpperCAmelCase : Union[str, Any] = ["input_features", "is_longer"] def __init__( self : Optional[int] , lowerCamelCase : Any=64 , lowerCamelCase : Dict=48000 , lowerCamelCase : Dict=480 , lowerCamelCase : Tuple=10 , lowerCamelCase : Optional[int]=1024 , lowerCamelCase : int=0.0 , lowerCamelCase : Any=False , lowerCamelCase : float = 0 , lowerCamelCase : float = 14000 , lowerCamelCase : int = None , lowerCamelCase : str = "fusion" , lowerCamelCase : str = "repeatpad" , **lowerCamelCase : Optional[int] , ) -> Dict: super().__init__( feature_size=lowerCamelCase , sampling_rate=lowerCamelCase , padding_value=lowerCamelCase , return_attention_mask=lowerCamelCase , **lowerCamelCase , ) __snake_case : Optional[Any] = top_db __snake_case : Dict = truncation __snake_case : Dict = padding __snake_case : Optional[Any] = fft_window_size __snake_case : Optional[Any] = (fft_window_size >> 1) + 1 __snake_case : Dict = hop_length __snake_case : Optional[int] = max_length_s __snake_case : Optional[int] = max_length_s * sampling_rate __snake_case : Dict = sampling_rate __snake_case : Optional[int] = frequency_min __snake_case : Any = frequency_max __snake_case : Optional[int] = mel_filter_bank( num_frequency_bins=self.nb_frequency_bins , num_mel_filters=lowerCamelCase , min_frequency=lowerCamelCase , max_frequency=lowerCamelCase , sampling_rate=lowerCamelCase , norm=lowerCamelCase , mel_scale="htk" , ) __snake_case : Tuple = mel_filter_bank( num_frequency_bins=self.nb_frequency_bins , num_mel_filters=lowerCamelCase , min_frequency=lowerCamelCase , max_frequency=lowerCamelCase , sampling_rate=lowerCamelCase , norm="slaney" , mel_scale="slaney" , ) def __snake_case ( self : str ) -> Dict[str, Any]: __snake_case : List[str] = copy.deepcopy(self.__dict__ ) __snake_case : List[Any] = self.__class__.__name__ if "mel_filters" in output: del output["mel_filters"] if "mel_filters_slaney" in output: del output["mel_filters_slaney"] return output def __snake_case ( self : List[Any] , lowerCamelCase : np.array , lowerCamelCase : Optional[np.array] = None ) -> np.ndarray: __snake_case : List[Any] = spectrogram( lowerCamelCase , window_function(self.fft_window_size , "hann" ) , frame_length=self.fft_window_size , hop_length=self.hop_length , power=2.0 , mel_filters=lowerCamelCase , log_mel="dB" , ) return log_mel_spectrogram.T def __snake_case ( self : List[Any] , lowerCamelCase : Any , lowerCamelCase : Union[str, Any] , lowerCamelCase : Any ) -> str: __snake_case : Tuple = np.array_split(list(range(0 , total_frames - chunk_frames + 1 ) ) , 3 ) if len(ranges[1] ) == 0: # if the audio is too short, we just use the first chunk __snake_case : Tuple = [0] if len(ranges[2] ) == 0: # if the audio is too short, we just use the first chunk __snake_case : Tuple = [0] # randomly choose index for each part __snake_case : List[Any] = np.random.choice(ranges[0] ) __snake_case : int = np.random.choice(ranges[1] ) __snake_case : List[str] = np.random.choice(ranges[2] ) __snake_case : Dict = mel[idx_front : idx_front + chunk_frames, :] __snake_case : Optional[Any] = mel[idx_middle : idx_middle + chunk_frames, :] __snake_case : Tuple = mel[idx_back : idx_back + chunk_frames, :] __snake_case : Optional[Any] = torch.tensor(mel[None, None, :] ) __snake_case : Optional[int] = torch.nn.functional.interpolate( lowerCamelCase , size=[chunk_frames, 64] , mode="bilinear" , align_corners=lowerCamelCase ) __snake_case : List[Any] = mel_shrink[0][0].numpy() __snake_case : Union[str, Any] = np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] , axis=0 ) return mel_fusion def __snake_case ( self : Any , lowerCamelCase : np.array , lowerCamelCase : str , lowerCamelCase : Tuple , lowerCamelCase : Dict ) -> np.array: if waveform.shape[0] > max_length: if truncation == "rand_trunc": __snake_case : List[Any] = True # random crop to max_length (for compatibility) -> this should be handled by self.pad __snake_case : Tuple = len(lowerCamelCase ) - max_length __snake_case : List[Any] = np.random.randint(0 , overflow + 1 ) __snake_case : Dict = waveform[idx : idx + max_length] __snake_case : Optional[int] = self._np_extract_fbank_features(lowerCamelCase , self.mel_filters_slaney )[None, :] elif truncation == "fusion": __snake_case : Any = self._np_extract_fbank_features(lowerCamelCase , self.mel_filters ) __snake_case : Optional[int] = max_length // self.hop_length + 1 # the +1 related to how the spectrogram is computed __snake_case : str = mel.shape[0] if chunk_frames == total_frames: # there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length. # In this case, we just use the whole audio. __snake_case : str = np.stack([mel, mel, mel, mel] , axis=0 ) __snake_case : Optional[Any] = False else: __snake_case : Any = self._random_mel_fusion(lowerCamelCase , lowerCamelCase , lowerCamelCase ) __snake_case : Tuple = True else: raise NotImplementedError(F'data_truncating {truncation} not implemented' ) else: __snake_case : Dict = False # only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding if waveform.shape[0] < max_length: if padding == "repeat": __snake_case : List[str] = int(max_length / len(lowerCamelCase ) ) __snake_case : Any = np.stack(np.tile(lowerCamelCase , n_repeat + 1 ) )[:max_length] if padding == "repeatpad": __snake_case : str = int(max_length / len(lowerCamelCase ) ) __snake_case : List[str] = np.stack(np.tile(lowerCamelCase , lowerCamelCase ) ) __snake_case : str = np.pad(lowerCamelCase , (0, max_length - waveform.shape[0]) , mode="constant" , constant_values=0 ) if truncation == "fusion": __snake_case : List[str] = self._np_extract_fbank_features(lowerCamelCase , self.mel_filters ) __snake_case : List[str] = np.stack([input_mel, input_mel, input_mel, input_mel] , axis=0 ) else: __snake_case : Optional[int] = self._np_extract_fbank_features(lowerCamelCase , self.mel_filters_slaney )[None, :] return input_mel, longer def __call__( self : List[str] , lowerCamelCase : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] , lowerCamelCase : str = None , lowerCamelCase : Optional[str] = None , lowerCamelCase : Optional[int] = None , lowerCamelCase : Optional[int] = None , lowerCamelCase : Optional[Union[str, TensorType]] = None , **lowerCamelCase : Any , ) -> BatchFeature: __snake_case : Union[str, Any] = truncation if truncation is not None else self.truncation __snake_case : int = padding if padding else self.padding 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." ) __snake_case : Any = isinstance(lowerCamelCase , 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}' ) __snake_case : str = is_batched_numpy or ( isinstance(lowerCamelCase , (list, tuple) ) and (isinstance(raw_speech[0] , (np.ndarray, tuple, list) )) ) if is_batched: __snake_case : Tuple = [np.asarray(lowerCamelCase , dtype=np.floataa ) for speech in raw_speech] elif not is_batched and not isinstance(lowerCamelCase , np.ndarray ): __snake_case : str = np.asarray(lowerCamelCase , dtype=np.floataa ) elif isinstance(lowerCamelCase , np.ndarray ) and raw_speech.dtype is np.dtype(np.floataa ): __snake_case : int = raw_speech.astype(np.floataa ) # always return batch if not is_batched: __snake_case : Union[str, Any] = [np.asarray(lowerCamelCase )] # convert to mel spectrogram, truncate and pad if needed. __snake_case : Optional[int] = [ self._get_input_mel(lowerCamelCase , max_length if max_length else self.nb_max_samples , lowerCamelCase , lowerCamelCase ) for waveform in raw_speech ] __snake_case : Optional[int] = [] __snake_case : Any = [] for mel, longer in padded_inputs: input_mel.append(lowerCamelCase ) is_longer.append(lowerCamelCase ) if truncation == "fusion" and sum(lowerCamelCase ) == 0: # if no audio is longer than 10s, then randomly select one audio to be longer __snake_case : Optional[Any] = np.random.randint(0 , len(lowerCamelCase ) ) __snake_case : Union[str, Any] = True if isinstance(input_mel[0] , lowerCamelCase ): __snake_case : List[str] = [np.asarray(lowerCamelCase , dtype=np.floataa ) for feature in input_mel] # is_longer is a list of bool __snake_case : Any = [[longer] for longer in is_longer] __snake_case : Tuple = {"input_features": input_mel, "is_longer": is_longer} __snake_case : List[str] = BatchFeature(lowerCamelCase ) if return_tensors is not None: __snake_case : Any = input_features.convert_to_tensors(lowerCamelCase ) return input_features
134
1
"""simple docstring""" import argparse import json from pathlib import Path import requests import timm import torch from huggingface_hub import hf_hub_download from PIL import Image from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel from transformers.utils import logging logging.set_verbosity_info() __magic_name__ = logging.get_logger(__name__) def _lowerCAmelCase ( UpperCamelCase_ , UpperCamelCase_=False ): __SCREAMING_SNAKE_CASE = [] for i in range(config.num_hidden_layers ): # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms rename_keys.append((f"blocks.{i}.norm1.weight", f"vit.encoder.layer.{i}.layernorm_before.weight") ) rename_keys.append((f"blocks.{i}.norm1.bias", f"vit.encoder.layer.{i}.layernorm_before.bias") ) rename_keys.append((f"blocks.{i}.attn.proj.weight", f"vit.encoder.layer.{i}.attention.output.dense.weight") ) rename_keys.append((f"blocks.{i}.attn.proj.bias", f"vit.encoder.layer.{i}.attention.output.dense.bias") ) rename_keys.append((f"blocks.{i}.norm2.weight", f"vit.encoder.layer.{i}.layernorm_after.weight") ) rename_keys.append((f"blocks.{i}.norm2.bias", f"vit.encoder.layer.{i}.layernorm_after.bias") ) rename_keys.append((f"blocks.{i}.mlp.fc1.weight", f"vit.encoder.layer.{i}.intermediate.dense.weight") ) rename_keys.append((f"blocks.{i}.mlp.fc1.bias", f"vit.encoder.layer.{i}.intermediate.dense.bias") ) rename_keys.append((f"blocks.{i}.mlp.fc2.weight", f"vit.encoder.layer.{i}.output.dense.weight") ) rename_keys.append((f"blocks.{i}.mlp.fc2.bias", f"vit.encoder.layer.{i}.output.dense.bias") ) # projection layer + position embeddings rename_keys.extend( [ ("""cls_token""", """vit.embeddings.cls_token"""), ("""patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight"""), ("""patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias"""), ("""pos_embed""", """vit.embeddings.position_embeddings"""), ] ) if base_model: # layernorm + pooler rename_keys.extend( [ ("""norm.weight""", """layernorm.weight"""), ("""norm.bias""", """layernorm.bias"""), ("""pre_logits.fc.weight""", """pooler.dense.weight"""), ("""pre_logits.fc.bias""", """pooler.dense.bias"""), ] ) # if just the base model, we should remove "vit" from all keys that start with "vit" __SCREAMING_SNAKE_CASE = [(pair[0], pair[1][4:]) if pair[1].startswith("""vit""" ) else pair for pair in rename_keys] else: # layernorm + classification head rename_keys.extend( [ ("""norm.weight""", """vit.layernorm.weight"""), ("""norm.bias""", """vit.layernorm.bias"""), ("""head.weight""", """classifier.weight"""), ("""head.bias""", """classifier.bias"""), ] ) return rename_keys def _lowerCAmelCase ( UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_=False ): for i in range(config.num_hidden_layers ): if base_model: __SCREAMING_SNAKE_CASE = """""" else: __SCREAMING_SNAKE_CASE = """vit.""" # read in weights + bias of input projection layer (in timm, this is a single matrix + bias) __SCREAMING_SNAKE_CASE = state_dict.pop(f"blocks.{i}.attn.qkv.weight" ) __SCREAMING_SNAKE_CASE = state_dict.pop(f"blocks.{i}.attn.qkv.bias" ) # next, add query, keys and values (in that order) to the state dict __SCREAMING_SNAKE_CASE = in_proj_weight[ : config.hidden_size, : ] __SCREAMING_SNAKE_CASE = in_proj_bias[: config.hidden_size] __SCREAMING_SNAKE_CASE = in_proj_weight[ config.hidden_size : config.hidden_size * 2, : ] __SCREAMING_SNAKE_CASE = in_proj_bias[ config.hidden_size : config.hidden_size * 2 ] __SCREAMING_SNAKE_CASE = in_proj_weight[ -config.hidden_size :, : ] __SCREAMING_SNAKE_CASE = in_proj_bias[-config.hidden_size :] def _lowerCAmelCase ( UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = ["""head.weight""", """head.bias"""] for k in ignore_keys: state_dict.pop(_lowerCamelCase , _lowerCamelCase ) def _lowerCAmelCase ( UpperCamelCase_ , UpperCamelCase_ , UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = dct.pop(_lowerCamelCase ) __SCREAMING_SNAKE_CASE = val def _lowerCAmelCase ( ): __SCREAMING_SNAKE_CASE = """http://images.cocodataset.org/val2017/000000039769.jpg""" __SCREAMING_SNAKE_CASE = Image.open(requests.get(_lowerCamelCase , stream=_lowerCamelCase ).raw ) return im @torch.no_grad() def _lowerCAmelCase ( UpperCamelCase_ , UpperCamelCase_ ): __SCREAMING_SNAKE_CASE = ViTConfig() __SCREAMING_SNAKE_CASE = False # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size if vit_name[-5:] == "in21k": __SCREAMING_SNAKE_CASE = True __SCREAMING_SNAKE_CASE = int(vit_name[-12:-10] ) __SCREAMING_SNAKE_CASE = int(vit_name[-9:-6] ) else: __SCREAMING_SNAKE_CASE = 1000 __SCREAMING_SNAKE_CASE = """huggingface/label-files""" __SCREAMING_SNAKE_CASE = """imagenet-1k-id2label.json""" __SCREAMING_SNAKE_CASE = json.load(open(hf_hub_download(_lowerCamelCase , _lowerCamelCase , repo_type="""dataset""" ) , """r""" ) ) __SCREAMING_SNAKE_CASE = {int(_lowerCamelCase ): v for k, v in idalabel.items()} __SCREAMING_SNAKE_CASE = idalabel __SCREAMING_SNAKE_CASE = {v: k for k, v in idalabel.items()} __SCREAMING_SNAKE_CASE = int(vit_name[-6:-4] ) __SCREAMING_SNAKE_CASE = int(vit_name[-3:] ) # size of the architecture if "deit" in vit_name: if vit_name[9:].startswith("""tiny""" ): __SCREAMING_SNAKE_CASE = 192 __SCREAMING_SNAKE_CASE = 768 __SCREAMING_SNAKE_CASE = 12 __SCREAMING_SNAKE_CASE = 3 elif vit_name[9:].startswith("""small""" ): __SCREAMING_SNAKE_CASE = 384 __SCREAMING_SNAKE_CASE = 1536 __SCREAMING_SNAKE_CASE = 12 __SCREAMING_SNAKE_CASE = 6 else: pass else: if vit_name[4:].startswith("""small""" ): __SCREAMING_SNAKE_CASE = 768 __SCREAMING_SNAKE_CASE = 2304 __SCREAMING_SNAKE_CASE = 8 __SCREAMING_SNAKE_CASE = 8 elif vit_name[4:].startswith("""base""" ): pass elif vit_name[4:].startswith("""large""" ): __SCREAMING_SNAKE_CASE = 1024 __SCREAMING_SNAKE_CASE = 4096 __SCREAMING_SNAKE_CASE = 24 __SCREAMING_SNAKE_CASE = 16 elif vit_name[4:].startswith("""huge""" ): __SCREAMING_SNAKE_CASE = 1280 __SCREAMING_SNAKE_CASE = 5120 __SCREAMING_SNAKE_CASE = 32 __SCREAMING_SNAKE_CASE = 16 # load original model from timm __SCREAMING_SNAKE_CASE = timm.create_model(_lowerCamelCase , pretrained=_lowerCamelCase ) timm_model.eval() # load state_dict of original model, remove and rename some keys __SCREAMING_SNAKE_CASE = timm_model.state_dict() if base_model: remove_classification_head_(_lowerCamelCase ) __SCREAMING_SNAKE_CASE = create_rename_keys(_lowerCamelCase , _lowerCamelCase ) for src, dest in rename_keys: rename_key(_lowerCamelCase , _lowerCamelCase , _lowerCamelCase ) read_in_q_k_v(_lowerCamelCase , _lowerCamelCase , _lowerCamelCase ) # load HuggingFace model if vit_name[-5:] == "in21k": __SCREAMING_SNAKE_CASE = ViTModel(_lowerCamelCase ).eval() else: __SCREAMING_SNAKE_CASE = ViTForImageClassification(_lowerCamelCase ).eval() model.load_state_dict(_lowerCamelCase ) # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor if "deit" in vit_name: __SCREAMING_SNAKE_CASE = DeiTImageProcessor(size=config.image_size ) else: __SCREAMING_SNAKE_CASE = ViTImageProcessor(size=config.image_size ) __SCREAMING_SNAKE_CASE = image_processor(images=prepare_img() , return_tensors="""pt""" ) __SCREAMING_SNAKE_CASE = encoding["""pixel_values"""] __SCREAMING_SNAKE_CASE = model(_lowerCamelCase ) if base_model: __SCREAMING_SNAKE_CASE = timm_model.forward_features(_lowerCamelCase ) assert timm_pooled_output.shape == outputs.pooler_output.shape assert torch.allclose(_lowerCamelCase , outputs.pooler_output , atol=1e-3 ) else: __SCREAMING_SNAKE_CASE = timm_model(_lowerCamelCase ) assert timm_logits.shape == outputs.logits.shape assert torch.allclose(_lowerCamelCase , outputs.logits , atol=1e-3 ) Path(_lowerCamelCase ).mkdir(exist_ok=_lowerCamelCase ) print(f"Saving model {vit_name} to {pytorch_dump_folder_path}" ) model.save_pretrained(_lowerCamelCase ) print(f"Saving image processor to {pytorch_dump_folder_path}" ) image_processor.save_pretrained(_lowerCamelCase ) if __name__ == "__main__": __magic_name__ = argparse.ArgumentParser() # Required parameters parser.add_argument( "--vit_name", default="vit_base_patch16_224", type=str, help="Name of the ViT timm model you'd like to convert.", ) parser.add_argument( "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory." ) __magic_name__ = parser.parse_args() convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)
100
'''simple docstring''' 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 UpperCAmelCase_ ( self :Optional[Any] )-> Tuple: A__ = tempfile.mkdtemp() # fmt: off A__ = ["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 A__ = dict(zip(lowercase_ , range(len(lowercase_ ) ) ) ) A__ = ["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""] A__ = {"unk_token": "<unk>"} A__ = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["vocab_file"] ) A__ = 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(lowercase_ ) + "\n" ) with open(self.merges_file , "w" , encoding="utf-8" ) as fp: fp.write("\n".join(lowercase_ ) ) A__ = { "do_resize": True, "size": 20, "do_center_crop": True, "crop_size": 18, "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], } A__ = os.path.join(self.tmpdirname , lowercase_ ) with open(self.image_processor_file , "w" , encoding="utf-8" ) as fp: json.dump(lowercase_ , lowercase_ ) def UpperCAmelCase_ ( self :Any , **lowercase_ :Union[str, Any] )-> Tuple: return CLIPTokenizer.from_pretrained(self.tmpdirname , **lowercase_ ) def UpperCAmelCase_ ( self :Any , **lowercase_ :Tuple )-> Dict: return CLIPTokenizerFast.from_pretrained(self.tmpdirname , **lowercase_ ) def UpperCAmelCase_ ( self :Dict , **lowercase_ :Union[str, Any] )-> Any: return CLIPImageProcessor.from_pretrained(self.tmpdirname , **lowercase_ ) def UpperCAmelCase_ ( self :List[str] )-> int: shutil.rmtree(self.tmpdirname ) def UpperCAmelCase_ ( self :Optional[int] )-> Optional[int]: A__ = [np.random.randint(2_55 , size=(3, 30, 4_00) , dtype=np.uinta )] A__ = [Image.fromarray(np.moveaxis(lowercase_ , 0 , -1 ) ) for x in image_inputs] return image_inputs def UpperCAmelCase_ ( self :int )-> List[Any]: A__ = self.get_tokenizer() A__ = self.get_rust_tokenizer() A__ = self.get_image_processor() A__ = CLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_ ) processor_slow.save_pretrained(self.tmpdirname ) A__ = CLIPProcessor.from_pretrained(self.tmpdirname , use_fast=lowercase_ ) A__ = CLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_ ) processor_fast.save_pretrained(self.tmpdirname ) A__ = 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 , lowercase_ ) self.assertIsInstance(processor_fast.tokenizer , lowercase_ ) 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 , lowercase_ ) self.assertIsInstance(processor_fast.image_processor , lowercase_ ) def UpperCAmelCase_ ( self :Optional[Any] )-> Optional[int]: A__ = CLIPProcessor(tokenizer=self.get_tokenizer() , image_processor=self.get_image_processor() ) processor.save_pretrained(self.tmpdirname ) A__ = self.get_tokenizer(bos_token="(BOS)" , eos_token="(EOS)" ) A__ = self.get_image_processor(do_normalize=lowercase_ , padding_value=1.0 ) A__ = CLIPProcessor.from_pretrained( self.tmpdirname , bos_token="(BOS)" , eos_token="(EOS)" , do_normalize=lowercase_ , padding_value=1.0 ) self.assertEqual(processor.tokenizer.get_vocab() , tokenizer_add_kwargs.get_vocab() ) self.assertIsInstance(processor.tokenizer , lowercase_ ) self.assertEqual(processor.image_processor.to_json_string() , image_processor_add_kwargs.to_json_string() ) self.assertIsInstance(processor.image_processor , lowercase_ ) def UpperCAmelCase_ ( self :List[Any] )-> Tuple: A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = CLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_ ) A__ = self.prepare_image_inputs() A__ = image_processor(lowercase_ , return_tensors="np" ) A__ = processor(images=lowercase_ , 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 :Optional[int] )-> Dict: A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = CLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_ ) A__ = "lower newer" A__ = processor(text=lowercase_ ) A__ = tokenizer(lowercase_ ) for key in encoded_tok.keys(): self.assertListEqual(encoded_tok[key] , encoded_processor[key] ) def UpperCAmelCase_ ( self :str )-> Any: A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = CLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_ ) A__ = "lower newer" A__ = self.prepare_image_inputs() A__ = processor(text=lowercase_ , images=lowercase_ ) self.assertListEqual(list(inputs.keys() ) , ["input_ids", "attention_mask", "pixel_values"] ) # test if it raises when no input is passed with pytest.raises(lowercase_ ): processor() def UpperCAmelCase_ ( self :Tuple )-> Tuple: A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = CLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_ ) A__ = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]] A__ = processor.batch_decode(lowercase_ ) A__ = tokenizer.batch_decode(lowercase_ ) self.assertListEqual(lowercase_ , lowercase_ ) def UpperCAmelCase_ ( self :List[Any] )-> Dict: A__ = self.get_image_processor() A__ = self.get_tokenizer() A__ = CLIPProcessor(tokenizer=lowercase_ , image_processor=lowercase_ ) A__ = "lower newer" A__ = self.prepare_image_inputs() A__ = processor(text=lowercase_ , images=lowercase_ ) self.assertListEqual(list(inputs.keys() ) , processor.model_input_names )
237
0
import os import sys import warnings from dataclasses import dataclass, field from io import BytesIO from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union import numpy as np import pyarrow as pa from .. import config from ..download.streaming_download_manager import xopen from ..table import array_cast from ..utils.file_utils import is_local_path from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict if TYPE_CHECKING: import PIL.Image from .features import FeatureType _UpperCAmelCase = None _UpperCAmelCase = '<' if sys.byteorder == 'little' else '>' # Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image _UpperCAmelCase = [ np.dtype('|b1'), np.dtype('|u1'), np.dtype('<u2'), np.dtype('>u2'), np.dtype('<i2'), np.dtype('>i2'), np.dtype('<u4'), np.dtype('>u4'), np.dtype('<i4'), np.dtype('>i4'), np.dtype('<f4'), np.dtype('>f4'), np.dtype('<f8'), np.dtype('>f8'), ] @dataclass class _UpperCamelCase : _UpperCamelCase : bool = True _UpperCamelCase : Optional[str] = None # Automatically constructed _UpperCamelCase : ClassVar[str] = "PIL.Image.Image" _UpperCamelCase : ClassVar[Any] = pa.struct({'''bytes''': pa.binary(), '''path''': pa.string()} ) _UpperCamelCase : str = field(default='''Image''' , init=lowerCAmelCase_ , repr=lowerCAmelCase_ ) def __call__( self: List[Any] ) -> List[str]: """simple docstring""" return self.pa_type def lowercase ( self: List[str] , _SCREAMING_SNAKE_CASE: Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] ) -> dict: """simple docstring""" if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("To support encoding images, please install 'Pillow'." ) if isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): UpperCamelCase_ = np.array(_SCREAMING_SNAKE_CASE ) if isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): return {"path": value, "bytes": None} elif isinstance(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): return {"path": None, "bytes": value} elif isinstance(_SCREAMING_SNAKE_CASE , np.ndarray ): # convert the image array to PNG/TIFF bytes return encode_np_array(_SCREAMING_SNAKE_CASE ) elif isinstance(_SCREAMING_SNAKE_CASE , PIL.Image.Image ): # convert the PIL image to bytes (default format is PNG/TIFF) return encode_pil_image(_SCREAMING_SNAKE_CASE ) elif value.get("path" ) is not None and os.path.isfile(value["path"] ): # we set "bytes": None to not duplicate the data if they're already available locally return {"bytes": None, "path": value.get("path" )} elif value.get("bytes" ) is not None or value.get("path" ) is not None: # store the image bytes, and path is used to infer the image format using the file extension return {"bytes": value.get("bytes" ), "path": value.get("path" )} else: raise ValueError( f'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.''' ) def lowercase ( self: List[str] , _SCREAMING_SNAKE_CASE: dict , _SCREAMING_SNAKE_CASE: str=None ) -> "PIL.Image.Image": """simple docstring""" if not self.decode: raise RuntimeError("Decoding is disabled for this feature. Please use Image(decode=True) instead." ) if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("To support decoding images, please install 'Pillow'." ) if token_per_repo_id is None: UpperCamelCase_ = {} UpperCamelCase_ , UpperCamelCase_ = value["path"], value["bytes"] if bytes_ is None: if path is None: raise ValueError(f'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.''' ) else: if is_local_path(_SCREAMING_SNAKE_CASE ): UpperCamelCase_ = PIL.Image.open(_SCREAMING_SNAKE_CASE ) else: UpperCamelCase_ = path.split("::" )[-1] try: UpperCamelCase_ = string_to_dict(_SCREAMING_SNAKE_CASE , config.HUB_DATASETS_URL )["repo_id"] UpperCamelCase_ = token_per_repo_id.get(_SCREAMING_SNAKE_CASE ) except ValueError: UpperCamelCase_ = None with xopen(_SCREAMING_SNAKE_CASE , "rb" , use_auth_token=_SCREAMING_SNAKE_CASE ) as f: UpperCamelCase_ = BytesIO(f.read() ) UpperCamelCase_ = PIL.Image.open(bytes_ ) else: UpperCamelCase_ = PIL.Image.open(BytesIO(bytes_ ) ) image.load() # to avoid "Too many open files" errors return image def lowercase ( self: List[Any] ) -> Union["FeatureType", Dict[str, "FeatureType"]]: """simple docstring""" from .features import Value return ( self if self.decode else { "bytes": Value("binary" ), "path": Value("string" ), } ) def lowercase ( self: Union[str, Any] , _SCREAMING_SNAKE_CASE: Union[pa.StringArray, pa.StructArray, pa.ListArray] ) -> pa.StructArray: """simple docstring""" if pa.types.is_string(storage.type ): UpperCamelCase_ = pa.array([None] * len(_SCREAMING_SNAKE_CASE ) , type=pa.binary() ) UpperCamelCase_ = pa.StructArray.from_arrays([bytes_array, storage] , ["bytes", "path"] , mask=storage.is_null() ) elif pa.types.is_binary(storage.type ): UpperCamelCase_ = pa.array([None] * len(_SCREAMING_SNAKE_CASE ) , type=pa.string() ) UpperCamelCase_ = pa.StructArray.from_arrays([storage, path_array] , ["bytes", "path"] , mask=storage.is_null() ) elif pa.types.is_struct(storage.type ): if storage.type.get_field_index("bytes" ) >= 0: UpperCamelCase_ = storage.field("bytes" ) else: UpperCamelCase_ = pa.array([None] * len(_SCREAMING_SNAKE_CASE ) , type=pa.binary() ) if storage.type.get_field_index("path" ) >= 0: UpperCamelCase_ = storage.field("path" ) else: UpperCamelCase_ = pa.array([None] * len(_SCREAMING_SNAKE_CASE ) , type=pa.string() ) UpperCamelCase_ = pa.StructArray.from_arrays([bytes_array, path_array] , ["bytes", "path"] , mask=storage.is_null() ) elif pa.types.is_list(storage.type ): UpperCamelCase_ = pa.array( [encode_np_array(np.array(_SCREAMING_SNAKE_CASE ) )["bytes"] if arr is not None else None for arr in storage.to_pylist()] , type=pa.binary() , ) UpperCamelCase_ = pa.array([None] * len(_SCREAMING_SNAKE_CASE ) , type=pa.string() ) UpperCamelCase_ = pa.StructArray.from_arrays( [bytes_array, path_array] , ["bytes", "path"] , mask=bytes_array.is_null() ) return array_cast(_SCREAMING_SNAKE_CASE , self.pa_type ) def lowercase ( self: Tuple , _SCREAMING_SNAKE_CASE: pa.StructArray ) -> pa.StructArray: """simple docstring""" @no_op_if_value_is_null def path_to_bytes(_SCREAMING_SNAKE_CASE: Tuple ): with xopen(_SCREAMING_SNAKE_CASE , "rb" ) as f: UpperCamelCase_ = f.read() return bytes_ UpperCamelCase_ = pa.array( [ (path_to_bytes(x["path"] ) if x["bytes"] is None else x["bytes"]) if x is not None else None for x in storage.to_pylist() ] , type=pa.binary() , ) UpperCamelCase_ = pa.array( [os.path.basename(_SCREAMING_SNAKE_CASE ) if path is not None else None for path in storage.field("path" ).to_pylist()] , type=pa.string() , ) UpperCamelCase_ = pa.StructArray.from_arrays([bytes_array, path_array] , ["bytes", "path"] , mask=bytes_array.is_null() ) return array_cast(_SCREAMING_SNAKE_CASE , self.pa_type ) def lowerCAmelCase_ ( ) -> List[str]: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("To support encoding images, please install 'Pillow'." ) global _IMAGE_COMPRESSION_FORMATS if _IMAGE_COMPRESSION_FORMATS is None: PIL.Image.init() UpperCamelCase_ = list(set(PIL.Image.OPEN.keys() ) & set(PIL.Image.SAVE.keys() ) ) return _IMAGE_COMPRESSION_FORMATS def lowerCAmelCase_ ( UpperCamelCase_ ) -> bytes: UpperCamelCase_ = BytesIO() if image.format in list_image_compression_formats(): UpperCamelCase_ = image.format else: UpperCamelCase_ = "PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF" image.save(UpperCamelCase_ , format=UpperCamelCase_ ) return buffer.getvalue() def lowerCAmelCase_ ( UpperCamelCase_ ) -> dict: if hasattr(UpperCamelCase_ , "filename" ) and image.filename != "": return {"path": image.filename, "bytes": None} else: return {"path": None, "bytes": image_to_bytes(UpperCamelCase_ )} def lowerCAmelCase_ ( UpperCamelCase_ ) -> dict: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("To support encoding images, please install 'Pillow'." ) UpperCamelCase_ = array.dtype UpperCamelCase_ = dtype.byteorder if dtype.byteorder != "=" else _NATIVE_BYTEORDER UpperCamelCase_ = dtype.kind UpperCamelCase_ = dtype.itemsize UpperCamelCase_ = None # Multi-channel array case (only np.dtype("|u1") is allowed) if array.shape[2:]: UpperCamelCase_ = np.dtype("|u1" ) if dtype_kind not in ["u", "i"]: raise TypeError( F'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.''' ) if dtype is not dest_dtype: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) # Exact match elif dtype in _VALID_IMAGE_ARRAY_DTPYES: UpperCamelCase_ = dtype else: # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually) while dtype_itemsize >= 1: UpperCamelCase_ = dtype_byteorder + dtype_kind + str(UpperCamelCase_ ) UpperCamelCase_ = np.dtype(UpperCamelCase_ ) if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES: warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\'''' ) break else: dtype_itemsize //= 2 if dest_dtype is None: raise TypeError( F'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}''' ) UpperCamelCase_ = PIL.Image.fromarray(array.astype(UpperCamelCase_ ) ) return {"path": None, "bytes": image_to_bytes(UpperCamelCase_ )} def lowerCAmelCase_ ( UpperCamelCase_ ) -> List[dict]: if config.PIL_AVAILABLE: import PIL.Image else: raise ImportError("To support encoding images, please install 'Pillow'." ) if objs: UpperCamelCase_ , UpperCamelCase_ = first_non_null_value(UpperCamelCase_ ) if isinstance(UpperCamelCase_ , UpperCamelCase_ ): return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs] if isinstance(UpperCamelCase_ , np.ndarray ): UpperCamelCase_ = no_op_if_value_is_null(UpperCamelCase_ ) return [obj_to_image_dict_func(UpperCamelCase_ ) for obj in objs] elif isinstance(UpperCamelCase_ , PIL.Image.Image ): UpperCamelCase_ = no_op_if_value_is_null(UpperCamelCase_ ) return [obj_to_image_dict_func(UpperCamelCase_ ) for obj in objs] else: return objs else: return objs
328
import gc import unittest import numpy as np import torch from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu from ..pipeline_params import ( CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS, CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS, ) from ..test_pipelines_common import PipelineTesterMixin enable_full_determinism() class _UpperCamelCase ( lowerCAmelCase_ , unittest.TestCase ): _UpperCamelCase : Optional[Any] = DiTPipeline _UpperCamelCase : Any = CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS _UpperCamelCase : Dict = PipelineTesterMixin.required_optional_params - { '''latents''', '''num_images_per_prompt''', '''callback''', '''callback_steps''', } _UpperCamelCase : Optional[int] = CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS _UpperCamelCase : Dict = False def lowercase ( self: str ) -> List[str]: """simple docstring""" torch.manual_seed(0 ) UpperCamelCase_ = TransformeraDModel( sample_size=16 , num_layers=2 , patch_size=4 , attention_head_dim=8 , num_attention_heads=2 , in_channels=4 , out_channels=8 , attention_bias=_SCREAMING_SNAKE_CASE , activation_fn="gelu-approximate" , num_embeds_ada_norm=1000 , norm_type="ada_norm_zero" , norm_elementwise_affine=_SCREAMING_SNAKE_CASE , ) UpperCamelCase_ = AutoencoderKL() UpperCamelCase_ = DDIMScheduler() UpperCamelCase_ = {"transformer": transformer.eval(), "vae": vae.eval(), "scheduler": scheduler} return components def lowercase ( self: str , _SCREAMING_SNAKE_CASE: Dict , _SCREAMING_SNAKE_CASE: List[str]=0 ) -> Dict: """simple docstring""" if str(_SCREAMING_SNAKE_CASE ).startswith("mps" ): UpperCamelCase_ = torch.manual_seed(_SCREAMING_SNAKE_CASE ) else: UpperCamelCase_ = torch.Generator(device=_SCREAMING_SNAKE_CASE ).manual_seed(_SCREAMING_SNAKE_CASE ) UpperCamelCase_ = { "class_labels": [1], "generator": generator, "num_inference_steps": 2, "output_type": "numpy", } return inputs def lowercase ( self: Any ) -> List[str]: """simple docstring""" UpperCamelCase_ = "cpu" UpperCamelCase_ = self.get_dummy_components() UpperCamelCase_ = self.pipeline_class(**_SCREAMING_SNAKE_CASE ) pipe.to(_SCREAMING_SNAKE_CASE ) pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE ) UpperCamelCase_ = self.get_dummy_inputs(_SCREAMING_SNAKE_CASE ) UpperCamelCase_ = pipe(**_SCREAMING_SNAKE_CASE ).images UpperCamelCase_ = image[0, -3:, -3:, -1] self.assertEqual(image.shape , (1, 16, 16, 3) ) UpperCamelCase_ = np.array([0.29_46, 0.66_01, 0.43_29, 0.32_96, 0.41_44, 0.53_19, 0.72_73, 0.50_13, 0.44_57] ) UpperCamelCase_ = np.abs(image_slice.flatten() - expected_slice ).max() self.assertLessEqual(_SCREAMING_SNAKE_CASE , 1e-3 ) def lowercase ( self: Optional[int] ) -> Any: """simple docstring""" self._test_inference_batch_single_identical(relax_max_difference=_SCREAMING_SNAKE_CASE , expected_max_diff=1e-3 ) @unittest.skipIf( torch_device != "cuda" or not is_xformers_available() , reason="XFormers attention is only available with CUDA and `xformers` installed" , ) def lowercase ( self: Optional[Any] ) -> Optional[int]: """simple docstring""" self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3 ) @require_torch_gpu @slow class _UpperCamelCase ( unittest.TestCase ): def lowercase ( self: Optional[int] ) -> List[str]: """simple docstring""" super().tearDown() gc.collect() torch.cuda.empty_cache() def lowercase ( self: Union[str, Any] ) -> Optional[int]: """simple docstring""" UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = DiTPipeline.from_pretrained("facebook/DiT-XL-2-256" ) pipe.to("cuda" ) UpperCamelCase_ = ["vase", "umbrella", "white shark", "white wolf"] UpperCamelCase_ = pipe.get_label_ids(_SCREAMING_SNAKE_CASE ) UpperCamelCase_ = pipe(_SCREAMING_SNAKE_CASE , generator=_SCREAMING_SNAKE_CASE , num_inference_steps=40 , output_type="np" ).images for word, image in zip(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): UpperCamelCase_ = load_numpy( f'''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy''' ) assert np.abs((expected_image - image).max() ) < 1e-2 def lowercase ( self: int ) -> Union[str, Any]: """simple docstring""" UpperCamelCase_ = DiTPipeline.from_pretrained("facebook/DiT-XL-2-512" ) UpperCamelCase_ = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config ) pipe.to("cuda" ) UpperCamelCase_ = ["vase", "umbrella"] UpperCamelCase_ = pipe.get_label_ids(_SCREAMING_SNAKE_CASE ) UpperCamelCase_ = torch.manual_seed(0 ) UpperCamelCase_ = pipe(_SCREAMING_SNAKE_CASE , generator=_SCREAMING_SNAKE_CASE , num_inference_steps=25 , output_type="np" ).images for word, image in zip(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): UpperCamelCase_ = load_numpy( "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" f'''/dit/{word}_512.npy''' ) assert np.abs((expected_image - image).max() ) < 1e-1
328
1
import json import os import re import unittest from transformers import CodeGenTokenizer, CodeGenTokenizerFast from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class _A ( __UpperCAmelCase ,unittest.TestCase ): UpperCamelCase__ : Tuple = CodeGenTokenizer UpperCamelCase__ : Tuple = CodeGenTokenizerFast UpperCamelCase__ : int = True UpperCamelCase__ : List[str] = {'''add_prefix_space''': True} UpperCamelCase__ : str = False def _lowerCamelCase ( self : Optional[int]): '''simple docstring''' super().setUp() # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt __a = [ '''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''\u0120''', '''\u0120l''', '''\u0120n''', '''\u0120lo''', '''\u0120low''', '''er''', '''\u0120lowest''', '''\u0120newer''', '''\u0120wider''', '''<unk>''', '''<|endoftext|>''', ] __a = dict(zip(__SCREAMING_SNAKE_CASE , range(len(__SCREAMING_SNAKE_CASE)))) __a = ['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', ''''''] __a = {'''unk_token''': '''<unk>'''} __a = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES['''vocab_file''']) __a = 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(__SCREAMING_SNAKE_CASE) + '''\n''') with open(self.merges_file , '''w''' , encoding='''utf-8''') as fp: fp.write('''\n'''.join(__SCREAMING_SNAKE_CASE)) def _lowerCamelCase ( self : Any , **__SCREAMING_SNAKE_CASE : Optional[int]): '''simple docstring''' kwargs.update(self.special_tokens_map) return CodeGenTokenizer.from_pretrained(self.tmpdirname , **__SCREAMING_SNAKE_CASE) def _lowerCamelCase ( self : Tuple , **__SCREAMING_SNAKE_CASE : Optional[int]): '''simple docstring''' kwargs.update(self.special_tokens_map) return CodeGenTokenizerFast.from_pretrained(self.tmpdirname , **__SCREAMING_SNAKE_CASE) def _lowerCamelCase ( self : List[Any] , __SCREAMING_SNAKE_CASE : str): '''simple docstring''' __a = '''lower newer''' __a = '''lower newer''' return input_text, output_text def _lowerCamelCase ( self : List[str]): '''simple docstring''' __a = CodeGenTokenizer(self.vocab_file , self.merges_file , **self.special_tokens_map) __a = '''lower newer''' __a = ['''\u0120low''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er'''] __a = tokenizer.tokenize(__SCREAMING_SNAKE_CASE , add_prefix_space=__SCREAMING_SNAKE_CASE) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE) __a = tokens + [tokenizer.unk_token] __a = [14, 15, 10, 9, 3, 2, 15, 19] self.assertListEqual(tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE) , __SCREAMING_SNAKE_CASE) def _lowerCamelCase ( self : int): '''simple docstring''' if not self.test_rust_tokenizer: return __a = self.get_tokenizer() __a = self.get_rust_tokenizer(add_prefix_space=__SCREAMING_SNAKE_CASE) __a = '''lower newer''' # Testing tokenization __a = tokenizer.tokenize(__SCREAMING_SNAKE_CASE , add_prefix_space=__SCREAMING_SNAKE_CASE) __a = rust_tokenizer.tokenize(__SCREAMING_SNAKE_CASE) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE) # Testing conversion to ids without special tokens __a = tokenizer.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE , add_prefix_space=__SCREAMING_SNAKE_CASE) __a = rust_tokenizer.encode(__SCREAMING_SNAKE_CASE , add_special_tokens=__SCREAMING_SNAKE_CASE) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE) # Testing conversion to ids with special tokens __a = self.get_rust_tokenizer(add_prefix_space=__SCREAMING_SNAKE_CASE) __a = tokenizer.encode(__SCREAMING_SNAKE_CASE , add_prefix_space=__SCREAMING_SNAKE_CASE) __a = rust_tokenizer.encode(__SCREAMING_SNAKE_CASE) self.assertListEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE) # Testing the unknown token __a = tokens + [rust_tokenizer.unk_token] __a = [14, 15, 10, 9, 3, 2, 15, 19] self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE) , __SCREAMING_SNAKE_CASE) def _lowerCamelCase ( self : Union[str, Any] , *__SCREAMING_SNAKE_CASE : Optional[int] , **__SCREAMING_SNAKE_CASE : Dict): '''simple docstring''' pass def _lowerCamelCase ( self : str , __SCREAMING_SNAKE_CASE : str=15): '''simple docstring''' for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'): __a = self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE) # Simple input __a = '''This is a simple input''' __a = ['''This is a simple input 1''', '''This is a simple input 2'''] __a = ('''This is a simple input''', '''This is a pair''') __a = [ ('''This is a simple input 1''', '''This is a simple input 2'''), ('''This is a simple pair 1''', '''This is a simple pair 2'''), ] # Simple input tests self.assertRaises(__SCREAMING_SNAKE_CASE , tokenizer_r.encode , __SCREAMING_SNAKE_CASE , max_length=__SCREAMING_SNAKE_CASE , padding='''max_length''') # Simple input self.assertRaises(__SCREAMING_SNAKE_CASE , tokenizer_r.encode_plus , __SCREAMING_SNAKE_CASE , max_length=__SCREAMING_SNAKE_CASE , padding='''max_length''') # Simple input self.assertRaises( __SCREAMING_SNAKE_CASE , tokenizer_r.batch_encode_plus , __SCREAMING_SNAKE_CASE , max_length=__SCREAMING_SNAKE_CASE , padding='''max_length''' , ) # Pair input self.assertRaises(__SCREAMING_SNAKE_CASE , tokenizer_r.encode , __SCREAMING_SNAKE_CASE , max_length=__SCREAMING_SNAKE_CASE , padding='''max_length''') # Pair input self.assertRaises(__SCREAMING_SNAKE_CASE , tokenizer_r.encode_plus , __SCREAMING_SNAKE_CASE , max_length=__SCREAMING_SNAKE_CASE , padding='''max_length''') # Pair input self.assertRaises( __SCREAMING_SNAKE_CASE , tokenizer_r.batch_encode_plus , __SCREAMING_SNAKE_CASE , max_length=__SCREAMING_SNAKE_CASE , padding='''max_length''' , ) def _lowerCamelCase ( self : Any): '''simple docstring''' __a = CodeGenTokenizer.from_pretrained(self.tmpdirname , pad_token='''<pad>''') # Simple input __a = '''This is a simple input''' __a = ['''This is a simple input looooooooong''', '''This is a simple input'''] __a = ('''This is a simple input''', '''This is a pair''') __a = [ ('''This is a simple input loooooong''', '''This is a simple input'''), ('''This is a simple pair loooooong''', '''This is a simple pair'''), ] __a = tokenizer.pad_token_id __a = tokenizer(__SCREAMING_SNAKE_CASE , padding='''max_length''' , max_length=30 , return_tensors='''np''') __a = tokenizer(__SCREAMING_SNAKE_CASE , padding=__SCREAMING_SNAKE_CASE , truncate=__SCREAMING_SNAKE_CASE , return_tensors='''np''') __a = tokenizer(*__SCREAMING_SNAKE_CASE , padding='''max_length''' , max_length=60 , return_tensors='''np''') __a = tokenizer(__SCREAMING_SNAKE_CASE , padding=__SCREAMING_SNAKE_CASE , truncate=__SCREAMING_SNAKE_CASE , return_tensors='''np''') # s # test single string max_length padding self.assertEqual(out_s['''input_ids'''].shape[-1] , 30) self.assertTrue(pad_token_id in out_s['''input_ids''']) self.assertTrue(0 in out_s['''attention_mask''']) # s2 # test automatic padding self.assertEqual(out_sa['''input_ids'''].shape[-1] , 33) # long slice doesn't have padding self.assertFalse(pad_token_id in out_sa['''input_ids'''][0]) self.assertFalse(0 in out_sa['''attention_mask'''][0]) # short slice does have padding self.assertTrue(pad_token_id in out_sa['''input_ids'''][1]) self.assertTrue(0 in out_sa['''attention_mask'''][1]) # p # test single pair max_length padding self.assertEqual(out_p['''input_ids'''].shape[-1] , 60) self.assertTrue(pad_token_id in out_p['''input_ids''']) self.assertTrue(0 in out_p['''attention_mask''']) # p2 # test automatic padding pair self.assertEqual(out_pa['''input_ids'''].shape[-1] , 52) # long slice pair doesn't have padding self.assertFalse(pad_token_id in out_pa['''input_ids'''][0]) self.assertFalse(0 in out_pa['''attention_mask'''][0]) # short slice pair does have padding self.assertTrue(pad_token_id in out_pa['''input_ids'''][1]) self.assertTrue(0 in out_pa['''attention_mask'''][1]) def _lowerCamelCase ( self : List[str]): '''simple docstring''' __a = '''$$$''' __a = CodeGenTokenizer.from_pretrained(self.tmpdirname , bos_token=__SCREAMING_SNAKE_CASE , add_bos_token=__SCREAMING_SNAKE_CASE) __a = '''This is a simple input''' __a = ['''This is a simple input 1''', '''This is a simple input 2'''] __a = tokenizer.bos_token_id __a = tokenizer(__SCREAMING_SNAKE_CASE) __a = tokenizer(__SCREAMING_SNAKE_CASE) self.assertEqual(out_s.input_ids[0] , __SCREAMING_SNAKE_CASE) self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids)) __a = tokenizer.decode(out_s.input_ids) __a = tokenizer.batch_decode(out_sa.input_ids) self.assertEqual(decode_s.split()[0] , __SCREAMING_SNAKE_CASE) self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa)) @slow def _lowerCamelCase ( self : Tuple): '''simple docstring''' __a = CodeGenTokenizer.from_pretrained('''Salesforce/codegen-350M-mono''') __a = '''\nif len_a > len_b:\n result = a\nelse:\n result = b\n\n\n\n#''' __a = '''\nif len_a > len_b: result = a\nelse: result = b''' __a = tokenizer.encode(__SCREAMING_SNAKE_CASE) __a = ['''^#''', re.escape('''<|endoftext|>'''), '''^\'\'\'''', '''^"""''', '''\n\n\n'''] __a = tokenizer.decode(__SCREAMING_SNAKE_CASE , truncate_before_pattern=__SCREAMING_SNAKE_CASE) self.assertEqual(__SCREAMING_SNAKE_CASE , __SCREAMING_SNAKE_CASE) def _lowerCamelCase ( self : Union[str, Any]): '''simple docstring''' pass
49
import logging from transformers.configuration_utils import PretrainedConfig __snake_case :Any = logging.getLogger(__name__) class _A ( __UpperCAmelCase ): UpperCamelCase__ : Optional[Any] = '''masked_bert''' def __init__( self : str , __SCREAMING_SNAKE_CASE : int=30_522 , __SCREAMING_SNAKE_CASE : str=768 , __SCREAMING_SNAKE_CASE : List[str]=12 , __SCREAMING_SNAKE_CASE : Any=12 , __SCREAMING_SNAKE_CASE : Union[str, Any]=3_072 , __SCREAMING_SNAKE_CASE : List[Any]="gelu" , __SCREAMING_SNAKE_CASE : int=0.1 , __SCREAMING_SNAKE_CASE : Dict=0.1 , __SCREAMING_SNAKE_CASE : Optional[Any]=512 , __SCREAMING_SNAKE_CASE : Optional[int]=2 , __SCREAMING_SNAKE_CASE : Dict=0.02 , __SCREAMING_SNAKE_CASE : List[Any]=1E-12 , __SCREAMING_SNAKE_CASE : Union[str, Any]=0 , __SCREAMING_SNAKE_CASE : List[str]="topK" , __SCREAMING_SNAKE_CASE : List[Any]="constant" , __SCREAMING_SNAKE_CASE : int=0.0 , **__SCREAMING_SNAKE_CASE : List[Any] , ): '''simple docstring''' super().__init__(pad_token_id=__SCREAMING_SNAKE_CASE , **__SCREAMING_SNAKE_CASE) __a = vocab_size __a = hidden_size __a = num_hidden_layers __a = num_attention_heads __a = hidden_act __a = intermediate_size __a = hidden_dropout_prob __a = attention_probs_dropout_prob __a = max_position_embeddings __a = type_vocab_size __a = initializer_range __a = layer_norm_eps __a = pruning_method __a = mask_init __a = mask_scale
49
1
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) UpperCamelCase = {'''configuration_plbart''': ['''PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PLBartConfig''']} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase = ['''PLBartTokenizer'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase = [ '''PLBART_PRETRAINED_MODEL_ARCHIVE_LIST''', '''PLBartForCausalLM''', '''PLBartForConditionalGeneration''', '''PLBartForSequenceClassification''', '''PLBartModel''', '''PLBartPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_plbart import PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP, PLBartConfig try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_plbart import PLBartTokenizer try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_plbart import ( PLBART_PRETRAINED_MODEL_ARCHIVE_LIST, PLBartForCausalLM, PLBartForConditionalGeneration, PLBartForSequenceClassification, PLBartModel, PLBartPreTrainedModel, ) else: import sys UpperCamelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure)
334
'''simple docstring''' from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) UpperCamelCase = { '''configuration_vision_encoder_decoder''': ['''VisionEncoderDecoderConfig''', '''VisionEncoderDecoderOnnxConfig'''] } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase = ['''VisionEncoderDecoderModel'''] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase = ['''TFVisionEncoderDecoderModel'''] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase = ['''FlaxVisionEncoderDecoderModel'''] if TYPE_CHECKING: from .configuration_vision_encoder_decoder import VisionEncoderDecoderConfig, VisionEncoderDecoderOnnxConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_vision_encoder_decoder import VisionEncoderDecoderModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_vision_encoder_decoder import TFVisionEncoderDecoderModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_vision_encoder_decoder import FlaxVisionEncoderDecoderModel else: import sys UpperCamelCase = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
334
1
import warnings from ...utils import logging from .image_processing_glpn import GLPNImageProcessor lowercase__ : Any = logging.get_logger(__name__) class SCREAMING_SNAKE_CASE__ ( SCREAMING_SNAKE_CASE_ ): """simple docstring""" def __init__( self , *SCREAMING_SNAKE_CASE_ , **SCREAMING_SNAKE_CASE_ )-> None: '''simple docstring''' warnings.warn( '''The class GLPNFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please''' ''' use GLPNImageProcessor instead.''' , SCREAMING_SNAKE_CASE_ , ) super().__init__(*SCREAMING_SNAKE_CASE_ , **SCREAMING_SNAKE_CASE_ )
328
import itertools from dataclasses import dataclass from typing import Any, Callable, Dict, List, Optional, Union import pandas as pd import pyarrow as pa import datasets import datasets.config from datasets.features.features import require_storage_cast from datasets.table import table_cast from datasets.utils.py_utils import Literal lowercase__ : Optional[int] = datasets.utils.logging.get_logger(__name__) lowercase__ : Optional[Any] = ["names", "prefix"] lowercase__ : List[Any] = ["warn_bad_lines", "error_bad_lines", "mangle_dupe_cols"] lowercase__ : Optional[Any] = ["encoding_errors", "on_bad_lines"] lowercase__ : List[str] = ["date_format"] @dataclass class SCREAMING_SNAKE_CASE__ ( datasets.BuilderConfig ): """simple docstring""" _snake_case = "," _snake_case = None _snake_case = "infer" _snake_case = None _snake_case = None _snake_case = None _snake_case = None _snake_case = None _snake_case = True _snake_case = None _snake_case = None _snake_case = None _snake_case = None _snake_case = False _snake_case = None _snake_case = None _snake_case = None _snake_case = True _snake_case = True _snake_case = False _snake_case = True _snake_case = None _snake_case = "." _snake_case = None _snake_case = '"' _snake_case = 0 _snake_case = None _snake_case = None _snake_case = None _snake_case = None _snake_case = True _snake_case = True _snake_case = 0 _snake_case = True _snake_case = False _snake_case = None _snake_case = 10000 _snake_case = None _snake_case = "strict" _snake_case = "error" _snake_case = None def A__ ( self )-> Any: '''simple docstring''' if self.delimiter is not None: __UpperCamelCase = self.delimiter if self.column_names is not None: __UpperCamelCase = self.column_names @property def A__ ( self )-> Any: '''simple docstring''' __UpperCamelCase = { '''sep''': self.sep, '''header''': self.header, '''names''': self.names, '''index_col''': self.index_col, '''usecols''': self.usecols, '''prefix''': self.prefix, '''mangle_dupe_cols''': self.mangle_dupe_cols, '''engine''': self.engine, '''converters''': self.converters, '''true_values''': self.true_values, '''false_values''': self.false_values, '''skipinitialspace''': self.skipinitialspace, '''skiprows''': self.skiprows, '''nrows''': self.nrows, '''na_values''': self.na_values, '''keep_default_na''': self.keep_default_na, '''na_filter''': self.na_filter, '''verbose''': self.verbose, '''skip_blank_lines''': self.skip_blank_lines, '''thousands''': self.thousands, '''decimal''': self.decimal, '''lineterminator''': self.lineterminator, '''quotechar''': self.quotechar, '''quoting''': self.quoting, '''escapechar''': self.escapechar, '''comment''': self.comment, '''encoding''': self.encoding, '''dialect''': self.dialect, '''error_bad_lines''': self.error_bad_lines, '''warn_bad_lines''': self.warn_bad_lines, '''skipfooter''': self.skipfooter, '''doublequote''': self.doublequote, '''memory_map''': self.memory_map, '''float_precision''': self.float_precision, '''chunksize''': self.chunksize, '''encoding_errors''': self.encoding_errors, '''on_bad_lines''': self.on_bad_lines, '''date_format''': self.date_format, } # some kwargs must not be passed if they don't have a default value # some others are deprecated and we can also not pass them if they are the default value for pd_read_csv_parameter in _PANDAS_READ_CSV_NO_DEFAULT_PARAMETERS + _PANDAS_READ_CSV_DEPRECATED_PARAMETERS: if pd_read_csv_kwargs[pd_read_csv_parameter] == getattr(CsvConfig() , SCREAMING_SNAKE_CASE_ ): del pd_read_csv_kwargs[pd_read_csv_parameter] # Remove 2.0 new arguments if not (datasets.config.PANDAS_VERSION.major >= 2): for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_2_0_0_PARAMETERS: del pd_read_csv_kwargs[pd_read_csv_parameter] # Remove 1.3 new arguments if not (datasets.config.PANDAS_VERSION.major >= 1 and datasets.config.PANDAS_VERSION.minor >= 3): for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_1_3_0_PARAMETERS: del pd_read_csv_kwargs[pd_read_csv_parameter] return pd_read_csv_kwargs class SCREAMING_SNAKE_CASE__ ( datasets.ArrowBasedBuilder ): """simple docstring""" _snake_case = CsvConfig def A__ ( self )-> Any: '''simple docstring''' return datasets.DatasetInfo(features=self.config.features ) def A__ ( self , SCREAMING_SNAKE_CASE_ )-> Optional[int]: '''simple docstring''' if not self.config.data_files: raise ValueError(F"At least one data file must be specified, but got data_files={self.config.data_files}" ) __UpperCamelCase = dl_manager.download_and_extract(self.config.data_files ) if isinstance(SCREAMING_SNAKE_CASE_ , (str, list, tuple) ): __UpperCamelCase = data_files if isinstance(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): __UpperCamelCase = [files] __UpperCamelCase = [dl_manager.iter_files(SCREAMING_SNAKE_CASE_ ) for file in files] return [datasets.SplitGenerator(name=datasets.Split.TRAIN , gen_kwargs={'''files''': files} )] __UpperCamelCase = [] for split_name, files in data_files.items(): if isinstance(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ): __UpperCamelCase = [files] __UpperCamelCase = [dl_manager.iter_files(SCREAMING_SNAKE_CASE_ ) for file in files] splits.append(datasets.SplitGenerator(name=SCREAMING_SNAKE_CASE_ , gen_kwargs={'''files''': files} ) ) return splits def A__ ( self , SCREAMING_SNAKE_CASE_ )-> pa.Table: '''simple docstring''' if self.config.features is not None: __UpperCamelCase = self.config.features.arrow_schema if all(not require_storage_cast(SCREAMING_SNAKE_CASE_ ) for feature in self.config.features.values() ): # cheaper cast __UpperCamelCase = pa.Table.from_arrays([pa_table[field.name] for field in schema] , schema=SCREAMING_SNAKE_CASE_ ) else: # more expensive cast; allows str <-> int/float or str to Audio for example __UpperCamelCase = table_cast(SCREAMING_SNAKE_CASE_ , SCREAMING_SNAKE_CASE_ ) return pa_table def A__ ( self , SCREAMING_SNAKE_CASE_ )-> str: '''simple docstring''' __UpperCamelCase = self.config.features.arrow_schema if self.config.features else None # dtype allows reading an int column as str __UpperCamelCase = ( { name: dtype.to_pandas_dtype() if not require_storage_cast(SCREAMING_SNAKE_CASE_ ) else object for name, dtype, feature in zip(schema.names , schema.types , self.config.features.values() ) } if schema is not None else None ) for file_idx, file in enumerate(itertools.chain.from_iterable(SCREAMING_SNAKE_CASE_ ) ): __UpperCamelCase = pd.read_csv(SCREAMING_SNAKE_CASE_ , iterator=SCREAMING_SNAKE_CASE_ , dtype=SCREAMING_SNAKE_CASE_ , **self.config.pd_read_csv_kwargs ) try: for batch_idx, df in enumerate(SCREAMING_SNAKE_CASE_ ): __UpperCamelCase = pa.Table.from_pandas(SCREAMING_SNAKE_CASE_ ) # Uncomment for debugging (will print the Arrow table size and elements) # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}") # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows))) yield (file_idx, batch_idx), self._cast_table(SCREAMING_SNAKE_CASE_ ) except ValueError as e: logger.error(F"Failed to read file '{file}' with error {type(SCREAMING_SNAKE_CASE_ )}: {e}" ) raise
328
1
"""simple docstring""" import argparse import collections import os import re from transformers.utils import direct_transformers_import # All paths are set with the intent you should run this script from the root of the repo with the command # python utils/check_table.py UpperCAmelCase__ = 'src/transformers' UpperCAmelCase__ = 'docs/source/en' UpperCAmelCase__ = '.' def _UpperCAmelCase ( __lowerCamelCase : List[str] , __lowerCamelCase : Any , __lowerCamelCase : Tuple ) -> List[str]: with open(__lowerCamelCase , '''r''' , encoding='''utf-8''' , newline='''\n''' ) as f: _snake_case = f.readlines() # Find the start prompt. _snake_case = 0 while not lines[start_index].startswith(__lowerCamelCase ): start_index += 1 start_index += 1 _snake_case = start_index while not lines[end_index].startswith(__lowerCamelCase ): end_index += 1 end_index -= 1 while len(lines[start_index] ) <= 1: start_index += 1 while len(lines[end_index] ) <= 1: end_index -= 1 end_index += 1 return "".join(lines[start_index:end_index] ), start_index, end_index, lines # Add here suffixes that are used to identify models, separated by | UpperCAmelCase__ = 'Model|Encoder|Decoder|ForConditionalGeneration' # Regexes that match TF/Flax/PT model names. UpperCAmelCase__ = re.compile(r'TF(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)') UpperCAmelCase__ = re.compile(r'Flax(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)') # Will match any TF or Flax model too so need to be in an else branch afterthe two previous regexes. UpperCAmelCase__ = re.compile(r'(.*)(?:Model|Encoder|Decoder|ForConditionalGeneration)') # This is to make sure the transformers module imported is the one in the repo. UpperCAmelCase__ = direct_transformers_import(TRANSFORMERS_PATH) def _UpperCAmelCase ( __lowerCamelCase : str ) -> Any: _snake_case = re.finditer('''.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)''' , __lowerCamelCase ) return [m.group(0 ) for m in matches] def _UpperCAmelCase ( __lowerCamelCase : Tuple , __lowerCamelCase : int ) -> Optional[int]: _snake_case = 2 if text == '''✅''' or text == '''❌''' else len(__lowerCamelCase ) _snake_case = (width - text_length) // 2 _snake_case = width - text_length - left_indent return " " * left_indent + text + " " * right_indent def _UpperCAmelCase ( ) -> Tuple: _snake_case = transformers_module.models.auto.configuration_auto.CONFIG_MAPPING_NAMES _snake_case = { name: config_maping_names[code] for code, name in transformers_module.MODEL_NAMES_MAPPING.items() if code in config_maping_names } _snake_case = {name: config.replace('''Config''' , '''''' ) for name, config in model_name_to_config.items()} # Dictionaries flagging if each model prefix has a slow/fast tokenizer, backend in PT/TF/Flax. _snake_case = collections.defaultdict(__lowerCamelCase ) _snake_case = collections.defaultdict(__lowerCamelCase ) _snake_case = collections.defaultdict(__lowerCamelCase ) _snake_case = collections.defaultdict(__lowerCamelCase ) _snake_case = collections.defaultdict(__lowerCamelCase ) # Let's lookup through all transformers object (once). for attr_name in dir(__lowerCamelCase ): _snake_case = None if attr_name.endswith('''Tokenizer''' ): _snake_case = slow_tokenizers _snake_case = attr_name[:-9] elif attr_name.endswith('''TokenizerFast''' ): _snake_case = fast_tokenizers _snake_case = attr_name[:-13] elif _re_tf_models.match(__lowerCamelCase ) is not None: _snake_case = tf_models _snake_case = _re_tf_models.match(__lowerCamelCase ).groups()[0] elif _re_flax_models.match(__lowerCamelCase ) is not None: _snake_case = flax_models _snake_case = _re_flax_models.match(__lowerCamelCase ).groups()[0] elif _re_pt_models.match(__lowerCamelCase ) is not None: _snake_case = pt_models _snake_case = _re_pt_models.match(__lowerCamelCase ).groups()[0] if lookup_dict is not None: while len(__lowerCamelCase ) > 0: if attr_name in model_name_to_prefix.values(): _snake_case = True break # Try again after removing the last word in the name _snake_case = ''''''.join(camel_case_split(__lowerCamelCase )[:-1] ) # Let's build that table! _snake_case = list(model_name_to_config.keys() ) model_names.sort(key=str.lower ) _snake_case = ['''Model''', '''Tokenizer slow''', '''Tokenizer fast''', '''PyTorch support''', '''TensorFlow support''', '''Flax Support'''] # We'll need widths to properly display everything in the center (+2 is to leave one extra space on each side). _snake_case = [len(__lowerCamelCase ) + 2 for c in columns] _snake_case = max([len(__lowerCamelCase ) for name in model_names] ) + 2 # Build the table per se _snake_case = '''|''' + '''|'''.join([_center_text(__lowerCamelCase , __lowerCamelCase ) for c, w in zip(__lowerCamelCase , __lowerCamelCase )] ) + '''|\n''' # Use ":-----:" format to center-aligned table cell texts table += "|" + "|".join([''':''' + '''-''' * (w - 2) + ''':''' for w in widths] ) + "|\n" _snake_case = {True: '''✅''', False: '''❌'''} for name in model_names: _snake_case = model_name_to_prefix[name] _snake_case = [ name, check[slow_tokenizers[prefix]], check[fast_tokenizers[prefix]], check[pt_models[prefix]], check[tf_models[prefix]], check[flax_models[prefix]], ] table += "|" + "|".join([_center_text(__lowerCamelCase , __lowerCamelCase ) for l, w in zip(__lowerCamelCase , __lowerCamelCase )] ) + "|\n" return table def _UpperCAmelCase ( __lowerCamelCase : Union[str, Any]=False ) -> Any: _snake_case , _snake_case , _snake_case , _snake_case = _find_text_in_file( filename=os.path.join(__lowerCamelCase , '''index.md''' ) , start_prompt='''<!--This table is updated automatically from the auto modules''' , end_prompt='''<!-- End table-->''' , ) _snake_case = get_model_table_from_auto_modules() if current_table != new_table: if overwrite: with open(os.path.join(__lowerCamelCase , '''index.md''' ) , '''w''' , encoding='''utf-8''' , newline='''\n''' ) as f: f.writelines(lines[:start_index] + [new_table] + lines[end_index:] ) else: raise ValueError( '''The model table in the `index.md` has not been updated. Run `make fix-copies` to fix this.''' ) if __name__ == "__main__": UpperCAmelCase__ = argparse.ArgumentParser() parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.') UpperCAmelCase__ = parser.parse_args() check_model_table(args.fix_and_overwrite)
40
"""simple docstring""" def _UpperCAmelCase ( __lowerCamelCase : float , __lowerCamelCase : float ) -> float: if mass < 0: raise ValueError('''The mass of a body cannot be negative''' ) return 0.5 * mass * abs(__lowerCamelCase ) * abs(__lowerCamelCase ) if __name__ == "__main__": import doctest doctest.testmod(verbose=True)
40
1
import argparse import shutil from pathlib import Path from tqdm import tqdm from transformers import AutoTokenizer def UpperCamelCase ( __magic_name__ : Optional[Any] , __magic_name__ : Optional[int] , __magic_name__ : Optional[Any] , __magic_name__ : Tuple=1024 ) -> Optional[int]: """simple docstring""" lowercase__ , lowercase__ = [], [] lowercase__ = list(zip(__magic_name__ , __magic_name__ ) ) lowercase__ , lowercase__ = sorted_examples[0] def is_too_big(__magic_name__ : Union[str, Any] ): return tok(__magic_name__ , return_tensors="""pt""" ).input_ids.shape[1] > max_tokens for src, tgt in tqdm(sorted_examples[1:] ): lowercase__ = new_src + """ """ + src lowercase__ = new_tgt + """ """ + tgt if is_too_big(__magic_name__ ) or is_too_big(__magic_name__ ): # cant fit, finalize example finished_src.append(__magic_name__ ) finished_tgt.append(__magic_name__ ) lowercase__ , lowercase__ = src, tgt else: # can fit, keep adding lowercase__ , lowercase__ = cand_src, cand_tgt # cleanup if new_src: assert new_tgt finished_src.append(__magic_name__ ) finished_tgt.append(__magic_name__ ) return finished_src, finished_tgt def UpperCamelCase ( __magic_name__ : Optional[Any] , __magic_name__ : Path , __magic_name__ : Union[str, Any] , __magic_name__ : Any ) -> List[str]: """simple docstring""" lowercase__ = Path(__magic_name__ ) save_path.mkdir(exist_ok=__magic_name__ ) for split in ["train"]: lowercase__ , lowercase__ = data_dir / f'''{split}.source''', data_dir / f'''{split}.target''' lowercase__ = [x.rstrip() for x in Path(__magic_name__ ).open().readlines()] lowercase__ = [x.rstrip() for x in Path(__magic_name__ ).open().readlines()] lowercase__ , lowercase__ = pack_examples(__magic_name__ , __magic_name__ , __magic_name__ , __magic_name__ ) print(f'''packed {split} split from {len(__magic_name__ )} examples -> {len(__magic_name__ )}.''' ) Path(save_path / f'''{split}.source''' ).open("""w""" ).write("""\n""".join(__magic_name__ ) ) Path(save_path / f'''{split}.target''' ).open("""w""" ).write("""\n""".join(__magic_name__ ) ) for split in ["val", "test"]: lowercase__ , lowercase__ = data_dir / f'''{split}.source''', data_dir / f'''{split}.target''' shutil.copyfile(__magic_name__ , save_path / f'''{split}.source''' ) shutil.copyfile(__magic_name__ , save_path / f'''{split}.target''' ) def UpperCamelCase ( ) -> str: """simple docstring""" lowercase__ = argparse.ArgumentParser() parser.add_argument("""--tok_name""" , type=__magic_name__ , help="""like facebook/bart-large-cnn,t5-base, etc.""" ) parser.add_argument("""--max_seq_len""" , type=__magic_name__ , default=128 ) parser.add_argument("""--data_dir""" , type=__magic_name__ ) parser.add_argument("""--save_path""" , type=__magic_name__ ) lowercase__ = parser.parse_args() lowercase__ = AutoTokenizer.from_pretrained(args.tok_name ) return pack_data_dir(__magic_name__ , Path(args.data_dir ) , args.max_seq_len , args.save_path ) if __name__ == "__main__": packer_cli()
305
import os from typing import Dict, List, Union import tensorflow as tf from keras_nlp.tokenizers import BytePairTokenizer from tensorflow_text import pad_model_inputs from .tokenization_gpta import GPTaTokenizer class A ( tf.keras.layers.Layer ): '''simple docstring''' def __init__(self : Any , _UpperCAmelCase : Dict[str, int] , _UpperCAmelCase : List[str] , _UpperCAmelCase : int = None , _UpperCAmelCase : int = None ) -> Dict: """simple docstring""" super().__init__() lowercase__ = pad_token_id lowercase__ = max_length lowercase__ = vocab lowercase__ = merges lowercase__ = BytePairTokenizer(_UpperCAmelCase , _UpperCAmelCase , sequence_length=_UpperCAmelCase ) @classmethod def lowerCamelCase__ (cls : Optional[int] , _UpperCAmelCase : GPTaTokenizer , *_UpperCAmelCase : List[Any] , **_UpperCAmelCase : List[Any] ) -> Union[str, Any]: """simple docstring""" lowercase__ = [""" """.join(_UpperCAmelCase ) for m in tokenizer.bpe_ranks.keys()] lowercase__ = tokenizer.get_vocab() return cls(_UpperCAmelCase , _UpperCAmelCase , *_UpperCAmelCase , **_UpperCAmelCase ) @classmethod def lowerCamelCase__ (cls : Union[str, Any] , _UpperCAmelCase : Union[str, os.PathLike] , *_UpperCAmelCase : str , **_UpperCAmelCase : List[Any] ) -> Any: """simple docstring""" lowercase__ = GPTaTokenizer.from_pretrained(_UpperCAmelCase , *_UpperCAmelCase , **_UpperCAmelCase ) return cls.from_tokenizer(_UpperCAmelCase , *_UpperCAmelCase , **_UpperCAmelCase ) @classmethod def lowerCamelCase__ (cls : Any , _UpperCAmelCase : Tuple ) -> Union[str, Any]: """simple docstring""" return cls(**_UpperCAmelCase ) def lowerCamelCase__ (self : Union[str, Any] ) -> List[Any]: """simple docstring""" return { "vocab": self.vocab, "merges": self.merges, "max_length": self.max_length, "pad_token_id": self.pad_token_id, } def lowerCamelCase__ (self : str , _UpperCAmelCase : Optional[Any] , _UpperCAmelCase : int = None ) -> Optional[Any]: """simple docstring""" lowercase__ = self.tf_tokenizer(_UpperCAmelCase ) lowercase__ = tf.ones_like(_UpperCAmelCase ) if self.pad_token_id is not None: # pad the tokens up to max length lowercase__ = max_length if max_length is not None else self.max_length if max_length is not None: lowercase__ , lowercase__ = pad_model_inputs( _UpperCAmelCase , max_seq_length=_UpperCAmelCase , pad_value=self.pad_token_id ) return {"attention_mask": attention_mask, "input_ids": input_ids}
305
1
"""simple docstring""" import math class UpperCAmelCase_ : """simple docstring""" def __init__( self , _a=0 ) -> Dict: # a graph with Node 0,1,...,N-1 _a : List[str] = n _a : int = [ [math.inf for j in range(0 , _UpperCAmelCase )] for i in range(0 , _UpperCAmelCase ) ] # adjacency matrix for weight _a : List[str] = [ [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 __lowercase ( self , _a , _a , _a ) -> Tuple: _a : Optional[Any] = w def __lowercase ( self ) -> List[Any]: for k in range(0 , self.n ): for i in range(0 , self.n ): for j in range(0 , self.n ): _a : Union[str, Any] = min(self.dp[i][j] , self.dp[i][k] + self.dp[k][j] ) def __lowercase ( self , _a , _a ) -> Optional[Any]: return self.dp[u][v] if __name__ == "__main__": a__ = Graph(5) graph.add_edge(0, 2, 9) graph.add_edge(0, 4, 10) graph.add_edge(1, 3, 5) graph.add_edge(2, 3, 7) graph.add_edge(3, 0, 10) 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)
352
from typing import Dict, Iterable, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format, to_pil_image from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, make_list_of_images, to_numpy_array, valid_images, ) from ...utils import TensorType, is_pytesseract_available, is_vision_available, logging, requires_backends if is_vision_available(): import PIL # soft dependency if is_pytesseract_available(): import pytesseract a__ = logging.get_logger(__name__) def __UpperCAmelCase ( __a : Union[str, Any] ,__a : str ,__a : Union[str, Any] ) -> List[str]: """simple docstring""" return [ int(1_000 * (box[0] / width) ), int(1_000 * (box[1] / height) ), int(1_000 * (box[2] / width) ), int(1_000 * (box[3] / height) ), ] def __UpperCAmelCase ( __a : np.ndarray ,__a : Optional[str] ,__a : Optional[str] ) -> List[Any]: """simple docstring""" _a : str = to_pil_image(__a ) _a , _a : Optional[Any] = pil_image.size _a : Tuple = pytesseract.image_to_data(__a ,lang=__a ,output_type='''dict''' ,config=__a ) _a , _a , _a , _a , _a : List[str] = data['''text'''], data['''left'''], data['''top'''], data['''width'''], data['''height'''] # filter empty words and corresponding coordinates _a : Dict = [idx for idx, word in enumerate(__a ) if not word.strip()] _a : str = [word for idx, word in enumerate(__a ) if idx not in irrelevant_indices] _a : List[str] = [coord for idx, coord in enumerate(__a ) if idx not in irrelevant_indices] _a : Union[str, Any] = [coord for idx, coord in enumerate(__a ) if idx not in irrelevant_indices] _a : str = [coord for idx, coord in enumerate(__a ) if idx not in irrelevant_indices] _a : Union[str, Any] = [coord for idx, coord in enumerate(__a ) if idx not in irrelevant_indices] # turn coordinates into (left, top, left+width, top+height) format _a : int = [] for x, y, w, h in zip(__a ,__a ,__a ,__a ): _a : List[str] = [x, y, x + w, y + h] actual_boxes.append(__a ) # finally, normalize the bounding boxes _a : Dict = [] for box in actual_boxes: normalized_boxes.append(normalize_box(__a ,__a ,__a ) ) assert len(__a ) == len(__a ), "Not as many words as there are bounding boxes" return words, normalized_boxes class UpperCAmelCase_ ( __lowercase ): """simple docstring""" UpperCAmelCase__ : Optional[int] = ["pixel_values"] def __init__( self , _a = True , _a = None , _a = PILImageResampling.BILINEAR , _a = True , _a = 1 / 2_5_5 , _a = True , _a = None , _a = None , _a = True , _a = None , _a = "" , **_a , ) -> None: super().__init__(**_a ) _a : List[str] = size if size is not None else {'''height''': 2_2_4, '''width''': 2_2_4} _a : Union[str, Any] = get_size_dict(_a ) _a : int = do_resize _a : Optional[int] = size _a : str = resample _a : str = do_rescale _a : Any = rescale_value _a : Optional[Any] = do_normalize _a : int = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN _a : List[str] = image_std if image_std is not None else IMAGENET_STANDARD_STD _a : List[Any] = apply_ocr _a : Optional[int] = ocr_lang _a : Tuple = tesseract_config def __lowercase ( self , _a , _a , _a = PILImageResampling.BILINEAR , _a = None , **_a , ) -> np.ndarray: _a : Any = get_size_dict(_a ) if "height" not in size or "width" not in size: raise ValueError(F"""The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}""" ) _a : Optional[int] = (size['''height'''], size['''width''']) return resize(_a , size=_a , resample=_a , data_format=_a , **_a ) def __lowercase ( self , _a , _a , _a = None , **_a , ) -> np.ndarray: return rescale(_a , scale=_a , data_format=_a , **_a ) def __lowercase ( self , _a , _a , _a , _a = None , **_a , ) -> np.ndarray: return normalize(_a , mean=_a , std=_a , data_format=_a , **_a ) def __lowercase ( self , _a , _a = None , _a = None , _a=None , _a = None , _a = None , _a = None , _a = None , _a = None , _a = None , _a = None , _a = None , _a = None , _a = ChannelDimension.FIRST , **_a , ) -> PIL.Image.Image: _a : Optional[int] = do_resize if do_resize is not None else self.do_resize _a : Union[str, Any] = size if size is not None else self.size _a : Any = get_size_dict(_a ) _a : List[str] = resample if resample is not None else self.resample _a : int = do_rescale if do_rescale is not None else self.do_rescale _a : Union[str, Any] = rescale_factor if rescale_factor is not None else self.rescale_factor _a : int = do_normalize if do_normalize is not None else self.do_normalize _a : str = image_mean if image_mean is not None else self.image_mean _a : Tuple = image_std if image_std is not None else self.image_std _a : Any = apply_ocr if apply_ocr is not None else self.apply_ocr _a : int = ocr_lang if ocr_lang is not None else self.ocr_lang _a : Optional[int] = tesseract_config if tesseract_config is not None else self.tesseract_config _a : List[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: raise ValueError('''Size must be specified if do_resize 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('''If do_normalize is True, image_mean and image_std must be specified.''' ) # All transformations expect numpy arrays. _a : Any = [to_numpy_array(_a ) for image in images] # Tesseract OCR to get words + normalized bounding boxes if apply_ocr: requires_backends(self , '''pytesseract''' ) _a : str = [] _a : str = [] for image in images: _a , _a : Union[str, Any] = apply_tesseract(_a , _a , _a ) words_batch.append(_a ) boxes_batch.append(_a ) if do_resize: _a : List[str] = [self.resize(image=_a , size=_a , resample=_a ) for image in images] if do_rescale: _a : Optional[Any] = [self.rescale(image=_a , scale=_a ) for image in images] if do_normalize: _a : List[Any] = [self.normalize(image=_a , mean=_a , std=_a ) for image in images] _a : List[str] = [to_channel_dimension_format(_a , _a ) for image in images] _a : List[str] = BatchFeature(data={'''pixel_values''': images} , tensor_type=_a ) if apply_ocr: _a : Optional[int] = words_batch _a : List[Any] = boxes_batch return data
15
0
'''simple docstring''' from collections.abc import Callable from math import pi, sqrt from random import uniform from statistics import mean def UpperCamelCase ( _lowerCamelCase : int ): # A local function to see if a dot lands in the circle. def is_in_circle(_lowerCamelCase : float , _lowerCamelCase : float ) -> bool: A__ = sqrt((x**2) + (y**2) ) # Our circle has a radius of 1, so a distance # greater than 1 would land outside the circle. return distance_from_centre <= 1 # The proportion of guesses that landed in the circle A__ = mean( int(is_in_circle(uniform(-1.0 , 1.0 ) , uniform(-1.0 , 1.0 ) ) ) for _ in range(_lowerCamelCase ) ) # The ratio of the area for circle to square is pi/4. A__ = proportion * 4 print(F"The estimated value of pi is {pi_estimate}" ) print(F"The numpy value of pi is {pi}" ) print(F"The total error is {abs(pi - pi_estimate )}" ) def UpperCamelCase ( _lowerCamelCase : int , _lowerCamelCase : Callable[[float], float] , _lowerCamelCase : float = 0.0 , _lowerCamelCase : float = 1.0 , ): return mean( function_to_integrate(uniform(_lowerCamelCase , _lowerCamelCase ) ) for _ in range(_lowerCamelCase ) ) * (max_value - min_value) def UpperCamelCase ( _lowerCamelCase : int , _lowerCamelCase : float = 0.0 , _lowerCamelCase : float = 1.0 ): def identity_function(_lowerCamelCase : float ) -> float: return x A__ = area_under_curve_estimator( _lowerCamelCase , _lowerCamelCase , _lowerCamelCase , _lowerCamelCase ) A__ = (max_value * max_value - min_value * min_value) / 2 print("******************" ) print(F"Estimating area under y=x where x varies from {min_value} to {max_value}" ) print(F"Estimated value is {estimated_value}" ) print(F"Expected value is {expected_value}" ) print(F"Total error is {abs(estimated_value - expected_value )}" ) print("******************" ) def UpperCamelCase ( _lowerCamelCase : int ): def function_to_integrate(_lowerCamelCase : float ) -> float: return sqrt(4.0 - x * x ) A__ = area_under_curve_estimator( _lowerCamelCase , _lowerCamelCase , 0.0 , 2.0 ) print("******************" ) print("Estimating pi using area_under_curve_estimator" ) print(F"Estimated value is {estimated_value}" ) print(F"Expected value is {pi}" ) print(F"Total error is {abs(estimated_value - pi )}" ) print("******************" ) if __name__ == "__main__": import doctest doctest.testmod()
237
'''simple docstring''' from __future__ import annotations class UpperCAmelCase : def __init__( self :Optional[int] , lowercase_ :int )-> None: A__ = order # a_{0} ... a_{k} A__ = [1.0] + [0.0] * order # b_{0} ... b_{k} A__ = [1.0] + [0.0] * order # x[n-1] ... x[n-k] A__ = [0.0] * self.order # y[n-1] ... y[n-k] A__ = [0.0] * self.order def UpperCAmelCase_ ( self :List[str] , lowercase_ :list[float] , lowercase_ :list[float] )-> None: if len(lowercase_ ) < self.order: A__ = [1.0, *a_coeffs] if len(lowercase_ ) != self.order + 1: A__ = ( F"Expected a_coeffs to have {self.order + 1} elements " F"for {self.order}-order filter, got {len(lowercase_ )}" ) raise ValueError(lowercase_ ) if len(lowercase_ ) != self.order + 1: A__ = ( F"Expected b_coeffs to have {self.order + 1} elements " F"for {self.order}-order filter, got {len(lowercase_ )}" ) raise ValueError(lowercase_ ) A__ = a_coeffs A__ = b_coeffs def UpperCAmelCase_ ( self :Optional[int] , lowercase_ :float )-> float: A__ = 0.0 # Start at index 1 and do index 0 at the end. for i in range(1 , self.order + 1 ): result += ( self.b_coeffs[i] * self.input_history[i - 1] - self.a_coeffs[i] * self.output_history[i - 1] ) A__ = (result + self.b_coeffs[0] * sample) / self.a_coeffs[0] A__ = self.input_history[:-1] A__ = self.output_history[:-1] A__ = sample A__ = result return result
237
1
'''simple docstring''' import argparse from pathlib import Path from transformers import AutoConfig, AutoTokenizer, RagConfig, RagSequenceForGeneration, RagTokenForGeneration def __lowerCamelCase ( _lowercase , _lowercase , _lowercase , _lowercase , _lowercase = None , _lowercase = None , _lowercase = None , ) -> str: if config_name_or_path is None: UpperCAmelCase : List[str] = """facebook/rag-token-base""" if model_type == """rag_token""" else """facebook/rag-sequence-base""" if generator_tokenizer_name_or_path is None: UpperCAmelCase : List[Any] = generator_name_or_path if question_encoder_tokenizer_name_or_path is None: UpperCAmelCase : Union[str, Any] = question_encoder_name_or_path UpperCAmelCase : Tuple = RagTokenForGeneration if model_type == """rag_token""" else RagSequenceForGeneration # Save model. UpperCAmelCase : Optional[int] = RagConfig.from_pretrained(_lowercase ) UpperCAmelCase : Optional[int] = AutoConfig.from_pretrained(_lowercase ) UpperCAmelCase : int = AutoConfig.from_pretrained(_lowercase ) UpperCAmelCase : Tuple = gen_config UpperCAmelCase : Optional[int] = question_encoder_config UpperCAmelCase : Optional[Any] = model_class.from_pretrained_question_encoder_generator( _lowercase , _lowercase , config=_lowercase ) rag_model.save_pretrained(_lowercase ) # Sanity check. model_class.from_pretrained(_lowercase ) # Save tokenizers. UpperCAmelCase : Any = AutoTokenizer.from_pretrained(_lowercase ) gen_tokenizer.save_pretrained(dest_dir / """generator_tokenizer/""" ) UpperCAmelCase : int = AutoTokenizer.from_pretrained(_lowercase ) question_encoder_tokenizer.save_pretrained(dest_dir / """question_encoder_tokenizer/""" ) if __name__ == "__main__": a : List[Any] = argparse.ArgumentParser() parser.add_argument( """--model_type""", choices=["""rag_sequence""", """rag_token"""], required=True, type=str, help="""RAG model type: rag_sequence, rag_token""", ) parser.add_argument("""--dest""", type=str, required=True, help="""Path to the output checkpoint directory.""") parser.add_argument("""--generator_name_or_path""", type=str, required=True, help="""Generator model identifier""") parser.add_argument( """--question_encoder_name_or_path""", type=str, required=True, help="""Question encoder model identifier""" ) parser.add_argument( """--generator_tokenizer_name_or_path""", type=str, help="""Generator tokenizer identifier, if not specified, resolves to ``generator_name_or_path``""", ) parser.add_argument( """--question_encoder_tokenizer_name_or_path""", type=str, help="""Question encoder tokenizer identifier, if not specified, resolves to ``question_encoder_name_or_path``""", ) parser.add_argument( """--config_name_or_path""", type=str, help=( """Identifier of the model config to use, if not provided, resolves to a base config for a given""" """ ``model_type``""" ), ) a : str = parser.parse_args() a : int = Path(args.dest) dest_dir.mkdir(exist_ok=True) consolidate( args.model_type, args.generator_name_or_path, args.question_encoder_name_or_path, dest_dir, args.config_name_or_path, args.generator_tokenizer_name_or_path, args.question_encoder_tokenizer_name_or_path, )
371
'''simple docstring''' from typing import List, Optional from tokenizers import ByteLevelBPETokenizer from ...tokenization_utils_fast import PreTrainedTokenizerFast from ...utils import logging from .tokenization_blenderbot_small import BlenderbotSmallTokenizer a : List[Any] = logging.get_logger(__name__) a : List[str] = { """vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_config_file""": """tokenizer_config.json""", } a : List[Any] = { """vocab_file""": { """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/vocab.json""" }, """merges_file""": { """facebook/blenderbot_small-90M""": """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/merges.txt""" }, """tokenizer_config_file""": { """facebook/blenderbot_small-90M""": ( """https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/tokenizer_config.json""" ) }, } a : List[Any] = { """facebook/blenderbot_small-90M""": 5_1_2, } class UpperCamelCase_ ( __magic_name__ ): lowercase = VOCAB_FILES_NAMES lowercase = PRETRAINED_VOCAB_FILES_MAP lowercase = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES lowercase = BlenderbotSmallTokenizer def __init__( self , A=None , A=None , A="<|endoftext|>" , A="<|endoftext|>" , A="<|endoftext|>" , A=False , A=True , **A , ) -> Union[str, Any]: super().__init__( ByteLevelBPETokenizer( vocab=A , merges=A , add_prefix_space=A , trim_offsets=A , ) , bos_token=A , eos_token=A , unk_token=A , **A , ) UpperCAmelCase : Optional[Any] = add_prefix_space def _lowercase( self , A , A=None ) -> Optional[Any]: UpperCAmelCase : Optional[Any] = [self.bos_token_id] + token_ids_a + [self.eos_token_id] if token_ids_a is None: return output return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id] def _lowercase( self , A , A = None ) -> List[int]: UpperCAmelCase : Any = [self.sep_token_id] UpperCAmelCase : Tuple = [self.cls_token_id] if token_ids_a is None: return len(cls + token_ids_a + sep ) * [0] return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]
338
0
'''simple docstring''' import webbrowser from sys import argv from urllib.parse import parse_qs, quote import requests from bsa import BeautifulSoup from fake_useragent import UserAgent if __name__ == "__main__": __lowercase : Tuple = '%20'.join(argv[1:]) if len(argv) > 1 else quote(str(input('Search: '))) print('Googling.....') __lowercase : Any = f'''https://www.google.com/search?q={query}&num=100''' __lowercase : Optional[int] = requests.get( url, headers={'User-Agent': str(UserAgent().random)}, ) try: __lowercase : int = ( BeautifulSoup(res.text, 'html.parser') .find('div', attrs={'class': 'yuRUbf'}) .find('a') .get('href') ) except AttributeError: __lowercase : Optional[Any] = parse_qs( BeautifulSoup(res.text, 'html.parser') .find('div', attrs={'class': 'kCrYT'}) .find('a') .get('href') )['url'][0] webbrowser.open(link)
27
'''simple docstring''' import argparse import gc import json import os import torch from datasets import load_dataset from torch.optim import AdamW from torch.utils.data import DataLoader from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed from accelerate import Accelerator, DistributedType from accelerate.utils.deepspeed import DummyOptim, DummyScheduler __lowercase : Dict = 16 __lowercase : List[Any] = 32 def lowerCamelCase (_SCREAMING_SNAKE_CASE : int ): return int(x / 2**20 ) class __UpperCamelCase : def __enter__( self ): '''simple docstring''' gc.collect() torch.cuda.empty_cache() torch.cuda.reset_max_memory_allocated() # reset the peak gauge to zero __a : Optional[int] = torch.cuda.memory_allocated() return self def __exit__( self , *__a ): '''simple docstring''' gc.collect() torch.cuda.empty_cache() __a : Dict = torch.cuda.memory_allocated() __a : List[Any] = torch.cuda.max_memory_allocated() __a : Tuple = bamb(self.end - self.begin ) __a : Tuple = bamb(self.peak - self.begin ) # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}") def lowerCamelCase (_SCREAMING_SNAKE_CASE : Accelerator , _SCREAMING_SNAKE_CASE : int = 16 , _SCREAMING_SNAKE_CASE : str = "bert-base-cased" , _SCREAMING_SNAKE_CASE : int = 320 , _SCREAMING_SNAKE_CASE : int = 160 , ): __a : int = AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE ) __a : List[Any] = load_dataset( 'glue' , 'mrpc' , split={'train': F"""train[:{n_train}]""", 'validation': F"""validation[:{n_val}]"""} ) def tokenize_function(_SCREAMING_SNAKE_CASE : Tuple ): # max_length=None => use the model max length (it's actually the default) __a : Any = tokenizer(examples['sentence1'] , examples['sentence2'] , truncation=_SCREAMING_SNAKE_CASE , max_length=_SCREAMING_SNAKE_CASE ) return outputs # Apply the method we just defined to all the examples in all the splits of the dataset __a : List[str] = datasets.map( _SCREAMING_SNAKE_CASE , batched=_SCREAMING_SNAKE_CASE , remove_columns=['idx', 'sentence1', 'sentence2'] , load_from_cache_file=_SCREAMING_SNAKE_CASE ) # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the # transformers library __a : Tuple = tokenized_datasets.rename_column('label' , 'labels' ) def collate_fn(_SCREAMING_SNAKE_CASE : Tuple ): # On TPU it's best to pad everything to the same length or training will be very slow. if accelerator.distributed_type == DistributedType.TPU: return tokenizer.pad(_SCREAMING_SNAKE_CASE , padding='max_length' , max_length=128 , return_tensors='pt' ) return tokenizer.pad(_SCREAMING_SNAKE_CASE , padding='longest' , return_tensors='pt' ) # Instantiate dataloaders. __a : int = DataLoader( tokenized_datasets['train'] , shuffle=_SCREAMING_SNAKE_CASE , collate_fn=_SCREAMING_SNAKE_CASE , batch_size=_SCREAMING_SNAKE_CASE ) __a : Tuple = DataLoader( tokenized_datasets['validation'] , shuffle=_SCREAMING_SNAKE_CASE , collate_fn=_SCREAMING_SNAKE_CASE , batch_size=_SCREAMING_SNAKE_CASE ) return train_dataloader, eval_dataloader def lowerCamelCase (_SCREAMING_SNAKE_CASE : int , _SCREAMING_SNAKE_CASE : int ): # Initialize accelerator __a : str = Accelerator() # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs __a : Dict = config['lr'] __a : str = int(config['num_epochs'] ) __a : Optional[int] = int(config['seed'] ) __a : Any = int(config['batch_size'] ) __a : List[str] = args.model_name_or_path set_seed(_SCREAMING_SNAKE_CASE ) __a , __a : int = get_dataloaders(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , args.n_train , args.n_val ) # Instantiate the model (we build the model here so that the seed also control new weights initialization) __a : Optional[int] = AutoModelForSequenceClassification.from_pretrained(_SCREAMING_SNAKE_CASE , return_dict=_SCREAMING_SNAKE_CASE ) # Instantiate optimizer __a : Optional[Any] = ( AdamW if accelerator.state.deepspeed_plugin is None or 'optimizer' not in accelerator.state.deepspeed_plugin.deepspeed_config else DummyOptim ) __a : Optional[Any] = optimizer_cls(params=model.parameters() , lr=_SCREAMING_SNAKE_CASE ) if accelerator.state.deepspeed_plugin is not None: __a : int = accelerator.state.deepspeed_plugin.deepspeed_config[ 'gradient_accumulation_steps' ] else: __a : Union[str, Any] = 1 __a : Tuple = (len(_SCREAMING_SNAKE_CASE ) * num_epochs) // gradient_accumulation_steps # Instantiate scheduler if ( accelerator.state.deepspeed_plugin is None or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config ): __a : str = get_linear_schedule_with_warmup( optimizer=_SCREAMING_SNAKE_CASE , num_warmup_steps=0 , num_training_steps=_SCREAMING_SNAKE_CASE , ) else: __a : List[Any] = DummyScheduler(_SCREAMING_SNAKE_CASE , total_num_steps=_SCREAMING_SNAKE_CASE , warmup_num_steps=0 ) # Prepare everything # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the # prepare method. __a , __a , __a , __a , __a : Optional[Any] = accelerator.prepare( _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) # We need to keep track of how many total steps we have iterated over __a : Union[str, Any] = 0 # We also need to keep track of the stating epoch so files are named properly __a : Dict = 0 # Now we train the model __a : str = {} for epoch in range(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ): with TorchTracemalloc() as tracemalloc: model.train() for step, batch in enumerate(_SCREAMING_SNAKE_CASE ): __a : List[Any] = model(**_SCREAMING_SNAKE_CASE ) __a : str = outputs.loss __a : str = loss / gradient_accumulation_steps accelerator.backward(_SCREAMING_SNAKE_CASE ) if step % gradient_accumulation_steps == 0: optimizer.step() lr_scheduler.step() optimizer.zero_grad() overall_step += 1 # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage accelerator.print('Memory before entering the train : {}'.format(bamb(tracemalloc.begin ) ) ) accelerator.print('Memory consumed at the end of the train (end-begin): {}'.format(tracemalloc.used ) ) accelerator.print('Peak Memory consumed during the train (max-begin): {}'.format(tracemalloc.peaked ) ) accelerator.print( 'Total Peak Memory consumed during the train (max): {}'.format( tracemalloc.peaked + bamb(tracemalloc.begin ) ) ) __a : List[Any] = tracemalloc.peaked + bamb(tracemalloc.begin ) if args.peak_memory_upper_bound is not None: assert ( train_total_peak_memory[F"""epoch-{epoch}"""] <= args.peak_memory_upper_bound ), "Peak memory usage exceeded the upper bound" accelerator.wait_for_everyone() if accelerator.is_main_process: with open(os.path.join(args.output_dir , 'peak_memory_utilization.json' ) , 'w' ) as f: json.dump(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) def lowerCamelCase (): __a : int = argparse.ArgumentParser(description='Simple example of training script tracking peak GPU memory usage.' ) parser.add_argument( '--model_name_or_path' , type=_SCREAMING_SNAKE_CASE , default='bert-base-cased' , help='Path to pretrained model or model identifier from huggingface.co/models.' , required=_SCREAMING_SNAKE_CASE , ) parser.add_argument( '--output_dir' , type=_SCREAMING_SNAKE_CASE , default='.' , help='Optional save directory where all checkpoint folders will be stored. Default is the current working directory.' , ) parser.add_argument( '--peak_memory_upper_bound' , type=_SCREAMING_SNAKE_CASE , default=_SCREAMING_SNAKE_CASE , help='The upper bound of peak memory usage in MB. If set, the training will throw an error if the peak memory usage exceeds this value.' , ) parser.add_argument( '--n_train' , type=_SCREAMING_SNAKE_CASE , default=320 , help='Number of training examples to use.' , ) parser.add_argument( '--n_val' , type=_SCREAMING_SNAKE_CASE , default=160 , help='Number of validation examples to use.' , ) parser.add_argument( '--num_epochs' , type=_SCREAMING_SNAKE_CASE , default=1 , help='Number of train epochs.' , ) __a : List[str] = parser.parse_args() __a : List[Any] = {'lr': 2e-5, 'num_epochs': args.num_epochs, 'seed': 42, 'batch_size': 16} training_function(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) if __name__ == "__main__": main()
27
1
import unittest from transformers import CamembertTokenizer, CamembertTokenizerFast from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow from transformers.utils import is_torch_available from ...test_tokenization_common import TokenizerTesterMixin __A = get_tests_dir('''fixtures/test_sentencepiece.model''') __A = get_tests_dir('''fixtures/test_sentencepiece_bpe.model''') __A = 'pt' if is_torch_available() else 'tf' @require_sentencepiece @require_tokenizers class lowercase_ ( __SCREAMING_SNAKE_CASE , unittest.TestCase ): UpperCamelCase_ : Optional[Any] = CamembertTokenizer UpperCamelCase_ : Any = CamembertTokenizerFast UpperCamelCase_ : int = True UpperCamelCase_ : int = True def UpperCamelCase_ ( self : List[str] ) -> List[str]: super().setUp() # We have a SentencePiece fixture for testing _snake_case = CamembertTokenizer(_SCREAMING_SNAKE_CASE ) tokenizer.save_pretrained(self.tmpdirname ) def UpperCamelCase_ ( self : Dict ) -> Tuple: _snake_case = "<pad>" _snake_case = 1 self.assertEqual(self.get_tokenizer()._convert_token_to_id(_SCREAMING_SNAKE_CASE ) , _SCREAMING_SNAKE_CASE ) self.assertEqual(self.get_tokenizer()._convert_id_to_token(_SCREAMING_SNAKE_CASE ) , _SCREAMING_SNAKE_CASE ) def UpperCamelCase_ ( self : Optional[Any] ) -> Tuple: _snake_case = list(self.get_tokenizer().get_vocab().keys() ) self.assertEqual(vocab_keys[0] , '''<s>NOTUSED''' ) self.assertEqual(vocab_keys[1] , '''<pad>''' ) self.assertEqual(vocab_keys[-1] , '''<mask>''' ) self.assertEqual(len(_SCREAMING_SNAKE_CASE ) , 1004 ) def UpperCamelCase_ ( self : Optional[Any] ) -> Dict: self.assertEqual(self.get_tokenizer().vocab_size , 1005 ) def UpperCamelCase_ ( self : Union[str, Any] ) -> Dict: _snake_case = CamembertTokenizer(_SCREAMING_SNAKE_CASE ) tokenizer.save_pretrained(self.tmpdirname ) _snake_case = CamembertTokenizerFast.from_pretrained(self.tmpdirname ) _snake_case = "I was born in 92000, and this is falsé." _snake_case = tokenizer.encode(_SCREAMING_SNAKE_CASE ) _snake_case = rust_tokenizer.encode(_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) _snake_case = tokenizer.encode(_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE ) _snake_case = rust_tokenizer.encode(_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) # <unk> tokens are not the same for `rust` than for `slow`. # Because spm gives back raw token instead of `unk` in EncodeAsPieces # tokens = tokenizer.tokenize(sequence) _snake_case = tokenizer.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE ) _snake_case = rust_tokenizer.tokenize(_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) def UpperCamelCase_ ( self : Any ) -> int: if not self.test_rust_tokenizer: return _snake_case = self.get_tokenizer() _snake_case = self.get_rust_tokenizer() _snake_case = "I was born in 92000, and this is falsé." _snake_case = tokenizer.tokenize(_SCREAMING_SNAKE_CASE ) _snake_case = rust_tokenizer.tokenize(_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) _snake_case = tokenizer.encode(_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE ) _snake_case = rust_tokenizer.encode(_SCREAMING_SNAKE_CASE , add_special_tokens=_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) _snake_case = self.get_rust_tokenizer() _snake_case = tokenizer.encode(_SCREAMING_SNAKE_CASE ) _snake_case = rust_tokenizer.encode(_SCREAMING_SNAKE_CASE ) self.assertListEqual(_SCREAMING_SNAKE_CASE , _SCREAMING_SNAKE_CASE ) @slow def UpperCamelCase_ ( self : Union[str, Any] ) -> List[str]: _snake_case = {"input_ids": [[5, 54, 7196, 297, 30, 23, 776, 18, 11, 3215, 3705, 8252, 22, 3164, 1181, 2116, 29, 16, 813, 25, 791, 3314, 20, 3446, 38, 27575, 120, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [5, 468, 17, 11, 9088, 20, 1517, 8, 22804, 18818, 10, 38, 629, 607, 607, 142, 19, 7196, 867, 56, 10326, 24, 2267, 20, 416, 5072, 15612, 233, 734, 7, 2399, 27, 16, 3015, 1649, 7, 24, 20, 4338, 2399, 27, 13, 3400, 14, 13, 6189, 8, 930, 9, 6]], "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, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]} # noqa: E501 # fmt: on # camembert is a french model. So we also use french texts. _snake_case = [ "Le transformeur est un modèle d'apprentissage profond introduit en 2017, " "utilisé principalement dans le domaine du traitement automatique des langues (TAL).", "À l'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus " "pour gérer des données séquentielles, telles que le langage naturel, pour des tâches " "telles que la traduction et la synthèse de texte.", ] self.tokenizer_integration_test_util( expected_encoding=_SCREAMING_SNAKE_CASE , model_name='''camembert-base''' , revision='''3a0641d9a1aeb7e848a74299e7e4c4bca216b4cf''' , sequences=_SCREAMING_SNAKE_CASE , )
364
from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) __A = { '''configuration_falcon''': ['''FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FalconConfig'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: __A = [ '''FALCON_PRETRAINED_MODEL_ARCHIVE_LIST''', '''FalconForCausalLM''', '''FalconModel''', '''FalconPreTrainedModel''', '''FalconForSequenceClassification''', '''FalconForTokenClassification''', '''FalconForQuestionAnswering''', ] if TYPE_CHECKING: from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_falcon import ( FALCON_PRETRAINED_MODEL_ARCHIVE_LIST, FalconForCausalLM, FalconForQuestionAnswering, FalconForSequenceClassification, FalconForTokenClassification, FalconModel, FalconPreTrainedModel, ) else: import sys __A = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
278
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available, ) UpperCamelCase_ = {'configuration_encoder_decoder': ['EncoderDecoderConfig']} try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = ['EncoderDecoderModel'] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = ['TFEncoderDecoderModel'] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: UpperCamelCase_ = ['FlaxEncoderDecoderModel'] if TYPE_CHECKING: from .configuration_encoder_decoder import EncoderDecoderConfig try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_encoder_decoder import EncoderDecoderModel try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_encoder_decoder import TFEncoderDecoderModel try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_encoder_decoder import FlaxEncoderDecoderModel else: import sys UpperCamelCase_ = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
243
"""simple docstring""" def UpperCamelCase ( UpperCAmelCase = "The quick brown fox jumps over the lazy dog" , ) ->bool: """simple docstring""" a_ = set() # Replace all the whitespace in our sentence a_ = input_str.replace(" " , "" ) for alpha in input_str: if "a" <= alpha.lower() <= "z": frequency.add(alpha.lower() ) return len(UpperCAmelCase ) == 26 def UpperCamelCase ( UpperCAmelCase = "The quick brown fox jumps over the lazy dog" , ) ->bool: """simple docstring""" a_ = [False] * 26 for char in input_str: if char.islower(): a_ = True elif char.isupper(): a_ = True return all(UpperCAmelCase ) def UpperCamelCase ( UpperCAmelCase = "The quick brown fox jumps over the lazy dog" , ) ->bool: """simple docstring""" return len({char for char in input_str.lower() if char.isalpha()} ) == 26 def UpperCamelCase ( ) ->None: """simple docstring""" from timeit import timeit a_ = "from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest" print(timeit("is_pangram()" , setup=UpperCAmelCase ) ) print(timeit("is_pangram_faster()" , setup=UpperCAmelCase ) ) print(timeit("is_pangram_fastest()" , setup=UpperCAmelCase ) ) # 5.348480500048026, 2.6477354579837993, 1.8470395830227062 # 5.036091582966037, 2.644472333951853, 1.8869528750656173 if __name__ == "__main__": import doctest doctest.testmod() benchmark()
243
1
import argparse import datetime import json import time import warnings from logging import getLogger from pathlib import Path from typing import Dict, List import torch from tqdm import tqdm from transformers import AutoModelForSeqaSeqLM, AutoTokenizer from utils import calculate_bleu, calculate_rouge, chunks, parse_numeric_n_bool_cl_kwargs, use_task_specific_params UpperCAmelCase__ : Any = getLogger(__name__) UpperCAmelCase__ : Optional[Any] = 'cuda' if torch.cuda.is_available() else 'cpu' def lowerCamelCase__ ( a , a , a , a = 8 , a = DEFAULT_DEVICE , a=False , a="summarization" , a=None , **a , ) -> Dict: _A: str = Path(a ).open('''w''' , encoding='''utf-8''' ) _A: Optional[Any] = str(a ) _A: Union[str, Any] = AutoModelForSeqaSeqLM.from_pretrained(a ).to(a ) if fpaa: _A: Any = model.half() _A: Optional[int] = AutoTokenizer.from_pretrained(a ) logger.info(f"""Inferred tokenizer type: {tokenizer.__class__}""" ) # if this is wrong, check config.model_type. _A: Any = time.time() # update config with task specific params use_task_specific_params(a , a ) if prefix is None: _A: int = prefix or getattr(model.config , '''prefix''' , '''''' ) or '''''' for examples_chunk in tqdm(list(chunks(a , a ) ) ): _A: int = [prefix + text for text in examples_chunk] _A: str = tokenizer(a , return_tensors='''pt''' , truncation=a , padding='''longest''' ).to(a ) _A: str = model.generate( input_ids=batch.input_ids , attention_mask=batch.attention_mask , **a , ) _A: str = tokenizer.batch_decode(a , skip_special_tokens=a , clean_up_tokenization_spaces=a ) for hypothesis in dec: fout.write(hypothesis + '''\n''' ) fout.flush() fout.close() _A: Optional[int] = int(time.time() - start_time ) # seconds _A: Union[str, Any] = len(a ) return {"n_obs": n_obs, "runtime": runtime, "seconds_per_sample": round(runtime / n_obs , 4 )} def lowerCamelCase__ ( ) -> Tuple: return datetime.datetime.now().strftime('''%Y-%m-%d %H:%M:%S''' ) def lowerCamelCase__ ( a=True ) -> Optional[Any]: _A: str = argparse.ArgumentParser() parser.add_argument('''model_name''' , type=a , help='''like facebook/bart-large-cnn,t5-base, etc.''' ) parser.add_argument('''input_path''' , type=a , help='''like cnn_dm/test.source''' ) parser.add_argument('''save_path''' , type=a , help='''where to save summaries''' ) parser.add_argument('''--reference_path''' , type=a , required=a , help='''like cnn_dm/test.target''' ) parser.add_argument('''--score_path''' , type=a , required=a , default='''metrics.json''' , help='''where to save metrics''' ) parser.add_argument('''--device''' , type=a , required=a , default=a , help='''cuda, cuda:1, cpu etc.''' ) parser.add_argument( '''--prefix''' , type=a , required=a , default=a , help='''will be added to the begininng of src examples''' ) parser.add_argument('''--task''' , type=a , default='''summarization''' , help='''used for task_specific_params + metrics''' ) parser.add_argument('''--bs''' , type=a , default=8 , required=a , help='''batch size''' ) parser.add_argument( '''--n_obs''' , type=a , default=-1 , required=a , help='''How many observations. Defaults to all.''' ) parser.add_argument('''--fp16''' , action='''store_true''' ) parser.add_argument('''--dump-args''' , action='''store_true''' , help='''print the custom hparams with the results''' ) parser.add_argument( '''--info''' , nargs='''?''' , type=a , const=datetime_now() , help=( '''use in conjunction w/ --dump-args to print with the results whatever other info you\'d like, e.g.''' ''' lang=en-ru. If no value is passed, the current datetime string will be used.''' ) , ) # Unspecified args like --num_beams=2 --decoder_start_token_id=4 are passed to model.generate _A , _A: Tuple = parser.parse_known_args() _A: List[str] = parse_numeric_n_bool_cl_kwargs(a ) if parsed_args and verbose: print(f"""parsed the following generate kwargs: {parsed_args}""" ) _A: int = [''' ''' + x.rstrip() if '''t5''' in args.model_name else x.rstrip() for x in open(args.input_path ).readlines()] if args.n_obs > 0: _A: List[str] = examples[: args.n_obs] Path(args.save_path ).parent.mkdir(exist_ok=a ) if args.reference_path is None and Path(args.score_path ).exists(): warnings.warn(f"""score_path {args.score_path} will be overwritten unless you type ctrl-c.""" ) if args.device == "cpu" and args.fpaa: # this mix leads to RuntimeError: "threshold_cpu" not implemented for 'Half' raise ValueError('''Can\'t mix --fp16 and --device cpu''' ) _A: Dict = generate_summaries_or_translations( a , args.save_path , args.model_name , batch_size=args.bs , device=args.device , fpaa=args.fpaa , task=args.task , prefix=args.prefix , **a , ) if args.reference_path is None: return {} # Compute scores _A: Dict = calculate_bleu if '''translation''' in args.task else calculate_rouge _A: List[Any] = [x.rstrip() for x in open(args.save_path ).readlines()] _A: Any = [x.rstrip() for x in open(args.reference_path ).readlines()][: len(a )] _A: dict = score_fn(a , a ) scores.update(a ) if args.dump_args: scores.update(a ) if args.info: _A: Optional[Any] = args.info if verbose: print(a ) if args.score_path is not None: json.dump(a , open(args.score_path , '''w''' ) ) return scores if __name__ == "__main__": # Usage for MT: # python run_eval.py MODEL_NAME $DATA_DIR/test.source $save_dir/test_translations.txt --reference_path $DATA_DIR/test.target --score_path $save_dir/test_bleu.json --task translation $@ run_generate(verbose=True)
301
def lowerCamelCase__ ( a = 10 ) -> str: if not isinstance(a , a ) or n < 0: raise ValueError('''Invalid input''' ) _A: int = 10**n _A: List[Any] = 2_84_33 * (pow(2 , 7_83_04_57 , a )) + 1 return str(number % modulus ) if __name__ == "__main__": from doctest import testmod testmod() print(F"""{solution(10) = }""")
301
1
from collections.abc import Callable from math import pi, sqrt from random import uniform from statistics import mean def UpperCamelCase( __UpperCamelCase : int ): # A local function to see if a dot lands in the circle. def is_in_circle(__UpperCamelCase : float ,__UpperCamelCase : float ) -> bool: lowerCAmelCase_ : int = sqrt((x**2) + (y**2) ) # Our circle has a radius of 1, so a distance # greater than 1 would land outside the circle. return distance_from_centre <= 1 # The proportion of guesses that landed in the circle lowerCAmelCase_ : Optional[int] = mean( int(is_in_circle(uniform(-1.0 ,1.0 ) ,uniform(-1.0 ,1.0 ) ) ) for _ in range(__UpperCamelCase ) ) # The ratio of the area for circle to square is pi/4. lowerCAmelCase_ : str = proportion * 4 print(f"""The estimated value of pi is {pi_estimate}""" ) print(f"""The numpy value of pi is {pi}""" ) print(f"""The total error is {abs(pi - pi_estimate )}""" ) def UpperCamelCase( __UpperCamelCase : int ,__UpperCamelCase : Callable[[float], float] ,__UpperCamelCase : float = 0.0 ,__UpperCamelCase : float = 1.0 ,): return mean( function_to_integrate(uniform(__UpperCamelCase ,__UpperCamelCase ) ) for _ in range(__UpperCamelCase ) ) * (max_value - min_value) def UpperCamelCase( __UpperCamelCase : int ,__UpperCamelCase : float = 0.0 ,__UpperCamelCase : float = 1.0 ): def identity_function(__UpperCamelCase : float ) -> float: return x lowerCAmelCase_ : Optional[int] = area_under_curve_estimator( __UpperCamelCase ,__UpperCamelCase ,__UpperCamelCase ,__UpperCamelCase ) lowerCAmelCase_ : int = (max_value * max_value - min_value * min_value) / 2 print('''******************''' ) print(f"""Estimating area under y=x where x varies from {min_value} to {max_value}""" ) print(f"""Estimated value is {estimated_value}""" ) print(f"""Expected value is {expected_value}""" ) print(f"""Total error is {abs(estimated_value - expected_value )}""" ) print('''******************''' ) def UpperCamelCase( __UpperCamelCase : int ): def function_to_integrate(__UpperCamelCase : float ) -> float: return sqrt(4.0 - x * x ) lowerCAmelCase_ : Optional[int] = area_under_curve_estimator( __UpperCamelCase ,__UpperCamelCase ,0.0 ,2.0 ) print('''******************''' ) print('''Estimating pi using area_under_curve_estimator''' ) print(f"""Estimated value is {estimated_value}""" ) print(f"""Expected value is {pi}""" ) print(f"""Total error is {abs(estimated_value - pi )}""" ) print('''******************''' ) if __name__ == "__main__": import doctest doctest.testmod()
103
"""simple docstring""" # 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 platform import numpy as np import psutil import torch from accelerate import __version__ as version from accelerate.commands.config import default_config_file, load_config_from_file from ..utils import is_npu_available, is_xpu_available def lowercase__ ( snake_case_ :Union[str, Any]=None ): if subparsers is not None: __UpperCAmelCase = subparsers.add_parser('''env''' ) else: __UpperCAmelCase = argparse.ArgumentParser('''Accelerate env command''' ) parser.add_argument( '''--config_file''' , default=snake_case_ , help='''The config file to use for the default values in the launching script.''' ) if subparsers is not None: parser.set_defaults(func=snake_case_ ) return parser def lowercase__ ( snake_case_ :List[Any] ): __UpperCAmelCase = torch.__version__ __UpperCAmelCase = torch.cuda.is_available() __UpperCAmelCase = is_xpu_available() __UpperCAmelCase = is_npu_available() __UpperCAmelCase = '''Not found''' # Get the default from the config file. if args.config_file is not None or os.path.isfile(snake_case_ ): __UpperCAmelCase = load_config_from_file(args.config_file ).to_dict() __UpperCAmelCase = { '''`Accelerate` version''': version, '''Platform''': platform.platform(), '''Python version''': platform.python_version(), '''Numpy version''': np.__version__, '''PyTorch version (GPU?)''': F'''{pt_version} ({pt_cuda_available})''', '''PyTorch XPU available''': str(snake_case_ ), '''PyTorch NPU available''': str(snake_case_ ), '''System RAM''': F'''{psutil.virtual_memory().total / 1_024 ** 3:.2f} GB''', } if pt_cuda_available: __UpperCAmelCase = torch.cuda.get_device_name() print('''\nCopy-and-paste the text below in your GitHub issue\n''' ) print('''\n'''.join([F'''- {prop}: {val}''' for prop, val in info.items()] ) ) print('''- `Accelerate` default config:''' if args.config_file is None else '''- `Accelerate` config passed:''' ) __UpperCAmelCase = ( '''\n'''.join([F'''\t- {prop}: {val}''' for prop, val in accelerate_config.items()] ) if isinstance(snake_case_ , snake_case_ ) else F'''\t{accelerate_config}''' ) print(snake_case_ ) __UpperCAmelCase = accelerate_config return info def lowercase__ ( ): __UpperCAmelCase = env_command_parser() __UpperCAmelCase = parser.parse_args() env_command(snake_case_ ) return 0 if __name__ == "__main__": raise SystemExit(main())
332
0
"""simple docstring""" import argparse import ast import logging import os import sys import pandas as pd import torch from tqdm import tqdm from transformers import BartForConditionalGeneration, RagRetriever, RagSequenceForGeneration, RagTokenForGeneration from transformers import logging as transformers_logging sys.path.append(os.path.join(os.getcwd())) # noqa: E402 # isort:skip from utils_rag import exact_match_score, fa_score # noqa: E402 # isort:skip lowerCamelCase_ : Dict = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) transformers_logging.set_verbosity_info() def A__ ( lowerCamelCase ) -> Optional[int]: if "token" in model_name_or_path: return "rag_token" if "sequence" in model_name_or_path: return "rag_sequence" if "bart" in model_name_or_path: return "bart" return None def A__ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> str: return max(metric_fn(lowerCamelCase__ , lowerCamelCase__ ) for gt in ground_truths ) def A__ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> List[Any]: UpperCamelCase_: Union[str, Any] = [line.strip() for line in open(lowerCamelCase__ , """r""" ).readlines()] UpperCamelCase_: int = [] if args.gold_data_mode == "qa": UpperCamelCase_: Union[str, Any] = pd.read_csv(lowerCamelCase__ , sep="""\t""" , header=lowerCamelCase__ ) for answer_list in data[1]: UpperCamelCase_: Any = ast.literal_eval(lowerCamelCase__ ) answers.append(lowerCamelCase__ ) else: UpperCamelCase_: Union[str, Any] = [line.strip() for line in open(lowerCamelCase__ , """r""" ).readlines()] UpperCamelCase_: Any = [[reference] for reference in references] UpperCamelCase_: List[Any] = 0 for prediction, ground_truths in zip(lowerCamelCase__ , lowerCamelCase__ ): total += 1 em += metric_max_over_ground_truths(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) fa += metric_max_over_ground_truths(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) UpperCamelCase_: int = 1_00.0 * em / total UpperCamelCase_: List[Any] = 1_00.0 * fa / total logger.info(F'''F1: {fa:.2f}''' ) logger.info(F'''EM: {em:.2f}''' ) def A__ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> Tuple: UpperCamelCase_: List[str] = args.k UpperCamelCase_: List[str] = [line.strip() for line in open(lowerCamelCase__ , """r""" ).readlines()] UpperCamelCase_: List[str] = [line.strip() for line in open(lowerCamelCase__ , """r""" ).readlines()] UpperCamelCase_: List[str] = 0 for hypo, reference in zip(lowerCamelCase__ , lowerCamelCase__ ): UpperCamelCase_: List[str] = set(hypo.split("""\t""" )[:k] ) UpperCamelCase_: List[Any] = set(reference.split("""\t""" ) ) total += 1 em += len(hypo_provenance & ref_provenance ) / k UpperCamelCase_: Optional[int] = 1_00.0 * em / total logger.info(F'''Precision@{k}: {em: .2f}''' ) def A__ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> Union[str, Any]: def strip_title(lowerCamelCase ): if title.startswith("""\"""" ): UpperCamelCase_: List[Any] = title[1:] if title.endswith("""\"""" ): UpperCamelCase_: Union[str, Any] = title[:-1] return title UpperCamelCase_: Dict = rag_model.retriever.question_encoder_tokenizer.batch_encode_plus( lowerCamelCase__ , return_tensors="""pt""" , padding=lowerCamelCase__ , truncation=lowerCamelCase__ , )["""input_ids"""].to(args.device ) UpperCamelCase_: Tuple = rag_model.rag.question_encoder(lowerCamelCase__ ) UpperCamelCase_: Any = question_enc_outputs[0] UpperCamelCase_: Union[str, Any] = rag_model.retriever( lowerCamelCase__ , question_enc_pool_output.cpu().detach().to(torch.floataa ).numpy() , prefix=rag_model.rag.generator.config.prefix , n_docs=rag_model.config.n_docs , return_tensors="""pt""" , ) UpperCamelCase_: Any = rag_model.retriever.index.get_doc_dicts(result.doc_ids ) UpperCamelCase_: List[str] = [] for docs in all_docs: UpperCamelCase_: int = [strip_title(lowerCamelCase__ ) for title in docs["""title"""]] provenance_strings.append("""\t""".join(lowerCamelCase__ ) ) return provenance_strings def A__ ( lowerCamelCase , lowerCamelCase , lowerCamelCase ) -> Tuple: with torch.no_grad(): UpperCamelCase_: str = rag_model.retriever.question_encoder_tokenizer.batch_encode_plus( lowerCamelCase__ , return_tensors="""pt""" , padding=lowerCamelCase__ , truncation=lowerCamelCase__ ) UpperCamelCase_: List[Any] = inputs_dict.input_ids.to(args.device ) UpperCamelCase_: Optional[int] = inputs_dict.attention_mask.to(args.device ) UpperCamelCase_: Union[str, Any] = rag_model.generate( # rag_model overwrites generate lowerCamelCase__ , attention_mask=lowerCamelCase__ , num_beams=args.num_beams , min_length=args.min_length , max_length=args.max_length , early_stopping=lowerCamelCase__ , num_return_sequences=1 , bad_words_ids=[[0, 0]] , ) UpperCamelCase_: Tuple = rag_model.retriever.generator_tokenizer.batch_decode(lowerCamelCase__ , skip_special_tokens=lowerCamelCase__ ) if args.print_predictions: for q, a in zip(lowerCamelCase__ , lowerCamelCase__ ): logger.info("""Q: {} - A: {}""".format(lowerCamelCase__ , lowerCamelCase__ ) ) return answers def A__ ( ) -> Tuple: UpperCamelCase_: Optional[Any] = argparse.ArgumentParser() parser.add_argument( """--model_type""" , choices=["""rag_sequence""", """rag_token""", """bart"""] , type=lowerCamelCase__ , help=( """RAG model type: rag_sequence, rag_token or bart, if none specified, the type is inferred from the""" """ model_name_or_path""" ) , ) parser.add_argument( """--index_name""" , default=lowerCamelCase__ , choices=["""exact""", """compressed""", """legacy"""] , type=lowerCamelCase__ , help="""RAG model retriever type""" , ) parser.add_argument( """--index_path""" , default=lowerCamelCase__ , type=lowerCamelCase__ , help="""Path to the retrieval index""" , ) parser.add_argument("""--n_docs""" , default=5 , type=lowerCamelCase__ , help="""Number of retrieved docs""" ) parser.add_argument( """--model_name_or_path""" , default=lowerCamelCase__ , type=lowerCamelCase__ , required=lowerCamelCase__ , help="""Path to pretrained checkpoints or model identifier from huggingface.co/models""" , ) parser.add_argument( """--eval_mode""" , choices=["""e2e""", """retrieval"""] , default="""e2e""" , type=lowerCamelCase__ , help=( """Evaluation mode, e2e calculates exact match and F1 of the downstream task, retrieval calculates""" """ precision@k.""" ) , ) parser.add_argument("""--k""" , default=1 , type=lowerCamelCase__ , help="""k for the precision@k calculation""" ) parser.add_argument( """--evaluation_set""" , default=lowerCamelCase__ , type=lowerCamelCase__ , required=lowerCamelCase__ , help="""Path to a file containing evaluation samples""" , ) parser.add_argument( """--gold_data_path""" , default=lowerCamelCase__ , type=lowerCamelCase__ , required=lowerCamelCase__ , help="""Path to a tab-separated file with gold samples""" , ) parser.add_argument( """--gold_data_mode""" , default="""qa""" , type=lowerCamelCase__ , choices=["""qa""", """ans"""] , help=( """Format of the gold data file""" """qa - a single line in the following format: question [tab] answer_list""" """ans - a single line of the gold file contains the expected answer string""" ) , ) parser.add_argument( """--predictions_path""" , type=lowerCamelCase__ , default="""predictions.txt""" , help="""Name of the predictions file, to be stored in the checkpoints directory""" , ) parser.add_argument( """--eval_all_checkpoints""" , action="""store_true""" , help="""Evaluate all checkpoints starting with the same prefix as model_name ending and ending with step number""" , ) parser.add_argument( """--eval_batch_size""" , default=8 , type=lowerCamelCase__ , help="""Batch size per GPU/CPU for evaluation.""" , ) parser.add_argument( """--recalculate""" , help="""Recalculate predictions even if the prediction file exists""" , action="""store_true""" , ) parser.add_argument( """--num_beams""" , default=4 , type=lowerCamelCase__ , help="""Number of beams to be used when generating answers""" , ) parser.add_argument("""--min_length""" , default=1 , type=lowerCamelCase__ , help="""Min length of the generated answers""" ) parser.add_argument("""--max_length""" , default=50 , type=lowerCamelCase__ , help="""Max length of the generated answers""" ) parser.add_argument( """--print_predictions""" , action="""store_true""" , help="""If True, prints predictions while evaluating.""" , ) parser.add_argument( """--print_docs""" , action="""store_true""" , help="""If True, prints docs retried while generating.""" , ) UpperCamelCase_: str = parser.parse_args() UpperCamelCase_: Optional[int] = torch.device("""cuda""" if torch.cuda.is_available() else """cpu""" ) return args def A__ ( lowerCamelCase ) -> int: UpperCamelCase_: str = {} if args.model_type is None: UpperCamelCase_: Optional[int] = infer_model_type(args.model_name_or_path ) assert args.model_type is not None if args.model_type.startswith("""rag""" ): UpperCamelCase_: str = RagTokenForGeneration if args.model_type == """rag_token""" else RagSequenceForGeneration UpperCamelCase_: Optional[int] = args.n_docs if args.index_name is not None: UpperCamelCase_: Optional[Any] = args.index_name if args.index_path is not None: UpperCamelCase_: str = args.index_path else: UpperCamelCase_: str = BartForConditionalGeneration UpperCamelCase_: Union[str, Any] = ( [f.path for f in os.scandir(args.model_name_or_path ) if f.is_dir()] if args.eval_all_checkpoints else [args.model_name_or_path] ) logger.info("""Evaluate the following checkpoints: %s""" , lowerCamelCase__ ) UpperCamelCase_: int = get_scores if args.eval_mode == """e2e""" else get_precision_at_k UpperCamelCase_: Optional[int] = evaluate_batch_eae if args.eval_mode == """e2e""" else evaluate_batch_retrieval for checkpoint in checkpoints: if os.path.exists(args.predictions_path ) and (not args.recalculate): logger.info("""Calculating metrics based on an existing predictions file: {}""".format(args.predictions_path ) ) score_fn(lowerCamelCase__ , args.predictions_path , args.gold_data_path ) continue logger.info("""***** Running evaluation for {} *****""".format(lowerCamelCase__ ) ) logger.info(""" Batch size = %d""" , args.eval_batch_size ) logger.info(""" Predictions will be stored under {}""".format(args.predictions_path ) ) if args.model_type.startswith("""rag""" ): UpperCamelCase_: Optional[int] = RagRetriever.from_pretrained(lowerCamelCase__ , **lowerCamelCase__ ) UpperCamelCase_: Optional[Any] = model_class.from_pretrained(lowerCamelCase__ , retriever=lowerCamelCase__ , **lowerCamelCase__ ) model.retriever.init_retrieval() else: UpperCamelCase_: Any = model_class.from_pretrained(lowerCamelCase__ , **lowerCamelCase__ ) model.to(args.device ) with open(args.evaluation_set , """r""" ) as eval_file, open(args.predictions_path , """w""" ) as preds_file: UpperCamelCase_: Union[str, Any] = [] for line in tqdm(lowerCamelCase__ ): questions.append(line.strip() ) if len(lowerCamelCase__ ) == args.eval_batch_size: UpperCamelCase_: Tuple = evaluate_batch_fn(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) preds_file.write("""\n""".join(lowerCamelCase__ ) + """\n""" ) preds_file.flush() UpperCamelCase_: Optional[int] = [] if len(lowerCamelCase__ ) > 0: UpperCamelCase_: List[str] = evaluate_batch_fn(lowerCamelCase__ , lowerCamelCase__ , lowerCamelCase__ ) preds_file.write("""\n""".join(lowerCamelCase__ ) ) preds_file.flush() score_fn(lowerCamelCase__ , args.predictions_path , args.gold_data_path ) if __name__ == "__main__": lowerCamelCase_ : Optional[Any] = get_args() main(args)
353
from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding class _UpperCamelCase ( _A ): '''simple docstring''' __UpperCamelCase : Union[str, Any] = ["""image_processor""", """tokenizer"""] __UpperCamelCase : List[Any] = """AutoImageProcessor""" __UpperCamelCase : Tuple = """AutoTokenizer""" def __init__( self : Any , snake_case_ : Optional[Any] , snake_case_ : Any ): super().__init__(snake_case_ , snake_case_ ) UpperCamelCase_: int = self.image_processor def __call__( self : str , snake_case_ : Optional[int]=None , snake_case_ : int=None , snake_case_ : Dict=None , **snake_case_ : Optional[int] ): if text is None and images is None: raise ValueError("""You have to specify either text or images. Both cannot be none.""" ) if text is not None: UpperCamelCase_: List[Any] = self.tokenizer(snake_case_ , return_tensors=snake_case_ , **snake_case_ ) if images is not None: UpperCamelCase_: Any = self.image_processor(snake_case_ , return_tensors=snake_case_ , **snake_case_ ) if text is not None and images is not None: UpperCamelCase_: Tuple = image_features.pixel_values return encoding elif text is not None: return encoding else: return BatchEncoding(data=dict(**snake_case_ ) , tensor_type=snake_case_ ) def lowerCAmelCase__ ( self : List[str] , *snake_case_ : int , **snake_case_ : Optional[Any] ): return self.tokenizer.batch_decode(*snake_case_ , **snake_case_ ) def lowerCAmelCase__ ( self : int , *snake_case_ : Optional[Any] , **snake_case_ : str ): return self.tokenizer.decode(*snake_case_ , **snake_case_ ) @property def lowerCAmelCase__ ( self : Union[str, Any] ): return ["input_ids", "attention_mask", "pixel_values"]
223
0
"""simple docstring""" from __future__ import annotations def UpperCAmelCase ( UpperCamelCase__ , UpperCamelCase__ ): """simple docstring""" A__ = set(__lowerCamelCase ), [start] while stack: A__ = stack.pop() explored.add(__lowerCamelCase ) # 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(__lowerCamelCase ) return explored __lowerCamelCase = { "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"))
221
"""simple docstring""" import unittest import numpy as np import timeout_decorator # noqa from transformers import BlenderbotSmallConfig, is_flax_available from transformers.testing_utils import require_flax, slow from ...generation.test_flax_utils import FlaxGenerationTesterMixin from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor if is_flax_available(): import os # The slow tests are often failing with OOM error on GPU # This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed # but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html _a = 'platform' import jax import jax.numpy as jnp from transformers.models.blenderbot_small.modeling_flax_blenderbot_small import ( FlaxBlenderbotSmallForConditionalGeneration, FlaxBlenderbotSmallModel, shift_tokens_right, ) def __a ( __lowerCamelCase, __lowerCamelCase, __lowerCamelCase=None, __lowerCamelCase=None, __lowerCamelCase=None, __lowerCamelCase=None, __lowerCamelCase=None, __lowerCamelCase=None, ): if attention_mask is None: UpperCAmelCase_ : Union[str, Any] = np.where(input_ids != config.pad_token_id, 1, 0 ) if decoder_attention_mask is None: UpperCAmelCase_ : Optional[int] = np.where(decoder_input_ids != config.pad_token_id, 1, 0 ) if head_mask is None: UpperCAmelCase_ : int = np.ones((config.encoder_layers, config.encoder_attention_heads) ) if decoder_head_mask is None: UpperCAmelCase_ : Union[str, Any] = np.ones((config.decoder_layers, config.decoder_attention_heads) ) if cross_attn_head_mask is None: UpperCAmelCase_ : List[Any] = np.ones((config.decoder_layers, config.decoder_attention_heads) ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": attention_mask, } class A_ : '''simple docstring''' def __init__( self , lowercase_ , lowercase_=13 , lowercase_=7 , lowercase_=True , lowercase_=False , lowercase_=99 , lowercase_=16 , lowercase_=2 , lowercase_=4 , lowercase_=4 , lowercase_="gelu" , lowercase_=0.1 , lowercase_=0.1 , lowercase_=32 , lowercase_=2 , lowercase_=1 , lowercase_=0 , lowercase_=0.02 , ): """simple docstring""" UpperCAmelCase_ : List[str] = parent UpperCAmelCase_ : Tuple = batch_size UpperCAmelCase_ : str = seq_length UpperCAmelCase_ : Dict = is_training UpperCAmelCase_ : List[Any] = use_labels UpperCAmelCase_ : Optional[int] = vocab_size UpperCAmelCase_ : int = hidden_size UpperCAmelCase_ : Optional[Any] = num_hidden_layers UpperCAmelCase_ : Dict = num_attention_heads UpperCAmelCase_ : List[str] = intermediate_size UpperCAmelCase_ : Optional[int] = hidden_act UpperCAmelCase_ : str = hidden_dropout_prob UpperCAmelCase_ : int = attention_probs_dropout_prob UpperCAmelCase_ : Optional[Any] = max_position_embeddings UpperCAmelCase_ : str = eos_token_id UpperCAmelCase_ : str = pad_token_id UpperCAmelCase_ : str = bos_token_id UpperCAmelCase_ : List[Any] = initializer_range def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Optional[Any] = np.clip(ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ) , 3 , self.vocab_size ) UpperCAmelCase_ : Any = np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1) , dtype=np.intaa )) , -1 ) UpperCAmelCase_ : str = shift_tokens_right(lowercase_ , 1 , 2 ) UpperCAmelCase_ : str = BlenderbotSmallConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_id=self.eos_token_id , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , initializer_range=self.initializer_range , use_cache=lowercase_ , ) UpperCAmelCase_ : Optional[int] = prepare_blenderbot_inputs_dict(lowercase_ , lowercase_ , lowercase_ ) return config, inputs_dict def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Optional[int] = self.prepare_config_and_inputs() return config, inputs_dict def UpperCamelCase__ ( self , lowercase_ , lowercase_ , lowercase_ ): """simple docstring""" UpperCAmelCase_ : List[str] = 20 UpperCAmelCase_ : int = model_class_name(lowercase_ ) UpperCAmelCase_ : Optional[int] = model.encode(inputs_dict["input_ids"] ) UpperCAmelCase_ , UpperCAmelCase_ : Any = ( inputs_dict["decoder_input_ids"], inputs_dict["decoder_attention_mask"], ) UpperCAmelCase_ : Any = model.init_cache(decoder_input_ids.shape[0] , lowercase_ , lowercase_ ) UpperCAmelCase_ : Tuple = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) , dtype="i4" ) UpperCAmelCase_ : Union[str, Any] = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) UpperCAmelCase_ : int = model.decode( decoder_input_ids[:, :-1] , lowercase_ , decoder_attention_mask=lowercase_ , past_key_values=lowercase_ , decoder_position_ids=lowercase_ , ) UpperCAmelCase_ : int = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="i4" ) UpperCAmelCase_ : Dict = model.decode( decoder_input_ids[:, -1:] , lowercase_ , decoder_attention_mask=lowercase_ , past_key_values=outputs_cache.past_key_values , decoder_position_ids=lowercase_ , ) UpperCAmelCase_ : Optional[Any] = model.decode(lowercase_ , lowercase_ ) UpperCAmelCase_ : Tuple = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1E-3 , msg=F"""Max diff is {diff}""" ) def UpperCamelCase__ ( self , lowercase_ , lowercase_ , lowercase_ ): """simple docstring""" UpperCAmelCase_ : List[str] = 20 UpperCAmelCase_ : Any = model_class_name(lowercase_ ) UpperCAmelCase_ : Tuple = model.encode(inputs_dict["input_ids"] ) UpperCAmelCase_ , UpperCAmelCase_ : List[Any] = ( inputs_dict["decoder_input_ids"], inputs_dict["decoder_attention_mask"], ) UpperCAmelCase_ : Optional[Any] = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] , axis=-1 , ) UpperCAmelCase_ : int = model.init_cache(decoder_input_ids.shape[0] , lowercase_ , lowercase_ ) UpperCAmelCase_ : List[str] = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) UpperCAmelCase_ : List[str] = model.decode( decoder_input_ids[:, :-1] , lowercase_ , decoder_attention_mask=lowercase_ , past_key_values=lowercase_ , decoder_position_ids=lowercase_ , ) UpperCAmelCase_ : Any = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="i4" ) UpperCAmelCase_ : Dict = model.decode( decoder_input_ids[:, -1:] , lowercase_ , past_key_values=outputs_cache.past_key_values , decoder_attention_mask=lowercase_ , decoder_position_ids=lowercase_ , ) UpperCAmelCase_ : Dict = model.decode(lowercase_ , lowercase_ , decoder_attention_mask=lowercase_ ) UpperCAmelCase_ : Optional[Any] = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1E-3 , msg=F"""Max diff is {diff}""" ) @require_flax class A_ (unittest.TestCase ): '''simple docstring''' SCREAMING_SNAKE_CASE__ : Tuple = 99 def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Optional[Any] = np.array( [ [71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 82, 2], [5, 97, 17, 39, 94, 40, 2], [76, 83, 94, 25, 70, 78, 2], [87, 59, 41, 35, 48, 66, 2], [55, 13, 16, 58, 5, 2, 1], # note padding [64, 27, 31, 51, 12, 75, 2], [52, 64, 86, 17, 83, 39, 2], [48, 61, 9, 24, 71, 82, 2], [26, 1, 60, 48, 22, 13, 2], [21, 5, 62, 28, 14, 76, 2], [45, 98, 37, 86, 59, 48, 2], [70, 70, 50, 9, 28, 0, 2], ] , dtype=np.intaa , ) UpperCAmelCase_ : Any = input_ids.shape[0] UpperCAmelCase_ : Dict = BlenderbotSmallConfig( vocab_size=self.vocab_size , d_model=24 , encoder_layers=2 , decoder_layers=2 , encoder_attention_heads=2 , decoder_attention_heads=2 , encoder_ffn_dim=32 , decoder_ffn_dim=32 , max_position_embeddings=48 , eos_token_id=2 , pad_token_id=1 , bos_token_id=0 , ) return config, input_ids, batch_size def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ , UpperCAmelCase_ : Tuple = self._get_config_and_data() UpperCAmelCase_ : List[str] = FlaxBlenderbotSmallForConditionalGeneration(lowercase_ ) UpperCAmelCase_ : Optional[int] = lm_model(input_ids=lowercase_ ) UpperCAmelCase_ : Optional[int] = (batch_size, input_ids.shape[1], config.vocab_size) self.assertEqual(outputs["logits"].shape , lowercase_ ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : List[str] = BlenderbotSmallConfig( vocab_size=self.vocab_size , d_model=14 , encoder_layers=2 , decoder_layers=2 , encoder_attention_heads=2 , decoder_attention_heads=2 , encoder_ffn_dim=8 , decoder_ffn_dim=8 , max_position_embeddings=48 , ) UpperCAmelCase_ : Optional[int] = FlaxBlenderbotSmallForConditionalGeneration(lowercase_ ) UpperCAmelCase_ : str = np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]] , dtype=np.intaa ) UpperCAmelCase_ : str = np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]] , dtype=np.intaa ) UpperCAmelCase_ : Tuple = lm_model(input_ids=lowercase_ , decoder_input_ids=lowercase_ ) UpperCAmelCase_ : Tuple = (*summary.shape, config.vocab_size) self.assertEqual(outputs["logits"].shape , lowercase_ ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : List[Any] = np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]] , dtype=np.intaa ) UpperCAmelCase_ : Dict = shift_tokens_right(lowercase_ , 1 , 2 ) UpperCAmelCase_ : Tuple = np.equal(lowercase_ , 1 ).astype(np.floataa ).sum() UpperCAmelCase_ : Optional[Any] = np.equal(lowercase_ , 1 ).astype(np.floataa ).sum() self.assertEqual(shifted.shape , input_ids.shape ) self.assertEqual(lowercase_ , n_pad_before - 1 ) self.assertTrue(np.equal(shifted[:, 0] , 2 ).all() ) @require_flax class A_ (lowercase__ ,unittest.TestCase ,lowercase__ ): '''simple docstring''' SCREAMING_SNAKE_CASE__ : str = True SCREAMING_SNAKE_CASE__ : Union[str, Any] = ( ( FlaxBlenderbotSmallModel, FlaxBlenderbotSmallForConditionalGeneration, ) if is_flax_available() else () ) SCREAMING_SNAKE_CASE__ : List[Any] = (FlaxBlenderbotSmallForConditionalGeneration,) if is_flax_available() else () def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ : Dict = FlaxBlenderbotSmallModelTester(self ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Tuple = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(lowercase_ , lowercase_ , lowercase_ ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Optional[Any] = self.model_tester.prepare_config_and_inputs() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(lowercase_ , lowercase_ , lowercase_ ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Any = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): UpperCAmelCase_ : List[Any] = self._prepare_for_class(lowercase_ , lowercase_ ) UpperCAmelCase_ : Dict = model_class(lowercase_ ) @jax.jit def encode_jitted(lowercase_ , lowercase_=None , **lowercase_ ): return model.encode(input_ids=lowercase_ , attention_mask=lowercase_ ) with self.subTest("JIT Enabled" ): UpperCAmelCase_ : List[Any] = encode_jitted(**lowercase_ ).to_tuple() with self.subTest("JIT Disabled" ): with jax.disable_jit(): UpperCAmelCase_ : Optional[Any] = encode_jitted(**lowercase_ ).to_tuple() self.assertEqual(len(lowercase_ ) , len(lowercase_ ) ) for jitted_output, output in zip(lowercase_ , lowercase_ ): self.assertEqual(jitted_output.shape , output.shape ) def UpperCamelCase__ ( self ): """simple docstring""" UpperCAmelCase_ , UpperCAmelCase_ : Union[str, Any] = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): UpperCAmelCase_ : Optional[int] = model_class(lowercase_ ) UpperCAmelCase_ : Tuple = model.encode(inputs_dict["input_ids"] , inputs_dict["attention_mask"] ) UpperCAmelCase_ : int = { "decoder_input_ids": inputs_dict["decoder_input_ids"], "decoder_attention_mask": inputs_dict["decoder_attention_mask"], "encoder_outputs": encoder_outputs, } @jax.jit def decode_jitted(lowercase_ , lowercase_ , lowercase_ ): return model.decode( decoder_input_ids=lowercase_ , decoder_attention_mask=lowercase_ , encoder_outputs=lowercase_ , ) with self.subTest("JIT Enabled" ): UpperCAmelCase_ : str = decode_jitted(**lowercase_ ).to_tuple() with self.subTest("JIT Disabled" ): with jax.disable_jit(): UpperCAmelCase_ : List[Any] = decode_jitted(**lowercase_ ).to_tuple() self.assertEqual(len(lowercase_ ) , len(lowercase_ ) ) for jitted_output, output in zip(lowercase_ , lowercase_ ): self.assertEqual(jitted_output.shape , output.shape ) @slow def UpperCamelCase__ ( self ): """simple docstring""" for model_class_name in self.all_model_classes: UpperCAmelCase_ : Optional[Any] = model_class_name.from_pretrained("facebook/blenderbot_small-90M" ) # FlaxBlenderbotForSequenceClassification expects eos token in input_ids UpperCAmelCase_ : List[str] = np.ones((1, 1) ) * model.config.eos_token_id UpperCAmelCase_ : Optional[int] = model(lowercase_ ) self.assertIsNotNone(lowercase_ )
61
0
"""simple docstring""" from decimal import Decimal, getcontext from math import ceil, factorial def _SCREAMING_SNAKE_CASE (_UpperCAmelCase : Optional[int] ): if not isinstance(lowercase_ , lowercase_ ): raise TypeError('Undefined for non-integers' ) elif precision < 1: raise ValueError('Undefined for non-natural numbers' ) lowerCAmelCase = precision lowerCAmelCase = ceil(precision / 14 ) lowerCAmelCase = 42_6880 * Decimal(1_0005 ).sqrt() lowerCAmelCase = 1 lowerCAmelCase = 1359_1409 lowerCAmelCase = Decimal(lowercase_ ) for k in range(1 , lowercase_ ): lowerCAmelCase = factorial(6 * k ) // (factorial(3 * k ) * factorial(lowercase_ ) ** 3) linear_term += 5_4514_0134 exponential_term *= -26_2537_4126_4076_8000 partial_sum += Decimal(multinomial_term * linear_term ) / exponential_term return str(constant_term / partial_sum )[:-1] if __name__ == "__main__": __UpperCamelCase : List[str] = 50 print(f'''The first {n} digits of pi is: {pi(n)}''')
362
"""simple docstring""" import warnings from ...utils import logging from .image_processing_poolformer import PoolFormerImageProcessor __UpperCamelCase : Optional[Any] = logging.get_logger(__name__) class a ( a__ ): def __init__( self , *_snake_case , **_snake_case ): """simple docstring""" warnings.warn( 'The class PoolFormerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.' ' Please use PoolFormerImageProcessor instead.' , _snake_case , ) super().__init__(*_snake_case , **_snake_case )
309
0