code
stringlengths
81
54k
code_codestyle
int64
0
721
style_context
stringlengths
91
41.9k
style_context_codestyle
int64
0
699
label
int64
0
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_tokenizers_available, is_torch_available, ) a : Any = { '''configuration_blenderbot''': [ '''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''BlenderbotConfig''', '''BlenderbotOnnxConfig''', ], '''tokenization_blenderbot''': ['''BlenderbotTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : str = ['''BlenderbotTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Tuple = [ '''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''', '''BlenderbotForCausalLM''', '''BlenderbotForConditionalGeneration''', '''BlenderbotModel''', '''BlenderbotPreTrainedModel''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Dict = [ '''TFBlenderbotForConditionalGeneration''', '''TFBlenderbotModel''', '''TFBlenderbotPreTrainedModel''', ] try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : List[str] = [ '''FlaxBlenderbotForConditionalGeneration''', '''FlaxBlenderbotModel''', '''FlaxBlenderbotPreTrainedModel''', ] if TYPE_CHECKING: from .configuration_blenderbot import ( BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP, BlenderbotConfig, BlenderbotOnnxConfig, ) from .tokenization_blenderbot import BlenderbotTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_blenderbot_fast import BlenderbotTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_blenderbot import ( BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST, BlenderbotForCausalLM, BlenderbotForConditionalGeneration, BlenderbotModel, BlenderbotPreTrainedModel, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_blenderbot import ( TFBlenderbotForConditionalGeneration, TFBlenderbotModel, TFBlenderbotPreTrainedModel, ) try: if not is_flax_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_flax_blenderbot import ( FlaxBlenderbotForConditionalGeneration, FlaxBlenderbotModel, FlaxBlenderbotPreTrainedModel, ) else: import sys a : int = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
"""simple docstring""" import enum import warnings from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING a : List[str] = logging.get_logger(__name__) class a_ ( enum.Enum ): a : Optional[Any] = 0 a : Dict = 1 @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'generated' def __init__( self : int , *__UpperCamelCase : Optional[int] , **__UpperCamelCase : str ) ->Any: '''simple docstring''' super().__init__(*__UpperCamelCase , **__UpperCamelCase ) self.check_model_type( TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if self.framework == """tf""" else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : int=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : Dict=None , **__UpperCamelCase : Any , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = {} if truncation is not None: _UpperCAmelCase = truncation _UpperCAmelCase = generate_kwargs _UpperCAmelCase = {} if return_tensors is not None and return_type is None: _UpperCAmelCase = ReturnType.TENSORS if return_tensors else ReturnType.TEXT if return_type is not None: _UpperCAmelCase = return_type if clean_up_tokenization_spaces is not None: _UpperCAmelCase = clean_up_tokenization_spaces if stop_sequence is not None: _UpperCAmelCase = self.tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) if len(__UpperCamelCase ) > 1: warnings.warn( """Stopping on a multiple token sequence is not yet supported on transformers. The first token of""" """ the stop sequence will be used as the stop sequence string in the interim.""" ) _UpperCAmelCase = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def _snake_case ( self : int , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' return True def _snake_case ( self : Optional[Any] , *__UpperCamelCase : Any , __UpperCamelCase : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model.config.prefix if self.model.config.prefix is not None else """""" if isinstance(args[0] , __UpperCamelCase ): if self.tokenizer.pad_token_id is None: raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" ) _UpperCAmelCase = ([prefix + arg for arg in args[0]],) _UpperCAmelCase = True elif isinstance(args[0] , __UpperCamelCase ): _UpperCAmelCase = (prefix + args[0],) _UpperCAmelCase = False else: raise ValueError( f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" ) _UpperCAmelCase = self.tokenizer(*__UpperCamelCase , padding=__UpperCamelCase , truncation=__UpperCamelCase , return_tensors=self.framework ) # This is produced by tokenizers but is an invalid generate kwargs if "token_type_ids" in inputs: del inputs["token_type_ids"] return inputs def __call__( self : Dict , *__UpperCamelCase : str , **__UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = super().__call__(*__UpperCamelCase , **__UpperCamelCase ) if ( isinstance(args[0] , __UpperCamelCase ) and all(isinstance(__UpperCamelCase , __UpperCamelCase ) for el in args[0] ) and all(len(__UpperCamelCase ) == 1 for res in result ) ): return [res[0] for res in result] return result def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : str=TruncationStrategy.DO_NOT_TRUNCATE , **__UpperCamelCase : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self._parse_and_tokenize(__UpperCamelCase , truncation=__UpperCamelCase , **__UpperCamelCase ) return inputs def _snake_case ( self : str , __UpperCamelCase : Dict , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' if self.framework == "pt": _UpperCAmelCase ,_UpperCAmelCase = model_inputs["""input_ids"""].shape elif self.framework == "tf": _UpperCAmelCase ,_UpperCAmelCase = tf.shape(model_inputs["""input_ids"""] ).numpy() _UpperCAmelCase = generate_kwargs.get("""min_length""" , self.model.config.min_length ) _UpperCAmelCase = generate_kwargs.get("""max_length""" , self.model.config.max_length ) self.check_inputs(__UpperCamelCase , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] ) _UpperCAmelCase = self.model.generate(**__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = output_ids.shape[0] if self.framework == "pt": _UpperCAmelCase = output_ids.reshape(__UpperCamelCase , out_b // in_b , *output_ids.shape[1:] ) elif self.framework == "tf": _UpperCAmelCase = tf.reshape(__UpperCamelCase , (in_b, out_b // in_b, *output_ids.shape[1:]) ) return {"output_ids": output_ids} def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : Union[str, Any]=ReturnType.TEXT , __UpperCamelCase : int=False ) ->Any: '''simple docstring''' _UpperCAmelCase = [] for output_ids in model_outputs["output_ids"][0]: if return_type == ReturnType.TENSORS: _UpperCAmelCase = {f"""{self.return_name}_token_ids""": output_ids} elif return_type == ReturnType.TEXT: _UpperCAmelCase = { f"""{self.return_name}_text""": self.tokenizer.decode( __UpperCamelCase , skip_special_tokens=__UpperCamelCase , clean_up_tokenization_spaces=__UpperCamelCase , ) } records.append(__UpperCamelCase ) return records @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'summary' def __call__( self : Optional[Any] , *__UpperCamelCase : Optional[Any] , **__UpperCamelCase : Optional[int] ) ->Any: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->bool: '''simple docstring''' if max_length < min_length: logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" ) if input_length < max_length: logger.warning( f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """ """a summarization task, where outputs shorter than the input are typically wanted, you might """ f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" ) @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : Optional[int] = 'translation' def _snake_case ( self : Union[str, Any] , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' if input_length > 0.9 * max_length: logger.warning( f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """ """increasing your max_length manually, e.g. translator('...', max_length=400)""" ) return True def _snake_case ( self : Tuple , *__UpperCamelCase : List[str] , __UpperCamelCase : Tuple=TruncationStrategy.DO_NOT_TRUNCATE , __UpperCamelCase : Tuple=None , __UpperCamelCase : Union[str, Any]=None ) ->Tuple: '''simple docstring''' if getattr(self.tokenizer , """_build_translation_inputs""" , __UpperCamelCase ): return self.tokenizer._build_translation_inputs( *__UpperCamelCase , return_tensors=self.framework , truncation=__UpperCamelCase , src_lang=__UpperCamelCase , tgt_lang=__UpperCamelCase ) else: return super()._parse_and_tokenize(*__UpperCamelCase , truncation=__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : int=None , __UpperCamelCase : int=None , **__UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = super()._sanitize_parameters(**__UpperCamelCase ) if src_lang is not None: _UpperCAmelCase = src_lang if tgt_lang is not None: _UpperCAmelCase = tgt_lang if src_lang is None and tgt_lang is None: # Backward compatibility, direct arguments use is preferred. _UpperCAmelCase = kwargs.get("""task""" , self.task ) _UpperCAmelCase = task.split("""_""" ) if task and len(__UpperCamelCase ) == 4: # translation, XX, to YY _UpperCAmelCase = items[1] _UpperCAmelCase = items[3] return preprocess_params, forward_params, postprocess_params def __call__( self : List[str] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->int: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase )
19
1
"""simple docstring""" from collections import Counter import numpy as np from sklearn import datasets from sklearn.model_selection import train_test_split a : List[str] = datasets.load_iris() a : int = np.array(data['''data''']) a : Optional[int] = np.array(data['''target''']) a : Optional[int] = data['''target_names'''] a , a , a , a : Optional[Any] = train_test_split(X, y) def _UpperCamelCase ( _A , _A ) -> Tuple: """simple docstring""" return np.linalg.norm(np.array(_A ) - np.array(_A ) ) def _UpperCamelCase ( _A , _A , _A , _A , _A=5 ) -> str: """simple docstring""" _UpperCAmelCase = zip(_A , _A ) # List of distances of all points from the point to be classified _UpperCAmelCase = [] for data_point in data: _UpperCAmelCase = euclidean_distance(data_point[0] , _A ) distances.append((distance, data_point[1]) ) # Choosing 'k' points with the least distances. _UpperCAmelCase = [i[1] for i in sorted(_A )[:k]] # Most commonly occurring class among them # is the class into which the point is classified _UpperCAmelCase = Counter(_A ).most_common(1 )[0][0] return classes[result] if __name__ == "__main__": print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))
19
"""simple docstring""" import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class a_ ( unittest.TestCase ): @property def _snake_case ( self : Dict ) ->int: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") , up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") , ) return model @property def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = VQModel( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=3 , ) return model @property def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) return CLIPTextModel(__UpperCamelCase ) def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = self.dummy_vq_model _UpperCAmelCase = LDMPipeline(unet=__UpperCamelCase , vqvae=__UpperCamelCase , scheduler=__UpperCamelCase ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" ).images _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" , return_dict=__UpperCamelCase )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _UpperCAmelCase = np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < tolerance @slow @require_torch class a_ ( unittest.TestCase ): def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256""" ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=5 , output_type="""numpy""" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _UpperCAmelCase = np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance
19
1
"""simple docstring""" def _UpperCamelCase ( _A , _A = 0 ) -> list: """simple docstring""" _UpperCAmelCase = length or len(_A ) _UpperCAmelCase = False for i in range(length - 1 ): if list_data[i] > list_data[i + 1]: _UpperCAmelCase ,_UpperCAmelCase = list_data[i + 1], list_data[i] _UpperCAmelCase = True return list_data if not swapped else bubble_sort(_A , length - 1 ) if __name__ == "__main__": import doctest doctest.testmod()
19
"""simple docstring""" import re from filelock import FileLock try: import nltk a : str = True except (ImportError, ModuleNotFoundError): a : List[str] = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def _UpperCamelCase ( _A ) -> str: """simple docstring""" re.sub("""<n>""" , """""" , _A ) # 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(_A ) )
19
1
"""simple docstring""" import inspect import unittest from transformers import DecisionTransformerConfig, is_torch_available from transformers.testing_utils import require_torch, slow, torch_device from ...generation.test_utils import GenerationTesterMixin from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import DecisionTransformerModel from transformers.models.decision_transformer.modeling_decision_transformer import ( DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, ) class a_ : def __init__( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : int=13 , __UpperCamelCase : List[Any]=7 , __UpperCamelCase : str=6 , __UpperCamelCase : int=17 , __UpperCamelCase : Dict=23 , __UpperCamelCase : Optional[int]=11 , __UpperCamelCase : List[Any]=True , ) ->Dict: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = act_dim _UpperCAmelCase = state_dim _UpperCAmelCase = hidden_size _UpperCAmelCase = max_length _UpperCAmelCase = is_training def _snake_case ( self : Dict ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = floats_tensor((self.batch_size, self.seq_length, self.state_dim) ) _UpperCAmelCase = floats_tensor((self.batch_size, self.seq_length, self.act_dim) ) _UpperCAmelCase = floats_tensor((self.batch_size, self.seq_length, 1) ) _UpperCAmelCase = floats_tensor((self.batch_size, self.seq_length, 1) ) _UpperCAmelCase = ids_tensor((self.batch_size, self.seq_length) , vocab_size=10_00 ) _UpperCAmelCase = random_attention_mask((self.batch_size, self.seq_length) ) _UpperCAmelCase = self.get_config() return ( config, states, actions, rewards, returns_to_go, timesteps, attention_mask, ) def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' return DecisionTransformerConfig( batch_size=self.batch_size , seq_length=self.seq_length , act_dim=self.act_dim , state_dim=self.state_dim , hidden_size=self.hidden_size , max_length=self.max_length , ) def _snake_case ( self : List[str] , __UpperCamelCase : int , __UpperCamelCase : str , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : str , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = DecisionTransformerModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) self.parent.assertEqual(result.state_preds.shape , states.shape ) self.parent.assertEqual(result.action_preds.shape , actions.shape ) self.parent.assertEqual(result.return_preds.shape , returns_to_go.shape ) self.parent.assertEqual( result.last_hidden_state.shape , (self.batch_size, self.seq_length * 3, self.hidden_size) ) # seq length *3 as there are 3 modelities: states, returns and actions def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = { """states""": states, """actions""": actions, """rewards""": rewards, """returns_to_go""": returns_to_go, """timesteps""": timesteps, """attention_mask""": attention_mask, } return config, inputs_dict @require_torch class a_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : Optional[int] = (DecisionTransformerModel,) if is_torch_available() else () a : Union[str, Any] = () a : int = {'feature-extraction': DecisionTransformerModel} if is_torch_available() else {} # Ignoring of a failing test from GenerationTesterMixin, as the model does not use inputs_ids a : str = False # Ignoring of a failing tests from ModelTesterMixin, as the model does not implement these features a : Tuple = False a : Optional[int] = False a : Optional[int] = False a : Tuple = False a : Union[str, Any] = False a : Union[str, Any] = False a : str = False a : List[Any] = False a : int = False def _snake_case ( self : str ) ->List[str]: '''simple docstring''' _UpperCAmelCase = DecisionTransformerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : str ) ->Any: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCamelCase ) @slow def _snake_case ( self : Optional[Any] ) ->Tuple: '''simple docstring''' for model_name in DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = DecisionTransformerModel.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = [ """states""", """actions""", """rewards""", """returns_to_go""", """timesteps""", """attention_mask""", ] self.assertListEqual(arg_names[: len(__UpperCamelCase )] , __UpperCamelCase ) @require_torch class a_ ( unittest.TestCase ): @slow def _snake_case ( self : int ) ->int: '''simple docstring''' _UpperCAmelCase = 2 # number of steps of autoregressive prediction we will perform _UpperCAmelCase = 10 # defined by the RL environment, may be normalized _UpperCAmelCase = DecisionTransformerModel.from_pretrained("""edbeeching/decision-transformer-gym-hopper-expert""" ) _UpperCAmelCase = model.to(__UpperCamelCase ) _UpperCAmelCase = model.config torch.manual_seed(0 ) _UpperCAmelCase = torch.randn(1 , 1 , config.state_dim ).to(device=__UpperCamelCase , dtype=torch.floataa ) # env.reset() _UpperCAmelCase = torch.tensor( [[0.2_4_2_7_9_3, -0.2_8_6_9_3_0_7_4, 0.8_7_4_2_6_1_3], [0.6_7_8_1_5_2_7_4, -0.0_8_1_0_1_0_8_5, -0.1_2_9_5_2_1_4_7]] , device=__UpperCamelCase ) _UpperCAmelCase = torch.tensor(__UpperCamelCase , device=__UpperCamelCase , dtype=torch.floataa ).reshape(1 , 1 , 1 ) _UpperCAmelCase = state _UpperCAmelCase = torch.zeros(1 , 0 , config.act_dim , device=__UpperCamelCase , dtype=torch.floataa ) _UpperCAmelCase = torch.zeros(1 , 0 , device=__UpperCamelCase , dtype=torch.floataa ) _UpperCAmelCase = torch.tensor(0 , device=__UpperCamelCase , dtype=torch.long ).reshape(1 , 1 ) for step in range(__UpperCamelCase ): _UpperCAmelCase = torch.cat([actions, torch.zeros(1 , 1 , config.act_dim , device=__UpperCamelCase )] , dim=1 ) _UpperCAmelCase = torch.cat([rewards, torch.zeros(1 , 1 , device=__UpperCamelCase )] , dim=1 ) _UpperCAmelCase = torch.ones(1 , states.shape[1] ).to(dtype=torch.long , device=states.device ) with torch.no_grad(): _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = model( states=__UpperCamelCase , actions=__UpperCamelCase , rewards=__UpperCamelCase , returns_to_go=__UpperCamelCase , timesteps=__UpperCamelCase , attention_mask=__UpperCamelCase , return_dict=__UpperCamelCase , ) self.assertEqual(action_pred.shape , actions.shape ) self.assertTrue(torch.allclose(action_pred[0, -1] , expected_outputs[step] , atol=1e-4 ) ) _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = ( # env.step(action) torch.randn(1 , 1 , config.state_dim ).to(device=__UpperCamelCase , dtype=torch.floataa ), 1.0, False, {}, ) _UpperCAmelCase = action_pred[0, -1] _UpperCAmelCase = torch.cat([states, state] , dim=1 ) _UpperCAmelCase = returns_to_go[0, -1] - reward _UpperCAmelCase = torch.cat([returns_to_go, pred_return.reshape(1 , 1 , 1 )] , dim=1 ) _UpperCAmelCase = torch.cat( [timesteps, torch.ones((1, 1) , device=__UpperCamelCase , dtype=torch.long ) * (step + 1)] , dim=1 )
19
"""simple docstring""" import unittest from transformers import PegasusConfig, PegasusTokenizer, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_configuration_common import ConfigTester 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 : str = '''platform''' import jax import jax.numpy as jnp import numpy as np from transformers import FlaxPegasusForConditionalGeneration, FlaxPegasusModel @require_flax class a_ : a : List[Any] = PegasusConfig a : Dict = {} a : List[Any] = 'gelu' def __init__( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Tuple=13 , __UpperCamelCase : Tuple=7 , __UpperCamelCase : Tuple=True , __UpperCamelCase : Any=False , __UpperCamelCase : Any=99 , __UpperCamelCase : Optional[int]=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : List[str]=4 , __UpperCamelCase : Dict=37 , __UpperCamelCase : int=0.1 , __UpperCamelCase : Dict=0.1 , __UpperCamelCase : Optional[Any]=20 , __UpperCamelCase : Tuple=2 , __UpperCamelCase : Optional[int]=1 , __UpperCamelCase : Tuple=0 , ) ->int: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = bos_token_id def _snake_case ( self : Union[str, Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ).clip(3 , self.vocab_size ) _UpperCAmelCase = np.expand_dims(np.array([self.eos_token_id] * self.batch_size ) , 1 ) _UpperCAmelCase = np.concatenate([input_ids, eos_tensor] , axis=1 ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) _UpperCAmelCase = prepare_pegasus_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, inputs_dict def _snake_case ( self : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) , dtype="""i4""" ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _snake_case ( self : Any , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] , axis=-1 , ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_attention_mask=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _UpperCamelCase ( _A , _A , _A , _A=None , _A=None , ) -> int: """simple docstring""" if attention_mask is None: _UpperCAmelCase = np.not_equal(_A , config.pad_token_id ).astype(np.inta ) if decoder_attention_mask is None: _UpperCAmelCase = np.concatenate( [ np.ones(decoder_input_ids[:, :1].shape , dtype=np.inta ), np.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id ).astype(np.inta ), ] , axis=-1 , ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, } @require_flax class a_ ( _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( ( FlaxPegasusForConditionalGeneration, FlaxPegasusModel, ) if is_flax_available() else () ) a : Any = (FlaxPegasusForConditionalGeneration,) if is_flax_available() else () a : Any = True a : int = False a : Union[str, Any] = False a : Optional[int] = False def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->List[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model_class(__UpperCamelCase ) @jax.jit def encode_jitted(__UpperCamelCase : List[Any] , __UpperCamelCase : str=None , **__UpperCamelCase : int ): return model.encode(input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] , inputs_dict["""attention_mask"""] ) _UpperCAmelCase = { """decoder_input_ids""": inputs_dict["""decoder_input_ids"""], """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""], """encoder_outputs""": encoder_outputs, } @jax.jit def decode_jitted(__UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple ): return model.decode( decoder_input_ids=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , encoder_outputs=__UpperCamelCase , ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) @slow def _snake_case ( self : int ) ->int: '''simple docstring''' for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained("""google/pegasus-large""" , from_pt=__UpperCamelCase ) _UpperCAmelCase = np.ones((1, 1) ) _UpperCAmelCase = model(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) @slow def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusForConditionalGeneration.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = PegasusTokenizer.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = [ """ PG&E stated it scheduled the blackouts in response to forecasts for high winds amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow.""", """ The London trio are up for best UK act and best album, as well as getting two nominations in the best song category.\"We got told like this morning 'Oh I think you're nominated'\", said Dappy.\"And I was like 'Oh yeah, which one?' And now we've got nominated for four awards. I mean, wow!\"Bandmate Fazer added: \"We thought it's best of us to come down and mingle with everyone and say hello to the cameras. And now we find we've got four nominations.\"The band have two shots at the best song prize, getting the nod for their Tynchy Stryder collaboration Number One, and single Strong Again.Their album Uncle B will also go up against records by the likes of Beyonce and Kanye West.N-Dubz picked up the best newcomer Mobo in 2007, but female member Tulisa said they wouldn't be too disappointed if they didn't win this time around.\"At the end of the day we're grateful to be where we are in our careers.\"If it don't happen then it don't happen - live to fight another day and keep on making albums and hits for the fans.\"Dappy also revealed they could be performing live several times on the night.The group will be doing Number One and also a possible rendition of the War Child single, I Got Soul.The charity song is a re-working of The Killers' All These Things That I've Done and is set to feature artists like Chipmunk, Ironik and Pixie Lott.This year's Mobos will be held outside of London for the first time, in Glasgow on 30 September.N-Dubz said they were looking forward to performing for their Scottish fans and boasted about their recent shows north of the border.\"We just done Edinburgh the other day,\" said Dappy.\"We smashed up an N-Dubz show over there. We done Aberdeen about three or four months ago - we smashed up that show over there! Everywhere we go we smash it up!\" """, ] _UpperCAmelCase = [ """California's largest electricity provider has turned off power to hundreds of thousands of customers.""", """Pop group N-Dubz have revealed they were surprised to get four nominations for this year's Mobo Awards.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""np""" , truncation=__UpperCamelCase , max_length=5_12 , padding=__UpperCamelCase ) _UpperCAmelCase = model.generate(**__UpperCamelCase , num_beams=2 ).sequences _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase , skip_special_tokens=__UpperCamelCase ) assert tgt_text == decoded
19
1
"""simple docstring""" import os import unittest from transformers import BertTokenizerFast from transformers.models.bert.tokenization_bert import ( VOCAB_FILES_NAMES, BasicTokenizer, BertTokenizer, WordpieceTokenizer, _is_control, _is_punctuation, _is_whitespace, ) from transformers.testing_utils import require_tokenizers, slow from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english @require_tokenizers class a_ ( _UpperCAmelCase , unittest.TestCase ): a : List[str] = BertTokenizer a : List[Any] = BertTokenizerFast a : Tuple = True a : List[str] = True a : List[str] = filter_non_english def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' super().setUp() _UpperCAmelCase = [ """[UNK]""", """[CLS]""", """[SEP]""", """[PAD]""", """[MASK]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest""", ] _UpperCAmelCase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) def _snake_case ( self : List[str] , __UpperCamelCase : str ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = """UNwant\u00E9d,running""" _UpperCAmelCase = """unwanted, running""" return input_text, output_text def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.tokenizer_class(self.vocab_file ) _UpperCAmelCase = tokenizer.tokenize("""UNwant\u00E9d,running""" ) self.assertListEqual(__UpperCamelCase , ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__UpperCamelCase ) , [9, 6, 7, 12, 10, 11] ) def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' if not self.test_rust_tokenizer: return _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = self.get_rust_tokenizer() _UpperCAmelCase = """UNwant\u00E9d,running""" _UpperCAmelCase = tokenizer.tokenize(__UpperCamelCase ) _UpperCAmelCase = rust_tokenizer.tokenize(__UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = rust_tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = self.get_rust_tokenizer() _UpperCAmelCase = tokenizer.encode(__UpperCamelCase ) _UpperCAmelCase = rust_tokenizer.encode(__UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) # With lower casing _UpperCAmelCase = self.get_tokenizer(do_lower_case=__UpperCamelCase ) _UpperCAmelCase = self.get_rust_tokenizer(do_lower_case=__UpperCamelCase ) _UpperCAmelCase = """UNwant\u00E9d,running""" _UpperCAmelCase = tokenizer.tokenize(__UpperCamelCase ) _UpperCAmelCase = rust_tokenizer.tokenize(__UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = rust_tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = self.get_rust_tokenizer() _UpperCAmelCase = tokenizer.encode(__UpperCamelCase ) _UpperCAmelCase = rust_tokenizer.encode(__UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Any ) ->List[str]: '''simple docstring''' _UpperCAmelCase = BasicTokenizer() self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz""" ) , ["""ah""", """\u535A""", """\u63A8""", """zz"""] ) def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) , ["""hello""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def _snake_case ( self : int ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase , strip_accents=__UpperCamelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hällo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""h\u00E9llo"""] ) def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase , strip_accents=__UpperCamelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def _snake_case ( self : Union[str, Any] ) ->int: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""hallo""", """!""", """how""", """are""", """you""", """?"""] ) self.assertListEqual(tokenizer.tokenize("""H\u00E9llo""" ) , ["""hello"""] ) def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? """ ) , ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _snake_case ( self : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase , strip_accents=__UpperCamelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase , strip_accents=__UpperCamelCase ) self.assertListEqual( tokenizer.tokenize(""" \tHäLLo!how \n Are yoU? """ ) , ["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""] ) def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = BasicTokenizer(do_lower_case=__UpperCamelCase , never_split=["""[UNK]"""] ) self.assertListEqual( tokenizer.tokenize(""" \tHeLLo!how \n Are yoU? [UNK]""" ) , ["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""] ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = BasicTokenizer() _UpperCAmelCase = """a\n'll !!to?'d of, can't.""" _UpperCAmelCase = ["""a""", """'""", """ll""", """!""", """!""", """to""", """?""", """'""", """d""", """of""", """,""", """can""", """'""", """t""", """."""] self.assertListEqual(tokenizer.tokenize(__UpperCamelCase ) , __UpperCamelCase ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = ["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""] _UpperCAmelCase = {} for i, token in enumerate(__UpperCamelCase ): _UpperCAmelCase = i _UpperCAmelCase = WordpieceTokenizer(vocab=__UpperCamelCase , unk_token="""[UNK]""" ) self.assertListEqual(tokenizer.tokenize("""""" ) , [] ) self.assertListEqual(tokenizer.tokenize("""unwanted running""" ) , ["""un""", """##want""", """##ed""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.tokenize("""unwantedX running""" ) , ["""[UNK]""", """runn""", """##ing"""] ) def _snake_case ( self : Optional[int] ) ->str: '''simple docstring''' self.assertTrue(_is_whitespace(""" """ ) ) self.assertTrue(_is_whitespace("""\t""" ) ) self.assertTrue(_is_whitespace("""\r""" ) ) self.assertTrue(_is_whitespace("""\n""" ) ) self.assertTrue(_is_whitespace("""\u00A0""" ) ) self.assertFalse(_is_whitespace("""A""" ) ) self.assertFalse(_is_whitespace("""-""" ) ) def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' self.assertTrue(_is_control("""\u0005""" ) ) self.assertFalse(_is_control("""A""" ) ) self.assertFalse(_is_control(""" """ ) ) self.assertFalse(_is_control("""\t""" ) ) self.assertFalse(_is_control("""\r""" ) ) def _snake_case ( self : Tuple ) ->Union[str, Any]: '''simple docstring''' self.assertTrue(_is_punctuation("""-""" ) ) self.assertTrue(_is_punctuation("""$""" ) ) self.assertTrue(_is_punctuation("""`""" ) ) self.assertTrue(_is_punctuation(""".""" ) ) self.assertFalse(_is_punctuation("""A""" ) ) self.assertFalse(_is_punctuation(""" """ ) ) def _snake_case ( self : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.get_tokenizer() _UpperCAmelCase = self.get_rust_tokenizer() # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340 self.assertListEqual([tokenizer.tokenize(__UpperCamelCase ) for t in ["""Test""", """\xad""", """test"""]] , [["""[UNK]"""], [], ["""[UNK]"""]] ) self.assertListEqual( [rust_tokenizer.tokenize(__UpperCamelCase ) for t in ["""Test""", """\xad""", """test"""]] , [["""[UNK]"""], [], ["""[UNK]"""]] ) @slow def _snake_case ( self : Optional[int] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.tokenizer_class.from_pretrained("""bert-base-uncased""" ) _UpperCAmelCase = tokenizer.encode("""sequence builders""" , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = tokenizer.encode("""multi-sequence build""" , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = tokenizer.build_inputs_with_special_tokens(__UpperCamelCase ) _UpperCAmelCase = tokenizer.build_inputs_with_special_tokens(__UpperCamelCase , __UpperCamelCase ) assert encoded_sentence == [1_01] + text + [1_02] assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02] def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ): _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence.""" _UpperCAmelCase = tokenizer_r.encode_plus( __UpperCamelCase , return_attention_mask=__UpperCamelCase , return_token_type_ids=__UpperCamelCase , return_offsets_mapping=__UpperCamelCase , add_special_tokens=__UpperCamelCase , ) _UpperCAmelCase = tokenizer_r.do_lower_case if hasattr(__UpperCamelCase , """do_lower_case""" ) else False _UpperCAmelCase = ( [ ((0, 0), tokenizer_r.cls_token), ((0, 1), """A"""), ((1, 2), ""","""), ((3, 5), """na"""), ((5, 6), """##ï"""), ((6, 8), """##ve"""), ((9, 15), tokenizer_r.mask_token), ((16, 21), """Allen"""), ((21, 23), """##NL"""), ((23, 24), """##P"""), ((25, 33), """sentence"""), ((33, 34), """."""), ((0, 0), tokenizer_r.sep_token), ] if not do_lower_case else [ ((0, 0), tokenizer_r.cls_token), ((0, 1), """a"""), ((1, 2), ""","""), ((3, 8), """naive"""), ((9, 15), tokenizer_r.mask_token), ((16, 21), """allen"""), ((21, 23), """##nl"""), ((23, 24), """##p"""), ((25, 33), """sentence"""), ((33, 34), """."""), ((0, 0), tokenizer_r.sep_token), ] ) self.assertEqual( [e[1] for e in expected_results] , tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""] ) ) self.assertEqual([e[0] for e in expected_results] , tokens["""offset_mapping"""] ) def _snake_case ( self : Optional[int] ) ->List[str]: '''simple docstring''' _UpperCAmelCase = ["""的""", """人""", """有"""] _UpperCAmelCase = """""".join(__UpperCamelCase ) for tokenizer, pretrained_name, kwargs in self.tokenizers_list: with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})""" ): _UpperCAmelCase = True _UpperCAmelCase = self.tokenizer_class.from_pretrained(__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = tokenizer_p.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = tokenizer_r.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = tokenizer_r.convert_ids_to_tokens(__UpperCamelCase ) _UpperCAmelCase = tokenizer_p.convert_ids_to_tokens(__UpperCamelCase ) # it is expected that each Chinese character is not preceded by "##" self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = False _UpperCAmelCase = self.rust_tokenizer_class.from_pretrained(__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = self.tokenizer_class.from_pretrained(__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = tokenizer_r.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = tokenizer_p.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) _UpperCAmelCase = tokenizer_r.convert_ids_to_tokens(__UpperCamelCase ) _UpperCAmelCase = tokenizer_p.convert_ids_to_tokens(__UpperCamelCase ) # it is expected that only the first Chinese character is not preceded by "##". _UpperCAmelCase = [ f"""##{token}""" if idx != 0 else token for idx, token in enumerate(__UpperCamelCase ) ] self.assertListEqual(__UpperCamelCase , __UpperCamelCase ) self.assertListEqual(__UpperCamelCase , __UpperCamelCase )
19
"""simple docstring""" import tempfile import unittest from transformers import TaConfig, is_torch_available from transformers.testing_utils import ( require_sentencepiece, require_tokenizers, require_torch, slow, torch_device, ) from ...generation.test_utils import GenerationTesterMixin from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel class a_ : def __init__( self : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : List[Any]=99 , __UpperCamelCase : Optional[int]=13 , __UpperCamelCase : List[str]=7 , __UpperCamelCase : List[Any]=9 , __UpperCamelCase : List[Any]=True , __UpperCamelCase : str=True , __UpperCamelCase : int=False , __UpperCamelCase : int=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : Optional[int]=4 , __UpperCamelCase : Any=37 , __UpperCamelCase : List[Any]=8 , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : str=0.0_0_2 , __UpperCamelCase : Union[str, Any]=1 , __UpperCamelCase : List[Any]=0 , __UpperCamelCase : Tuple=0 , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Any=None , ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = encoder_seq_length _UpperCAmelCase = decoder_seq_length # For common tests _UpperCAmelCase = self.decoder_seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = d_ff _UpperCAmelCase = relative_attention_num_buckets _UpperCAmelCase = dropout_rate _UpperCAmelCase = initializer_factor _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = decoder_start_token_id _UpperCAmelCase = None _UpperCAmelCase = decoder_layers def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' return TaConfig.from_pretrained("""google/umt5-base""" ) def _snake_case ( self : List[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Tuple=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : str=None , ) ->int: '''simple docstring''' if attention_mask is None: _UpperCAmelCase = input_ids.ne(config.pad_token_id ) if decoder_attention_mask is None: _UpperCAmelCase = decoder_input_ids.ne(config.pad_token_id ) if head_mask is None: _UpperCAmelCase = torch.ones(config.num_hidden_layers , config.num_attention_heads , device=__UpperCamelCase ) if decoder_head_mask is None: _UpperCAmelCase = torch.ones(config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) if cross_attn_head_mask is None: _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.encoder_seq_length] , self.vocab_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size ) # we need to clamp the input ids here to avoid having pad token in between # this is because for NllbMoe the position_ids are prepared such that # all pad tokens have pos id = 2 and rest are between 2..seq_length # and the seq_length here is seq_length - num_pad_tokens # but when using past, there is no way of knowing if the past input ids had # pad tokens in them, which results in incorrect seq_lenth and which in turn results in # position_ids being off by num_pad_tokens in past input _UpperCAmelCase = input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = decoder_input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = self.get_config() _UpperCAmelCase = config.num_attention_heads _UpperCAmelCase = self.prepare_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, input_dict def _snake_case ( self : Union[str, Any] ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' return TaConfig( vocab_size=1_66 , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : Tuple ) ->Dict: '''simple docstring''' return TaConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[str] , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model( input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , ) _UpperCAmelCase = model(input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase ) _UpperCAmelCase = result.last_hidden_state _UpperCAmelCase = result.past_key_values _UpperCAmelCase = result.encoder_last_hidden_state self.parent.assertEqual(encoder_output.size() , (self.batch_size, self.encoder_seq_length, self.hidden_size) ) self.parent.assertEqual(decoder_output.size() , (self.batch_size, self.decoder_seq_length, self.hidden_size) ) # There should be `num_layers` key value embeddings stored in decoder_past self.parent.assertEqual(len(__UpperCamelCase ) , config.num_layers ) # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple self.parent.assertEqual(len(decoder_past[0] ) , 4 ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] , ) ->str: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).get_decoder().to(__UpperCamelCase ).eval() # first forward pass _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) + 1 ) _UpperCAmelCase ,_UpperCAmelCase = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids _UpperCAmelCase = ids_tensor((self.batch_size, 1) , config.vocab_size ) # append to next input_ids and _UpperCAmelCase = torch.cat([input_ids, next_tokens] , dim=-1 ) _UpperCAmelCase = model(__UpperCamelCase )["""last_hidden_state"""] _UpperCAmelCase = model(__UpperCamelCase , past_key_values=__UpperCamelCase )["""last_hidden_state"""] # select random slice _UpperCAmelCase = ids_tensor((1,) , output_from_past.shape[-1] ).item() _UpperCAmelCase = output_from_no_past[:, -1, random_slice_idx].detach() _UpperCAmelCase = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(__UpperCamelCase , __UpperCamelCase , atol=1e-3 ) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : int , __UpperCamelCase : Dict , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).to(__UpperCamelCase ).half().eval() _UpperCAmelCase = model(**__UpperCamelCase )["""last_hidden_state"""] self.parent.assertFalse(torch.isnan(__UpperCamelCase ).any().item() ) @require_torch class a_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else () ) a : Tuple = (UMTaForConditionalGeneration,) if is_torch_available() else () a : Optional[Any] = ( { 'conversational': UMTaForConditionalGeneration, 'feature-extraction': UMTaModel, 'summarization': UMTaForConditionalGeneration, 'text2text-generation': UMTaForConditionalGeneration, 'translation': UMTaForConditionalGeneration, 'question-answering': UMTaForQuestionAnswering, } if is_torch_available() else {} ) a : Any = True a : Optional[int] = False a : Any = False a : Optional[int] = True a : Optional[Any] = True # The small UMT5 model needs higher percentages for CPU/MP tests a : int = [0.8, 0.9] def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = UMTaModelTester(self ) @unittest.skip("""Test has a segmentation fault on torch 1.8.0""" ) def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = UMTaModel(config_and_inputs[0] ).to(__UpperCamelCase ) with tempfile.TemporaryDirectory() as tmpdirname: torch.onnx.export( __UpperCamelCase , (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) , f"""{tmpdirname}/t5_test.onnx""" , export_params=__UpperCamelCase , opset_version=9 , input_names=["""input_ids""", """decoder_input_ids"""] , ) @unittest.skipIf(torch_device == """cpu""" , """Cant do half precision""" ) def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model_fpaa_forward(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = ["""encoder_attentions""", """decoder_attentions""", """cross_attentions"""] _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = config_and_inputs[0] _UpperCAmelCase = UMTaForConditionalGeneration(__UpperCamelCase ).eval() model.to(__UpperCamelCase ) _UpperCAmelCase = { """head_mask""": torch.zeros(config.num_layers , config.num_heads , device=__UpperCamelCase ), """decoder_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), """cross_attn_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), } for attn_name, (name, mask) in zip(__UpperCamelCase , head_masking.items() ): _UpperCAmelCase = {name: mask} # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified if name == "head_mask": _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ) _UpperCAmelCase = model.generate( config_and_inputs[1]["""input_ids"""] , num_beams=1 , max_length=3 , output_attentions=__UpperCamelCase , return_dict_in_generate=__UpperCamelCase , **__UpperCamelCase , ) # We check the state of decoder_attentions and cross_attentions just from the last step _UpperCAmelCase = out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1] self.assertEqual(sum([w.sum().item() for w in attn_weights] ) , 0.0 ) @unittest.skip("""Does not work on the tiny model as we keep hitting edge cases.""" ) def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' pass @require_torch @require_sentencepiece @require_tokenizers class a_ ( unittest.TestCase ): @slow @unittest.skip( """Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged""" ) def _snake_case ( self : Optional[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = UMTaForConditionalGeneration.from_pretrained("""google/umt5-small""" , return_dict=__UpperCamelCase ).to(__UpperCamelCase ) _UpperCAmelCase = AutoTokenizer.from_pretrained("""google/umt5-small""" , use_fast=__UpperCamelCase , legacy=__UpperCamelCase ) _UpperCAmelCase = [ """Bonjour monsieur <extra_id_0> bien <extra_id_1>.""", """No se como puedo <extra_id_0>.""", """This is the reason why we <extra_id_0> them.""", """The <extra_id_0> walks in <extra_id_1>, seats""", """A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""pt""" , padding=__UpperCamelCase ).input_ids # fmt: off _UpperCAmelCase = torch.tensor( [ [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0], [ 5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1], ] ) # fmt: on torch.testing.assert_allclose(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model.generate(input_ids.to(__UpperCamelCase ) ) _UpperCAmelCase = [ """<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>""", """<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", ] _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase ) self.assertEqual(__UpperCamelCase , __UpperCamelCase )
19
1
"""simple docstring""" def _UpperCamelCase ( _A ) -> int: """simple docstring""" if a < 0: raise ValueError("""Input value must be a positive integer""" ) elif isinstance(_A , _A ): raise TypeError("""Input value must be a 'int' type""" ) return bin(_A ).count("""1""" ) if __name__ == "__main__": import doctest doctest.testmod()
19
"""simple docstring""" import copy import os import tempfile from unittest import TestCase from unittest.mock import patch import numpy as np import pyarrow as pa import pyarrow.parquet as pq import pytest from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence from datasets.features import ArrayaD, ClassLabel, Features, Image, Value from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects from datasets.keyhash import DuplicatedKeysError, InvalidKeyError from .utils import require_pil class a_ ( _UpperCAmelCase ): def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : Any ) ->List[str]: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) , type=pa.intaa() ) def _snake_case ( self : Optional[int] ) ->Tuple: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""bool""" ) , type=Value("""int64""" ) ) ) def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : str ) ->Dict: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=Value("""int64""" ) ) ) def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : List[str] ) ->Any: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=Value("""int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) def _snake_case ( self : List[Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=ArrayaD((1, 3) , """int64""" ) ) ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : Optional[int] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) @require_pil def _snake_case ( self : str ) ->Optional[Any]: '''simple docstring''' import PIL.Image _UpperCAmelCase = PIL.Image.fromarray(np.arange(10 , dtype=np.uinta ).reshape(2 , 5 ) ) with patch( """datasets.arrow_writer.cast_to_python_objects""" , side_effect=__UpperCamelCase ) as mock_cast_to_python_objects: _UpperCAmelCase = pa.array(TypedSequence([{"""path""": None, """bytes""": b"""image_bytes"""}, pil_image] , type=Image() ) ) _UpperCAmelCase ,_UpperCAmelCase = mock_cast_to_python_objects.call_args_list[-1] self.assertIn("""optimize_list_casting""" , __UpperCamelCase ) self.assertFalse(kwargs["""optimize_list_casting"""] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferReader(_A ) if isinstance(_A , pa.Buffer ) else pa.memory_map(_A ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() assert len(pa_table.to_batches() ) == expected_num_chunks assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} del pa_table @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} ) with ArrowWriter(stream=_A , features=_A ) as writer: writer.write({"""labels""": 0} ) writer.write({"""labels""": 1} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == features.arrow_schema assert writer._schema.metadata == features.arrow_schema.metadata _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() _UpperCAmelCase = pa_table.schema assert pa_table.num_rows == 2 assert schema == features.arrow_schema assert schema.metadata == features.arrow_schema.metadata assert features == Features.from_arrow_schema(_A ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=[1, 2] ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1_0 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=1_0 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=2 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) writer.write_batch({"""col_1""": [], """col_2""": []} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) ) writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> str: """simple docstring""" with tempfile.TemporaryDirectory() as tmp_dir: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} _UpperCAmelCase = os.path.join(_A , """test.arrow""" ) with ArrowWriter(path=_A , schema=pa.schema(_A ) ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(_A , 1 ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" if pa.types.is_list(_A ): return get_base_dtype(arr_type.value_type ) else: return arr_type def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" if isinstance(lst[0] , _A ): change_first_primitive_element_in_list(lst[0] , _A ) else: _UpperCAmelCase = value @pytest.mark.parametrize("""optimized_int_type, expected_dtype""" , [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.array(TypedSequence(_A , optimized_int_type=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype @pytest.mark.parametrize( """col, expected_dtype""" , [ ("""attention_mask""", pa.inta()), ("""special_tokens_mask""", pa.inta()), ("""token_type_ids""", pa.inta()), ("""input_ids""", pa.intaa()), ("""other""", pa.intaa()), ] , ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> str: """simple docstring""" _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype # not in range if col != "other": # avoids errors due to in-place modifications _UpperCAmelCase = copy.deepcopy(_A ) _UpperCAmelCase = np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1 change_first_primitive_element_in_list(_A , _A ) _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == pa.intaa() @pytest.mark.parametrize("""raise_exception""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = str(tmp_path / """dataset-train.arrow""" ) try: with ArrowWriter(path=_A ) as writer: if raise_exception: raise pa.lib.ArrowInvalid() else: writer.stream.close() except pa.lib.ArrowInvalid: pass finally: assert writer.stream.closed def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = """mock://dataset-train.arrow""" with ArrowWriter(path=_A , storage_options=mockfs.storage_options ) as writer: assert isinstance(writer._fs , type(_A ) ) assert writer._fs.storage_options == mockfs.storage_options writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert mockfs.exists(_A ) def _UpperCamelCase ( ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter(stream=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} @require_pil @pytest.mark.parametrize("""embed_local_files""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" import PIL.Image _UpperCAmelCase = str(tmp_path / """test_image_rgb.jpg""" ) PIL.Image.fromarray(np.zeros((5, 5) , dtype=np.uinta ) ).save(_A , format="""png""" ) _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter( stream=_A , features=Features({"""image""": Image()} ) , embed_local_files=_A ) as writer: writer.write({"""image""": image_path} ) writer.finalize() _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) _UpperCAmelCase = pa_table.to_pydict() if embed_local_files: assert isinstance(out["""image"""][0]["""path"""] , _A ) with open(_A , """rb""" ) as f: assert out["image"][0]["bytes"] == f.read() else: assert out["image"][0]["path"] == image_path assert out["image"][0]["bytes"] is None def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = pa.schema([pa.field("""col_1""" , pa.string() , nullable=_A )] ) _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter(stream=_A ) as writer: writer._build_writer(inferred_schema=_A ) assert writer._schema == pa.schema([pa.field("""col_1""" , pa.string() )] )
19
1
"""simple docstring""" import colorsys from PIL import Image # type: ignore def _UpperCamelCase ( _A , _A , _A ) -> float: """simple docstring""" _UpperCAmelCase = x _UpperCAmelCase = y for step in range(_A ): # noqa: B007 _UpperCAmelCase = a * a - b * b + x _UpperCAmelCase = 2 * a * b + y _UpperCAmelCase = a_new # divergence happens for all complex number with an absolute value # greater than 4 if a * a + b * b > 4: break return step / (max_step - 1) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return (2_5_5, 2_5_5, 2_5_5) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return tuple(round(i * 2_5_5 ) for i in colorsys.hsv_to_rgb(_A , 1 , 1 ) ) def _UpperCamelCase ( _A = 8_0_0 , _A = 6_0_0 , _A = -0.6 , _A = 0 , _A = 3.2 , _A = 5_0 , _A = True , ) -> Image.Image: """simple docstring""" _UpperCAmelCase = Image.new("""RGB""" , (image_width, image_height) ) _UpperCAmelCase = img.load() # loop through the image-coordinates for image_x in range(_A ): for image_y in range(_A ): # determine the figure-coordinates based on the image-coordinates _UpperCAmelCase = figure_width / image_width * image_height _UpperCAmelCase = figure_center_x + (image_x / image_width - 0.5) * figure_width _UpperCAmelCase = figure_center_y + (image_y / image_height - 0.5) * figure_height _UpperCAmelCase = get_distance(_A , _A , _A ) # color the corresponding pixel based on the selected coloring-function if use_distance_color_coding: _UpperCAmelCase = get_color_coded_rgb(_A ) else: _UpperCAmelCase = get_black_and_white_rgb(_A ) return img if __name__ == "__main__": import doctest doctest.testmod() # colored version, full figure a : List[str] = get_image() # uncomment for colored version, different section, zoomed in # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4, # figure_width = 0.8) # uncomment for black and white version, full figure # img = get_image(use_distance_color_coding = False) # uncomment to save the image # img.save("mandelbrot.png") img.show()
19
"""simple docstring""" # Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING, Dict, Optional import numpy as np import pyarrow as pa from .. import config from ..utils.logging import get_logger from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import jax import jaxlib a : List[Any] = get_logger() a : Optional[dict] = None class a_ ( TensorFormatter[Mapping, 'jax.Array', Mapping] ): def __init__( self : int , __UpperCamelCase : List[str]=None , __UpperCamelCase : Optional[int]=None , **__UpperCamelCase : int ) ->Tuple: '''simple docstring''' super().__init__(features=__UpperCamelCase ) import jax from jaxlib.xla_client import Device if isinstance(__UpperCamelCase , __UpperCamelCase ): raise ValueError( f"""Expected {device} to be a `str` not {type(__UpperCamelCase )}, as `jaxlib.xla_extension.Device` """ """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """ """the device with `str()` to get its string identifier that will be internally mapped """ """to the actual `jaxlib.xla_extension.Device`.""" ) _UpperCAmelCase = device if isinstance(__UpperCamelCase , __UpperCamelCase ) else str(jax.devices()[0] ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() if self.device not in list(DEVICE_MAPPING.keys() ): logger.warning( f"""Device with string identifier {self.device} not listed among the available """ f"""devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default """ f"""device: {str(jax.devices()[0] )}.""" ) _UpperCAmelCase = str(jax.devices()[0] ) _UpperCAmelCase = jnp_array_kwargs @staticmethod def _snake_case ( ) ->Dict[str, "jaxlib.xla_extension.Device"]: '''simple docstring''' import jax return {str(__UpperCamelCase ): device for device in jax.devices()} def _snake_case ( self : Dict , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , __UpperCamelCase ) and column: if all( isinstance(__UpperCamelCase , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return jnp.stack(__UpperCamelCase , axis=0 ) return column def _snake_case ( self : List[str] , __UpperCamelCase : Any ) ->Optional[int]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , (str, bytes, type(__UpperCamelCase )) ): return value elif isinstance(__UpperCamelCase , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() _UpperCAmelCase = {} if isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): # the default int precision depends on the jax config # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision if jax.config.jax_enable_xaa: _UpperCAmelCase = {"""dtype""": jnp.intaa} else: _UpperCAmelCase = {"""dtype""": jnp.intaa} elif isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): _UpperCAmelCase = {"""dtype""": jnp.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(__UpperCamelCase , PIL.Image.Image ): _UpperCAmelCase = np.asarray(__UpperCamelCase ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() with jax.default_device(DEVICE_MAPPING[self.device] ): # calling jnp.array on a np.ndarray does copy the data # see https://github.com/google/jax/issues/4486 return jnp.array(__UpperCamelCase , **{**default_dtype, **self.jnp_array_kwargs} ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->Any: '''simple docstring''' import jax # support for torch, tf, jax etc. if config.TORCH_AVAILABLE and "torch" in sys.modules: import torch if isinstance(__UpperCamelCase , torch.Tensor ): return self._tensorize(data_struct.detach().cpu().numpy()[()] ) if hasattr(__UpperCamelCase , """__array__""" ) and not isinstance(__UpperCamelCase , jax.Array ): _UpperCAmelCase = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(__UpperCamelCase , np.ndarray ): if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) elif isinstance(__UpperCamelCase , (list, tuple) ): return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) return self._tensorize(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : dict ) ->int: '''simple docstring''' return map_nested(self._recursive_tensorize , __UpperCamelCase , map_list=__UpperCamelCase ) def _snake_case ( self : Dict , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_row(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_row(__UpperCamelCase ) return self.recursive_tensorize(__UpperCamelCase ) def _snake_case ( self : Optional[int] , __UpperCamelCase : pa.Table ) ->"jax.Array": '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_column(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_column(__UpperCamelCase , pa_table.column_names[0] ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) _UpperCAmelCase = self._consolidate(__UpperCamelCase ) return column def _snake_case ( self : Optional[Any] , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_batch(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_batch(__UpperCamelCase ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) for column_name in batch: _UpperCAmelCase = self._consolidate(batch[column_name] ) return batch
19
1
"""simple docstring""" # flake8: noqa # Lint as: python3 from typing import Dict, List, Optional, Type from .. import config from ..utils import logging from .formatting import ( ArrowFormatter, CustomFormatter, Formatter, PandasFormatter, PythonFormatter, TensorFormatter, format_table, query_table, ) from .np_formatter import NumpyFormatter a : Union[str, Any] = logging.get_logger(__name__) a : Dict[Optional[str], Type[Formatter]] = {} a : Dict[Optional[str], str] = {} a : Dict[Optional[str], Exception] = {} def _UpperCamelCase ( _A , _A , _A = None , ) -> str: """simple docstring""" _UpperCAmelCase = aliases if aliases is not None else [] if format_type in _FORMAT_TYPES: logger.warning( F"""Overwriting format type '{format_type}' ({_FORMAT_TYPES[format_type].__name__} -> {formatter_cls.__name__})""" ) _UpperCAmelCase = formatter_cls for alias in set(aliases + [format_type] ): if alias in _FORMAT_TYPES_ALIASES: logger.warning( F"""Overwriting format type alias '{alias}' ({_FORMAT_TYPES_ALIASES[alias]} -> {format_type})""" ) _UpperCAmelCase = format_type def _UpperCamelCase ( _A , _A , _A = None ) -> Dict: """simple docstring""" _UpperCAmelCase = aliases if aliases is not None else [] for alias in set(aliases + [format_type] ): _UpperCAmelCase = unavailable_error # Here we define all the available formatting functions that can be used by `Dataset.set_format` _register_formatter(PythonFormatter, None, aliases=['''python''']) _register_formatter(ArrowFormatter, '''arrow''', aliases=['''pa''', '''pyarrow''']) _register_formatter(NumpyFormatter, '''numpy''', aliases=['''np''']) _register_formatter(PandasFormatter, '''pandas''', aliases=['''pd''']) _register_formatter(CustomFormatter, '''custom''') if config.TORCH_AVAILABLE: from .torch_formatter import TorchFormatter _register_formatter(TorchFormatter, '''torch''', aliases=['''pt''', '''pytorch''']) else: a : Optional[Any] = ValueError('''PyTorch needs to be installed to be able to return PyTorch tensors.''') _register_unavailable_formatter(_torch_error, '''torch''', aliases=['''pt''', '''pytorch''']) if config.TF_AVAILABLE: from .tf_formatter import TFFormatter _register_formatter(TFFormatter, '''tensorflow''', aliases=['''tf''']) else: a : Dict = ValueError('''Tensorflow needs to be installed to be able to return Tensorflow tensors.''') _register_unavailable_formatter(_tf_error, '''tensorflow''', aliases=['''tf''']) if config.JAX_AVAILABLE: from .jax_formatter import JaxFormatter _register_formatter(JaxFormatter, '''jax''', aliases=[]) else: a : List[Any] = ValueError('''JAX needs to be installed to be able to return JAX arrays.''') _register_unavailable_formatter(_jax_error, '''jax''', aliases=[]) def _UpperCamelCase ( _A ) -> Optional[str]: """simple docstring""" if format_type in _FORMAT_TYPES_ALIASES: return _FORMAT_TYPES_ALIASES[format_type] else: return format_type def _UpperCamelCase ( _A , **_A ) -> Formatter: """simple docstring""" _UpperCAmelCase = get_format_type_from_alias(_A ) if format_type in _FORMAT_TYPES: return _FORMAT_TYPES[format_type](**_A ) if format_type in _FORMAT_TYPES_ALIASES_UNAVAILABLE: raise _FORMAT_TYPES_ALIASES_UNAVAILABLE[format_type] else: raise ValueError( F"""Return type should be None or selected in {list(type for type in _FORMAT_TYPES.keys() if type != None )}, but got '{format_type}'""" )
19
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a : Tuple = { '''configuration_pegasus_x''': ['''PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PegasusXConfig'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : List[str] = [ '''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 : Dict = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
1
"""simple docstring""" def _UpperCamelCase ( _A , _A , _A ) -> int: """simple docstring""" def update_area_of_max_square(_A , _A ) -> int: # BASE CASE if row >= rows or col >= cols: return 0 _UpperCAmelCase = update_area_of_max_square(_A , col + 1 ) _UpperCAmelCase = update_area_of_max_square(row + 1 , col + 1 ) _UpperCAmelCase = update_area_of_max_square(row + 1 , _A ) if mat[row][col]: _UpperCAmelCase = 1 + min([right, diagonal, down] ) _UpperCAmelCase = max(largest_square_area[0] , _A ) return sub_problem_sol else: return 0 _UpperCAmelCase = [0] update_area_of_max_square(0 , 0 ) return largest_square_area[0] def _UpperCamelCase ( _A , _A , _A ) -> int: """simple docstring""" def update_area_of_max_square_using_dp_array( _A , _A , _A ) -> int: if row >= rows or col >= cols: return 0 if dp_array[row][col] != -1: return dp_array[row][col] _UpperCAmelCase = update_area_of_max_square_using_dp_array(_A , col + 1 , _A ) _UpperCAmelCase = update_area_of_max_square_using_dp_array(row + 1 , col + 1 , _A ) _UpperCAmelCase = update_area_of_max_square_using_dp_array(row + 1 , _A , _A ) if mat[row][col]: _UpperCAmelCase = 1 + min([right, diagonal, down] ) _UpperCAmelCase = max(largest_square_area[0] , _A ) _UpperCAmelCase = sub_problem_sol return sub_problem_sol else: return 0 _UpperCAmelCase = [0] _UpperCAmelCase = [[-1] * cols for _ in range(_A )] update_area_of_max_square_using_dp_array(0 , 0 , _A ) return largest_square_area[0] def _UpperCamelCase ( _A , _A , _A ) -> int: """simple docstring""" _UpperCAmelCase = [[0] * (cols + 1) for _ in range(rows + 1 )] _UpperCAmelCase = 0 for row in range(rows - 1 , -1 , -1 ): for col in range(cols - 1 , -1 , -1 ): _UpperCAmelCase = dp_array[row][col + 1] _UpperCAmelCase = dp_array[row + 1][col + 1] _UpperCAmelCase = dp_array[row + 1][col] if mat[row][col] == 1: _UpperCAmelCase = 1 + min(_A , _A , _A ) _UpperCAmelCase = max(dp_array[row][col] , _A ) else: _UpperCAmelCase = 0 return largest_square_area def _UpperCamelCase ( _A , _A , _A ) -> int: """simple docstring""" _UpperCAmelCase = [0] * (cols + 1) _UpperCAmelCase = [0] * (cols + 1) _UpperCAmelCase = 0 for row in range(rows - 1 , -1 , -1 ): for col in range(cols - 1 , -1 , -1 ): _UpperCAmelCase = current_row[col + 1] _UpperCAmelCase = next_row[col + 1] _UpperCAmelCase = next_row[col] if mat[row][col] == 1: _UpperCAmelCase = 1 + min(_A , _A , _A ) _UpperCAmelCase = max(current_row[col] , _A ) else: _UpperCAmelCase = 0 _UpperCAmelCase = current_row return largest_square_area if __name__ == "__main__": import doctest doctest.testmod() print(largest_square_area_in_matrix_bottom_up(2, 2, [[1, 1], [1, 1]]))
19
"""simple docstring""" import collections import json import math import os import re import time from fnmatch import fnmatch from typing import Dict import requests from slack_sdk import WebClient a : int = WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN''']) def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = test_results.split(""" """ ) _UpperCAmelCase = 0 _UpperCAmelCase = 0 # When the output is short enough, the output is surrounded by = signs: "== OUTPUT ==" # When it is too long, those signs are not present. _UpperCAmelCase = expressions[-2] if """=""" in expressions[-1] else expressions[-1] for i, expression in enumerate(_A ): if "failed" in expression: failed += int(expressions[i - 1] ) if "passed" in expression: success += int(expressions[i - 1] ) return failed, success, time_spent def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = {} _UpperCAmelCase = None _UpperCAmelCase = False for line in failures_short_lines.split("""\n""" ): if re.search(R"""_ \[doctest\]""" , _A ): _UpperCAmelCase = True _UpperCAmelCase = line.split(""" """ )[2] elif in_error and not line.split(""" """ )[0].isdigit(): _UpperCAmelCase = line _UpperCAmelCase = False return failures class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = title _UpperCAmelCase = doc_test_results["""time_spent"""].split(""",""" )[0] _UpperCAmelCase = doc_test_results["""success"""] _UpperCAmelCase = doc_test_results["""failures"""] _UpperCAmelCase = self.n_success + self.n_failures # Failures and success of the modeling tests _UpperCAmelCase = doc_test_results @property def _snake_case ( self : int ) ->str: '''simple docstring''' _UpperCAmelCase = [self._time_spent] _UpperCAmelCase = 0 for time in time_spent: _UpperCAmelCase = time.split(""":""" ) # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute. if len(__UpperCamelCase ) == 1: _UpperCAmelCase = [0, 0, time_parts[0]] _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = int(time_parts[0] ), int(time_parts[1] ), float(time_parts[2] ) total_secs += hours * 36_00 + minutes * 60 + seconds _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60 return f"""{int(__UpperCamelCase )}h{int(__UpperCamelCase )}m{int(__UpperCamelCase )}s""" @property def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' return {"type": "header", "text": {"type": "plain_text", "text": self.title}} @property def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": f"""🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.""", "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": ( f"""There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in""" f""" {self.time}.""" ), "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = 40 _UpperCAmelCase = {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase , __UpperCamelCase )} _UpperCAmelCase = """""" for category, failures in category_failures.items(): if len(__UpperCamelCase ) == 0: continue if report != "": report += "\n\n" report += f"""*{category} failures*:""".ljust(line_length // 2 ).rjust(line_length // 2 ) + "\n" report += "`" report += "`\n`".join(__UpperCamelCase ) report += "`" return { "type": "section", "text": { "type": "mrkdwn", "text": f"""The following examples had failures:\n\n\n{report}\n""", }, } @property def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = [self.header] if self.n_failures > 0: blocks.append(self.failures ) if self.n_failures > 0: blocks.extend([self.category_failures] ) if self.n_failures == 0: blocks.append(self.no_failures ) return json.dumps(__UpperCamelCase ) @staticmethod def _snake_case ( ) ->Any: '''simple docstring''' _UpperCAmelCase = [ { """type""": """section""", """text""": { """type""": """plain_text""", """text""": """There was an issue running the tests.""", }, """accessory""": { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """Check Action results""", """emoji""": True}, """url""": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } ] print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(__UpperCamelCase )} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text="""There was an issue running the tests.""" , blocks=__UpperCamelCase , ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(self.payload )} ) ) _UpperCAmelCase = f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed.""" _UpperCAmelCase = client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , blocks=self.payload , text=__UpperCamelCase , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Any , __UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = """""" for key, value in failures.items(): _UpperCAmelCase = value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase ) > 2_50 else value failures_text += f"""*{key}*\n_{value}_\n\n""" _UpperCAmelCase = job_name _UpperCAmelCase = {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}} if job_link is not None: _UpperCAmelCase = { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """GitHub Action job""", """emoji""": True}, """url""": job_link, } return [ {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}}, content, {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}}, ] def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' if self.thread_ts is None: raise ValueError("""Can only post reply if a post has been made.""" ) _UpperCAmelCase = self.doc_test_results.pop("""job_link""" ) self.doc_test_results.pop("""failures""" ) self.doc_test_results.pop("""success""" ) self.doc_test_results.pop("""time_spent""" ) _UpperCAmelCase = sorted(self.doc_test_results.items() , key=lambda __UpperCamelCase : t[0] ) for job, job_result in sorted_dict: if len(job_result["""failures"""] ): _UpperCAmelCase = f"""*Num failures* :{len(job_result["failed"] )} \n""" _UpperCAmelCase = job_result["""failures"""] _UpperCAmelCase = self.get_reply_blocks(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , text=__UpperCamelCase ) print("""Sending the following reply""" ) print(json.dumps({"""blocks""": blocks} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text=f"""Results for {job}""" , blocks=__UpperCamelCase , thread_ts=self.thread_ts["""ts"""] , ) time.sleep(1 ) def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = os.environ["""GITHUB_RUN_ID"""] _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A ).json() _UpperCAmelCase = {} try: jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" ).json() jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return jobs except Exception as e: print("""Unknown error, could not fetch links.""" , _A ) return {} def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = {} if os.path.exists(_A ): _UpperCAmelCase = os.listdir(_A ) for file in files: try: with open(os.path.join(_A , _A ) , encoding="""utf-8""" ) as f: _UpperCAmelCase = f.read() except UnicodeDecodeError as e: raise ValueError(F"""Could not open {os.path.join(_A , _A )}.""" ) from e return _artifact def _UpperCamelCase ( ) -> int: """simple docstring""" class a_ : def __init__( self : List[Any] , __UpperCamelCase : str ) ->Tuple: '''simple docstring''' _UpperCAmelCase = name _UpperCAmelCase = [] def __str__( self : int ) ->Optional[Any]: '''simple docstring''' return self.name def _snake_case ( self : Dict , __UpperCamelCase : str ) ->int: '''simple docstring''' self.paths.append({"""name""": self.name, """path""": path} ) _UpperCAmelCase = {} _UpperCAmelCase = filter(os.path.isdir , os.listdir() ) for directory in directories: _UpperCAmelCase = directory if artifact_name not in _available_artifacts: _UpperCAmelCase = Artifact(_A ) _available_artifacts[artifact_name].add_path(_A ) return _available_artifacts if __name__ == "__main__": a : Dict = get_job_links() a : Dict = retrieve_available_artifacts() a : Optional[int] = collections.OrderedDict( [ ('''*.py''', '''API Examples'''), ('''*.md''', '''MD Examples'''), ] ) # This dict will contain all the information relative to each doc test category: # - failed: list of failed tests # - failures: dict in the format 'test': 'error_message' a : Dict = { v: { '''failed''': [], '''failures''': {}, } for v in docs.values() } # Link to the GitHub Action job a : int = github_actions_job_links.get('''run_doctests''') a : Tuple = available_artifacts['''doc_tests_gpu_test_reports'''].paths[0] a : Optional[Any] = retrieve_artifact(artifact_path['''name''']) if "stats" in artifact: a , a , a : str = handle_test_results(artifact['''stats''']) a : Tuple = failed a : int = success a : Any = time_spent[1:-1] + ''', ''' a : Dict = extract_first_line_failure(artifact['''failures_short''']) for line in artifact["summary_short"].split('''\n'''): if re.search('''FAILED''', line): a : List[Any] = line.replace('''FAILED ''', '''''') a : Tuple = line.split()[0].replace('''\n''', '''''') if "::" in line: a , a : Union[str, Any] = line.split('''::''') else: a , a : Optional[Any] = line, line for file_regex in docs.keys(): if fnmatch(file_path, file_regex): a : List[Any] = docs[file_regex] doc_test_results[category]["failed"].append(test) a : Optional[Any] = all_failures[test] if test in all_failures else '''N/A''' a : List[str] = failure break a : List[Any] = Message('''🤗 Results of the doc tests.''', doc_test_results) message.post() message.post_reply()
19
1
"""simple docstring""" from dataclasses import dataclass from typing import List, Optional, Union import numpy as np import torch from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available @dataclass class a_ ( _UpperCAmelCase ): a : Union[List[np.ndarray], torch.FloatTensor] try: if not (is_transformers_available() and is_torch_available()): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: from ...utils.dummy_torch_and_transformers_objects import * # noqa F403 else: from .pipeline_text_to_video_synth import TextToVideoSDPipeline from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline # noqa: F401 from .pipeline_text_to_video_zero import TextToVideoZeroPipeline
19
"""simple docstring""" import asyncio import os import re import sys import tempfile import unittest from contextlib import contextmanager from copy import deepcopy from distutils.util import strtobool from enum import Enum from importlib.util import find_spec from pathlib import Path from unittest.mock import patch import pyarrow as pa import pytest import requests from packaging import version from datasets import config if config.PY_VERSION < version.parse('''3.8'''): import importlib_metadata else: import importlib.metadata as importlib_metadata def _UpperCamelCase ( _A , _A=False ) -> str: """simple docstring""" try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_A ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"""If set, {key} must be yes or no.""" ) return _value a : Union[str, Any] = parse_flag_from_env('''RUN_SLOW''', default=False) a : Tuple = parse_flag_from_env('''RUN_REMOTE''', default=False) a : Union[str, Any] = parse_flag_from_env('''RUN_LOCAL''', default=True) a : int = parse_flag_from_env('''RUN_PACKAGED''', default=True) # Compression a : List[Any] = pytest.mark.skipif(not config.LZ4_AVAILABLE, reason='''test requires lz4''') a : List[Any] = pytest.mark.skipif(not config.PY7ZR_AVAILABLE, reason='''test requires py7zr''') a : Optional[Any] = pytest.mark.skipif(not config.ZSTANDARD_AVAILABLE, reason='''test requires zstandard''') # Audio a : int = pytest.mark.skipif( # On Windows and OS X, soundfile installs sndfile find_spec('''soundfile''') is None or version.parse(importlib_metadata.version('''soundfile''')) < version.parse('''0.12.0'''), reason='''test requires sndfile>=0.12.1: \'pip install \"soundfile>=0.12.1\"\'; ''', ) # Beam a : Tuple = pytest.mark.skipif( not config.BEAM_AVAILABLE or config.DILL_VERSION >= version.parse('''0.3.2'''), reason='''test requires apache-beam and a compatible dill version''', ) # Dill-cloudpickle compatibility a : Any = pytest.mark.skipif( config.DILL_VERSION <= version.parse('''0.3.2'''), reason='''test requires dill>0.3.2 for cloudpickle compatibility''', ) # Windows a : int = pytest.mark.skipif( sys.platform == '''win32''', reason='''test should not be run on Windows''', ) def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import faiss # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires faiss""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" try: import regex # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires regex""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" try: import elasticsearch # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires elasticsearch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" try: import sqlalchemy # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires sqlalchemy""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" if not config.TORCH_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires PyTorch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" if not config.TF_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires TensorFlow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" if not config.JAX_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires JAX""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not config.PIL_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires Pillow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import transformers # noqa F401 except ImportError: return unittest.skip("""test requires transformers""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import tiktoken # noqa F401 except ImportError: return unittest.skip("""test requires tiktoken""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import spacy # noqa F401 except ImportError: return unittest.skip("""test requires spacy""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> int: """simple docstring""" def _require_spacy_model(_A ): try: import spacy # noqa F401 spacy.load(_A ) except ImportError: return unittest.skip("""test requires spacy""" )(_A ) except OSError: return unittest.skip("""test requires spacy model '{}'""".format(_A ) )(_A ) else: return test_case return _require_spacy_model def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import pyspark # noqa F401 except ImportError: return unittest.skip("""test requires pyspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import joblibspark # noqa F401 except ImportError: return unittest.skip("""test requires joblibspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_slow_tests or _run_slow_tests == 0: _UpperCAmelCase = unittest.skip("""test is slow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_local_tests or _run_local_tests == 0: _UpperCAmelCase = unittest.skip("""test is local""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" if not _run_packaged_tests or _run_packaged_tests == 0: _UpperCAmelCase = unittest.skip("""test is packaged""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not _run_remote_tests or _run_remote_tests == 0: _UpperCAmelCase = unittest.skip("""test requires remote""" )(_A ) return test_case def _UpperCamelCase ( *_A ) -> Dict: """simple docstring""" def decorate(cls ): for name, fn in cls.__dict__.items(): if callable(_A ) and name.startswith("""test""" ): for decorator in decorators: _UpperCAmelCase = decorator(_A ) setattr(cls , _A , _A ) return cls return decorate class a_ ( _UpperCAmelCase ): pass class a_ ( _UpperCAmelCase ): a : Any = 0 a : Optional[Any] = 1 a : int = 2 @contextmanager def _UpperCamelCase ( _A=OfflineSimulationMode.CONNECTION_FAILS , _A=1e-16 ) -> List[Any]: """simple docstring""" _UpperCAmelCase = requests.Session().request def timeout_request(_A , _A , _A , **_A ): # Change the url to an invalid url so that the connection hangs _UpperCAmelCase = """https://10.255.255.1""" if kwargs.get("""timeout""" ) is None: raise RequestWouldHangIndefinitelyError( F"""Tried a call to {url} in offline mode with no timeout set. Please set a timeout.""" ) _UpperCAmelCase = timeout try: return online_request(_A , _A , **_A ) except Exception as e: # The following changes in the error are just here to make the offline timeout error prettier _UpperCAmelCase = url _UpperCAmelCase = e.args[0] _UpperCAmelCase = (max_retry_error.args[0].replace("""10.255.255.1""" , F"""OfflineMock[{url}]""" ),) _UpperCAmelCase = (max_retry_error,) raise def raise_connection_error(_A , _A , **_A ): raise requests.ConnectionError("""Offline mode is enabled.""" , request=_A ) if mode is OfflineSimulationMode.CONNECTION_FAILS: with patch("""requests.Session.send""" , _A ): yield elif mode is OfflineSimulationMode.CONNECTION_TIMES_OUT: # inspired from https://stackoverflow.com/a/904609 with patch("""requests.Session.request""" , _A ): yield elif mode is OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1: with patch("""datasets.config.HF_DATASETS_OFFLINE""" , _A ): yield else: raise ValueError("""Please use a value from the OfflineSimulationMode enum.""" ) @contextmanager def _UpperCamelCase ( *_A , **_A ) -> str: """simple docstring""" _UpperCAmelCase = str(Path().resolve() ) with tempfile.TemporaryDirectory(*_A , **_A ) as tmp_dir: try: os.chdir(_A ) yield finally: os.chdir(_A ) @contextmanager def _UpperCamelCase ( ) -> Any: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory > 0, "Arrow memory didn't increase." @contextmanager def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory <= 0, "Arrow memory wasn't expected to increase." def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" return deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() == deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" import decorator from requests.exceptions import HTTPError def _wrapper(_A , *_A , **_A ): try: return func(*_A , **_A ) except HTTPError as err: if str(_A ).startswith("""500""" ) or str(_A ).startswith("""502""" ): pytest.xfail(str(_A ) ) raise err return decorator.decorator(_wrapper , _A ) class a_ : def __init__( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def _UpperCamelCase ( _A , _A ) -> Union[str, Any]: """simple docstring""" while True: _UpperCAmelCase = await stream.readline() if line: callback(_A ) else: break async def _UpperCamelCase ( _A , _A=None , _A=None , _A=None , _A=False , _A=False ) -> _RunOutput: """simple docstring""" if echo: print("""\nRunning: """ , """ """.join(_A ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_A , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_A , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_A , _A , _A , _A="" ): _UpperCAmelCase = line.decode("""utf-8""" ).rstrip() sink.append(_A ) if not quiet: print(_A , _A , file=_A ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ _read_stream(p.stdout , lambda _A : tee(_A , _A , sys.stdout , label="""stdout:""" ) ), _read_stream(p.stderr , lambda _A : tee(_A , _A , sys.stderr , label="""stderr:""" ) ), ] , timeout=_A , ) return _RunOutput(await p.wait() , _A , _A ) def _UpperCamelCase ( _A , _A=None , _A=None , _A=1_8_0 , _A=False , _A=True ) -> _RunOutput: """simple docstring""" _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_A , env=_A , stdin=_A , timeout=_A , quiet=_A , echo=_A ) ) _UpperCAmelCase = """ """.join(_A ) if result.returncode > 0: _UpperCAmelCase = """\n""".join(result.stderr ) raise RuntimeError( F"""'{cmd_str}' failed with returncode {result.returncode}\n\n""" F"""The combined stderr from workers follows:\n{stderr}""" ) # check that the subprocess actually did run and produced some output, should the test rely on # the remote side to do the testing if not result.stdout and not result.stderr: raise RuntimeError(F"""'{cmd_str}' produced no output.""" ) return result def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = os.environ.get("""PYTEST_XDIST_WORKER""" , """gw0""" ) _UpperCAmelCase = re.sub(R"""^gw""" , """""" , _A , 0 , re.M ) return int(_A ) def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = 2_9_5_0_0 _UpperCAmelCase = pytest_xdist_worker_id() return port + uniq_delta
19
1
"""simple docstring""" import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class a_ ( unittest.TestCase ): @property def _snake_case ( self : Dict ) ->int: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") , up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") , ) return model @property def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = VQModel( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=3 , ) return model @property def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) return CLIPTextModel(__UpperCamelCase ) def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = self.dummy_vq_model _UpperCAmelCase = LDMPipeline(unet=__UpperCamelCase , vqvae=__UpperCamelCase , scheduler=__UpperCamelCase ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" ).images _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" , return_dict=__UpperCamelCase )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _UpperCAmelCase = np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < tolerance @slow @require_torch class a_ ( unittest.TestCase ): def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256""" ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=5 , output_type="""numpy""" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _UpperCAmelCase = np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance
19
"""simple docstring""" from pathlib import PurePosixPath from typing import Optional import fsspec from fsspec import AbstractFileSystem from huggingface_hub.hf_api import DatasetInfo from ..utils.file_utils import get_authentication_headers_for_url from ..utils.hub import hf_hub_url class a_ ( _UpperCAmelCase ): a : List[Any] = '' a : Union[str, Any] = 'hf-legacy' # "hf://"" is reserved for hffs def __init__( self : Tuple , __UpperCamelCase : Optional[DatasetInfo] = None , __UpperCamelCase : Optional[str] = None , **__UpperCamelCase : Any , ) ->Any: '''simple docstring''' super().__init__(self , **__UpperCamelCase ) _UpperCAmelCase = repo_info _UpperCAmelCase = token _UpperCAmelCase = None def _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' if self.dir_cache is None: _UpperCAmelCase = {} for hf_file in self.repo_info.siblings: # TODO(QL): add sizes _UpperCAmelCase = { """name""": hf_file.rfilename, """size""": None, """type""": """file""", } self.dir_cache.update( { str(__UpperCamelCase ): {"""name""": str(__UpperCamelCase ), """size""": None, """type""": """directory"""} for d in list(PurePosixPath(hf_file.rfilename ).parents )[:-1] } ) def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : str = "rb" , **__UpperCamelCase : Any , ) ->List[str]: '''simple docstring''' if not isinstance(self.repo_info , __UpperCamelCase ): raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}""" ) _UpperCAmelCase = hf_hub_url(self.repo_info.id , __UpperCamelCase , revision=self.repo_info.sha ) return fsspec.open( __UpperCamelCase , mode=__UpperCamelCase , headers=get_authentication_headers_for_url(__UpperCamelCase , use_auth_token=self.token ) , client_kwargs={"""trust_env""": True} , ).open() def _snake_case ( self : int , __UpperCamelCase : int , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' self._get_dirs() _UpperCAmelCase = self._strip_protocol(__UpperCamelCase ) if path in self.dir_cache: return self.dir_cache[path] else: raise FileNotFoundError(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple=False , **__UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' self._get_dirs() _UpperCAmelCase = PurePosixPath(path.strip("""/""" ) ) _UpperCAmelCase = {} for p, f in self.dir_cache.items(): _UpperCAmelCase = PurePosixPath(p.strip("""/""" ) ) _UpperCAmelCase = p.parent if root == path: _UpperCAmelCase = f _UpperCAmelCase = list(paths.values() ) if detail: return out else: return sorted(f["""name"""] for f in out )
19
1
"""simple docstring""" import asyncio import os import re import sys import tempfile import unittest from contextlib import contextmanager from copy import deepcopy from distutils.util import strtobool from enum import Enum from importlib.util import find_spec from pathlib import Path from unittest.mock import patch import pyarrow as pa import pytest import requests from packaging import version from datasets import config if config.PY_VERSION < version.parse('''3.8'''): import importlib_metadata else: import importlib.metadata as importlib_metadata def _UpperCamelCase ( _A , _A=False ) -> str: """simple docstring""" try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_A ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"""If set, {key} must be yes or no.""" ) return _value a : Union[str, Any] = parse_flag_from_env('''RUN_SLOW''', default=False) a : Tuple = parse_flag_from_env('''RUN_REMOTE''', default=False) a : Union[str, Any] = parse_flag_from_env('''RUN_LOCAL''', default=True) a : int = parse_flag_from_env('''RUN_PACKAGED''', default=True) # Compression a : List[Any] = pytest.mark.skipif(not config.LZ4_AVAILABLE, reason='''test requires lz4''') a : List[Any] = pytest.mark.skipif(not config.PY7ZR_AVAILABLE, reason='''test requires py7zr''') a : Optional[Any] = pytest.mark.skipif(not config.ZSTANDARD_AVAILABLE, reason='''test requires zstandard''') # Audio a : int = pytest.mark.skipif( # On Windows and OS X, soundfile installs sndfile find_spec('''soundfile''') is None or version.parse(importlib_metadata.version('''soundfile''')) < version.parse('''0.12.0'''), reason='''test requires sndfile>=0.12.1: \'pip install \"soundfile>=0.12.1\"\'; ''', ) # Beam a : Tuple = pytest.mark.skipif( not config.BEAM_AVAILABLE or config.DILL_VERSION >= version.parse('''0.3.2'''), reason='''test requires apache-beam and a compatible dill version''', ) # Dill-cloudpickle compatibility a : Any = pytest.mark.skipif( config.DILL_VERSION <= version.parse('''0.3.2'''), reason='''test requires dill>0.3.2 for cloudpickle compatibility''', ) # Windows a : int = pytest.mark.skipif( sys.platform == '''win32''', reason='''test should not be run on Windows''', ) def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import faiss # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires faiss""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" try: import regex # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires regex""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" try: import elasticsearch # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires elasticsearch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" try: import sqlalchemy # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires sqlalchemy""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" if not config.TORCH_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires PyTorch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" if not config.TF_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires TensorFlow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" if not config.JAX_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires JAX""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not config.PIL_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires Pillow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import transformers # noqa F401 except ImportError: return unittest.skip("""test requires transformers""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import tiktoken # noqa F401 except ImportError: return unittest.skip("""test requires tiktoken""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import spacy # noqa F401 except ImportError: return unittest.skip("""test requires spacy""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> int: """simple docstring""" def _require_spacy_model(_A ): try: import spacy # noqa F401 spacy.load(_A ) except ImportError: return unittest.skip("""test requires spacy""" )(_A ) except OSError: return unittest.skip("""test requires spacy model '{}'""".format(_A ) )(_A ) else: return test_case return _require_spacy_model def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import pyspark # noqa F401 except ImportError: return unittest.skip("""test requires pyspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import joblibspark # noqa F401 except ImportError: return unittest.skip("""test requires joblibspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_slow_tests or _run_slow_tests == 0: _UpperCAmelCase = unittest.skip("""test is slow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_local_tests or _run_local_tests == 0: _UpperCAmelCase = unittest.skip("""test is local""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" if not _run_packaged_tests or _run_packaged_tests == 0: _UpperCAmelCase = unittest.skip("""test is packaged""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not _run_remote_tests or _run_remote_tests == 0: _UpperCAmelCase = unittest.skip("""test requires remote""" )(_A ) return test_case def _UpperCamelCase ( *_A ) -> Dict: """simple docstring""" def decorate(cls ): for name, fn in cls.__dict__.items(): if callable(_A ) and name.startswith("""test""" ): for decorator in decorators: _UpperCAmelCase = decorator(_A ) setattr(cls , _A , _A ) return cls return decorate class a_ ( _UpperCAmelCase ): pass class a_ ( _UpperCAmelCase ): a : Any = 0 a : Optional[Any] = 1 a : int = 2 @contextmanager def _UpperCamelCase ( _A=OfflineSimulationMode.CONNECTION_FAILS , _A=1e-16 ) -> List[Any]: """simple docstring""" _UpperCAmelCase = requests.Session().request def timeout_request(_A , _A , _A , **_A ): # Change the url to an invalid url so that the connection hangs _UpperCAmelCase = """https://10.255.255.1""" if kwargs.get("""timeout""" ) is None: raise RequestWouldHangIndefinitelyError( F"""Tried a call to {url} in offline mode with no timeout set. Please set a timeout.""" ) _UpperCAmelCase = timeout try: return online_request(_A , _A , **_A ) except Exception as e: # The following changes in the error are just here to make the offline timeout error prettier _UpperCAmelCase = url _UpperCAmelCase = e.args[0] _UpperCAmelCase = (max_retry_error.args[0].replace("""10.255.255.1""" , F"""OfflineMock[{url}]""" ),) _UpperCAmelCase = (max_retry_error,) raise def raise_connection_error(_A , _A , **_A ): raise requests.ConnectionError("""Offline mode is enabled.""" , request=_A ) if mode is OfflineSimulationMode.CONNECTION_FAILS: with patch("""requests.Session.send""" , _A ): yield elif mode is OfflineSimulationMode.CONNECTION_TIMES_OUT: # inspired from https://stackoverflow.com/a/904609 with patch("""requests.Session.request""" , _A ): yield elif mode is OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1: with patch("""datasets.config.HF_DATASETS_OFFLINE""" , _A ): yield else: raise ValueError("""Please use a value from the OfflineSimulationMode enum.""" ) @contextmanager def _UpperCamelCase ( *_A , **_A ) -> str: """simple docstring""" _UpperCAmelCase = str(Path().resolve() ) with tempfile.TemporaryDirectory(*_A , **_A ) as tmp_dir: try: os.chdir(_A ) yield finally: os.chdir(_A ) @contextmanager def _UpperCamelCase ( ) -> Any: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory > 0, "Arrow memory didn't increase." @contextmanager def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory <= 0, "Arrow memory wasn't expected to increase." def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" return deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() == deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" import decorator from requests.exceptions import HTTPError def _wrapper(_A , *_A , **_A ): try: return func(*_A , **_A ) except HTTPError as err: if str(_A ).startswith("""500""" ) or str(_A ).startswith("""502""" ): pytest.xfail(str(_A ) ) raise err return decorator.decorator(_wrapper , _A ) class a_ : def __init__( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def _UpperCamelCase ( _A , _A ) -> Union[str, Any]: """simple docstring""" while True: _UpperCAmelCase = await stream.readline() if line: callback(_A ) else: break async def _UpperCamelCase ( _A , _A=None , _A=None , _A=None , _A=False , _A=False ) -> _RunOutput: """simple docstring""" if echo: print("""\nRunning: """ , """ """.join(_A ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_A , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_A , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_A , _A , _A , _A="" ): _UpperCAmelCase = line.decode("""utf-8""" ).rstrip() sink.append(_A ) if not quiet: print(_A , _A , file=_A ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ _read_stream(p.stdout , lambda _A : tee(_A , _A , sys.stdout , label="""stdout:""" ) ), _read_stream(p.stderr , lambda _A : tee(_A , _A , sys.stderr , label="""stderr:""" ) ), ] , timeout=_A , ) return _RunOutput(await p.wait() , _A , _A ) def _UpperCamelCase ( _A , _A=None , _A=None , _A=1_8_0 , _A=False , _A=True ) -> _RunOutput: """simple docstring""" _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_A , env=_A , stdin=_A , timeout=_A , quiet=_A , echo=_A ) ) _UpperCAmelCase = """ """.join(_A ) if result.returncode > 0: _UpperCAmelCase = """\n""".join(result.stderr ) raise RuntimeError( F"""'{cmd_str}' failed with returncode {result.returncode}\n\n""" F"""The combined stderr from workers follows:\n{stderr}""" ) # check that the subprocess actually did run and produced some output, should the test rely on # the remote side to do the testing if not result.stdout and not result.stderr: raise RuntimeError(F"""'{cmd_str}' produced no output.""" ) return result def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = os.environ.get("""PYTEST_XDIST_WORKER""" , """gw0""" ) _UpperCAmelCase = re.sub(R"""^gw""" , """""" , _A , 0 , re.M ) return int(_A ) def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = 2_9_5_0_0 _UpperCAmelCase = pytest_xdist_worker_id() return port + uniq_delta
19
"""simple docstring""" import itertools import os from collections import Counter, defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed import numpy as np import datasets from .execute import check_correctness a : Optional[Any] = '''\ @misc{chen2021evaluating, title={Evaluating Large Language Models Trained on Code}, author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \ and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \ and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \ and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \ and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \ and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \ and Mohammad Bavarian and Clemens Winter and Philippe Tillet \ and Felipe Petroski Such and Dave Cummings and Matthias Plappert \ and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \ and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \ and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \ and William Saunders and Christopher Hesse and Andrew N. Carr \ and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \ and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \ and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \ and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba}, year={2021}, eprint={2107.03374}, archivePrefix={arXiv}, primaryClass={cs.LG} } ''' a : List[str] = '''\ This metric implements the evaluation harness for the HumanEval problem solving dataset described in the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). ''' a : Any = ''' Calculates how good are predictions given some references, using certain scores Args: predictions: list of candidates to evaluate. Each candidates should be a list of strings with several code candidates to solve the problem. references: a list with a test for each prediction. Each test should evaluate the correctness of a code candidate. k: number of code candidates to consider in the evaluation (Default: [1, 10, 100]) num_workers: number of workers used to evaluate the canidate programs (Default: 4). timeout: Returns: pass_at_k: dict with pass rates for each k results: dict with granular results of each unittest Examples: >>> code_eval = datasets.load_metric("code_eval") >>> test_cases = ["assert add(2,3)==5"] >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]] >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2]) >>> print(pass_at_k) {\'pass@1\': 0.5, \'pass@2\': 1.0} ''' a : int = ''' ################################################################################ !!!WARNING!!! ################################################################################ The "code_eval" metric executes untrusted model-generated code in Python. Although it is highly unlikely that model-generated code will do something overtly malicious in response to this test suite, model-generated code may act destructively due to a lack of model capability or alignment. Users are strongly encouraged to sandbox this evaluation suite so that it does not perform destructive actions on their host or network. For more information on how OpenAI sandboxes its code, see the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). Once you have read this disclaimer and taken appropriate precautions, set the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this with: >>> import os >>> os.environ["HF_ALLOW_CODE_EVAL"] = "1" ################################################################################\ ''' a : List[Any] = '''The MIT License Copyright (c) OpenAI (https://openai.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a_ ( datasets.Metric ): def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' return datasets.MetricInfo( # This is the description that will appear on the metrics page. description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Sequence(datasets.Value("""string""" ) ), """references""": datasets.Value("""string""" ), } ) , homepage="""https://github.com/openai/human-eval""" , codebase_urls=["""https://github.com/openai/human-eval"""] , reference_urls=["""https://github.com/openai/human-eval"""] , license=_LICENSE , ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any]=[1, 10, 1_00] , __UpperCamelCase : Dict=4 , __UpperCamelCase : Tuple=3.0 ) ->Union[str, Any]: '''simple docstring''' if os.getenv("""HF_ALLOW_CODE_EVAL""" , 0 ) != "1": raise ValueError(_WARNING ) if os.name == "nt": raise NotImplementedError("""This metric is currently not supported on Windows.""" ) with ThreadPoolExecutor(max_workers=__UpperCamelCase ) as executor: _UpperCAmelCase = [] _UpperCAmelCase = Counter() _UpperCAmelCase = 0 _UpperCAmelCase = defaultdict(__UpperCamelCase ) for task_id, (candidates, test_case) in enumerate(zip(__UpperCamelCase , __UpperCamelCase ) ): for candidate in candidates: _UpperCAmelCase = candidate + """\n""" + test_case _UpperCAmelCase = (test_program, timeout, task_id, completion_id[task_id]) _UpperCAmelCase = executor.submit(__UpperCamelCase , *__UpperCamelCase ) futures.append(__UpperCamelCase ) completion_id[task_id] += 1 n_samples += 1 for future in as_completed(__UpperCamelCase ): _UpperCAmelCase = future.result() results[result["task_id"]].append((result["""completion_id"""], result) ) _UpperCAmelCase ,_UpperCAmelCase = [], [] for result in results.values(): result.sort() _UpperCAmelCase = [r[1]["""passed"""] for r in result] total.append(len(__UpperCamelCase ) ) correct.append(sum(__UpperCamelCase ) ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = k _UpperCAmelCase = {f"""pass@{k}""": estimate_pass_at_k(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ).mean() for k in ks if (total >= k).all()} return pass_at_k, results def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" def estimator(_A , _A , _A ) -> float: if n - c < k: return 1.0 return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1 , n + 1 ) ) if isinstance(_A , _A ): _UpperCAmelCase = itertools.repeat(_A , len(_A ) ) else: assert len(_A ) == len(_A ) _UpperCAmelCase = iter(_A ) return np.array([estimator(int(_A ) , int(_A ) , _A ) for n, c in zip(_A , _A )] )
19
1
"""simple docstring""" import os import re import shutil import sys import tempfile import unittest import black a : int = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) sys.path.append(os.path.join(git_repo_path, '''utils''')) import check_copies # noqa: E402 # This is the reference code that will be used in the tests. # If DDPMSchedulerOutput is changed in scheduling_ddpm.py, this code needs to be manually updated. a : List[str] = ''' \""" Output class for the scheduler\'s step function output. Args: prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images): Computed sample (x_{t-1}) of previous timestep. `prev_sample` should be used as next model input in the denoising loop. pred_original_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images): The predicted denoised sample (x_{0}) based on the model output from the current timestep. `pred_original_sample` can be used to preview progress or for guidance. \""" prev_sample: torch.FloatTensor pred_original_sample: Optional[torch.FloatTensor] = None ''' class a_ ( unittest.TestCase ): def _snake_case ( self : Optional[Any] ) ->int: '''simple docstring''' _UpperCAmelCase = tempfile.mkdtemp() os.makedirs(os.path.join(self.diffusers_dir , """schedulers/""" ) ) _UpperCAmelCase = self.diffusers_dir shutil.copy( os.path.join(__UpperCamelCase , """src/diffusers/schedulers/scheduling_ddpm.py""" ) , os.path.join(self.diffusers_dir , """schedulers/scheduling_ddpm.py""" ) , ) def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = """src/diffusers""" shutil.rmtree(self.diffusers_dir ) def _snake_case ( self : str , __UpperCamelCase : List[Any] , __UpperCamelCase : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[Any]=None ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = comment + f"""\nclass {class_name}(nn.Module):\n""" + class_code if overwrite_result is not None: _UpperCAmelCase = comment + f"""\nclass {class_name}(nn.Module):\n""" + overwrite_result _UpperCAmelCase = black.Mode(target_versions={black.TargetVersion.PYaa} , line_length=1_19 ) _UpperCAmelCase = black.format_str(__UpperCamelCase , mode=__UpperCamelCase ) _UpperCAmelCase = os.path.join(self.diffusers_dir , """new_code.py""" ) with open(__UpperCamelCase , """w""" , newline="""\n""" ) as f: f.write(__UpperCamelCase ) if overwrite_result is None: self.assertTrue(len(check_copies.is_copy_consistent(__UpperCamelCase ) ) == 0 ) else: check_copies.is_copy_consistent(f.name , overwrite=__UpperCamelCase ) with open(__UpperCamelCase , """r""" ) as f: self.assertTrue(f.read() , __UpperCamelCase ) def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = check_copies.find_code_in_diffusers("""schedulers.scheduling_ddpm.DDPMSchedulerOutput""" ) self.assertEqual(__UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput""" , """DDPMSchedulerOutput""" , REFERENCE_CODE + """\n""" , ) # With no empty line at the end self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput""" , """DDPMSchedulerOutput""" , __UpperCamelCase , ) # Copy consistency with rename self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test""" , """TestSchedulerOutput""" , re.sub("""DDPM""" , """Test""" , __UpperCamelCase ) , ) # Copy consistency with a really long name _UpperCAmelCase = """TestClassWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason""" self.check_copy_consistency( f"""# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->{long_class_name}""" , f"""{long_class_name}SchedulerOutput""" , re.sub("""Bert""" , __UpperCamelCase , __UpperCamelCase ) , ) # Copy consistency with overwrite self.check_copy_consistency( """# Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->Test""" , """TestSchedulerOutput""" , __UpperCamelCase , overwrite_result=re.sub("""DDPM""" , """Test""" , __UpperCamelCase ) , )
19
"""simple docstring""" from collections.abc import Callable import numpy as np def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> np.array: """simple docstring""" _UpperCAmelCase = int(np.ceil((x_end - xa) / step_size ) ) _UpperCAmelCase = np.zeros((n + 1,) ) _UpperCAmelCase = ya _UpperCAmelCase = xa for k in range(_A ): _UpperCAmelCase = y[k] + step_size * ode_func(_A , y[k] ) _UpperCAmelCase = y[k] + ( (step_size / 2) * (ode_func(_A , y[k] ) + ode_func(x + step_size , _A )) ) x += step_size return y if __name__ == "__main__": import doctest doctest.testmod()
19
1
"""simple docstring""" import numpy as np def _UpperCamelCase ( _A ) -> np.array: """simple docstring""" return 1 / (1 + np.exp(-vector )) if __name__ == "__main__": import doctest doctest.testmod()
19
"""simple docstring""" import argparse import logging import os import sys import numpy as np import onnxruntime import torch from bart_onnx.generation_onnx import BARTBeamSearchGenerator from bart_onnx.reduce_onnx_size import remove_dup_initializers import transformers from transformers import BartForConditionalGeneration, BartTokenizer logging.basicConfig( format='''%(asctime)s | %(levelname)s | %(name)s | [%(filename)s:%(lineno)d] %(message)s''', datefmt='''%Y-%m-%d %H:%M:%S''', level=os.environ.get('''LOGLEVEL''', '''INFO''').upper(), stream=sys.stdout, ) a : List[str] = logging.getLogger(__name__) a : int = {'''facebook/bart-base''': BartForConditionalGeneration} a : Dict = {'''facebook/bart-base''': BartTokenizer} def _UpperCamelCase ( ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = argparse.ArgumentParser(description="""Export Bart model + Beam Search to ONNX graph.""" ) parser.add_argument( """--validation_file""" , type=_A , default=_A , help="""A csv or a json file containing the validation data.""" ) parser.add_argument( """--max_length""" , type=_A , default=5 , help="""The maximum total input sequence length after tokenization.""" , ) parser.add_argument( """--num_beams""" , type=_A , default=_A , help=( """Number of beams to use for evaluation. This argument will be """ """passed to ``model.generate``, which is used during ``evaluate`` and ``predict``.""" ) , ) parser.add_argument( """--model_name_or_path""" , type=_A , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=_A , ) parser.add_argument( """--config_name""" , type=_A , default=_A , help="""Pretrained config name or path if not the same as model_name""" , ) parser.add_argument( """--device""" , type=_A , default="""cpu""" , help="""Device where the model will be run""" , ) parser.add_argument("""--output_file_path""" , type=_A , default=_A , help="""Where to store the final ONNX file.""" ) _UpperCAmelCase = parser.parse_args() return args def _UpperCamelCase ( _A , _A="cpu" ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = model_dict[model_name].from_pretrained(_A ).to(_A ) _UpperCAmelCase = tokenizer_dict[model_name].from_pretrained(_A ) if model_name in ["facebook/bart-base"]: _UpperCAmelCase = 0 _UpperCAmelCase = None _UpperCAmelCase = 0 return huggingface_model, tokenizer def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> Optional[int]: """simple docstring""" model.eval() _UpperCAmelCase = None _UpperCAmelCase = torch.jit.script(BARTBeamSearchGenerator(_A ) ) with torch.no_grad(): _UpperCAmelCase = """My friends are cool but they eat too many carbs.""" _UpperCAmelCase = tokenizer([ARTICLE_TO_SUMMARIZE] , max_length=1_0_2_4 , return_tensors="""pt""" ).to(model.device ) _UpperCAmelCase = model.generate( inputs["""input_ids"""] , attention_mask=inputs["""attention_mask"""] , num_beams=_A , max_length=_A , early_stopping=_A , decoder_start_token_id=model.config.decoder_start_token_id , ) torch.onnx.export( _A , ( inputs["""input_ids"""], inputs["""attention_mask"""], num_beams, max_length, model.config.decoder_start_token_id, ) , _A , opset_version=1_4 , input_names=["""input_ids""", """attention_mask""", """num_beams""", """max_length""", """decoder_start_token_id"""] , output_names=["""output_ids"""] , dynamic_axes={ """input_ids""": {0: """batch""", 1: """seq"""}, """output_ids""": {0: """batch""", 1: """seq_out"""}, } , example_outputs=_A , ) logger.info("""Model exported to {}""".format(_A ) ) _UpperCAmelCase = remove_dup_initializers(os.path.abspath(_A ) ) logger.info("""Deduplicated and optimized model written to {}""".format(_A ) ) _UpperCAmelCase = onnxruntime.InferenceSession(_A ) _UpperCAmelCase = ort_sess.run( _A , { """input_ids""": inputs["""input_ids"""].cpu().numpy(), """attention_mask""": inputs["""attention_mask"""].cpu().numpy(), """num_beams""": np.array(_A ), """max_length""": np.array(_A ), """decoder_start_token_id""": np.array(model.config.decoder_start_token_id ), } , ) np.testing.assert_allclose(summary_ids.cpu().numpy() , ort_out[0] , rtol=1e-3 , atol=1e-3 ) logger.info("""Model outputs from torch and ONNX Runtime are similar.""" ) logger.info("""Success.""" ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = parse_args() _UpperCAmelCase = 5 _UpperCAmelCase = 4 # Make one log on every process with the configuration for debugging. logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , level=logging.INFO , ) logger.setLevel(logging.INFO ) transformers.utils.logging.set_verbosity_error() _UpperCAmelCase = torch.device(args.device ) _UpperCAmelCase ,_UpperCAmelCase = load_model_tokenizer(args.model_name_or_path , _A ) if model.config.decoder_start_token_id is None: raise ValueError("""Make sure that `config.decoder_start_token_id` is correctly defined""" ) model.to(_A ) if args.max_length: _UpperCAmelCase = args.max_length if args.num_beams: _UpperCAmelCase = args.num_beams if args.output_file_path: _UpperCAmelCase = args.output_file_path else: _UpperCAmelCase = """BART.onnx""" logger.info("""Exporting model to ONNX""" ) export_and_validate_model(_A , _A , _A , _A , _A ) if __name__ == "__main__": main()
19
1
"""simple docstring""" a : int = tuple[float, float, float] a : Optional[int] = tuple[float, float, float] def _UpperCamelCase ( _A , _A ) -> Vectorad: """simple docstring""" _UpperCAmelCase = end_pointa[0] - end_pointa[0] _UpperCAmelCase = end_pointa[1] - end_pointa[1] _UpperCAmelCase = end_pointa[2] - end_pointa[2] return (x, y, z) def _UpperCamelCase ( _A , _A ) -> Vectorad: """simple docstring""" _UpperCAmelCase = ab[1] * ac[2] - ab[2] * ac[1] # *i _UpperCAmelCase = (ab[0] * ac[2] - ab[2] * ac[0]) * -1 # *j _UpperCAmelCase = ab[0] * ac[1] - ab[1] * ac[0] # *k return (x, y, z) def _UpperCamelCase ( _A , _A ) -> bool: """simple docstring""" return tuple(round(_A , _A ) for x in vector ) == (0, 0, 0) def _UpperCamelCase ( _A , _A , _A , _A = 1_0 ) -> bool: """simple docstring""" _UpperCAmelCase = create_vector(_A , _A ) _UpperCAmelCase = create_vector(_A , _A ) return is_zero_vector(get_ad_vectors_cross(_A , _A ) , _A )
19
"""simple docstring""" import argparse import json import math import os import time import traceback import zipfile from collections import Counter import requests def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return job_links except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{worflow_run_id}/artifacts?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) return artifacts except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A , _A , _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = requests.get(_A , headers=_A , allow_redirects=_A ) _UpperCAmelCase = result.headers["""Location"""] _UpperCAmelCase = requests.get(_A , allow_redirects=_A ) _UpperCAmelCase = os.path.join(_A , F"""{artifact_name}.zip""" ) with open(_A , """wb""" ) as fp: fp.write(response.content ) def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [] _UpperCAmelCase = None with zipfile.ZipFile(_A ) as z: for filename in z.namelist(): if not os.path.isdir(_A ): # read the file if filename in ["failures_line.txt", "summary_short.txt", "job_name.txt"]: with z.open(_A ) as f: for line in f: _UpperCAmelCase = line.decode("""UTF-8""" ).strip() if filename == "failures_line.txt": try: # `error_line` is the place where `error` occurs _UpperCAmelCase = line[: line.index(""": """ )] _UpperCAmelCase = line[line.index(""": """ ) + len(""": """ ) :] errors.append([error_line, error] ) except Exception: # skip un-related lines pass elif filename == "summary_short.txt" and line.startswith("""FAILED """ ): # `test` is the test method that failed _UpperCAmelCase = line[len("""FAILED """ ) :] failed_tests.append(_A ) elif filename == "job_name.txt": _UpperCAmelCase = line if len(_A ) != len(_A ): raise ValueError( F"""`errors` and `failed_tests` should have the same number of elements. Got {len(_A )} for `errors` """ F"""and {len(_A )} for `failed_tests` instead. The test reports in {artifact_zip_path} have some""" """ problem.""" ) _UpperCAmelCase = None if job_name and job_links: _UpperCAmelCase = job_links.get(_A , _A ) # A list with elements of the form (line of error, error, failed test) _UpperCAmelCase = [x + [y] + [job_link] for x, y in zip(_A , _A )] return result def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [os.path.join(_A , _A ) for p in os.listdir(_A ) if p.endswith(""".zip""" )] for p in paths: errors.extend(get_errors_from_single_artifact(_A , job_links=_A ) ) return errors def _UpperCamelCase ( _A , _A=None ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = Counter() counter.update([x[1] for x in logs] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {} for error, count in counts: if error_filter is None or error not in error_filter: _UpperCAmelCase = {"""count""": count, """failed_tests""": [(x[2], x[0]) for x in logs if x[1] == error]} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = test.split("""::""" )[0] if test.startswith("""tests/models/""" ): _UpperCAmelCase = test.split("""/""" )[2] else: _UpperCAmelCase = None return test def _UpperCamelCase ( _A , _A=None ) -> Any: """simple docstring""" _UpperCAmelCase = [(x[0], x[1], get_model(x[2] )) for x in logs] _UpperCAmelCase = [x for x in logs if x[2] is not None] _UpperCAmelCase = {x[2] for x in logs} _UpperCAmelCase = {} for test in tests: _UpperCAmelCase = Counter() # count by errors in `test` counter.update([x[1] for x in logs if x[2] == test] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {error: count for error, count in counts if (error_filter is None or error not in error_filter)} _UpperCAmelCase = sum(error_counts.values() ) if n_errors > 0: _UpperCAmelCase = {"""count""": n_errors, """errors""": error_counts} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = """| no. | error | status |""" _UpperCAmelCase = """|-:|:-|:-|""" _UpperCAmelCase = [header, sep] for error in reduced_by_error: _UpperCAmelCase = reduced_by_error[error]["""count"""] _UpperCAmelCase = F"""| {count} | {error[:1_0_0]} | |""" lines.append(_A ) return "\n".join(_A ) def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = """| model | no. of errors | major error | count |""" _UpperCAmelCase = """|-:|-:|-:|-:|""" _UpperCAmelCase = [header, sep] for model in reduced_by_model: _UpperCAmelCase = reduced_by_model[model]["""count"""] _UpperCAmelCase ,_UpperCAmelCase = list(reduced_by_model[model]["""errors"""].items() )[0] _UpperCAmelCase = F"""| {model} | {count} | {error[:6_0]} | {_count} |""" lines.append(_A ) return "\n".join(_A ) if __name__ == "__main__": a : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument('''--workflow_run_id''', type=str, required=True, help='''A GitHub Actions workflow run id.''') parser.add_argument( '''--output_dir''', type=str, required=True, help='''Where to store the downloaded artifacts and other result files.''', ) parser.add_argument('''--token''', default=None, type=str, help='''A token that has actions:read permission.''') a : Dict = parser.parse_args() os.makedirs(args.output_dir, exist_ok=True) a : Tuple = get_job_links(args.workflow_run_id, token=args.token) a : Tuple = {} # To deal with `workflow_call` event, where a job name is the combination of the job names in the caller and callee. # For example, `PyTorch 1.11 / Model tests (models/albert, single-gpu)`. if _job_links: for k, v in _job_links.items(): # This is how GitHub actions combine job names. if " / " in k: a : List[Any] = k.find(''' / ''') a : Tuple = k[index + len(''' / ''') :] a : int = v with open(os.path.join(args.output_dir, '''job_links.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(job_links, fp, ensure_ascii=False, indent=4) a : Tuple = get_artifacts_links(args.workflow_run_id, token=args.token) with open(os.path.join(args.output_dir, '''artifacts.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(artifacts, fp, ensure_ascii=False, indent=4) for idx, (name, url) in enumerate(artifacts.items()): download_artifact(name, url, args.output_dir, args.token) # Be gentle to GitHub time.sleep(1) a : Optional[int] = get_all_errors(args.output_dir, job_links=job_links) # `e[1]` is the error a : Union[str, Any] = Counter() counter.update([e[1] for e in errors]) # print the top 30 most common test errors a : Optional[int] = counter.most_common(3_0) for item in most_common: print(item) with open(os.path.join(args.output_dir, '''errors.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(errors, fp, ensure_ascii=False, indent=4) a : int = reduce_by_error(errors) a : str = reduce_by_model(errors) a : int = make_github_table(reduced_by_error) a : Optional[int] = make_github_table_per_model(reduced_by_model) with open(os.path.join(args.output_dir, '''reduced_by_error.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa) with open(os.path.join(args.output_dir, '''reduced_by_model.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa)
19
1
"""simple docstring""" import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging a : Union[str, Any] = logging.get_logger(__name__) a : Any = '''▁''' a : List[str] = {'''vocab_file''': '''sentencepiece.bpe.model'''} a : Tuple = { '''vocab_file''': { '''facebook/xglm-564M''': '''https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model''', } } a : Optional[int] = { '''facebook/xglm-564M''': 2_0_4_8, } class a_ ( _UpperCAmelCase ): a : int = VOCAB_FILES_NAMES a : str = PRETRAINED_VOCAB_FILES_MAP a : Any = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES a : Optional[int] = ['input_ids', 'attention_mask'] def __init__( self : Dict , __UpperCamelCase : List[str] , __UpperCamelCase : Any="<s>" , __UpperCamelCase : Union[str, Any]="</s>" , __UpperCamelCase : Optional[Any]="</s>" , __UpperCamelCase : List[str]="<s>" , __UpperCamelCase : Optional[int]="<unk>" , __UpperCamelCase : Union[str, Any]="<pad>" , __UpperCamelCase : Optional[Dict[str, Any]] = None , **__UpperCamelCase : List[Any] , ) ->None: '''simple docstring''' _UpperCAmelCase = {} if sp_model_kwargs is None else sp_model_kwargs # Compatibility with the original tokenizer _UpperCAmelCase = 7 _UpperCAmelCase = [f"""<madeupword{i}>""" for i in range(self.num_madeup_words )] _UpperCAmelCase = 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=__UpperCamelCase , eos_token=__UpperCamelCase , unk_token=__UpperCamelCase , sep_token=__UpperCamelCase , cls_token=__UpperCamelCase , pad_token=__UpperCamelCase , sp_model_kwargs=self.sp_model_kwargs , **__UpperCamelCase , ) _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(__UpperCamelCase ) ) _UpperCAmelCase = 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 _UpperCAmelCase = 1 # Mimic fairseq token-to-id alignment for the first 4 token _UpperCAmelCase = {"""<s>""": 0, """<pad>""": 1, """</s>""": 2, """<unk>""": 3} _UpperCAmelCase = len(self.sp_model ) _UpperCAmelCase = {f"""<madeupword{i}>""": sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words )} self.fairseq_tokens_to_ids.update(__UpperCamelCase ) _UpperCAmelCase = {v: k for k, v in self.fairseq_tokens_to_ids.items()} def __getstate__( self : Optional[Any] ) ->str: '''simple docstring''' _UpperCAmelCase = self.__dict__.copy() _UpperCAmelCase = None _UpperCAmelCase = self.sp_model.serialized_model_proto() return state def __setstate__( self : Dict , __UpperCamelCase : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): _UpperCAmelCase = {} _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.LoadFromSerializedProto(self.sp_model_proto ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None ) ->List[int]: '''simple docstring''' if token_ids_a is None: return [self.sep_token_id] + token_ids_a _UpperCAmelCase = [self.sep_token_id] return sep + token_ids_a + sep + sep + token_ids_a def _snake_case ( self : Dict , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None , __UpperCamelCase : bool = False ) ->List[int]: '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=__UpperCamelCase , token_ids_a=__UpperCamelCase , already_has_special_tokens=__UpperCamelCase ) if token_ids_a is None: return [1] + ([0] * len(__UpperCamelCase )) return [1] + ([0] * len(__UpperCamelCase )) + [1, 1] + ([0] * len(__UpperCamelCase )) def _snake_case ( self : Any , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None ) ->List[int]: '''simple docstring''' _UpperCAmelCase = [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 : Optional[Any] ) ->Optional[int]: '''simple docstring''' return len(self.sp_model ) + self.fairseq_offset + self.num_madeup_words def _snake_case ( self : str ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = {self.convert_ids_to_tokens(__UpperCamelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def _snake_case ( self : Optional[int] , __UpperCamelCase : str ) ->List[str]: '''simple docstring''' return self.sp_model.encode(__UpperCamelCase , out_type=__UpperCamelCase ) def _snake_case ( self : List[Any] , __UpperCamelCase : Dict ) ->List[str]: '''simple docstring''' if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] _UpperCAmelCase = self.sp_model.PieceToId(__UpperCamelCase ) # 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 : Tuple , __UpperCamelCase : Union[str, Any] ) ->str: '''simple docstring''' 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 : Optional[Any] , __UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = """""".join(__UpperCamelCase ).replace(__UpperCamelCase , """ """ ).strip() return out_string def _snake_case ( self : Any , __UpperCamelCase : str , __UpperCamelCase : Optional[str] = None ) ->Tuple[str]: '''simple docstring''' if not os.path.isdir(__UpperCamelCase ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" ) return _UpperCAmelCase = os.path.join( __UpperCamelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(__UpperCamelCase ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , __UpperCamelCase ) elif not os.path.isfile(self.vocab_file ): with open(__UpperCamelCase , """wb""" ) as fi: _UpperCAmelCase = self.sp_model.serialized_model_proto() fi.write(__UpperCamelCase ) return (out_vocab_file,)
19
"""simple docstring""" import re import warnings from contextlib import contextmanager from ...processing_utils import ProcessorMixin class a_ ( _UpperCAmelCase ): a : Any = ['image_processor', 'tokenizer'] a : Optional[int] = 'AutoImageProcessor' a : Any = 'AutoTokenizer' def __init__( self : List[str] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : List[str]=None , **__UpperCamelCase : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`""" """ instead.""" , __UpperCamelCase , ) _UpperCAmelCase = kwargs.pop("""feature_extractor""" ) _UpperCAmelCase = 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__(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def __call__( self : Union[str, Any] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->List[str]: '''simple docstring''' if self._in_target_context_manager: return self.current_processor(*__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""images""" , __UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""text""" , __UpperCamelCase ) if len(__UpperCamelCase ) > 0: _UpperCAmelCase = args[0] _UpperCAmelCase = args[1:] if images is None and text is None: raise ValueError("""You need to specify either an `images` or `text` input to process.""" ) if images is not None: _UpperCAmelCase = self.image_processor(__UpperCamelCase , *__UpperCamelCase , **__UpperCamelCase ) if text is not None: _UpperCAmelCase = self.tokenizer(__UpperCamelCase , **__UpperCamelCase ) if text is None: return inputs elif images is None: return encodings else: _UpperCAmelCase = encodings["""input_ids"""] return inputs def _snake_case ( self : Union[str, Any] , *__UpperCamelCase : int , **__UpperCamelCase : Tuple ) ->Tuple: '''simple docstring''' return self.tokenizer.batch_decode(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Tuple , *__UpperCamelCase : int , **__UpperCamelCase : Union[str, Any] ) ->int: '''simple docstring''' return self.tokenizer.decode(*__UpperCamelCase , **__UpperCamelCase ) @contextmanager def _snake_case ( self : Tuple ) ->Union[str, Any]: '''simple docstring''' warnings.warn( """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """ """labels by using the argument `text` of the regular `__call__` method (either in the same call as """ """your images inputs, or in a separate call.""" ) _UpperCAmelCase = True _UpperCAmelCase = self.tokenizer yield _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def _snake_case ( self : str , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any]=False , __UpperCamelCase : Union[str, Any]=None ) ->List[str]: '''simple docstring''' if added_vocab is None: _UpperCAmelCase = self.tokenizer.get_added_vocab() _UpperCAmelCase = {} while tokens: _UpperCAmelCase = re.search(r"""<s_(.*?)>""" , __UpperCamelCase , re.IGNORECASE ) if start_token is None: break _UpperCAmelCase = start_token.group(1 ) _UpperCAmelCase = re.search(rf"""</s_{key}>""" , __UpperCamelCase , re.IGNORECASE ) _UpperCAmelCase = start_token.group() if end_token is None: _UpperCAmelCase = tokens.replace(__UpperCamelCase , """""" ) else: _UpperCAmelCase = end_token.group() _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.search(f"""{start_token_escaped}(.*?){end_token_escaped}""" , __UpperCamelCase , re.IGNORECASE ) if content is not None: _UpperCAmelCase = content.group(1 ).strip() if r"<s_" in content and r"</s_" in content: # non-leaf node _UpperCAmelCase = self.tokenajson(__UpperCamelCase , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if value: if len(__UpperCamelCase ) == 1: _UpperCAmelCase = value[0] _UpperCAmelCase = value else: # leaf nodes _UpperCAmelCase = [] for leaf in content.split(r"""<sep/>""" ): _UpperCAmelCase = leaf.strip() if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>": _UpperCAmelCase = leaf[1:-2] # for categorical special tokens output[key].append(__UpperCamelCase ) if len(output[key] ) == 1: _UpperCAmelCase = output[key][0] _UpperCAmelCase = tokens[tokens.find(__UpperCamelCase ) + len(__UpperCamelCase ) :].strip() if tokens[:6] == r"<sep/>": # non-leaf nodes return [output] + self.tokenajson(tokens[6:] , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if len(__UpperCamelCase ): return [output] if is_inner_value else output else: return [] if is_inner_value else {"text_sequence": tokens} @property def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' warnings.warn( """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""" , __UpperCamelCase , ) return self.image_processor_class @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' warnings.warn( """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""" , __UpperCamelCase , ) return self.image_processor
19
1
"""simple docstring""" import torch from diffusers import DDPMScheduler from .test_schedulers import SchedulerCommonTest class a_ ( _UpperCAmelCase ): a : List[Any] = (DDPMScheduler,) def _snake_case ( self : List[str] , **__UpperCamelCase : List[Any] ) ->str: '''simple docstring''' _UpperCAmelCase = { """num_train_timesteps""": 10_00, """beta_start""": 0.0_0_0_1, """beta_end""": 0.0_2, """beta_schedule""": """linear""", """variance_type""": """fixed_small""", """clip_sample""": True, } config.update(**__UpperCamelCase ) return config def _snake_case ( self : Any ) ->Union[str, Any]: '''simple docstring''' for timesteps in [1, 5, 1_00, 10_00]: self.check_over_configs(num_train_timesteps=__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->List[Any]: '''simple docstring''' for beta_start, beta_end in zip([0.0_0_0_1, 0.0_0_1, 0.0_1, 0.1] , [0.0_0_2, 0.0_2, 0.2, 2] ): self.check_over_configs(beta_start=__UpperCamelCase , beta_end=__UpperCamelCase ) def _snake_case ( self : int ) ->Tuple: '''simple docstring''' for schedule in ["linear", "squaredcos_cap_v2"]: self.check_over_configs(beta_schedule=__UpperCamelCase ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' for variance in ["fixed_small", "fixed_large", "other"]: self.check_over_configs(variance_type=__UpperCamelCase ) def _snake_case ( self : int ) ->Union[str, Any]: '''simple docstring''' for clip_sample in [True, False]: self.check_over_configs(clip_sample=__UpperCamelCase ) def _snake_case ( self : Union[str, Any] ) ->List[str]: '''simple docstring''' self.check_over_configs(thresholding=__UpperCamelCase ) for threshold in [0.5, 1.0, 2.0]: for prediction_type in ["epsilon", "sample", "v_prediction"]: self.check_over_configs( thresholding=__UpperCamelCase , prediction_type=__UpperCamelCase , sample_max_value=__UpperCamelCase , ) def _snake_case ( self : int ) ->List[Any]: '''simple docstring''' for prediction_type in ["epsilon", "sample", "v_prediction"]: self.check_over_configs(prediction_type=__UpperCamelCase ) def _snake_case ( self : int ) ->int: '''simple docstring''' for t in [0, 5_00, 9_99]: self.check_over_forward(time_step=__UpperCamelCase ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) assert torch.sum(torch.abs(scheduler._get_variance(0 ) - 0.0 ) ) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(4_87 ) - 0.0_0_9_7_9 ) ) < 1e-5 assert torch.sum(torch.abs(scheduler._get_variance(9_99 ) - 0.0_2 ) ) < 1e-5 def _snake_case ( self : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) _UpperCAmelCase = len(__UpperCamelCase ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter _UpperCAmelCase = torch.manual_seed(0 ) for t in reversed(range(__UpperCamelCase ) ): # 1. predict noise residual _UpperCAmelCase = model(__UpperCamelCase , __UpperCamelCase ) # 2. predict previous mean of sample x_t-1 _UpperCAmelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , generator=__UpperCamelCase ).prev_sample # if t > 0: # noise = self.dummy_sample_deter # variance = scheduler.get_variance(t) ** (0.5) * noise # # sample = pred_prev_sample + variance _UpperCAmelCase = pred_prev_sample _UpperCAmelCase = torch.sum(torch.abs(__UpperCamelCase ) ) _UpperCAmelCase = torch.mean(torch.abs(__UpperCamelCase ) ) assert abs(result_sum.item() - 2_5_8.9_6_0_6 ) < 1e-2 assert abs(result_mean.item() - 0.3_3_7_2 ) < 1e-3 def _snake_case ( self : Optional[int] ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config(prediction_type="""v_prediction""" ) _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) _UpperCAmelCase = len(__UpperCamelCase ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter _UpperCAmelCase = torch.manual_seed(0 ) for t in reversed(range(__UpperCamelCase ) ): # 1. predict noise residual _UpperCAmelCase = model(__UpperCamelCase , __UpperCamelCase ) # 2. predict previous mean of sample x_t-1 _UpperCAmelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , generator=__UpperCamelCase ).prev_sample # if t > 0: # noise = self.dummy_sample_deter # variance = scheduler.get_variance(t) ** (0.5) * noise # # sample = pred_prev_sample + variance _UpperCAmelCase = pred_prev_sample _UpperCAmelCase = torch.sum(torch.abs(__UpperCamelCase ) ) _UpperCAmelCase = torch.mean(torch.abs(__UpperCamelCase ) ) assert abs(result_sum.item() - 2_0_2.0_2_9_6 ) < 1e-2 assert abs(result_mean.item() - 0.2_6_3_1 ) < 1e-3 def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) _UpperCAmelCase = [1_00, 87, 50, 1, 0] scheduler.set_timesteps(timesteps=__UpperCamelCase ) _UpperCAmelCase = scheduler.timesteps for i, timestep in enumerate(__UpperCamelCase ): if i == len(__UpperCamelCase ) - 1: _UpperCAmelCase = -1 else: _UpperCAmelCase = timesteps[i + 1] _UpperCAmelCase = scheduler.previous_timestep(__UpperCamelCase ) _UpperCAmelCase = prev_t.item() self.assertEqual(__UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) _UpperCAmelCase = [1_00, 87, 50, 51, 0] with self.assertRaises(__UpperCamelCase , msg="""`custom_timesteps` must be in descending order.""" ): scheduler.set_timesteps(timesteps=__UpperCamelCase ) def _snake_case ( self : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) _UpperCAmelCase = [1_00, 87, 50, 1, 0] _UpperCAmelCase = len(__UpperCamelCase ) with self.assertRaises(__UpperCamelCase , msg="""Can only pass one of `num_inference_steps` or `custom_timesteps`.""" ): scheduler.set_timesteps(num_inference_steps=__UpperCamelCase , timesteps=__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) _UpperCAmelCase = [scheduler.config.num_train_timesteps] with self.assertRaises( __UpperCamelCase , msg="""`timesteps` must start before `self.config.train_timesteps`: {scheduler.config.num_train_timesteps}}""" , ): scheduler.set_timesteps(timesteps=__UpperCamelCase )
19
"""simple docstring""" import colorsys from PIL import Image # type: ignore def _UpperCamelCase ( _A , _A , _A ) -> float: """simple docstring""" _UpperCAmelCase = x _UpperCAmelCase = y for step in range(_A ): # noqa: B007 _UpperCAmelCase = a * a - b * b + x _UpperCAmelCase = 2 * a * b + y _UpperCAmelCase = a_new # divergence happens for all complex number with an absolute value # greater than 4 if a * a + b * b > 4: break return step / (max_step - 1) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return (2_5_5, 2_5_5, 2_5_5) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return tuple(round(i * 2_5_5 ) for i in colorsys.hsv_to_rgb(_A , 1 , 1 ) ) def _UpperCamelCase ( _A = 8_0_0 , _A = 6_0_0 , _A = -0.6 , _A = 0 , _A = 3.2 , _A = 5_0 , _A = True , ) -> Image.Image: """simple docstring""" _UpperCAmelCase = Image.new("""RGB""" , (image_width, image_height) ) _UpperCAmelCase = img.load() # loop through the image-coordinates for image_x in range(_A ): for image_y in range(_A ): # determine the figure-coordinates based on the image-coordinates _UpperCAmelCase = figure_width / image_width * image_height _UpperCAmelCase = figure_center_x + (image_x / image_width - 0.5) * figure_width _UpperCAmelCase = figure_center_y + (image_y / image_height - 0.5) * figure_height _UpperCAmelCase = get_distance(_A , _A , _A ) # color the corresponding pixel based on the selected coloring-function if use_distance_color_coding: _UpperCAmelCase = get_color_coded_rgb(_A ) else: _UpperCAmelCase = get_black_and_white_rgb(_A ) return img if __name__ == "__main__": import doctest doctest.testmod() # colored version, full figure a : List[str] = get_image() # uncomment for colored version, different section, zoomed in # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4, # figure_width = 0.8) # uncomment for black and white version, full figure # img = get_image(use_distance_color_coding = False) # uncomment to save the image # img.save("mandelbrot.png") img.show()
19
1
"""simple docstring""" import os from bleurt import score # From: git+https://github.com/google-research/bleurt.git import datasets a : Optional[int] = datasets.logging.get_logger(__name__) a : Optional[Any] = '''\ @inproceedings{bleurt, title={BLEURT: Learning Robust Metrics for Text Generation}, author={Thibault Sellam and Dipanjan Das and Ankur P. Parikh}, booktitle={ACL}, year={2020}, url={https://arxiv.org/abs/2004.04696} } ''' a : int = '''\ BLEURT a learnt evaluation metric for Natural Language Generation. It is built using multiple phases of transfer learning starting from a pretrained BERT model (Devlin et al. 2018) and then employing another pre-training phrase using synthetic data. Finally it is trained on WMT human annotations. You may run BLEURT out-of-the-box or fine-tune it for your specific application (the latter is expected to perform better). See the project\'s README at https://github.com/google-research/bleurt#readme for more information. ''' a : Optional[int] = ''' BLEURT score. Args: `predictions` (list of str): prediction/candidate sentences `references` (list of str): reference sentences `checkpoint` BLEURT checkpoint. Will default to BLEURT-tiny if None. Returns: \'scores\': List of scores. Examples: >>> predictions = ["hello there", "general kenobi"] >>> references = ["hello there", "general kenobi"] >>> bleurt = datasets.load_metric("bleurt") >>> results = bleurt.compute(predictions=predictions, references=references) >>> print([round(v, 2) for v in results["scores"]]) [1.03, 1.04] ''' a : str = { '''bleurt-tiny-128''': '''https://storage.googleapis.com/bleurt-oss/bleurt-tiny-128.zip''', '''bleurt-tiny-512''': '''https://storage.googleapis.com/bleurt-oss/bleurt-tiny-512.zip''', '''bleurt-base-128''': '''https://storage.googleapis.com/bleurt-oss/bleurt-base-128.zip''', '''bleurt-base-512''': '''https://storage.googleapis.com/bleurt-oss/bleurt-base-512.zip''', '''bleurt-large-128''': '''https://storage.googleapis.com/bleurt-oss/bleurt-large-128.zip''', '''bleurt-large-512''': '''https://storage.googleapis.com/bleurt-oss/bleurt-large-512.zip''', '''BLEURT-20-D3''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D3.zip''', '''BLEURT-20-D6''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D6.zip''', '''BLEURT-20-D12''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20-D12.zip''', '''BLEURT-20''': '''https://storage.googleapis.com/bleurt-oss-21/BLEURT-20.zip''', } @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a_ ( datasets.Metric ): def _snake_case ( self : Dict ) ->str: '''simple docstring''' return datasets.MetricInfo( description=_DESCRIPTION , citation=_CITATION , homepage="""https://github.com/google-research/bleurt""" , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Value("""string""" , id="""sequence""" ), """references""": datasets.Value("""string""" , id="""sequence""" ), } ) , codebase_urls=["""https://github.com/google-research/bleurt"""] , reference_urls=["""https://github.com/google-research/bleurt""", """https://arxiv.org/abs/2004.04696"""] , ) def _snake_case ( self : Tuple , __UpperCamelCase : Union[str, Any] ) ->Tuple: '''simple docstring''' if self.config_name == "default": logger.warning( """Using default BLEURT-Base checkpoint for sequence maximum length 128. """ """You can use a bigger model for better results with e.g.: datasets.load_metric('bleurt', 'bleurt-large-512').""" ) _UpperCAmelCase = """bleurt-base-128""" if self.config_name.lower() in CHECKPOINT_URLS: _UpperCAmelCase = self.config_name.lower() elif self.config_name.upper() in CHECKPOINT_URLS: _UpperCAmelCase = self.config_name.upper() else: raise KeyError( f"""{self.config_name} model not found. You should supply the name of a model checkpoint for bleurt in {CHECKPOINT_URLS.keys()}""" ) # download the model checkpoint specified by self.config_name and set up the scorer _UpperCAmelCase = dl_manager.download_and_extract(CHECKPOINT_URLS[checkpoint_name] ) _UpperCAmelCase = score.BleurtScorer(os.path.join(__UpperCamelCase , __UpperCamelCase ) ) def _snake_case ( self : Any , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.scorer.score(references=__UpperCamelCase , candidates=__UpperCamelCase ) return {"scores": scores}
19
"""simple docstring""" from typing import Optional from torch import nn from .transformer_ad import TransformeraDModel, TransformeraDModelOutput class a_ ( nn.Module ): def __init__( self : List[str] , __UpperCamelCase : int = 16 , __UpperCamelCase : int = 88 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : int = 1 , __UpperCamelCase : float = 0.0 , __UpperCamelCase : int = 32 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : bool = False , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : str = "geglu" , __UpperCamelCase : Optional[int] = None , ) ->Dict: '''simple docstring''' super().__init__() _UpperCAmelCase = nn.ModuleList( [ TransformeraDModel( num_attention_heads=__UpperCamelCase , attention_head_dim=__UpperCamelCase , in_channels=__UpperCamelCase , num_layers=__UpperCamelCase , dropout=__UpperCamelCase , norm_num_groups=__UpperCamelCase , cross_attention_dim=__UpperCamelCase , attention_bias=__UpperCamelCase , sample_size=__UpperCamelCase , num_vector_embeds=__UpperCamelCase , activation_fn=__UpperCamelCase , num_embeds_ada_norm=__UpperCamelCase , ) for _ in range(2 ) ] ) # Variables that can be set by a pipeline: # The ratio of transformer1 to transformer2's output states to be combined during inference _UpperCAmelCase = 0.5 # The shape of `encoder_hidden_states` is expected to be # `(batch_size, condition_lengths[0]+condition_lengths[1], num_features)` _UpperCAmelCase = [77, 2_57] # Which transformer to use to encode which condition. # E.g. `(1, 0)` means that we'll use `transformers[1](conditions[0])` and `transformers[0](conditions[1])` _UpperCAmelCase = [1, 0] def _snake_case ( self : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : bool = True , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = hidden_states _UpperCAmelCase = [] _UpperCAmelCase = 0 # attention_mask is not used yet for i in range(2 ): # for each of the two transformers, pass the corresponding condition tokens _UpperCAmelCase = encoder_hidden_states[:, tokens_start : tokens_start + self.condition_lengths[i]] _UpperCAmelCase = self.transformer_index_for_condition[i] _UpperCAmelCase = self.transformers[transformer_index]( __UpperCamelCase , encoder_hidden_states=__UpperCamelCase , timestep=__UpperCamelCase , cross_attention_kwargs=__UpperCamelCase , return_dict=__UpperCamelCase , )[0] encoded_states.append(encoded_state - input_states ) tokens_start += self.condition_lengths[i] _UpperCAmelCase = encoded_states[0] * self.mix_ratio + encoded_states[1] * (1 - self.mix_ratio) _UpperCAmelCase = output_states + input_states if not return_dict: return (output_states,) return TransformeraDModelOutput(sample=__UpperCamelCase )
19
1
"""simple docstring""" import argparse import json from typing import List from ltp import LTP from transformers.models.bert.tokenization_bert import BertTokenizer def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if ( (cp >= 0X4E00 and cp <= 0X9FFF) or (cp >= 0X3400 and cp <= 0X4DBF) # or (cp >= 0X2_0000 and cp <= 0X2_A6DF) # or (cp >= 0X2_A700 and cp <= 0X2_B73F) # or (cp >= 0X2_B740 and cp <= 0X2_B81F) # or (cp >= 0X2_B820 and cp <= 0X2_CEAF) # or (cp >= 0XF900 and cp <= 0XFAFF) or (cp >= 0X2_F800 and cp <= 0X2_FA1F) # ): # return True return False def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" for char in word: _UpperCAmelCase = ord(_A ) if not _is_chinese_char(_A ): return 0 return 1 def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" _UpperCAmelCase = set() for token in tokens: _UpperCAmelCase = len(_A ) > 1 and is_chinese(_A ) if chinese_word: word_set.add(_A ) _UpperCAmelCase = list(_A ) return word_list def _UpperCamelCase ( _A , _A ) -> List[str]: """simple docstring""" if not chinese_word_set: return bert_tokens _UpperCAmelCase = max([len(_A ) for w in chinese_word_set] ) _UpperCAmelCase = bert_tokens _UpperCAmelCase ,_UpperCAmelCase = 0, len(_A ) while start < end: _UpperCAmelCase = True if is_chinese(bert_word[start] ): _UpperCAmelCase = min(end - start , _A ) for i in range(_A , 1 , -1 ): _UpperCAmelCase = """""".join(bert_word[start : start + i] ) if whole_word in chinese_word_set: for j in range(start + 1 , start + i ): _UpperCAmelCase = """##""" + bert_word[j] _UpperCAmelCase = start + i _UpperCAmelCase = False break if single_word: start += 1 return bert_word def _UpperCamelCase ( _A , _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = [] for i in range(0 , len(_A ) , 1_0_0 ): _UpperCAmelCase = ltp_tokenizer.pipeline(lines[i : i + 1_0_0] , tasks=["""cws"""] ).cws _UpperCAmelCase = [get_chinese_word(_A ) for r in res] ltp_res.extend(_A ) assert len(_A ) == len(_A ) _UpperCAmelCase = [] for i in range(0 , len(_A ) , 1_0_0 ): _UpperCAmelCase = bert_tokenizer(lines[i : i + 1_0_0] , add_special_tokens=_A , truncation=_A , max_length=5_1_2 ) bert_res.extend(res["""input_ids"""] ) assert len(_A ) == len(_A ) _UpperCAmelCase = [] for input_ids, chinese_word in zip(_A , _A ): _UpperCAmelCase = [] for id in input_ids: _UpperCAmelCase = bert_tokenizer._convert_id_to_token(_A ) input_tokens.append(_A ) _UpperCAmelCase = add_sub_symbol(_A , _A ) _UpperCAmelCase = [] # We only save pos of chinese subwords start with ##, which mean is part of a whole word. for i, token in enumerate(_A ): if token[:2] == "##": _UpperCAmelCase = token[2:] # save chinese tokens' pos if len(_A ) == 1 and _is_chinese_char(ord(_A ) ): ref_id.append(_A ) ref_ids.append(_A ) assert len(_A ) == len(_A ) return ref_ids def _UpperCamelCase ( _A ) -> int: """simple docstring""" with open(args.file_name , """r""" , encoding="""utf-8""" ) as f: _UpperCAmelCase = f.readlines() _UpperCAmelCase = [line.strip() for line in data if len(_A ) > 0 and not line.isspace()] # avoid delimiter like '\u2029' _UpperCAmelCase = LTP(args.ltp ) # faster in GPU device _UpperCAmelCase = BertTokenizer.from_pretrained(args.bert ) _UpperCAmelCase = prepare_ref(_A , _A , _A ) with open(args.save_path , """w""" , encoding="""utf-8""" ) as f: _UpperCAmelCase = [json.dumps(_A ) + """\n""" for ref in ref_ids] f.writelines(_A ) if __name__ == "__main__": a : Dict = argparse.ArgumentParser(description='''prepare_chinese_ref''') parser.add_argument( '''--file_name''', required=False, type=str, default='''./resources/chinese-demo.txt''', help='''file need process, same as training data in lm''', ) parser.add_argument( '''--ltp''', required=False, type=str, default='''./resources/ltp''', help='''resources for LTP tokenizer, usually a path''', ) parser.add_argument( '''--bert''', required=False, type=str, default='''./resources/robert''', help='''resources for Bert tokenizer''', ) parser.add_argument( '''--save_path''', required=False, type=str, default='''./resources/ref.txt''', help='''path to save res''', ) a : Union[str, Any] = parser.parse_args() main(args)
19
"""simple docstring""" import argparse import torch from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert from transformers.utils import logging logging.set_verbosity_info() def _UpperCamelCase ( _A , _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = LxmertConfig.from_json_file(_A ) print(F"""Building PyTorch model from configuration: {config}""" ) _UpperCAmelCase = LxmertForPreTraining(_A ) # Load weights from tf checkpoint load_tf_weights_in_lxmert(_A , _A , _A ) # Save pytorch-model print(F"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict() , _A ) if __name__ == "__main__": a : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--config_file''', default=None, type=str, required=True, help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''', ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) a : Union[str, Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
19
1
"""simple docstring""" import unittest import numpy as np import torch from diffusers import VersatileDiffusionImageVariationPipeline from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device a : Any = False class a_ ( unittest.TestCase ): pass @slow @require_torch_gpu class a_ ( unittest.TestCase ): def _snake_case ( self : List[Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = VersatileDiffusionImageVariationPipeline.from_pretrained("""shi-labs/versatile-diffusion""" ) pipe.to(__UpperCamelCase ) pipe.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = load_image( """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg""" ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = pipe( image=__UpperCamelCase , generator=__UpperCamelCase , guidance_scale=7.5 , num_inference_steps=50 , output_type="""numpy""" , ).images _UpperCAmelCase = image[0, 2_53:2_56, 2_53:2_56, -1] assert image.shape == (1, 5_12, 5_12, 3) _UpperCAmelCase = np.array([0.0_4_4_1, 0.0_4_6_9, 0.0_5_0_7, 0.0_5_7_5, 0.0_6_3_2, 0.0_6_5_0, 0.0_8_6_5, 0.0_9_0_9, 0.0_9_4_5] ) assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
19
"""simple docstring""" import argparse import os import re import packaging.version a : str = '''examples/''' a : List[str] = { '''examples''': (re.compile(r'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''), '''init''': (re.compile(r'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''), '''setup''': (re.compile(r'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), r'''\1version="VERSION",'''), '''doc''': (re.compile(r'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''), } a : Tuple = { '''init''': '''src/diffusers/__init__.py''', '''setup''': '''setup.py''', } a : List[str] = '''README.md''' def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase ,_UpperCAmelCase = REPLACE_PATTERNS[pattern] _UpperCAmelCase = replace.replace("""VERSION""" , _A ) _UpperCAmelCase = re_pattern.sub(_A , _A ) with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.write(_A ) def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" for folder, directories, fnames in os.walk(_A ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("""research_projects""" ) if "legacy" in directories: directories.remove("""legacy""" ) for fname in fnames: if fname.endswith(""".py""" ): update_version_in_file(os.path.join(_A , _A ) , _A , pattern="""examples""" ) def _UpperCamelCase ( _A , _A=False ) -> int: """simple docstring""" for pattern, fname in REPLACE_FILES.items(): update_version_in_file(_A , _A , _A ) if not patch: update_version_in_examples(_A ) def _UpperCamelCase ( ) -> Any: """simple docstring""" _UpperCAmelCase = """🤗 Transformers currently provides the following architectures""" _UpperCAmelCase = """1. Want to contribute a new model?""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.readlines() # Find the start of the list. _UpperCAmelCase = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 _UpperCAmelCase = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("""1.""" ): _UpperCAmelCase = lines[index].replace( """https://huggingface.co/docs/diffusers/main/model_doc""" , """https://huggingface.co/docs/diffusers/model_doc""" , ) index += 1 with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.writelines(_A ) def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" with open(REPLACE_FILES["""init"""] , """r""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase = REPLACE_PATTERNS["""init"""][0].search(_A ).groups()[0] return packaging.version.parse(_A ) def _UpperCamelCase ( _A=False ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() if patch and default_version.is_devrelease: raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" ) if default_version.is_devrelease: _UpperCAmelCase = default_version.base_version elif patch: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}""" else: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor + 1}.0""" # Now let's ask nicely if that's the right one. _UpperCAmelCase = input(F"""Which version are you releasing? [{default_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = default_version print(F"""Updating version to {version}.""" ) global_version_update(_A , patch=_A ) def _UpperCamelCase ( ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() _UpperCAmelCase = F"""{current_version.major}.{current_version.minor + 1}.0.dev0""" _UpperCAmelCase = current_version.base_version # Check with the user we got that right. _UpperCAmelCase = input(F"""Which version are we developing now? [{dev_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = dev_version print(F"""Updating version to {version}.""" ) global_version_update(_A ) # print("Cleaning main README, don't forget to run `make fix-copies`.") # clean_main_ref_in_model_list() if __name__ == "__main__": a : Dict = argparse.ArgumentParser() parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''') parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''') a : Tuple = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('''Nothing to do after a patch :-)''') else: post_release_work()
19
1
"""simple docstring""" import heapq def _UpperCamelCase ( _A ) -> set[int]: """simple docstring""" _UpperCAmelCase = [] # for each node and his adjacency list add them and the rank of the node to queue # using heapq module the queue will be filled like a Priority Queue # heapq works with a min priority queue, so I used -1*len(v) to build it for key, value in graph.items(): # O(log(n)) heapq.heappush(_A , [-1 * len(_A ), (key, value)] ) # chosen_vertices = set of chosen vertices _UpperCAmelCase = set() # while queue isn't empty and there are still edges # (queue[0][0] is the rank of the node with max rank) while queue and queue[0][0] != 0: # extract vertex with max rank from queue and add it to chosen_vertices _UpperCAmelCase = heapq.heappop(_A )[1][0] chosen_vertices.add(_A ) # Remove all arcs adjacent to argmax for elem in queue: # if v haven't adjacent node, skip if elem[0] == 0: continue # if argmax is reachable from elem # remove argmax from elem's adjacent list and update his rank if argmax in elem[1][1]: _UpperCAmelCase = elem[1][1].index(_A ) del elem[1][1][index] elem[0] += 1 # re-order the queue heapq.heapify(_A ) return chosen_vertices if __name__ == "__main__": import doctest doctest.testmod() a : str = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]} print(F"Minimum vertex cover:\n{greedy_min_vertex_cover(graph)}")
19
"""simple docstring""" from __future__ import annotations def _UpperCamelCase ( _A ) -> None: """simple docstring""" create_state_space_tree(_A , [] , 0 , [0 for i in range(len(_A ) )] ) def _UpperCamelCase ( _A , _A , _A , _A , ) -> None: """simple docstring""" if index == len(_A ): print(_A ) return for i in range(len(_A ) ): if not index_used[i]: current_sequence.append(sequence[i] ) _UpperCAmelCase = True create_state_space_tree(_A , _A , index + 1 , _A ) current_sequence.pop() _UpperCAmelCase = False a : list[int | str] = [3, 1, 2, 4] generate_all_permutations(sequence) a : list[int | str] = ["A", "B", "C"] generate_all_permutations(sequence_a)
19
1
"""simple docstring""" from __future__ import annotations from fractions import Fraction from math import gcd, sqrt def _UpperCamelCase ( _A ) -> bool: """simple docstring""" _UpperCAmelCase = int(number**0.5 ) return number == sq * sq def _UpperCamelCase ( _A , _A , _A , _A , _A , _A ) -> tuple[int, int]: """simple docstring""" _UpperCAmelCase = x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den _UpperCAmelCase = x_den * y_den * z_den _UpperCAmelCase = gcd(_A , _A ) top //= hcf bottom //= hcf return top, bottom def _UpperCamelCase ( _A = 3_5 ) -> int: """simple docstring""" _UpperCAmelCase = set() _UpperCAmelCase = 42 _UpperCAmelCase = Fraction(0 ) _UpperCAmelCase = 42 for x_num in range(1 , order + 1 ): for x_den in range(x_num + 1 , order + 1 ): for y_num in range(1 , order + 1 ): for y_den in range(y_num + 1 , order + 1 ): # n=1 _UpperCAmelCase = x_num * y_den + x_den * y_num _UpperCAmelCase = x_den * y_den _UpperCAmelCase = gcd(_A , _A ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _UpperCAmelCase = add_three( _A , _A , _A , _A , _A , _A ) unique_s.add(_A ) # n=2 _UpperCAmelCase = ( x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num ) _UpperCAmelCase = x_den * x_den * y_den * y_den if is_sq(_A ) and is_sq(_A ): _UpperCAmelCase = int(sqrt(_A ) ) _UpperCAmelCase = int(sqrt(_A ) ) _UpperCAmelCase = gcd(_A , _A ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _UpperCAmelCase = add_three( _A , _A , _A , _A , _A , _A ) unique_s.add(_A ) # n=-1 _UpperCAmelCase = x_num * y_num _UpperCAmelCase = x_den * y_num + x_num * y_den _UpperCAmelCase = gcd(_A , _A ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _UpperCAmelCase = add_three( _A , _A , _A , _A , _A , _A ) unique_s.add(_A ) # n=2 _UpperCAmelCase = x_num * x_num * y_num * y_num _UpperCAmelCase = ( x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den ) if is_sq(_A ) and is_sq(_A ): _UpperCAmelCase = int(sqrt(_A ) ) _UpperCAmelCase = int(sqrt(_A ) ) _UpperCAmelCase = gcd(_A , _A ) z_num //= hcf z_den //= hcf if 0 < z_num < z_den <= order: _UpperCAmelCase = add_three( _A , _A , _A , _A , _A , _A ) unique_s.add(_A ) for num, den in unique_s: total += Fraction(_A , _A ) return total.denominator + total.numerator if __name__ == "__main__": print(F"{solution() = }")
19
"""simple docstring""" import inspect import unittest from transformers import DPTConfig from transformers.file_utils import is_torch_available, is_vision_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, require_vision, slow, torch_device 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 MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import DPTImageProcessor class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int]=2 , __UpperCamelCase : int=32 , __UpperCamelCase : Tuple=16 , __UpperCamelCase : Dict=3 , __UpperCamelCase : Dict=True , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Optional[Any]=32 , __UpperCamelCase : Any=4 , __UpperCamelCase : Optional[int]=[0, 1, 2, 3] , __UpperCamelCase : str=4 , __UpperCamelCase : Optional[Any]=37 , __UpperCamelCase : str="gelu" , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : Any=0.1 , __UpperCamelCase : Any=0.0_2 , __UpperCamelCase : Optional[int]=3 , __UpperCamelCase : int=[1, 3_84, 24, 24] , __UpperCamelCase : Union[str, Any]=True , __UpperCamelCase : Any=None , ) ->Optional[Any]: '''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 = backbone_out_indices _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = backbone_featmap_shape _UpperCAmelCase = scope _UpperCAmelCase = is_hybrid # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token) _UpperCAmelCase = (image_size // patch_size) ** 2 _UpperCAmelCase = num_patches + 1 def _snake_case ( self : str ) ->int: '''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.image_size, self.image_size] , self.num_labels ) _UpperCAmelCase = self.get_config() return config, pixel_values, labels def _snake_case ( self : List[str] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = { """global_padding""": """same""", """layer_type""": """bottleneck""", """depths""": [3, 4, 9], """out_features""": ["""stage1""", """stage2""", """stage3"""], """embedding_dynamic_padding""": True, """hidden_sizes""": [96, 1_92, 3_84, 7_68], """num_groups""": 2, } return DPTConfig( 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 , backbone_out_indices=self.backbone_out_indices , 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 , is_hybrid=self.is_hybrid , backbone_config=__UpperCamelCase , backbone_featmap_shape=self.backbone_featmap_shape , ) def _snake_case ( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = DPTModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : str , __UpperCamelCase : List[Any] ) ->int: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.predicted_depth.shape , (self.batch_size, self.image_size, self.image_size) ) def _snake_case ( self : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForSemanticSegmentation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , labels=__UpperCamelCase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size, self.image_size) ) def _snake_case ( self : Tuple ) ->Any: '''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 a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : Dict = (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else () a : int = ( { 'depth-estimation': DPTForDepthEstimation, 'feature-extraction': DPTModel, 'image-segmentation': DPTForSemanticSegmentation, } if is_torch_available() else {} ) a : str = False a : List[str] = False a : Dict = False def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = DPTModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , has_text_modality=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : Optional[int] ) ->Any: '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason="""DPT does not use inputs_embeds""" ) def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' pass def _snake_case ( self : int ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) _UpperCAmelCase = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__UpperCamelCase , nn.Linear ) ) def _snake_case ( self : Optional[int] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , __UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCamelCase ) def _snake_case ( self : str ) ->int: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_depth_estimation(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCamelCase ) def _snake_case ( self : str ) ->Any: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ): continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = False _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ) or not model_class.supports_gradient_checkpointing: continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.gradient_checkpointing_enable() model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : Tuple ) ->List[str]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = _config_zero_init(__UpperCamelCase ) for model_class in self.all_model_classes: _UpperCAmelCase = model_class(config=__UpperCamelCase ) # Skip the check for the backbone _UpperCAmelCase = [] for name, module in model.named_modules(): if module.__class__.__name__ == "DPTViTHybridEmbeddings": _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""" , ) @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" ) def _snake_case ( self : Dict ) ->Tuple: '''simple docstring''' pass @slow def _snake_case ( self : Optional[int] ) ->List[Any]: '''simple docstring''' for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]: _UpperCAmelCase = DPTModel.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = """add""" with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) return image @require_torch @require_vision @slow class a_ ( unittest.TestCase ): def _snake_case ( self : Any ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = DPTImageProcessor.from_pretrained("""Intel/dpt-hybrid-midas""" ) _UpperCAmelCase = DPTForDepthEstimation.from_pretrained("""Intel/dpt-hybrid-midas""" ).to(__UpperCamelCase ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=__UpperCamelCase , return_tensors="""pt""" ).to(__UpperCamelCase ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**__UpperCamelCase ) _UpperCAmelCase = outputs.predicted_depth # verify the predicted depth _UpperCAmelCase = torch.Size((1, 3_84, 3_84) ) self.assertEqual(predicted_depth.shape , __UpperCamelCase ) _UpperCAmelCase = torch.tensor( [[[5.6_4_3_7, 5.6_1_4_6, 5.6_5_1_1], [5.4_3_7_1, 5.5_6_4_9, 5.5_9_5_8], [5.5_2_1_5, 5.5_1_8_4, 5.5_2_9_3]]] ).to(__UpperCamelCase ) self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 1_00 , __UpperCamelCase , atol=1e-4 ) )
19
1
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging a : List[Any] = logging.get_logger(__name__) a : Dict = { '''microsoft/markuplm-base''': '''https://huggingface.co/microsoft/markuplm-base/resolve/main/config.json''', '''microsoft/markuplm-large''': '''https://huggingface.co/microsoft/markuplm-large/resolve/main/config.json''', } class a_ ( _UpperCAmelCase ): a : str = 'markuplm' def __init__( self : Dict , __UpperCamelCase : List[str]=3_05_22 , __UpperCamelCase : Tuple=7_68 , __UpperCamelCase : int=12 , __UpperCamelCase : Any=12 , __UpperCamelCase : Optional[Any]=30_72 , __UpperCamelCase : str="gelu" , __UpperCamelCase : Dict=0.1 , __UpperCamelCase : Union[str, Any]=0.1 , __UpperCamelCase : Optional[Any]=5_12 , __UpperCamelCase : str=2 , __UpperCamelCase : List[str]=0.0_2 , __UpperCamelCase : Optional[int]=1e-12 , __UpperCamelCase : Optional[Any]=0 , __UpperCamelCase : Dict=0 , __UpperCamelCase : Dict=2 , __UpperCamelCase : int=2_56 , __UpperCamelCase : Union[str, Any]=10_24 , __UpperCamelCase : Optional[int]=2_16 , __UpperCamelCase : List[Any]=10_01 , __UpperCamelCase : Optional[int]=32 , __UpperCamelCase : List[str]=50 , __UpperCamelCase : List[Any]="absolute" , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : int=None , **__UpperCamelCase : List[Any] , ) ->Any: '''simple docstring''' super().__init__( pad_token_id=__UpperCamelCase , bos_token_id=__UpperCamelCase , eos_token_id=__UpperCamelCase , **__UpperCamelCase , ) _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = position_embedding_type _UpperCAmelCase = use_cache _UpperCAmelCase = classifier_dropout # additional properties _UpperCAmelCase = max_depth _UpperCAmelCase = max_xpath_tag_unit_embeddings _UpperCAmelCase = max_xpath_subs_unit_embeddings _UpperCAmelCase = tag_pad_id _UpperCAmelCase = subs_pad_id _UpperCAmelCase = xpath_unit_hidden_size
19
"""simple docstring""" import enum import warnings from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING a : List[str] = logging.get_logger(__name__) class a_ ( enum.Enum ): a : Optional[Any] = 0 a : Dict = 1 @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'generated' def __init__( self : int , *__UpperCamelCase : Optional[int] , **__UpperCamelCase : str ) ->Any: '''simple docstring''' super().__init__(*__UpperCamelCase , **__UpperCamelCase ) self.check_model_type( TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if self.framework == """tf""" else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : int=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : Dict=None , **__UpperCamelCase : Any , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = {} if truncation is not None: _UpperCAmelCase = truncation _UpperCAmelCase = generate_kwargs _UpperCAmelCase = {} if return_tensors is not None and return_type is None: _UpperCAmelCase = ReturnType.TENSORS if return_tensors else ReturnType.TEXT if return_type is not None: _UpperCAmelCase = return_type if clean_up_tokenization_spaces is not None: _UpperCAmelCase = clean_up_tokenization_spaces if stop_sequence is not None: _UpperCAmelCase = self.tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) if len(__UpperCamelCase ) > 1: warnings.warn( """Stopping on a multiple token sequence is not yet supported on transformers. The first token of""" """ the stop sequence will be used as the stop sequence string in the interim.""" ) _UpperCAmelCase = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def _snake_case ( self : int , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' return True def _snake_case ( self : Optional[Any] , *__UpperCamelCase : Any , __UpperCamelCase : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model.config.prefix if self.model.config.prefix is not None else """""" if isinstance(args[0] , __UpperCamelCase ): if self.tokenizer.pad_token_id is None: raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" ) _UpperCAmelCase = ([prefix + arg for arg in args[0]],) _UpperCAmelCase = True elif isinstance(args[0] , __UpperCamelCase ): _UpperCAmelCase = (prefix + args[0],) _UpperCAmelCase = False else: raise ValueError( f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" ) _UpperCAmelCase = self.tokenizer(*__UpperCamelCase , padding=__UpperCamelCase , truncation=__UpperCamelCase , return_tensors=self.framework ) # This is produced by tokenizers but is an invalid generate kwargs if "token_type_ids" in inputs: del inputs["token_type_ids"] return inputs def __call__( self : Dict , *__UpperCamelCase : str , **__UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = super().__call__(*__UpperCamelCase , **__UpperCamelCase ) if ( isinstance(args[0] , __UpperCamelCase ) and all(isinstance(__UpperCamelCase , __UpperCamelCase ) for el in args[0] ) and all(len(__UpperCamelCase ) == 1 for res in result ) ): return [res[0] for res in result] return result def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : str=TruncationStrategy.DO_NOT_TRUNCATE , **__UpperCamelCase : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self._parse_and_tokenize(__UpperCamelCase , truncation=__UpperCamelCase , **__UpperCamelCase ) return inputs def _snake_case ( self : str , __UpperCamelCase : Dict , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' if self.framework == "pt": _UpperCAmelCase ,_UpperCAmelCase = model_inputs["""input_ids"""].shape elif self.framework == "tf": _UpperCAmelCase ,_UpperCAmelCase = tf.shape(model_inputs["""input_ids"""] ).numpy() _UpperCAmelCase = generate_kwargs.get("""min_length""" , self.model.config.min_length ) _UpperCAmelCase = generate_kwargs.get("""max_length""" , self.model.config.max_length ) self.check_inputs(__UpperCamelCase , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] ) _UpperCAmelCase = self.model.generate(**__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = output_ids.shape[0] if self.framework == "pt": _UpperCAmelCase = output_ids.reshape(__UpperCamelCase , out_b // in_b , *output_ids.shape[1:] ) elif self.framework == "tf": _UpperCAmelCase = tf.reshape(__UpperCamelCase , (in_b, out_b // in_b, *output_ids.shape[1:]) ) return {"output_ids": output_ids} def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : Union[str, Any]=ReturnType.TEXT , __UpperCamelCase : int=False ) ->Any: '''simple docstring''' _UpperCAmelCase = [] for output_ids in model_outputs["output_ids"][0]: if return_type == ReturnType.TENSORS: _UpperCAmelCase = {f"""{self.return_name}_token_ids""": output_ids} elif return_type == ReturnType.TEXT: _UpperCAmelCase = { f"""{self.return_name}_text""": self.tokenizer.decode( __UpperCamelCase , skip_special_tokens=__UpperCamelCase , clean_up_tokenization_spaces=__UpperCamelCase , ) } records.append(__UpperCamelCase ) return records @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'summary' def __call__( self : Optional[Any] , *__UpperCamelCase : Optional[Any] , **__UpperCamelCase : Optional[int] ) ->Any: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->bool: '''simple docstring''' if max_length < min_length: logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" ) if input_length < max_length: logger.warning( f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """ """a summarization task, where outputs shorter than the input are typically wanted, you might """ f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" ) @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : Optional[int] = 'translation' def _snake_case ( self : Union[str, Any] , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' if input_length > 0.9 * max_length: logger.warning( f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """ """increasing your max_length manually, e.g. translator('...', max_length=400)""" ) return True def _snake_case ( self : Tuple , *__UpperCamelCase : List[str] , __UpperCamelCase : Tuple=TruncationStrategy.DO_NOT_TRUNCATE , __UpperCamelCase : Tuple=None , __UpperCamelCase : Union[str, Any]=None ) ->Tuple: '''simple docstring''' if getattr(self.tokenizer , """_build_translation_inputs""" , __UpperCamelCase ): return self.tokenizer._build_translation_inputs( *__UpperCamelCase , return_tensors=self.framework , truncation=__UpperCamelCase , src_lang=__UpperCamelCase , tgt_lang=__UpperCamelCase ) else: return super()._parse_and_tokenize(*__UpperCamelCase , truncation=__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : int=None , __UpperCamelCase : int=None , **__UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = super()._sanitize_parameters(**__UpperCamelCase ) if src_lang is not None: _UpperCAmelCase = src_lang if tgt_lang is not None: _UpperCAmelCase = tgt_lang if src_lang is None and tgt_lang is None: # Backward compatibility, direct arguments use is preferred. _UpperCAmelCase = kwargs.get("""task""" , self.task ) _UpperCAmelCase = task.split("""_""" ) if task and len(__UpperCamelCase ) == 4: # translation, XX, to YY _UpperCAmelCase = items[1] _UpperCAmelCase = items[3] return preprocess_params, forward_params, postprocess_params def __call__( self : List[str] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->int: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase )
19
1
"""simple docstring""" import os import tempfile import unittest from transformers import FlaubertConfig, is_torch_available from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import ( FlaubertForMultipleChoice, FlaubertForQuestionAnswering, FlaubertForQuestionAnsweringSimple, FlaubertForSequenceClassification, FlaubertForTokenClassification, FlaubertModel, FlaubertWithLMHeadModel, ) from transformers.models.flaubert.modeling_flaubert import FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST class a_ ( _UpperCAmelCase ): def __init__( self : int , __UpperCamelCase : int , __UpperCamelCase : Any=13 , __UpperCamelCase : Tuple=7 , __UpperCamelCase : str=True , __UpperCamelCase : Optional[int]=True , __UpperCamelCase : Dict=True , __UpperCamelCase : List[str]=True , __UpperCamelCase : Tuple=True , __UpperCamelCase : Dict=False , __UpperCamelCase : List[str]=False , __UpperCamelCase : Optional[Any]=False , __UpperCamelCase : List[Any]=2 , __UpperCamelCase : List[Any]=99 , __UpperCamelCase : List[str]=0 , __UpperCamelCase : List[str]=32 , __UpperCamelCase : List[Any]=5 , __UpperCamelCase : Dict=4 , __UpperCamelCase : List[Any]=0.1 , __UpperCamelCase : Tuple=0.1 , __UpperCamelCase : Optional[Any]=5_12 , __UpperCamelCase : Optional[int]=12 , __UpperCamelCase : List[Any]=2 , __UpperCamelCase : str=0.0_2 , __UpperCamelCase : Any=3 , __UpperCamelCase : Dict=4 , __UpperCamelCase : Tuple="last" , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Dict=None , ) ->Dict: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_input_lengths _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = gelu_activation _UpperCAmelCase = sinusoidal_embeddings _UpperCAmelCase = causal _UpperCAmelCase = asm _UpperCAmelCase = n_langs _UpperCAmelCase = vocab_size _UpperCAmelCase = n_special _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = num_choices _UpperCAmelCase = summary_type _UpperCAmelCase = use_proj _UpperCAmelCase = scope def _snake_case ( self : Any ) ->str: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_input_lengths: _UpperCAmelCase = ( ids_tensor([self.batch_size] , vocab_size=2 ) + self.seq_length - 2 ) # small variation of seq_length _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.n_langs ) _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _UpperCAmelCase = ids_tensor([self.batch_size] , 2 ).float() _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_choices ) _UpperCAmelCase = self.get_config() return ( config, input_ids, token_type_ids, input_lengths, sequence_labels, token_labels, is_impossible_labels, choice_labels, input_mask, ) def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' return FlaubertConfig( vocab_size=self.vocab_size , n_special=self.n_special , emb_dim=self.hidden_size , n_layers=self.num_hidden_layers , n_heads=self.num_attention_heads , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , gelu_activation=self.gelu_activation , sinusoidal_embeddings=self.sinusoidal_embeddings , asm=self.asm , causal=self.causal , n_langs=self.n_langs , max_position_embeddings=self.max_position_embeddings , initializer_range=self.initializer_range , summary_type=self.summary_type , use_proj=self.use_proj , ) def _snake_case ( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : str , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : int , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = FlaubertModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , lengths=__UpperCamelCase , langs=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , langs=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : int , __UpperCamelCase : Tuple , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : str , __UpperCamelCase : str , ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = FlaubertWithLMHeadModel(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , token_type_ids=__UpperCamelCase , labels=__UpperCamelCase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def _snake_case ( self : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : str , __UpperCamelCase : Any , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Any , __UpperCamelCase : Optional[int] , ) ->Any: '''simple docstring''' _UpperCAmelCase = FlaubertForQuestionAnsweringSimple(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , start_positions=__UpperCamelCase , end_positions=__UpperCamelCase ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def _snake_case ( self : Dict , __UpperCamelCase : Optional[int] , __UpperCamelCase : List[Any] , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Tuple , __UpperCamelCase : int , __UpperCamelCase : List[str] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , ) ->Any: '''simple docstring''' _UpperCAmelCase = FlaubertForQuestionAnswering(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model( __UpperCamelCase , start_positions=__UpperCamelCase , end_positions=__UpperCamelCase , cls_index=__UpperCamelCase , is_impossible=__UpperCamelCase , p_mask=__UpperCamelCase , ) _UpperCAmelCase = model( __UpperCamelCase , start_positions=__UpperCamelCase , end_positions=__UpperCamelCase , cls_index=__UpperCamelCase , is_impossible=__UpperCamelCase , ) ((_UpperCAmelCase) ,) = result_with_labels.to_tuple() _UpperCAmelCase = model(__UpperCamelCase , start_positions=__UpperCamelCase , end_positions=__UpperCamelCase ) ((_UpperCAmelCase) ,) = result_with_labels.to_tuple() self.parent.assertEqual(result_with_labels.loss.shape , () ) self.parent.assertEqual(result.start_top_log_probs.shape , (self.batch_size, model.config.start_n_top) ) self.parent.assertEqual(result.start_top_index.shape , (self.batch_size, model.config.start_n_top) ) self.parent.assertEqual( result.end_top_log_probs.shape , (self.batch_size, model.config.start_n_top * model.config.end_n_top) ) self.parent.assertEqual( result.end_top_index.shape , (self.batch_size, model.config.start_n_top * model.config.end_n_top) ) self.parent.assertEqual(result.cls_logits.shape , (self.batch_size,) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Tuple , __UpperCamelCase : str , __UpperCamelCase : Optional[Any] , __UpperCamelCase : str , ) ->Dict: '''simple docstring''' _UpperCAmelCase = FlaubertForSequenceClassification(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , labels=__UpperCamelCase ) self.parent.assertEqual(result.loss.shape , () ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.type_sequence_label_size) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : Dict , __UpperCamelCase : int , __UpperCamelCase : Any , __UpperCamelCase : int , __UpperCamelCase : List[str] , __UpperCamelCase : str , __UpperCamelCase : Optional[int] , ) ->Any: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = FlaubertForTokenClassification(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , attention_mask=__UpperCamelCase , labels=__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[str] , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.num_choices _UpperCAmelCase = FlaubertForMultipleChoice(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = input_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = token_type_ids.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = input_mask.unsqueeze(1 ).expand(-1 , self.num_choices , -1 ).contiguous() _UpperCAmelCase = model( __UpperCamelCase , attention_mask=__UpperCamelCase , token_type_ids=__UpperCamelCase , labels=__UpperCamelCase , ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def _snake_case ( self : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = { """input_ids""": input_ids, """token_type_ids""": token_type_ids, """lengths""": input_lengths, """attention_mask""": input_mask, } return config, inputs_dict @require_torch class a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : Dict = ( ( FlaubertModel, FlaubertWithLMHeadModel, FlaubertForQuestionAnswering, FlaubertForQuestionAnsweringSimple, FlaubertForSequenceClassification, FlaubertForTokenClassification, FlaubertForMultipleChoice, ) if is_torch_available() else () ) a : Tuple = ( { 'feature-extraction': FlaubertModel, 'fill-mask': FlaubertWithLMHeadModel, 'question-answering': FlaubertForQuestionAnsweringSimple, 'text-classification': FlaubertForSequenceClassification, 'token-classification': FlaubertForTokenClassification, 'zero-shot': FlaubertForSequenceClassification, } if is_torch_available() else {} ) def _snake_case ( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : str ) ->Union[str, Any]: '''simple docstring''' if ( pipeline_test_casse_name == "QAPipelineTests" and tokenizer_name is not None and not tokenizer_name.endswith("""Fast""" ) ): # `QAPipelineTests` fails for a few models when the slower tokenizer are used. # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework) # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer return True return False def _snake_case ( self : Dict , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple=False ) ->List[str]: '''simple docstring''' _UpperCAmelCase = super()._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) if return_labels: if model_class.__name__ == "FlaubertForQuestionAnswering": _UpperCAmelCase = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=__UpperCamelCase ) _UpperCAmelCase = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=__UpperCamelCase ) return inputs_dict def _snake_case ( self : Optional[Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = FlaubertModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , emb_dim=37 ) def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : Any ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_model(*__UpperCamelCase ) def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_lm_head(*__UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_simple_qa(*__UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_qa(*__UpperCamelCase ) def _snake_case ( self : Dict ) ->str: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_sequence_classif(*__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_token_classif(*__UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_flaubert_multiple_choice(*__UpperCamelCase ) @slow def _snake_case ( self : Any ) ->List[Any]: '''simple docstring''' for model_name in FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = FlaubertModel.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) @slow @require_torch_gpu def _snake_case ( self : Tuple ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: # FlauBertForMultipleChoice behaves incorrectly in JIT environments. if model_class == FlaubertForMultipleChoice: return _UpperCAmelCase = True _UpperCAmelCase = model_class(config=__UpperCamelCase ) _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = torch.jit.trace( __UpperCamelCase , (inputs_dict["""input_ids"""].to("""cpu""" ), inputs_dict["""attention_mask"""].to("""cpu""" )) ) with tempfile.TemporaryDirectory() as tmp: torch.jit.save(__UpperCamelCase , os.path.join(__UpperCamelCase , """traced_model.pt""" ) ) _UpperCAmelCase = torch.jit.load(os.path.join(__UpperCamelCase , """traced_model.pt""" ) , map_location=__UpperCamelCase ) loaded(inputs_dict["""input_ids"""].to(__UpperCamelCase ) , inputs_dict["""attention_mask"""].to(__UpperCamelCase ) ) @require_torch class a_ ( unittest.TestCase ): @slow def _snake_case ( self : Tuple ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = FlaubertModel.from_pretrained("""flaubert/flaubert_base_cased""" ) _UpperCAmelCase = torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]] ) with torch.no_grad(): _UpperCAmelCase = model(__UpperCamelCase )[0] _UpperCAmelCase = torch.Size((1, 11, 7_68) ) self.assertEqual(output.shape , __UpperCamelCase ) _UpperCAmelCase = torch.tensor( [[[-2.6_2_5_1, -1.4_2_9_8, -0.0_2_2_7], [-2.8_5_1_0, -1.6_3_8_7, 0.2_2_5_8], [-2.8_1_1_4, -1.1_8_3_2, -0.3_0_6_6]]] ) self.assertTrue(torch.allclose(output[:, :3, :3] , __UpperCamelCase , atol=1e-4 ) )
19
"""simple docstring""" import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class a_ ( unittest.TestCase ): @property def _snake_case ( self : Dict ) ->int: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") , up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") , ) return model @property def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = VQModel( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=3 , ) return model @property def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) return CLIPTextModel(__UpperCamelCase ) def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = self.dummy_vq_model _UpperCAmelCase = LDMPipeline(unet=__UpperCamelCase , vqvae=__UpperCamelCase , scheduler=__UpperCamelCase ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" ).images _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" , return_dict=__UpperCamelCase )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _UpperCAmelCase = np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < tolerance @slow @require_torch class a_ ( unittest.TestCase ): def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256""" ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=5 , output_type="""numpy""" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _UpperCAmelCase = np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance
19
1
"""simple docstring""" import unittest from transformers.testing_utils import CaptureStdout from transformers.tools.python_interpreter import evaluate def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" return x + 2 class a_ ( unittest.TestCase ): def _snake_case ( self : Dict ) ->str: '''simple docstring''' _UpperCAmelCase = """x = 3""" _UpperCAmelCase = {} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) assert result == 3 self.assertDictEqual(__UpperCamelCase , {"""x""": 3} ) _UpperCAmelCase = """x = y""" _UpperCAmelCase = {"""y""": 5} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) # evaluate returns the value of the last assignment. assert result == 5 self.assertDictEqual(__UpperCamelCase , {"""x""": 5, """y""": 5} ) def _snake_case ( self : Optional[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = """y = add_two(x)""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {"""add_two""": add_two} , state=__UpperCamelCase ) assert result == 5 self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """y""": 5} ) # Won't work without the tool with CaptureStdout() as out: _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) assert result is None assert "tried to execute add_two" in out.out def _snake_case ( self : Optional[Any] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = """x = 3""" _UpperCAmelCase = {} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) assert result == 3 self.assertDictEqual(__UpperCamelCase , {"""x""": 3} ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = """test_dict = {'x': x, 'y': add_two(x)}""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {"""add_two""": add_two} , state=__UpperCamelCase ) self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """y""": 5} ) self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}} ) def _snake_case ( self : Tuple ) ->int: '''simple docstring''' _UpperCAmelCase = """x = 3\ny = 5""" _UpperCAmelCase = {} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) # evaluate returns the value of the last assignment. assert result == 5 self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """y""": 5} ) def _snake_case ( self : Optional[int] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = """text = f'This is x: {x}.'""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) # evaluate returns the value of the last assignment. assert result == "This is x: 3." self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """text""": """This is x: 3."""} ) def _snake_case ( self : Union[str, Any] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = """if x <= 3:\n y = 2\nelse:\n y = 5""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) # evaluate returns the value of the last assignment. assert result == 2 self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """y""": 2} ) _UpperCAmelCase = {"""x""": 8} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) # evaluate returns the value of the last assignment. assert result == 5 self.assertDictEqual(__UpperCamelCase , {"""x""": 8, """y""": 5} ) def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = """test_list = [x, add_two(x)]""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {"""add_two""": add_two} , state=__UpperCamelCase ) self.assertListEqual(__UpperCamelCase , [3, 5] ) self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """test_list""": [3, 5]} ) def _snake_case ( self : List[str] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = """y = x""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {} , state=__UpperCamelCase ) assert result == 3 self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """y""": 3} ) def _snake_case ( self : Any ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = """test_list = [x, add_two(x)]\ntest_list[1]""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {"""add_two""": add_two} , state=__UpperCamelCase ) assert result == 5 self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """test_list""": [3, 5]} ) _UpperCAmelCase = """test_dict = {'x': x, 'y': add_two(x)}\ntest_dict['y']""" _UpperCAmelCase = {"""x""": 3} _UpperCAmelCase = evaluate(__UpperCamelCase , {"""add_two""": add_two} , state=__UpperCamelCase ) assert result == 5 self.assertDictEqual(__UpperCamelCase , {"""x""": 3, """test_dict""": {"""x""": 3, """y""": 5}} ) def _snake_case ( self : Tuple ) ->str: '''simple docstring''' _UpperCAmelCase = """x = 0\nfor i in range(3):\n x = i""" _UpperCAmelCase = {} _UpperCAmelCase = evaluate(__UpperCamelCase , {"""range""": range} , state=__UpperCamelCase ) assert result == 2 self.assertDictEqual(__UpperCamelCase , {"""x""": 2, """i""": 2} )
19
"""simple docstring""" import re from filelock import FileLock try: import nltk a : str = True except (ImportError, ModuleNotFoundError): a : List[str] = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def _UpperCamelCase ( _A ) -> str: """simple docstring""" re.sub("""<n>""" , """""" , _A ) # 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(_A ) )
19
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_deformable_detr import DeformableDetrImageProcessor a : Any = logging.get_logger(__name__) class a_ ( _UpperCAmelCase ): def __init__( self : Tuple , *__UpperCamelCase : Optional[Any] , **__UpperCamelCase : Optional[Any] ) ->None: '''simple docstring''' warnings.warn( """The class DeformableDetrFeatureExtractor is deprecated and will be removed in version 5 of Transformers.""" """ Please use DeformableDetrImageProcessor instead.""" , __UpperCamelCase , ) super().__init__(*__UpperCamelCase , **__UpperCamelCase )
19
"""simple docstring""" import unittest from transformers import PegasusConfig, PegasusTokenizer, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_configuration_common import ConfigTester 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 : str = '''platform''' import jax import jax.numpy as jnp import numpy as np from transformers import FlaxPegasusForConditionalGeneration, FlaxPegasusModel @require_flax class a_ : a : List[Any] = PegasusConfig a : Dict = {} a : List[Any] = 'gelu' def __init__( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Tuple=13 , __UpperCamelCase : Tuple=7 , __UpperCamelCase : Tuple=True , __UpperCamelCase : Any=False , __UpperCamelCase : Any=99 , __UpperCamelCase : Optional[int]=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : List[str]=4 , __UpperCamelCase : Dict=37 , __UpperCamelCase : int=0.1 , __UpperCamelCase : Dict=0.1 , __UpperCamelCase : Optional[Any]=20 , __UpperCamelCase : Tuple=2 , __UpperCamelCase : Optional[int]=1 , __UpperCamelCase : Tuple=0 , ) ->int: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = bos_token_id def _snake_case ( self : Union[str, Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ).clip(3 , self.vocab_size ) _UpperCAmelCase = np.expand_dims(np.array([self.eos_token_id] * self.batch_size ) , 1 ) _UpperCAmelCase = np.concatenate([input_ids, eos_tensor] , axis=1 ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) _UpperCAmelCase = prepare_pegasus_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, inputs_dict def _snake_case ( self : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) , dtype="""i4""" ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _snake_case ( self : Any , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] , axis=-1 , ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_attention_mask=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _UpperCamelCase ( _A , _A , _A , _A=None , _A=None , ) -> int: """simple docstring""" if attention_mask is None: _UpperCAmelCase = np.not_equal(_A , config.pad_token_id ).astype(np.inta ) if decoder_attention_mask is None: _UpperCAmelCase = np.concatenate( [ np.ones(decoder_input_ids[:, :1].shape , dtype=np.inta ), np.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id ).astype(np.inta ), ] , axis=-1 , ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, } @require_flax class a_ ( _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( ( FlaxPegasusForConditionalGeneration, FlaxPegasusModel, ) if is_flax_available() else () ) a : Any = (FlaxPegasusForConditionalGeneration,) if is_flax_available() else () a : Any = True a : int = False a : Union[str, Any] = False a : Optional[int] = False def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->List[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model_class(__UpperCamelCase ) @jax.jit def encode_jitted(__UpperCamelCase : List[Any] , __UpperCamelCase : str=None , **__UpperCamelCase : int ): return model.encode(input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] , inputs_dict["""attention_mask"""] ) _UpperCAmelCase = { """decoder_input_ids""": inputs_dict["""decoder_input_ids"""], """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""], """encoder_outputs""": encoder_outputs, } @jax.jit def decode_jitted(__UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple ): return model.decode( decoder_input_ids=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , encoder_outputs=__UpperCamelCase , ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) @slow def _snake_case ( self : int ) ->int: '''simple docstring''' for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained("""google/pegasus-large""" , from_pt=__UpperCamelCase ) _UpperCAmelCase = np.ones((1, 1) ) _UpperCAmelCase = model(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) @slow def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusForConditionalGeneration.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = PegasusTokenizer.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = [ """ PG&E stated it scheduled the blackouts in response to forecasts for high winds amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow.""", """ The London trio are up for best UK act and best album, as well as getting two nominations in the best song category.\"We got told like this morning 'Oh I think you're nominated'\", said Dappy.\"And I was like 'Oh yeah, which one?' And now we've got nominated for four awards. I mean, wow!\"Bandmate Fazer added: \"We thought it's best of us to come down and mingle with everyone and say hello to the cameras. And now we find we've got four nominations.\"The band have two shots at the best song prize, getting the nod for their Tynchy Stryder collaboration Number One, and single Strong Again.Their album Uncle B will also go up against records by the likes of Beyonce and Kanye West.N-Dubz picked up the best newcomer Mobo in 2007, but female member Tulisa said they wouldn't be too disappointed if they didn't win this time around.\"At the end of the day we're grateful to be where we are in our careers.\"If it don't happen then it don't happen - live to fight another day and keep on making albums and hits for the fans.\"Dappy also revealed they could be performing live several times on the night.The group will be doing Number One and also a possible rendition of the War Child single, I Got Soul.The charity song is a re-working of The Killers' All These Things That I've Done and is set to feature artists like Chipmunk, Ironik and Pixie Lott.This year's Mobos will be held outside of London for the first time, in Glasgow on 30 September.N-Dubz said they were looking forward to performing for their Scottish fans and boasted about their recent shows north of the border.\"We just done Edinburgh the other day,\" said Dappy.\"We smashed up an N-Dubz show over there. We done Aberdeen about three or four months ago - we smashed up that show over there! Everywhere we go we smash it up!\" """, ] _UpperCAmelCase = [ """California's largest electricity provider has turned off power to hundreds of thousands of customers.""", """Pop group N-Dubz have revealed they were surprised to get four nominations for this year's Mobo Awards.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""np""" , truncation=__UpperCamelCase , max_length=5_12 , padding=__UpperCamelCase ) _UpperCAmelCase = model.generate(**__UpperCamelCase , num_beams=2 ).sequences _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase , skip_special_tokens=__UpperCamelCase ) assert tgt_text == decoded
19
1
"""simple docstring""" import datasets import faiss import numpy as np import streamlit as st import torch from elasticsearch import Elasticsearch from elia_utils import ( embed_questions_for_retrieval, make_qa_sas_model, qa_sas_generate, query_es_index, query_qa_dense_index, ) import transformers from transformers import AutoModel, AutoModelForSeqaSeqLM, AutoTokenizer a : int = '''bart''' a : str = True @st.cache(allow_output_mutation=_A ) def _UpperCamelCase ( ) -> str: """simple docstring""" if LOAD_DENSE_INDEX: _UpperCAmelCase = AutoTokenizer.from_pretrained("""yjernite/retribert-base-uncased""" ) _UpperCAmelCase = AutoModel.from_pretrained("""yjernite/retribert-base-uncased""" ).to("""cuda:0""" ) _UpperCAmelCase = qar_model.eval() else: _UpperCAmelCase ,_UpperCAmelCase = (None, None) if MODEL_TYPE == "bart": _UpperCAmelCase = AutoTokenizer.from_pretrained("""yjernite/bart_eli5""" ) _UpperCAmelCase = AutoModelForSeqaSeqLM.from_pretrained("""yjernite/bart_eli5""" ).to("""cuda:0""" ) _UpperCAmelCase = torch.load("""seq2seq_models/eli5_bart_model_blm_2.pth""" ) sas_model.load_state_dict(save_dict["""model"""] ) _UpperCAmelCase = sas_model.eval() else: _UpperCAmelCase ,_UpperCAmelCase = make_qa_sas_model( model_name="""t5-small""" , from_file="""seq2seq_models/eli5_t5_model_1024_4.pth""" , device="""cuda:0""" ) return (qar_tokenizer, qar_model, sas_tokenizer, sas_model) @st.cache(allow_output_mutation=_A ) def _UpperCamelCase ( ) -> Dict: """simple docstring""" if LOAD_DENSE_INDEX: _UpperCAmelCase = faiss.StandardGpuResources() _UpperCAmelCase = datasets.load_dataset(path="""wiki_snippets""" , name="""wiki40b_en_100_0""" )["""train"""] _UpperCAmelCase = np.memmap( """wiki40b_passages_reps_32_l-8_h-768_b-512-512.dat""" , dtype="""float32""" , mode="""r""" , shape=(wikiaab_passages.num_rows, 1_2_8) , ) _UpperCAmelCase = faiss.IndexFlatIP(1_2_8 ) _UpperCAmelCase = faiss.index_cpu_to_gpu(_A , 1 , _A ) wikiaab_gpu_index_flat.add(_A ) # TODO fix for larger GPU else: _UpperCAmelCase ,_UpperCAmelCase = (None, None) _UpperCAmelCase = Elasticsearch([{"""host""": """localhost""", """port""": """9200"""}] ) return (wikiaab_passages, wikiaab_gpu_index_flat, es_client) @st.cache(allow_output_mutation=_A ) def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = datasets.load_dataset("""eli5""" , name="""LFQA_reddit""" ) _UpperCAmelCase = elia["""train_eli5"""] _UpperCAmelCase = np.memmap( """eli5_questions_reps.dat""" , dtype="""float32""" , mode="""r""" , shape=(elia_train.num_rows, 1_2_8) ) _UpperCAmelCase = faiss.IndexFlatIP(1_2_8 ) eli5_train_q_index.add(_A ) return (elia_train, eli5_train_q_index) a , a , a : str = load_indexes() a , a , a , a : Union[str, Any] = load_models() a , a : Tuple = load_train_data() def _UpperCamelCase ( _A , _A=1_0 ) -> List[Any]: """simple docstring""" _UpperCAmelCase = embed_questions_for_retrieval([question] , _A , _A ) _UpperCAmelCase ,_UpperCAmelCase = eli5_train_q_index.search(_A , _A ) _UpperCAmelCase = [elia_train[int(_A )] for i in I[0]] return nn_examples def _UpperCamelCase ( _A , _A="wiki40b" , _A="dense" , _A=1_0 ) -> List[Any]: """simple docstring""" if source == "none": _UpperCAmelCase ,_UpperCAmelCase = (""" <P> """.join(["""""" for _ in range(1_1 )] ).strip(), []) else: if method == "dense": _UpperCAmelCase ,_UpperCAmelCase = query_qa_dense_index( _A , _A , _A , _A , _A , _A ) else: _UpperCAmelCase ,_UpperCAmelCase = query_es_index( _A , _A , index_name="""english_wiki40b_snippets_100w""" , n_results=_A , ) _UpperCAmelCase = [ (res["""article_title"""], res["""section_title"""].strip(), res["""score"""], res["""passage_text"""]) for res in hit_lst ] _UpperCAmelCase = """question: {} context: {}""".format(_A , _A ) return question_doc, support_list @st.cache( hash_funcs={ torch.Tensor: (lambda _A : None), transformers.models.bart.tokenization_bart.BartTokenizer: (lambda _A : None), } ) def _UpperCamelCase ( _A , _A , _A , _A=6_4 , _A=2_5_6 , _A=False , _A=2 , _A=0.95 , _A=0.8 ) -> Any: """simple docstring""" with torch.no_grad(): _UpperCAmelCase = qa_sas_generate( _A , _A , _A , num_answers=1 , num_beams=_A , min_len=_A , max_len=_A , do_sample=_A , temp=_A , top_p=_A , top_k=_A , max_input_length=1_0_2_4 , device="""cuda:0""" , )[0] return (answer, support_list) st.title('''Long Form Question Answering with ELI5''') # Start sidebar a : Optional[Any] = '''<img src=\'https://huggingface.co/front/assets/huggingface_logo.svg\'>''' a : Optional[int] = ''' <html> <head> <style> .img-container { padding-left: 90px; padding-right: 90px; padding-top: 50px; padding-bottom: 50px; background-color: #f0f3f9; } </style> </head> <body> <span class="img-container"> <!-- Inline parent element --> %s </span> </body> </html> ''' % ( header_html, ) st.sidebar.markdown( header_full, unsafe_allow_html=True, ) # Long Form QA with ELI5 and Wikipedia a : Any = ''' This demo presents a model trained to [provide long-form answers to open-domain questions](https://yjernite.github.io/lfqa.html). First, a document retriever fetches a set of relevant Wikipedia passages given the question from the [Wiki40b](https://research.google/pubs/pub49029/) dataset, a pre-processed fixed snapshot of Wikipedia. ''' st.sidebar.markdown(description, unsafe_allow_html=True) a : Dict = [ '''Answer the question''', '''View the retrieved document only''', '''View the most similar ELI5 question and answer''', '''Show me everything, please!''', ] a : Optional[Any] = st.sidebar.checkbox('''Demo options''') if demo_options: a : List[str] = st.sidebar.selectbox( '''''', action_list, index=3, ) a : Any = action_list.index(action_st) a : List[Any] = st.sidebar.selectbox( '''''', ['''Show full text of passages''', '''Show passage section titles'''], index=0, ) a : Optional[Any] = show_type == '''Show full text of passages''' else: a : Optional[int] = 3 a : Optional[Any] = True a : Optional[Any] = st.sidebar.checkbox('''Retrieval options''') if retrieval_options: a : Union[str, Any] = ''' ### Information retriever options The **sparse** retriever uses ElasticSearch, while the **dense** retriever uses max-inner-product search between a question and passage embedding trained using the [ELI5](https://arxiv.org/abs/1907.09190) questions-answer pairs. The answer is then generated by sequence to sequence model which takes the question and retrieved document as input. ''' st.sidebar.markdown(retriever_info) a : Dict = st.sidebar.selectbox('''Which Wikipedia format should the model use?''', ['''wiki40b''', '''none''']) a : List[Any] = st.sidebar.selectbox('''Which Wikipedia indexer should the model use?''', ['''dense''', '''sparse''', '''mixed''']) else: a : int = '''wiki40b''' a : Dict = '''dense''' a : Any = '''beam''' a : str = 2 a : Tuple = 6_4 a : Union[str, Any] = 2_5_6 a : Optional[int] = None a : Tuple = None a : str = st.sidebar.checkbox('''Generation options''') if generate_options: a : str = ''' ### Answer generation options The sequence-to-sequence model was initialized with [BART](https://huggingface.co/facebook/bart-large) weights and fine-tuned on the ELI5 QA pairs and retrieved documents. You can use the model for greedy decoding with **beam** search, or **sample** from the decoder\'s output probabilities. ''' st.sidebar.markdown(generate_info) a : Dict = st.sidebar.selectbox('''Would you like to use beam search or sample an answer?''', ['''beam''', '''sampled''']) a : List[Any] = st.sidebar.slider( '''Minimum generation length''', min_value=8, max_value=2_5_6, value=6_4, step=8, format=None, key=None ) a : Optional[int] = st.sidebar.slider( '''Maximum generation length''', min_value=6_4, max_value=5_1_2, value=2_5_6, step=1_6, format=None, key=None ) if sampled == "beam": a : List[Any] = st.sidebar.slider('''Beam size''', min_value=1, max_value=8, value=2, step=None, format=None, key=None) else: a : int = st.sidebar.slider( '''Nucleus sampling p''', min_value=0.1, max_value=1.0, value=0.95, step=0.01, format=None, key=None ) a : Optional[Any] = st.sidebar.slider( '''Temperature''', min_value=0.1, max_value=1.0, value=0.7, step=0.01, format=None, key=None ) a : Optional[Any] = None # start main text a : Union[str, Any] = [ '''<MY QUESTION>''', '''How do people make chocolate?''', '''Why do we get a fever when we are sick?''', '''How can different animals perceive different colors?''', '''What is natural language processing?''', '''What\'s the best way to treat a sunburn?''', '''What exactly are vitamins ?''', '''How does nuclear energy provide electricity?''', '''What\'s the difference between viruses and bacteria?''', '''Why are flutes classified as woodwinds when most of them are made out of metal ?''', '''Why do people like drinking coffee even though it tastes so bad?''', '''What happens when wine ages? How does it make the wine taste better?''', '''If an animal is an herbivore, where does it get the protein that it needs to survive if it only eats grass?''', '''How can we set a date to the beginning or end of an artistic period? Doesn\'t the change happen gradually?''', '''How does New Zealand have so many large bird predators?''', ] a : Dict = st.selectbox( '''What would you like to ask? ---- select <MY QUESTION> to enter a new query''', questions_list, index=1, ) if question_s == "<MY QUESTION>": a : Union[str, Any] = st.text_input('''Enter your question here:''', '''''') else: a : Tuple = question_s if st.button('''Show me!'''): if action in [0, 1, 3]: if index_type == "mixed": a , a : List[Any] = make_support(question, source=wiki_source, method='''dense''', n_results=1_0) a , a : Any = make_support(question, source=wiki_source, method='''sparse''', n_results=1_0) a : Any = [] for res_d, res_s in zip(support_list_dense, support_list_sparse): if tuple(res_d) not in support_list: support_list += [tuple(res_d)] if tuple(res_s) not in support_list: support_list += [tuple(res_s)] a : List[Any] = support_list[:1_0] a : List[Any] = '''<P> ''' + ''' <P> '''.join([res[-1] for res in support_list]) else: a , a : Any = make_support(question, source=wiki_source, method=index_type, n_results=1_0) if action in [0, 3]: a , a : Any = answer_question( question_doc, sas_model, sas_tokenizer, min_len=min_len, max_len=int(max_len), sampling=(sampled == '''sampled'''), n_beams=n_beams, top_p=top_p, temp=temp, ) st.markdown('''### The model generated answer is:''') st.write(answer) if action in [0, 1, 3] and wiki_source != "none": st.markdown('''--- \n ### The model is drawing information from the following Wikipedia passages:''') for i, res in enumerate(support_list): a : str = '''https://en.wikipedia.org/wiki/{}'''.format(res[0].replace(''' ''', '''_''')) a : Tuple = res[1].strip() if sec_titles == "": a : List[Any] = '''[{}]({})'''.format(res[0], wiki_url) else: a : Union[str, Any] = sec_titles.split(''' & ''') a : Optional[Any] = ''' & '''.join( ['''[{}]({}#{})'''.format(sec.strip(), wiki_url, sec.strip().replace(''' ''', '''_''')) for sec in sec_list] ) st.markdown( '''{0:02d} - **Article**: {1:<18} <br> _Section_: {2}'''.format(i + 1, res[0], sections), unsafe_allow_html=True, ) if show_passages: st.write( '''> <span style="font-family:arial; font-size:10pt;">''' + res[-1] + '''</span>''', unsafe_allow_html=True ) if action in [2, 3]: a : int = find_nearest_training(question) a : int = nn_train_list[0] st.markdown( '''--- \n ### The most similar question in the ELI5 training set was: \n\n {}'''.format(train_exple['''title''']) ) a : Union[str, Any] = [ '''{}. {}'''.format(i + 1, ''' \n'''.join([line.strip() for line in ans.split('''\n''') if line.strip() != ''''''])) for i, (ans, sc) in enumerate(zip(train_exple['''answers''']['''text'''], train_exple['''answers''']['''score'''])) if i == 0 or sc > 2 ] st.markdown('''##### Its answers were: \n\n {}'''.format('''\n'''.join(answers_st))) a : Any = ''' --- **Disclaimer** *The intent of this app is to provide some (hopefully entertaining) insights into the behavior of a current LFQA system. Evaluating biases of such a model and ensuring factual generations are still very much open research problems. Therefore, until some significant progress is achieved, we caution against using the generated answers for practical purposes.* ''' st.sidebar.markdown(disclaimer, unsafe_allow_html=True)
19
"""simple docstring""" import tempfile import unittest from transformers import TaConfig, is_torch_available from transformers.testing_utils import ( require_sentencepiece, require_tokenizers, require_torch, slow, torch_device, ) from ...generation.test_utils import GenerationTesterMixin from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel class a_ : def __init__( self : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : List[Any]=99 , __UpperCamelCase : Optional[int]=13 , __UpperCamelCase : List[str]=7 , __UpperCamelCase : List[Any]=9 , __UpperCamelCase : List[Any]=True , __UpperCamelCase : str=True , __UpperCamelCase : int=False , __UpperCamelCase : int=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : Optional[int]=4 , __UpperCamelCase : Any=37 , __UpperCamelCase : List[Any]=8 , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : str=0.0_0_2 , __UpperCamelCase : Union[str, Any]=1 , __UpperCamelCase : List[Any]=0 , __UpperCamelCase : Tuple=0 , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Any=None , ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = encoder_seq_length _UpperCAmelCase = decoder_seq_length # For common tests _UpperCAmelCase = self.decoder_seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = d_ff _UpperCAmelCase = relative_attention_num_buckets _UpperCAmelCase = dropout_rate _UpperCAmelCase = initializer_factor _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = decoder_start_token_id _UpperCAmelCase = None _UpperCAmelCase = decoder_layers def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' return TaConfig.from_pretrained("""google/umt5-base""" ) def _snake_case ( self : List[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Tuple=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : str=None , ) ->int: '''simple docstring''' if attention_mask is None: _UpperCAmelCase = input_ids.ne(config.pad_token_id ) if decoder_attention_mask is None: _UpperCAmelCase = decoder_input_ids.ne(config.pad_token_id ) if head_mask is None: _UpperCAmelCase = torch.ones(config.num_hidden_layers , config.num_attention_heads , device=__UpperCamelCase ) if decoder_head_mask is None: _UpperCAmelCase = torch.ones(config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) if cross_attn_head_mask is None: _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.encoder_seq_length] , self.vocab_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size ) # we need to clamp the input ids here to avoid having pad token in between # this is because for NllbMoe the position_ids are prepared such that # all pad tokens have pos id = 2 and rest are between 2..seq_length # and the seq_length here is seq_length - num_pad_tokens # but when using past, there is no way of knowing if the past input ids had # pad tokens in them, which results in incorrect seq_lenth and which in turn results in # position_ids being off by num_pad_tokens in past input _UpperCAmelCase = input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = decoder_input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = self.get_config() _UpperCAmelCase = config.num_attention_heads _UpperCAmelCase = self.prepare_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, input_dict def _snake_case ( self : Union[str, Any] ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' return TaConfig( vocab_size=1_66 , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : Tuple ) ->Dict: '''simple docstring''' return TaConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[str] , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model( input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , ) _UpperCAmelCase = model(input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase ) _UpperCAmelCase = result.last_hidden_state _UpperCAmelCase = result.past_key_values _UpperCAmelCase = result.encoder_last_hidden_state self.parent.assertEqual(encoder_output.size() , (self.batch_size, self.encoder_seq_length, self.hidden_size) ) self.parent.assertEqual(decoder_output.size() , (self.batch_size, self.decoder_seq_length, self.hidden_size) ) # There should be `num_layers` key value embeddings stored in decoder_past self.parent.assertEqual(len(__UpperCamelCase ) , config.num_layers ) # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple self.parent.assertEqual(len(decoder_past[0] ) , 4 ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] , ) ->str: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).get_decoder().to(__UpperCamelCase ).eval() # first forward pass _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) + 1 ) _UpperCAmelCase ,_UpperCAmelCase = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids _UpperCAmelCase = ids_tensor((self.batch_size, 1) , config.vocab_size ) # append to next input_ids and _UpperCAmelCase = torch.cat([input_ids, next_tokens] , dim=-1 ) _UpperCAmelCase = model(__UpperCamelCase )["""last_hidden_state"""] _UpperCAmelCase = model(__UpperCamelCase , past_key_values=__UpperCamelCase )["""last_hidden_state"""] # select random slice _UpperCAmelCase = ids_tensor((1,) , output_from_past.shape[-1] ).item() _UpperCAmelCase = output_from_no_past[:, -1, random_slice_idx].detach() _UpperCAmelCase = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(__UpperCamelCase , __UpperCamelCase , atol=1e-3 ) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : int , __UpperCamelCase : Dict , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).to(__UpperCamelCase ).half().eval() _UpperCAmelCase = model(**__UpperCamelCase )["""last_hidden_state"""] self.parent.assertFalse(torch.isnan(__UpperCamelCase ).any().item() ) @require_torch class a_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else () ) a : Tuple = (UMTaForConditionalGeneration,) if is_torch_available() else () a : Optional[Any] = ( { 'conversational': UMTaForConditionalGeneration, 'feature-extraction': UMTaModel, 'summarization': UMTaForConditionalGeneration, 'text2text-generation': UMTaForConditionalGeneration, 'translation': UMTaForConditionalGeneration, 'question-answering': UMTaForQuestionAnswering, } if is_torch_available() else {} ) a : Any = True a : Optional[int] = False a : Any = False a : Optional[int] = True a : Optional[Any] = True # The small UMT5 model needs higher percentages for CPU/MP tests a : int = [0.8, 0.9] def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = UMTaModelTester(self ) @unittest.skip("""Test has a segmentation fault on torch 1.8.0""" ) def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = UMTaModel(config_and_inputs[0] ).to(__UpperCamelCase ) with tempfile.TemporaryDirectory() as tmpdirname: torch.onnx.export( __UpperCamelCase , (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) , f"""{tmpdirname}/t5_test.onnx""" , export_params=__UpperCamelCase , opset_version=9 , input_names=["""input_ids""", """decoder_input_ids"""] , ) @unittest.skipIf(torch_device == """cpu""" , """Cant do half precision""" ) def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model_fpaa_forward(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = ["""encoder_attentions""", """decoder_attentions""", """cross_attentions"""] _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = config_and_inputs[0] _UpperCAmelCase = UMTaForConditionalGeneration(__UpperCamelCase ).eval() model.to(__UpperCamelCase ) _UpperCAmelCase = { """head_mask""": torch.zeros(config.num_layers , config.num_heads , device=__UpperCamelCase ), """decoder_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), """cross_attn_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), } for attn_name, (name, mask) in zip(__UpperCamelCase , head_masking.items() ): _UpperCAmelCase = {name: mask} # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified if name == "head_mask": _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ) _UpperCAmelCase = model.generate( config_and_inputs[1]["""input_ids"""] , num_beams=1 , max_length=3 , output_attentions=__UpperCamelCase , return_dict_in_generate=__UpperCamelCase , **__UpperCamelCase , ) # We check the state of decoder_attentions and cross_attentions just from the last step _UpperCAmelCase = out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1] self.assertEqual(sum([w.sum().item() for w in attn_weights] ) , 0.0 ) @unittest.skip("""Does not work on the tiny model as we keep hitting edge cases.""" ) def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' pass @require_torch @require_sentencepiece @require_tokenizers class a_ ( unittest.TestCase ): @slow @unittest.skip( """Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged""" ) def _snake_case ( self : Optional[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = UMTaForConditionalGeneration.from_pretrained("""google/umt5-small""" , return_dict=__UpperCamelCase ).to(__UpperCamelCase ) _UpperCAmelCase = AutoTokenizer.from_pretrained("""google/umt5-small""" , use_fast=__UpperCamelCase , legacy=__UpperCamelCase ) _UpperCAmelCase = [ """Bonjour monsieur <extra_id_0> bien <extra_id_1>.""", """No se como puedo <extra_id_0>.""", """This is the reason why we <extra_id_0> them.""", """The <extra_id_0> walks in <extra_id_1>, seats""", """A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""pt""" , padding=__UpperCamelCase ).input_ids # fmt: off _UpperCAmelCase = torch.tensor( [ [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0], [ 5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1], ] ) # fmt: on torch.testing.assert_allclose(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model.generate(input_ids.to(__UpperCamelCase ) ) _UpperCAmelCase = [ """<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>""", """<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", ] _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase ) self.assertEqual(__UpperCamelCase , __UpperCamelCase )
19
1
"""simple docstring""" from __future__ import annotations def _UpperCamelCase ( _A ) -> None: """simple docstring""" create_state_space_tree(_A , [] , 0 , [0 for i in range(len(_A ) )] ) def _UpperCamelCase ( _A , _A , _A , _A , ) -> None: """simple docstring""" if index == len(_A ): print(_A ) return for i in range(len(_A ) ): if not index_used[i]: current_sequence.append(sequence[i] ) _UpperCAmelCase = True create_state_space_tree(_A , _A , index + 1 , _A ) current_sequence.pop() _UpperCAmelCase = False a : list[int | str] = [3, 1, 2, 4] generate_all_permutations(sequence) a : list[int | str] = ["A", "B", "C"] generate_all_permutations(sequence_a)
19
"""simple docstring""" import copy import os import tempfile from unittest import TestCase from unittest.mock import patch import numpy as np import pyarrow as pa import pyarrow.parquet as pq import pytest from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence from datasets.features import ArrayaD, ClassLabel, Features, Image, Value from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects from datasets.keyhash import DuplicatedKeysError, InvalidKeyError from .utils import require_pil class a_ ( _UpperCAmelCase ): def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : Any ) ->List[str]: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) , type=pa.intaa() ) def _snake_case ( self : Optional[int] ) ->Tuple: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""bool""" ) , type=Value("""int64""" ) ) ) def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : str ) ->Dict: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=Value("""int64""" ) ) ) def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : List[str] ) ->Any: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=Value("""int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) def _snake_case ( self : List[Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=ArrayaD((1, 3) , """int64""" ) ) ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : Optional[int] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) @require_pil def _snake_case ( self : str ) ->Optional[Any]: '''simple docstring''' import PIL.Image _UpperCAmelCase = PIL.Image.fromarray(np.arange(10 , dtype=np.uinta ).reshape(2 , 5 ) ) with patch( """datasets.arrow_writer.cast_to_python_objects""" , side_effect=__UpperCamelCase ) as mock_cast_to_python_objects: _UpperCAmelCase = pa.array(TypedSequence([{"""path""": None, """bytes""": b"""image_bytes"""}, pil_image] , type=Image() ) ) _UpperCAmelCase ,_UpperCAmelCase = mock_cast_to_python_objects.call_args_list[-1] self.assertIn("""optimize_list_casting""" , __UpperCamelCase ) self.assertFalse(kwargs["""optimize_list_casting"""] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferReader(_A ) if isinstance(_A , pa.Buffer ) else pa.memory_map(_A ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() assert len(pa_table.to_batches() ) == expected_num_chunks assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} del pa_table @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} ) with ArrowWriter(stream=_A , features=_A ) as writer: writer.write({"""labels""": 0} ) writer.write({"""labels""": 1} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == features.arrow_schema assert writer._schema.metadata == features.arrow_schema.metadata _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() _UpperCAmelCase = pa_table.schema assert pa_table.num_rows == 2 assert schema == features.arrow_schema assert schema.metadata == features.arrow_schema.metadata assert features == Features.from_arrow_schema(_A ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=[1, 2] ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1_0 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=1_0 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=2 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) writer.write_batch({"""col_1""": [], """col_2""": []} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) ) writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> str: """simple docstring""" with tempfile.TemporaryDirectory() as tmp_dir: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} _UpperCAmelCase = os.path.join(_A , """test.arrow""" ) with ArrowWriter(path=_A , schema=pa.schema(_A ) ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(_A , 1 ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" if pa.types.is_list(_A ): return get_base_dtype(arr_type.value_type ) else: return arr_type def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" if isinstance(lst[0] , _A ): change_first_primitive_element_in_list(lst[0] , _A ) else: _UpperCAmelCase = value @pytest.mark.parametrize("""optimized_int_type, expected_dtype""" , [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.array(TypedSequence(_A , optimized_int_type=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype @pytest.mark.parametrize( """col, expected_dtype""" , [ ("""attention_mask""", pa.inta()), ("""special_tokens_mask""", pa.inta()), ("""token_type_ids""", pa.inta()), ("""input_ids""", pa.intaa()), ("""other""", pa.intaa()), ] , ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> str: """simple docstring""" _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype # not in range if col != "other": # avoids errors due to in-place modifications _UpperCAmelCase = copy.deepcopy(_A ) _UpperCAmelCase = np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1 change_first_primitive_element_in_list(_A , _A ) _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == pa.intaa() @pytest.mark.parametrize("""raise_exception""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = str(tmp_path / """dataset-train.arrow""" ) try: with ArrowWriter(path=_A ) as writer: if raise_exception: raise pa.lib.ArrowInvalid() else: writer.stream.close() except pa.lib.ArrowInvalid: pass finally: assert writer.stream.closed def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = """mock://dataset-train.arrow""" with ArrowWriter(path=_A , storage_options=mockfs.storage_options ) as writer: assert isinstance(writer._fs , type(_A ) ) assert writer._fs.storage_options == mockfs.storage_options writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert mockfs.exists(_A ) def _UpperCamelCase ( ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter(stream=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} @require_pil @pytest.mark.parametrize("""embed_local_files""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" import PIL.Image _UpperCAmelCase = str(tmp_path / """test_image_rgb.jpg""" ) PIL.Image.fromarray(np.zeros((5, 5) , dtype=np.uinta ) ).save(_A , format="""png""" ) _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter( stream=_A , features=Features({"""image""": Image()} ) , embed_local_files=_A ) as writer: writer.write({"""image""": image_path} ) writer.finalize() _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) _UpperCAmelCase = pa_table.to_pydict() if embed_local_files: assert isinstance(out["""image"""][0]["""path"""] , _A ) with open(_A , """rb""" ) as f: assert out["image"][0]["bytes"] == f.read() else: assert out["image"][0]["path"] == image_path assert out["image"][0]["bytes"] is None def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = pa.schema([pa.field("""col_1""" , pa.string() , nullable=_A )] ) _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter(stream=_A ) as writer: writer._build_writer(inferred_schema=_A ) assert writer._schema == pa.schema([pa.field("""col_1""" , pa.string() )] )
19
1
"""simple docstring""" from __future__ import annotations from functools import lru_cache from math import ceil a : str = 1_0_0 a : Any = set(range(3, NUM_PRIMES, 2)) primes.add(2) a : int for prime in range(3, ceil(NUM_PRIMES**0.5), 2): if prime not in primes: continue primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime))) @lru_cache(maxsize=1_0_0 ) def _UpperCamelCase ( _A ) -> set[int]: """simple docstring""" if number_to_partition < 0: return set() elif number_to_partition == 0: return {1} _UpperCAmelCase = set() _UpperCAmelCase = 42 _UpperCAmelCase = 42 for prime in primes: if prime > number_to_partition: continue for sub in partition(number_to_partition - prime ): ret.add(sub * prime ) return ret def _UpperCamelCase ( _A = 5_0_0_0 ) -> int | None: """simple docstring""" for number_to_partition in range(1 , _A ): if len(partition(_A ) ) > number_unique_partitions: return number_to_partition return None if __name__ == "__main__": print(F"{solution() = }")
19
"""simple docstring""" # Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING, Dict, Optional import numpy as np import pyarrow as pa from .. import config from ..utils.logging import get_logger from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import jax import jaxlib a : List[Any] = get_logger() a : Optional[dict] = None class a_ ( TensorFormatter[Mapping, 'jax.Array', Mapping] ): def __init__( self : int , __UpperCamelCase : List[str]=None , __UpperCamelCase : Optional[int]=None , **__UpperCamelCase : int ) ->Tuple: '''simple docstring''' super().__init__(features=__UpperCamelCase ) import jax from jaxlib.xla_client import Device if isinstance(__UpperCamelCase , __UpperCamelCase ): raise ValueError( f"""Expected {device} to be a `str` not {type(__UpperCamelCase )}, as `jaxlib.xla_extension.Device` """ """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """ """the device with `str()` to get its string identifier that will be internally mapped """ """to the actual `jaxlib.xla_extension.Device`.""" ) _UpperCAmelCase = device if isinstance(__UpperCamelCase , __UpperCamelCase ) else str(jax.devices()[0] ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() if self.device not in list(DEVICE_MAPPING.keys() ): logger.warning( f"""Device with string identifier {self.device} not listed among the available """ f"""devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default """ f"""device: {str(jax.devices()[0] )}.""" ) _UpperCAmelCase = str(jax.devices()[0] ) _UpperCAmelCase = jnp_array_kwargs @staticmethod def _snake_case ( ) ->Dict[str, "jaxlib.xla_extension.Device"]: '''simple docstring''' import jax return {str(__UpperCamelCase ): device for device in jax.devices()} def _snake_case ( self : Dict , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , __UpperCamelCase ) and column: if all( isinstance(__UpperCamelCase , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return jnp.stack(__UpperCamelCase , axis=0 ) return column def _snake_case ( self : List[str] , __UpperCamelCase : Any ) ->Optional[int]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , (str, bytes, type(__UpperCamelCase )) ): return value elif isinstance(__UpperCamelCase , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() _UpperCAmelCase = {} if isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): # the default int precision depends on the jax config # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision if jax.config.jax_enable_xaa: _UpperCAmelCase = {"""dtype""": jnp.intaa} else: _UpperCAmelCase = {"""dtype""": jnp.intaa} elif isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): _UpperCAmelCase = {"""dtype""": jnp.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(__UpperCamelCase , PIL.Image.Image ): _UpperCAmelCase = np.asarray(__UpperCamelCase ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() with jax.default_device(DEVICE_MAPPING[self.device] ): # calling jnp.array on a np.ndarray does copy the data # see https://github.com/google/jax/issues/4486 return jnp.array(__UpperCamelCase , **{**default_dtype, **self.jnp_array_kwargs} ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->Any: '''simple docstring''' import jax # support for torch, tf, jax etc. if config.TORCH_AVAILABLE and "torch" in sys.modules: import torch if isinstance(__UpperCamelCase , torch.Tensor ): return self._tensorize(data_struct.detach().cpu().numpy()[()] ) if hasattr(__UpperCamelCase , """__array__""" ) and not isinstance(__UpperCamelCase , jax.Array ): _UpperCAmelCase = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(__UpperCamelCase , np.ndarray ): if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) elif isinstance(__UpperCamelCase , (list, tuple) ): return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) return self._tensorize(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : dict ) ->int: '''simple docstring''' return map_nested(self._recursive_tensorize , __UpperCamelCase , map_list=__UpperCamelCase ) def _snake_case ( self : Dict , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_row(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_row(__UpperCamelCase ) return self.recursive_tensorize(__UpperCamelCase ) def _snake_case ( self : Optional[int] , __UpperCamelCase : pa.Table ) ->"jax.Array": '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_column(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_column(__UpperCamelCase , pa_table.column_names[0] ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) _UpperCAmelCase = self._consolidate(__UpperCamelCase ) return column def _snake_case ( self : Optional[Any] , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_batch(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_batch(__UpperCamelCase ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) for column_name in batch: _UpperCAmelCase = self._consolidate(batch[column_name] ) return batch
19
1
"""simple docstring""" import hashlib import unittest from typing import Dict import numpy as np from transformers import ( MODEL_FOR_MASK_GENERATION_MAPPING, TF_MODEL_FOR_MASK_GENERATION_MAPPING, is_vision_available, pipeline, ) from transformers.pipelines import MaskGenerationPipeline from transformers.testing_utils import ( is_pipeline_test, nested_simplify, require_tf, require_torch, require_vision, slow, ) if is_vision_available(): from PIL import Image else: class a_ : @staticmethod def _snake_case ( *__UpperCamelCase : Any , **__UpperCamelCase : Any ) ->str: '''simple docstring''' pass def _UpperCamelCase ( _A ) -> str: """simple docstring""" _UpperCAmelCase = hashlib.mda(image.tobytes() ) return m.hexdigest()[:1_0] def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = np.array(_A ) _UpperCAmelCase = npimg.shape return {"hash": hashimage(_A ), "shape": shape} @is_pipeline_test @require_vision @require_torch class a_ ( unittest.TestCase ): a : List[Any] = dict( (list(MODEL_FOR_MASK_GENERATION_MAPPING.items() ) if MODEL_FOR_MASK_GENERATION_MAPPING else []) ) a : List[Any] = dict( (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items() ) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else []) ) def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : Dict , __UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = MaskGenerationPipeline(model=__UpperCamelCase , image_processor=__UpperCamelCase ) return image_segmenter, [ "./tests/fixtures/tests_samples/COCO/000000039769.png", "./tests/fixtures/tests_samples/COCO/000000039769.png", ] def _snake_case ( self : Tuple , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] ) ->Dict: '''simple docstring''' pass @require_tf @unittest.skip("""Image segmentation not implemented in TF""" ) def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' pass @slow @require_torch def _snake_case ( self : Optional[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = pipeline("""mask-generation""" , model="""facebook/sam-vit-huge""" ) _UpperCAmelCase = image_segmenter("""http://images.cocodataset.org/val2017/000000039769.jpg""" , points_per_batch=2_56 ) # Shortening by hashing _UpperCAmelCase = [] for i, o in enumerate(outputs["""masks"""] ): new_outupt += [{"mask": mask_to_test_readable(__UpperCamelCase ), "scores": outputs["scores"][i]}] # fmt: off self.assertEqual( nested_simplify(__UpperCamelCase , decimals=4 ) , [ {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0_4_4_4}, {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.0_2_1}, {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0_1_6_7}, {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0_1_3_2}, {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0_0_5_3}, {"""mask""": {"""hash""": """e2d0b7a0b7""", """shape""": (4_80, 6_40)}, """scores""": 0.9_9_6_7}, {"""mask""": {"""hash""": """453c7844bd""", """shape""": (4_80, 6_40)}, """scores""": 0.9_9_3}, {"""mask""": {"""hash""": """3d44f2926d""", """shape""": (4_80, 6_40)}, """scores""": 0.9_9_0_9}, {"""mask""": {"""hash""": """64033ddc3f""", """shape""": (4_80, 6_40)}, """scores""": 0.9_8_7_9}, {"""mask""": {"""hash""": """801064ff79""", """shape""": (4_80, 6_40)}, """scores""": 0.9_8_3_4}, {"""mask""": {"""hash""": """6172f276ef""", """shape""": (4_80, 6_40)}, """scores""": 0.9_7_1_6}, {"""mask""": {"""hash""": """b49e60e084""", """shape""": (4_80, 6_40)}, """scores""": 0.9_6_1_2}, {"""mask""": {"""hash""": """a811e775fd""", """shape""": (4_80, 6_40)}, """scores""": 0.9_5_9_9}, {"""mask""": {"""hash""": """a6a8ebcf4b""", """shape""": (4_80, 6_40)}, """scores""": 0.9_5_5_2}, {"""mask""": {"""hash""": """9d8257e080""", """shape""": (4_80, 6_40)}, """scores""": 0.9_5_3_2}, {"""mask""": {"""hash""": """32de6454a8""", """shape""": (4_80, 6_40)}, """scores""": 0.9_5_1_6}, {"""mask""": {"""hash""": """af3d4af2c8""", """shape""": (4_80, 6_40)}, """scores""": 0.9_4_9_9}, {"""mask""": {"""hash""": """3c6db475fb""", """shape""": (4_80, 6_40)}, """scores""": 0.9_4_8_3}, {"""mask""": {"""hash""": """c290813fb9""", """shape""": (4_80, 6_40)}, """scores""": 0.9_4_6_4}, {"""mask""": {"""hash""": """b6f0b8f606""", """shape""": (4_80, 6_40)}, """scores""": 0.9_4_3}, {"""mask""": {"""hash""": """92ce16bfdf""", """shape""": (4_80, 6_40)}, """scores""": 0.9_4_3}, {"""mask""": {"""hash""": """c749b25868""", """shape""": (4_80, 6_40)}, """scores""": 0.9_4_0_8}, {"""mask""": {"""hash""": """efb6cab859""", """shape""": (4_80, 6_40)}, """scores""": 0.9_3_3_5}, {"""mask""": {"""hash""": """1ff2eafb30""", """shape""": (4_80, 6_40)}, """scores""": 0.9_3_2_6}, {"""mask""": {"""hash""": """788b798e24""", """shape""": (4_80, 6_40)}, """scores""": 0.9_2_6_2}, {"""mask""": {"""hash""": """abea804f0e""", """shape""": (4_80, 6_40)}, """scores""": 0.8_9_9_9}, {"""mask""": {"""hash""": """7b9e8ddb73""", """shape""": (4_80, 6_40)}, """scores""": 0.8_9_8_6}, {"""mask""": {"""hash""": """cd24047c8a""", """shape""": (4_80, 6_40)}, """scores""": 0.8_9_8_4}, {"""mask""": {"""hash""": """6943e6bcbd""", """shape""": (4_80, 6_40)}, """scores""": 0.8_8_7_3}, {"""mask""": {"""hash""": """b5f47c9191""", """shape""": (4_80, 6_40)}, """scores""": 0.8_8_7_1} ] , ) # fmt: on @require_torch @slow def _snake_case ( self : Optional[int] ) ->Any: '''simple docstring''' _UpperCAmelCase = """facebook/sam-vit-huge""" _UpperCAmelCase = pipeline("""mask-generation""" , model=__UpperCamelCase ) _UpperCAmelCase = image_segmenter( """http://images.cocodataset.org/val2017/000000039769.jpg""" , pred_iou_thresh=1 , points_per_batch=2_56 ) # Shortening by hashing _UpperCAmelCase = [] for i, o in enumerate(outputs["""masks"""] ): new_outupt += [{"mask": mask_to_test_readable(__UpperCamelCase ), "scores": outputs["scores"][i]}] self.assertEqual( nested_simplify(__UpperCamelCase , decimals=4 ) , [ {"""mask""": {"""hash""": """115ad19f5f""", """shape""": (4_80, 6_40)}, """scores""": 1.0_4_4_4}, {"""mask""": {"""hash""": """6affa964c6""", """shape""": (4_80, 6_40)}, """scores""": 1.0_2_1_0}, {"""mask""": {"""hash""": """dfe28a0388""", """shape""": (4_80, 6_40)}, """scores""": 1.0_1_6_7}, {"""mask""": {"""hash""": """c0a5f4a318""", """shape""": (4_80, 6_40)}, """scores""": 1.0_1_3_2}, {"""mask""": {"""hash""": """fe8065c197""", """shape""": (4_80, 6_40)}, """scores""": 1.0_0_5_3}, ] , )
19
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a : Tuple = { '''configuration_pegasus_x''': ['''PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PegasusXConfig'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : List[str] = [ '''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 : Dict = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
1
"""simple docstring""" import math import flax.linen as nn import jax.numpy as jnp def _UpperCamelCase ( _A , _A , _A = 1 , _A = 1 , _A = 1.0e4 , _A = False , _A = 1.0 , ) -> jnp.ndarray: """simple docstring""" assert timesteps.ndim == 1, "Timesteps should be a 1d-array" assert embedding_dim % 2 == 0, F"""Embedding dimension {embedding_dim} should be even""" _UpperCAmelCase = float(embedding_dim // 2 ) _UpperCAmelCase = math.log(max_timescale / min_timescale ) / (num_timescales - freq_shift) _UpperCAmelCase = min_timescale * jnp.exp(jnp.arange(_A , dtype=jnp.floataa ) * -log_timescale_increment ) _UpperCAmelCase = jnp.expand_dims(_A , 1 ) * jnp.expand_dims(_A , 0 ) # scale embeddings _UpperCAmelCase = scale * emb if flip_sin_to_cos: _UpperCAmelCase = jnp.concatenate([jnp.cos(_A ), jnp.sin(_A )] , axis=1 ) else: _UpperCAmelCase = jnp.concatenate([jnp.sin(_A ), jnp.cos(_A )] , axis=1 ) _UpperCAmelCase = jnp.reshape(_A , [jnp.shape(_A )[0], embedding_dim] ) return signal class a_ ( nn.Module ): a : int = 32 a : jnp.dtype = jnp.floataa @nn.compact def __call__( self : Optional[Any] , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = nn.Dense(self.time_embed_dim , dtype=self.dtype , name="""linear_1""" )(__UpperCamelCase ) _UpperCAmelCase = nn.silu(__UpperCamelCase ) _UpperCAmelCase = nn.Dense(self.time_embed_dim , dtype=self.dtype , name="""linear_2""" )(__UpperCamelCase ) return temb class a_ ( nn.Module ): a : int = 32 a : bool = False a : float = 1 @nn.compact def __call__( self : Dict , __UpperCamelCase : Union[str, Any] ) ->List[str]: '''simple docstring''' return get_sinusoidal_embeddings( __UpperCamelCase , embedding_dim=self.dim , flip_sin_to_cos=self.flip_sin_to_cos , freq_shift=self.freq_shift )
19
"""simple docstring""" import collections import json import math import os import re import time from fnmatch import fnmatch from typing import Dict import requests from slack_sdk import WebClient a : int = WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN''']) def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = test_results.split(""" """ ) _UpperCAmelCase = 0 _UpperCAmelCase = 0 # When the output is short enough, the output is surrounded by = signs: "== OUTPUT ==" # When it is too long, those signs are not present. _UpperCAmelCase = expressions[-2] if """=""" in expressions[-1] else expressions[-1] for i, expression in enumerate(_A ): if "failed" in expression: failed += int(expressions[i - 1] ) if "passed" in expression: success += int(expressions[i - 1] ) return failed, success, time_spent def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = {} _UpperCAmelCase = None _UpperCAmelCase = False for line in failures_short_lines.split("""\n""" ): if re.search(R"""_ \[doctest\]""" , _A ): _UpperCAmelCase = True _UpperCAmelCase = line.split(""" """ )[2] elif in_error and not line.split(""" """ )[0].isdigit(): _UpperCAmelCase = line _UpperCAmelCase = False return failures class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = title _UpperCAmelCase = doc_test_results["""time_spent"""].split(""",""" )[0] _UpperCAmelCase = doc_test_results["""success"""] _UpperCAmelCase = doc_test_results["""failures"""] _UpperCAmelCase = self.n_success + self.n_failures # Failures and success of the modeling tests _UpperCAmelCase = doc_test_results @property def _snake_case ( self : int ) ->str: '''simple docstring''' _UpperCAmelCase = [self._time_spent] _UpperCAmelCase = 0 for time in time_spent: _UpperCAmelCase = time.split(""":""" ) # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute. if len(__UpperCamelCase ) == 1: _UpperCAmelCase = [0, 0, time_parts[0]] _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = int(time_parts[0] ), int(time_parts[1] ), float(time_parts[2] ) total_secs += hours * 36_00 + minutes * 60 + seconds _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60 return f"""{int(__UpperCamelCase )}h{int(__UpperCamelCase )}m{int(__UpperCamelCase )}s""" @property def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' return {"type": "header", "text": {"type": "plain_text", "text": self.title}} @property def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": f"""🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.""", "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": ( f"""There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in""" f""" {self.time}.""" ), "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = 40 _UpperCAmelCase = {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase , __UpperCamelCase )} _UpperCAmelCase = """""" for category, failures in category_failures.items(): if len(__UpperCamelCase ) == 0: continue if report != "": report += "\n\n" report += f"""*{category} failures*:""".ljust(line_length // 2 ).rjust(line_length // 2 ) + "\n" report += "`" report += "`\n`".join(__UpperCamelCase ) report += "`" return { "type": "section", "text": { "type": "mrkdwn", "text": f"""The following examples had failures:\n\n\n{report}\n""", }, } @property def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = [self.header] if self.n_failures > 0: blocks.append(self.failures ) if self.n_failures > 0: blocks.extend([self.category_failures] ) if self.n_failures == 0: blocks.append(self.no_failures ) return json.dumps(__UpperCamelCase ) @staticmethod def _snake_case ( ) ->Any: '''simple docstring''' _UpperCAmelCase = [ { """type""": """section""", """text""": { """type""": """plain_text""", """text""": """There was an issue running the tests.""", }, """accessory""": { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """Check Action results""", """emoji""": True}, """url""": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } ] print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(__UpperCamelCase )} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text="""There was an issue running the tests.""" , blocks=__UpperCamelCase , ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(self.payload )} ) ) _UpperCAmelCase = f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed.""" _UpperCAmelCase = client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , blocks=self.payload , text=__UpperCamelCase , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Any , __UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = """""" for key, value in failures.items(): _UpperCAmelCase = value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase ) > 2_50 else value failures_text += f"""*{key}*\n_{value}_\n\n""" _UpperCAmelCase = job_name _UpperCAmelCase = {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}} if job_link is not None: _UpperCAmelCase = { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """GitHub Action job""", """emoji""": True}, """url""": job_link, } return [ {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}}, content, {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}}, ] def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' if self.thread_ts is None: raise ValueError("""Can only post reply if a post has been made.""" ) _UpperCAmelCase = self.doc_test_results.pop("""job_link""" ) self.doc_test_results.pop("""failures""" ) self.doc_test_results.pop("""success""" ) self.doc_test_results.pop("""time_spent""" ) _UpperCAmelCase = sorted(self.doc_test_results.items() , key=lambda __UpperCamelCase : t[0] ) for job, job_result in sorted_dict: if len(job_result["""failures"""] ): _UpperCAmelCase = f"""*Num failures* :{len(job_result["failed"] )} \n""" _UpperCAmelCase = job_result["""failures"""] _UpperCAmelCase = self.get_reply_blocks(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , text=__UpperCamelCase ) print("""Sending the following reply""" ) print(json.dumps({"""blocks""": blocks} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text=f"""Results for {job}""" , blocks=__UpperCamelCase , thread_ts=self.thread_ts["""ts"""] , ) time.sleep(1 ) def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = os.environ["""GITHUB_RUN_ID"""] _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A ).json() _UpperCAmelCase = {} try: jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" ).json() jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return jobs except Exception as e: print("""Unknown error, could not fetch links.""" , _A ) return {} def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = {} if os.path.exists(_A ): _UpperCAmelCase = os.listdir(_A ) for file in files: try: with open(os.path.join(_A , _A ) , encoding="""utf-8""" ) as f: _UpperCAmelCase = f.read() except UnicodeDecodeError as e: raise ValueError(F"""Could not open {os.path.join(_A , _A )}.""" ) from e return _artifact def _UpperCamelCase ( ) -> int: """simple docstring""" class a_ : def __init__( self : List[Any] , __UpperCamelCase : str ) ->Tuple: '''simple docstring''' _UpperCAmelCase = name _UpperCAmelCase = [] def __str__( self : int ) ->Optional[Any]: '''simple docstring''' return self.name def _snake_case ( self : Dict , __UpperCamelCase : str ) ->int: '''simple docstring''' self.paths.append({"""name""": self.name, """path""": path} ) _UpperCAmelCase = {} _UpperCAmelCase = filter(os.path.isdir , os.listdir() ) for directory in directories: _UpperCAmelCase = directory if artifact_name not in _available_artifacts: _UpperCAmelCase = Artifact(_A ) _available_artifacts[artifact_name].add_path(_A ) return _available_artifacts if __name__ == "__main__": a : Dict = get_job_links() a : Dict = retrieve_available_artifacts() a : Optional[int] = collections.OrderedDict( [ ('''*.py''', '''API Examples'''), ('''*.md''', '''MD Examples'''), ] ) # This dict will contain all the information relative to each doc test category: # - failed: list of failed tests # - failures: dict in the format 'test': 'error_message' a : Dict = { v: { '''failed''': [], '''failures''': {}, } for v in docs.values() } # Link to the GitHub Action job a : int = github_actions_job_links.get('''run_doctests''') a : Tuple = available_artifacts['''doc_tests_gpu_test_reports'''].paths[0] a : Optional[Any] = retrieve_artifact(artifact_path['''name''']) if "stats" in artifact: a , a , a : str = handle_test_results(artifact['''stats''']) a : Tuple = failed a : int = success a : Any = time_spent[1:-1] + ''', ''' a : Dict = extract_first_line_failure(artifact['''failures_short''']) for line in artifact["summary_short"].split('''\n'''): if re.search('''FAILED''', line): a : List[Any] = line.replace('''FAILED ''', '''''') a : Tuple = line.split()[0].replace('''\n''', '''''') if "::" in line: a , a : Union[str, Any] = line.split('''::''') else: a , a : Optional[Any] = line, line for file_regex in docs.keys(): if fnmatch(file_path, file_regex): a : List[Any] = docs[file_regex] doc_test_results[category]["failed"].append(test) a : Optional[Any] = all_failures[test] if test in all_failures else '''N/A''' a : List[str] = failure break a : List[Any] = Message('''🤗 Results of the doc tests.''', doc_test_results) message.post() message.post_reply()
19
1
"""simple docstring""" a : Union[str, Any] = 8.3_14_45_98 def _UpperCamelCase ( _A , _A ) -> float: """simple docstring""" if temperature < 0: raise Exception("""Temperature cannot be less than 0 K""" ) if molar_mass <= 0: raise Exception("""Molar mass cannot be less than or equal to 0 kg/mol""" ) else: return (3 * UNIVERSAL_GAS_CONSTANT * temperature / molar_mass) ** 0.5 if __name__ == "__main__": import doctest # run doctest doctest.testmod() # example a : Union[str, Any] = 3_0_0 a : Dict = 2_8 a : Optional[Any] = rms_speed_of_molecule(temperature, molar_mass) print(F"Vrms of Nitrogen gas at 300 K is {vrms} m/s")
19
"""simple docstring""" import asyncio import os import re import sys import tempfile import unittest from contextlib import contextmanager from copy import deepcopy from distutils.util import strtobool from enum import Enum from importlib.util import find_spec from pathlib import Path from unittest.mock import patch import pyarrow as pa import pytest import requests from packaging import version from datasets import config if config.PY_VERSION < version.parse('''3.8'''): import importlib_metadata else: import importlib.metadata as importlib_metadata def _UpperCamelCase ( _A , _A=False ) -> str: """simple docstring""" try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_A ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"""If set, {key} must be yes or no.""" ) return _value a : Union[str, Any] = parse_flag_from_env('''RUN_SLOW''', default=False) a : Tuple = parse_flag_from_env('''RUN_REMOTE''', default=False) a : Union[str, Any] = parse_flag_from_env('''RUN_LOCAL''', default=True) a : int = parse_flag_from_env('''RUN_PACKAGED''', default=True) # Compression a : List[Any] = pytest.mark.skipif(not config.LZ4_AVAILABLE, reason='''test requires lz4''') a : List[Any] = pytest.mark.skipif(not config.PY7ZR_AVAILABLE, reason='''test requires py7zr''') a : Optional[Any] = pytest.mark.skipif(not config.ZSTANDARD_AVAILABLE, reason='''test requires zstandard''') # Audio a : int = pytest.mark.skipif( # On Windows and OS X, soundfile installs sndfile find_spec('''soundfile''') is None or version.parse(importlib_metadata.version('''soundfile''')) < version.parse('''0.12.0'''), reason='''test requires sndfile>=0.12.1: \'pip install \"soundfile>=0.12.1\"\'; ''', ) # Beam a : Tuple = pytest.mark.skipif( not config.BEAM_AVAILABLE or config.DILL_VERSION >= version.parse('''0.3.2'''), reason='''test requires apache-beam and a compatible dill version''', ) # Dill-cloudpickle compatibility a : Any = pytest.mark.skipif( config.DILL_VERSION <= version.parse('''0.3.2'''), reason='''test requires dill>0.3.2 for cloudpickle compatibility''', ) # Windows a : int = pytest.mark.skipif( sys.platform == '''win32''', reason='''test should not be run on Windows''', ) def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import faiss # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires faiss""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" try: import regex # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires regex""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" try: import elasticsearch # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires elasticsearch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" try: import sqlalchemy # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires sqlalchemy""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" if not config.TORCH_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires PyTorch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" if not config.TF_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires TensorFlow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" if not config.JAX_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires JAX""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not config.PIL_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires Pillow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import transformers # noqa F401 except ImportError: return unittest.skip("""test requires transformers""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import tiktoken # noqa F401 except ImportError: return unittest.skip("""test requires tiktoken""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import spacy # noqa F401 except ImportError: return unittest.skip("""test requires spacy""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> int: """simple docstring""" def _require_spacy_model(_A ): try: import spacy # noqa F401 spacy.load(_A ) except ImportError: return unittest.skip("""test requires spacy""" )(_A ) except OSError: return unittest.skip("""test requires spacy model '{}'""".format(_A ) )(_A ) else: return test_case return _require_spacy_model def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import pyspark # noqa F401 except ImportError: return unittest.skip("""test requires pyspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import joblibspark # noqa F401 except ImportError: return unittest.skip("""test requires joblibspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_slow_tests or _run_slow_tests == 0: _UpperCAmelCase = unittest.skip("""test is slow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_local_tests or _run_local_tests == 0: _UpperCAmelCase = unittest.skip("""test is local""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" if not _run_packaged_tests or _run_packaged_tests == 0: _UpperCAmelCase = unittest.skip("""test is packaged""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not _run_remote_tests or _run_remote_tests == 0: _UpperCAmelCase = unittest.skip("""test requires remote""" )(_A ) return test_case def _UpperCamelCase ( *_A ) -> Dict: """simple docstring""" def decorate(cls ): for name, fn in cls.__dict__.items(): if callable(_A ) and name.startswith("""test""" ): for decorator in decorators: _UpperCAmelCase = decorator(_A ) setattr(cls , _A , _A ) return cls return decorate class a_ ( _UpperCAmelCase ): pass class a_ ( _UpperCAmelCase ): a : Any = 0 a : Optional[Any] = 1 a : int = 2 @contextmanager def _UpperCamelCase ( _A=OfflineSimulationMode.CONNECTION_FAILS , _A=1e-16 ) -> List[Any]: """simple docstring""" _UpperCAmelCase = requests.Session().request def timeout_request(_A , _A , _A , **_A ): # Change the url to an invalid url so that the connection hangs _UpperCAmelCase = """https://10.255.255.1""" if kwargs.get("""timeout""" ) is None: raise RequestWouldHangIndefinitelyError( F"""Tried a call to {url} in offline mode with no timeout set. Please set a timeout.""" ) _UpperCAmelCase = timeout try: return online_request(_A , _A , **_A ) except Exception as e: # The following changes in the error are just here to make the offline timeout error prettier _UpperCAmelCase = url _UpperCAmelCase = e.args[0] _UpperCAmelCase = (max_retry_error.args[0].replace("""10.255.255.1""" , F"""OfflineMock[{url}]""" ),) _UpperCAmelCase = (max_retry_error,) raise def raise_connection_error(_A , _A , **_A ): raise requests.ConnectionError("""Offline mode is enabled.""" , request=_A ) if mode is OfflineSimulationMode.CONNECTION_FAILS: with patch("""requests.Session.send""" , _A ): yield elif mode is OfflineSimulationMode.CONNECTION_TIMES_OUT: # inspired from https://stackoverflow.com/a/904609 with patch("""requests.Session.request""" , _A ): yield elif mode is OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1: with patch("""datasets.config.HF_DATASETS_OFFLINE""" , _A ): yield else: raise ValueError("""Please use a value from the OfflineSimulationMode enum.""" ) @contextmanager def _UpperCamelCase ( *_A , **_A ) -> str: """simple docstring""" _UpperCAmelCase = str(Path().resolve() ) with tempfile.TemporaryDirectory(*_A , **_A ) as tmp_dir: try: os.chdir(_A ) yield finally: os.chdir(_A ) @contextmanager def _UpperCamelCase ( ) -> Any: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory > 0, "Arrow memory didn't increase." @contextmanager def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory <= 0, "Arrow memory wasn't expected to increase." def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" return deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() == deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" import decorator from requests.exceptions import HTTPError def _wrapper(_A , *_A , **_A ): try: return func(*_A , **_A ) except HTTPError as err: if str(_A ).startswith("""500""" ) or str(_A ).startswith("""502""" ): pytest.xfail(str(_A ) ) raise err return decorator.decorator(_wrapper , _A ) class a_ : def __init__( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def _UpperCamelCase ( _A , _A ) -> Union[str, Any]: """simple docstring""" while True: _UpperCAmelCase = await stream.readline() if line: callback(_A ) else: break async def _UpperCamelCase ( _A , _A=None , _A=None , _A=None , _A=False , _A=False ) -> _RunOutput: """simple docstring""" if echo: print("""\nRunning: """ , """ """.join(_A ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_A , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_A , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_A , _A , _A , _A="" ): _UpperCAmelCase = line.decode("""utf-8""" ).rstrip() sink.append(_A ) if not quiet: print(_A , _A , file=_A ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ _read_stream(p.stdout , lambda _A : tee(_A , _A , sys.stdout , label="""stdout:""" ) ), _read_stream(p.stderr , lambda _A : tee(_A , _A , sys.stderr , label="""stderr:""" ) ), ] , timeout=_A , ) return _RunOutput(await p.wait() , _A , _A ) def _UpperCamelCase ( _A , _A=None , _A=None , _A=1_8_0 , _A=False , _A=True ) -> _RunOutput: """simple docstring""" _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_A , env=_A , stdin=_A , timeout=_A , quiet=_A , echo=_A ) ) _UpperCAmelCase = """ """.join(_A ) if result.returncode > 0: _UpperCAmelCase = """\n""".join(result.stderr ) raise RuntimeError( F"""'{cmd_str}' failed with returncode {result.returncode}\n\n""" F"""The combined stderr from workers follows:\n{stderr}""" ) # check that the subprocess actually did run and produced some output, should the test rely on # the remote side to do the testing if not result.stdout and not result.stderr: raise RuntimeError(F"""'{cmd_str}' produced no output.""" ) return result def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = os.environ.get("""PYTEST_XDIST_WORKER""" , """gw0""" ) _UpperCAmelCase = re.sub(R"""^gw""" , """""" , _A , 0 , re.M ) return int(_A ) def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = 2_9_5_0_0 _UpperCAmelCase = pytest_xdist_worker_id() return port + uniq_delta
19
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_tokenizers_available, is_torch_available, ) a : List[str] = { '''configuration_longformer''': [ '''LONGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LongformerConfig''', '''LongformerOnnxConfig''', ], '''tokenization_longformer''': ['''LongformerTokenizer'''], } try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Optional[Any] = ['''LongformerTokenizerFast'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : int = [ '''LONGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''LongformerForMaskedLM''', '''LongformerForMultipleChoice''', '''LongformerForQuestionAnswering''', '''LongformerForSequenceClassification''', '''LongformerForTokenClassification''', '''LongformerModel''', '''LongformerPreTrainedModel''', '''LongformerSelfAttention''', ] try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Tuple = [ '''TF_LONGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''', '''TFLongformerForMaskedLM''', '''TFLongformerForMultipleChoice''', '''TFLongformerForQuestionAnswering''', '''TFLongformerForSequenceClassification''', '''TFLongformerForTokenClassification''', '''TFLongformerModel''', '''TFLongformerPreTrainedModel''', '''TFLongformerSelfAttention''', ] if TYPE_CHECKING: from .configuration_longformer import ( LONGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, LongformerConfig, LongformerOnnxConfig, ) from .tokenization_longformer import LongformerTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_longformer_fast import LongformerTokenizerFast try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_longformer import ( LONGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, LongformerForMaskedLM, LongformerForMultipleChoice, LongformerForQuestionAnswering, LongformerForSequenceClassification, LongformerForTokenClassification, LongformerModel, LongformerPreTrainedModel, LongformerSelfAttention, ) try: if not is_tf_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .modeling_tf_longformer import ( TF_LONGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST, TFLongformerForMaskedLM, TFLongformerForMultipleChoice, TFLongformerForQuestionAnswering, TFLongformerForSequenceClassification, TFLongformerForTokenClassification, TFLongformerModel, TFLongformerPreTrainedModel, TFLongformerSelfAttention, ) else: import sys a : Tuple = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
"""simple docstring""" from pathlib import PurePosixPath from typing import Optional import fsspec from fsspec import AbstractFileSystem from huggingface_hub.hf_api import DatasetInfo from ..utils.file_utils import get_authentication_headers_for_url from ..utils.hub import hf_hub_url class a_ ( _UpperCAmelCase ): a : List[Any] = '' a : Union[str, Any] = 'hf-legacy' # "hf://"" is reserved for hffs def __init__( self : Tuple , __UpperCamelCase : Optional[DatasetInfo] = None , __UpperCamelCase : Optional[str] = None , **__UpperCamelCase : Any , ) ->Any: '''simple docstring''' super().__init__(self , **__UpperCamelCase ) _UpperCAmelCase = repo_info _UpperCAmelCase = token _UpperCAmelCase = None def _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' if self.dir_cache is None: _UpperCAmelCase = {} for hf_file in self.repo_info.siblings: # TODO(QL): add sizes _UpperCAmelCase = { """name""": hf_file.rfilename, """size""": None, """type""": """file""", } self.dir_cache.update( { str(__UpperCamelCase ): {"""name""": str(__UpperCamelCase ), """size""": None, """type""": """directory"""} for d in list(PurePosixPath(hf_file.rfilename ).parents )[:-1] } ) def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : str = "rb" , **__UpperCamelCase : Any , ) ->List[str]: '''simple docstring''' if not isinstance(self.repo_info , __UpperCamelCase ): raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}""" ) _UpperCAmelCase = hf_hub_url(self.repo_info.id , __UpperCamelCase , revision=self.repo_info.sha ) return fsspec.open( __UpperCamelCase , mode=__UpperCamelCase , headers=get_authentication_headers_for_url(__UpperCamelCase , use_auth_token=self.token ) , client_kwargs={"""trust_env""": True} , ).open() def _snake_case ( self : int , __UpperCamelCase : int , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' self._get_dirs() _UpperCAmelCase = self._strip_protocol(__UpperCamelCase ) if path in self.dir_cache: return self.dir_cache[path] else: raise FileNotFoundError(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple=False , **__UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' self._get_dirs() _UpperCAmelCase = PurePosixPath(path.strip("""/""" ) ) _UpperCAmelCase = {} for p, f in self.dir_cache.items(): _UpperCAmelCase = PurePosixPath(p.strip("""/""" ) ) _UpperCAmelCase = p.parent if root == path: _UpperCAmelCase = f _UpperCAmelCase = list(paths.values() ) if detail: return out else: return sorted(f["""name"""] for f in out )
19
1
"""simple docstring""" from typing import List, Optional, Tuple, Union import torch from ...utils import logging, randn_tensor from ..pipeline_utils import AudioPipelineOutput, DiffusionPipeline a : Optional[Any] = logging.get_logger(__name__) # pylint: disable=invalid-name class a_ ( _UpperCAmelCase ): def __init__( self : List[str] , __UpperCamelCase : int , __UpperCamelCase : int ) ->Optional[int]: '''simple docstring''' super().__init__() self.register_modules(unet=__UpperCamelCase , scheduler=__UpperCamelCase ) @torch.no_grad() def __call__( self : int , __UpperCamelCase : int = 1 , __UpperCamelCase : int = 1_00 , __UpperCamelCase : Optional[Union[torch.Generator, List[torch.Generator]]] = None , __UpperCamelCase : Optional[float] = None , __UpperCamelCase : bool = True , ) ->Union[AudioPipelineOutput, Tuple]: '''simple docstring''' if audio_length_in_s is None: _UpperCAmelCase = self.unet.config.sample_size / self.unet.config.sample_rate _UpperCAmelCase = audio_length_in_s * self.unet.config.sample_rate _UpperCAmelCase = 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}.""" ) _UpperCAmelCase = int(__UpperCamelCase ) if sample_size % down_scale_factor != 0: _UpperCAmelCase = ( (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.""" ) _UpperCAmelCase = int(__UpperCamelCase ) _UpperCAmelCase = next(iter(self.unet.parameters() ) ).dtype _UpperCAmelCase = (batch_size, self.unet.config.in_channels, sample_size) if isinstance(__UpperCamelCase , __UpperCamelCase ) and len(__UpperCamelCase ) != batch_size: raise ValueError( f"""You have passed a list of generators of length {len(__UpperCamelCase )}, but requested an effective batch""" f""" size of {batch_size}. Make sure the batch size matches the length of the generators.""" ) _UpperCAmelCase = randn_tensor(__UpperCamelCase , generator=__UpperCamelCase , device=self.device , dtype=__UpperCamelCase ) # set step values self.scheduler.set_timesteps(__UpperCamelCase , device=audio.device ) _UpperCAmelCase = self.scheduler.timesteps.to(__UpperCamelCase ) for t in self.progress_bar(self.scheduler.timesteps ): # 1. predict noise model_output _UpperCAmelCase = self.unet(__UpperCamelCase , __UpperCamelCase ).sample # 2. compute previous image: x_t -> t_t-1 _UpperCAmelCase = self.scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ).prev_sample _UpperCAmelCase = audio.clamp(-1 , 1 ).float().cpu().numpy() _UpperCAmelCase = audio[:, :, :original_sample_size] if not return_dict: return (audio,) return AudioPipelineOutput(audios=__UpperCamelCase )
19
"""simple docstring""" import itertools import os from collections import Counter, defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed import numpy as np import datasets from .execute import check_correctness a : Optional[Any] = '''\ @misc{chen2021evaluating, title={Evaluating Large Language Models Trained on Code}, author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \ and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \ and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \ and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \ and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \ and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \ and Mohammad Bavarian and Clemens Winter and Philippe Tillet \ and Felipe Petroski Such and Dave Cummings and Matthias Plappert \ and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \ and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \ and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \ and William Saunders and Christopher Hesse and Andrew N. Carr \ and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \ and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \ and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \ and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba}, year={2021}, eprint={2107.03374}, archivePrefix={arXiv}, primaryClass={cs.LG} } ''' a : List[str] = '''\ This metric implements the evaluation harness for the HumanEval problem solving dataset described in the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). ''' a : Any = ''' Calculates how good are predictions given some references, using certain scores Args: predictions: list of candidates to evaluate. Each candidates should be a list of strings with several code candidates to solve the problem. references: a list with a test for each prediction. Each test should evaluate the correctness of a code candidate. k: number of code candidates to consider in the evaluation (Default: [1, 10, 100]) num_workers: number of workers used to evaluate the canidate programs (Default: 4). timeout: Returns: pass_at_k: dict with pass rates for each k results: dict with granular results of each unittest Examples: >>> code_eval = datasets.load_metric("code_eval") >>> test_cases = ["assert add(2,3)==5"] >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]] >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2]) >>> print(pass_at_k) {\'pass@1\': 0.5, \'pass@2\': 1.0} ''' a : int = ''' ################################################################################ !!!WARNING!!! ################################################################################ The "code_eval" metric executes untrusted model-generated code in Python. Although it is highly unlikely that model-generated code will do something overtly malicious in response to this test suite, model-generated code may act destructively due to a lack of model capability or alignment. Users are strongly encouraged to sandbox this evaluation suite so that it does not perform destructive actions on their host or network. For more information on how OpenAI sandboxes its code, see the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). Once you have read this disclaimer and taken appropriate precautions, set the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this with: >>> import os >>> os.environ["HF_ALLOW_CODE_EVAL"] = "1" ################################################################################\ ''' a : List[Any] = '''The MIT License Copyright (c) OpenAI (https://openai.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a_ ( datasets.Metric ): def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' return datasets.MetricInfo( # This is the description that will appear on the metrics page. description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Sequence(datasets.Value("""string""" ) ), """references""": datasets.Value("""string""" ), } ) , homepage="""https://github.com/openai/human-eval""" , codebase_urls=["""https://github.com/openai/human-eval"""] , reference_urls=["""https://github.com/openai/human-eval"""] , license=_LICENSE , ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any]=[1, 10, 1_00] , __UpperCamelCase : Dict=4 , __UpperCamelCase : Tuple=3.0 ) ->Union[str, Any]: '''simple docstring''' if os.getenv("""HF_ALLOW_CODE_EVAL""" , 0 ) != "1": raise ValueError(_WARNING ) if os.name == "nt": raise NotImplementedError("""This metric is currently not supported on Windows.""" ) with ThreadPoolExecutor(max_workers=__UpperCamelCase ) as executor: _UpperCAmelCase = [] _UpperCAmelCase = Counter() _UpperCAmelCase = 0 _UpperCAmelCase = defaultdict(__UpperCamelCase ) for task_id, (candidates, test_case) in enumerate(zip(__UpperCamelCase , __UpperCamelCase ) ): for candidate in candidates: _UpperCAmelCase = candidate + """\n""" + test_case _UpperCAmelCase = (test_program, timeout, task_id, completion_id[task_id]) _UpperCAmelCase = executor.submit(__UpperCamelCase , *__UpperCamelCase ) futures.append(__UpperCamelCase ) completion_id[task_id] += 1 n_samples += 1 for future in as_completed(__UpperCamelCase ): _UpperCAmelCase = future.result() results[result["task_id"]].append((result["""completion_id"""], result) ) _UpperCAmelCase ,_UpperCAmelCase = [], [] for result in results.values(): result.sort() _UpperCAmelCase = [r[1]["""passed"""] for r in result] total.append(len(__UpperCamelCase ) ) correct.append(sum(__UpperCamelCase ) ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = k _UpperCAmelCase = {f"""pass@{k}""": estimate_pass_at_k(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ).mean() for k in ks if (total >= k).all()} return pass_at_k, results def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" def estimator(_A , _A , _A ) -> float: if n - c < k: return 1.0 return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1 , n + 1 ) ) if isinstance(_A , _A ): _UpperCAmelCase = itertools.repeat(_A , len(_A ) ) else: assert len(_A ) == len(_A ) _UpperCAmelCase = iter(_A ) return np.array([estimator(int(_A ) , int(_A ) , _A ) for n, c in zip(_A , _A )] )
19
1
"""simple docstring""" import os from huggingface_hub.constants import HUGGINGFACE_HUB_CACHE, hf_cache_home a : List[Any] = HUGGINGFACE_HUB_CACHE a : Optional[int] = '''config.json''' a : List[Any] = '''diffusion_pytorch_model.bin''' a : Union[str, Any] = '''diffusion_flax_model.msgpack''' a : Union[str, Any] = '''model.onnx''' a : Optional[int] = '''diffusion_pytorch_model.safetensors''' a : str = '''weights.pb''' a : Dict = '''https://huggingface.co''' a : Optional[Any] = default_cache_path a : Dict = '''diffusers_modules''' a : Optional[Any] = os.getenv('''HF_MODULES_CACHE''', os.path.join(hf_cache_home, '''modules''')) a : str = ['''fp16''', '''non-ema'''] a : Optional[Any] = '''.self_attn'''
19
"""simple docstring""" from collections.abc import Callable import numpy as np def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> np.array: """simple docstring""" _UpperCAmelCase = int(np.ceil((x_end - xa) / step_size ) ) _UpperCAmelCase = np.zeros((n + 1,) ) _UpperCAmelCase = ya _UpperCAmelCase = xa for k in range(_A ): _UpperCAmelCase = y[k] + step_size * ode_func(_A , y[k] ) _UpperCAmelCase = y[k] + ( (step_size / 2) * (ode_func(_A , y[k] ) + ode_func(x + step_size , _A )) ) x += step_size return y if __name__ == "__main__": import doctest doctest.testmod()
19
1
"""simple docstring""" from functools import lru_cache @lru_cache def _UpperCamelCase ( _A ) -> int: """simple docstring""" if num < 0: raise ValueError("""Number should not be negative.""" ) return 1 if num in (0, 1) else num * factorial(num - 1 ) if __name__ == "__main__": import doctest doctest.testmod()
19
"""simple docstring""" import argparse import logging import os import sys import numpy as np import onnxruntime import torch from bart_onnx.generation_onnx import BARTBeamSearchGenerator from bart_onnx.reduce_onnx_size import remove_dup_initializers import transformers from transformers import BartForConditionalGeneration, BartTokenizer logging.basicConfig( format='''%(asctime)s | %(levelname)s | %(name)s | [%(filename)s:%(lineno)d] %(message)s''', datefmt='''%Y-%m-%d %H:%M:%S''', level=os.environ.get('''LOGLEVEL''', '''INFO''').upper(), stream=sys.stdout, ) a : List[str] = logging.getLogger(__name__) a : int = {'''facebook/bart-base''': BartForConditionalGeneration} a : Dict = {'''facebook/bart-base''': BartTokenizer} def _UpperCamelCase ( ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = argparse.ArgumentParser(description="""Export Bart model + Beam Search to ONNX graph.""" ) parser.add_argument( """--validation_file""" , type=_A , default=_A , help="""A csv or a json file containing the validation data.""" ) parser.add_argument( """--max_length""" , type=_A , default=5 , help="""The maximum total input sequence length after tokenization.""" , ) parser.add_argument( """--num_beams""" , type=_A , default=_A , help=( """Number of beams to use for evaluation. This argument will be """ """passed to ``model.generate``, which is used during ``evaluate`` and ``predict``.""" ) , ) parser.add_argument( """--model_name_or_path""" , type=_A , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=_A , ) parser.add_argument( """--config_name""" , type=_A , default=_A , help="""Pretrained config name or path if not the same as model_name""" , ) parser.add_argument( """--device""" , type=_A , default="""cpu""" , help="""Device where the model will be run""" , ) parser.add_argument("""--output_file_path""" , type=_A , default=_A , help="""Where to store the final ONNX file.""" ) _UpperCAmelCase = parser.parse_args() return args def _UpperCamelCase ( _A , _A="cpu" ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = model_dict[model_name].from_pretrained(_A ).to(_A ) _UpperCAmelCase = tokenizer_dict[model_name].from_pretrained(_A ) if model_name in ["facebook/bart-base"]: _UpperCAmelCase = 0 _UpperCAmelCase = None _UpperCAmelCase = 0 return huggingface_model, tokenizer def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> Optional[int]: """simple docstring""" model.eval() _UpperCAmelCase = None _UpperCAmelCase = torch.jit.script(BARTBeamSearchGenerator(_A ) ) with torch.no_grad(): _UpperCAmelCase = """My friends are cool but they eat too many carbs.""" _UpperCAmelCase = tokenizer([ARTICLE_TO_SUMMARIZE] , max_length=1_0_2_4 , return_tensors="""pt""" ).to(model.device ) _UpperCAmelCase = model.generate( inputs["""input_ids"""] , attention_mask=inputs["""attention_mask"""] , num_beams=_A , max_length=_A , early_stopping=_A , decoder_start_token_id=model.config.decoder_start_token_id , ) torch.onnx.export( _A , ( inputs["""input_ids"""], inputs["""attention_mask"""], num_beams, max_length, model.config.decoder_start_token_id, ) , _A , opset_version=1_4 , input_names=["""input_ids""", """attention_mask""", """num_beams""", """max_length""", """decoder_start_token_id"""] , output_names=["""output_ids"""] , dynamic_axes={ """input_ids""": {0: """batch""", 1: """seq"""}, """output_ids""": {0: """batch""", 1: """seq_out"""}, } , example_outputs=_A , ) logger.info("""Model exported to {}""".format(_A ) ) _UpperCAmelCase = remove_dup_initializers(os.path.abspath(_A ) ) logger.info("""Deduplicated and optimized model written to {}""".format(_A ) ) _UpperCAmelCase = onnxruntime.InferenceSession(_A ) _UpperCAmelCase = ort_sess.run( _A , { """input_ids""": inputs["""input_ids"""].cpu().numpy(), """attention_mask""": inputs["""attention_mask"""].cpu().numpy(), """num_beams""": np.array(_A ), """max_length""": np.array(_A ), """decoder_start_token_id""": np.array(model.config.decoder_start_token_id ), } , ) np.testing.assert_allclose(summary_ids.cpu().numpy() , ort_out[0] , rtol=1e-3 , atol=1e-3 ) logger.info("""Model outputs from torch and ONNX Runtime are similar.""" ) logger.info("""Success.""" ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = parse_args() _UpperCAmelCase = 5 _UpperCAmelCase = 4 # Make one log on every process with the configuration for debugging. logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , level=logging.INFO , ) logger.setLevel(logging.INFO ) transformers.utils.logging.set_verbosity_error() _UpperCAmelCase = torch.device(args.device ) _UpperCAmelCase ,_UpperCAmelCase = load_model_tokenizer(args.model_name_or_path , _A ) if model.config.decoder_start_token_id is None: raise ValueError("""Make sure that `config.decoder_start_token_id` is correctly defined""" ) model.to(_A ) if args.max_length: _UpperCAmelCase = args.max_length if args.num_beams: _UpperCAmelCase = args.num_beams if args.output_file_path: _UpperCAmelCase = args.output_file_path else: _UpperCAmelCase = """BART.onnx""" logger.info("""Exporting model to ONNX""" ) export_and_validate_model(_A , _A , _A , _A , _A ) if __name__ == "__main__": main()
19
1
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging a : str = logging.get_logger(__name__) a : Optional[int] = { '''google/vivit-b-16x2-kinetics400''': ( '''https://huggingface.co/google/vivit-b-16x2-kinetics400/resolve/main/config.json''' ), # See all Vivit models at https://huggingface.co/models?filter=vivit } class a_ ( _UpperCAmelCase ): a : Dict = 'vivit' def __init__( self : Tuple , __UpperCamelCase : Tuple=2_24 , __UpperCamelCase : Optional[Any]=32 , __UpperCamelCase : Tuple=[2, 16, 16] , __UpperCamelCase : Dict=3 , __UpperCamelCase : Tuple=7_68 , __UpperCamelCase : Optional[Any]=12 , __UpperCamelCase : Optional[Any]=12 , __UpperCamelCase : Dict=30_72 , __UpperCamelCase : Any="gelu_fast" , __UpperCamelCase : int=0.0 , __UpperCamelCase : Dict=0.0 , __UpperCamelCase : Optional[int]=0.0_2 , __UpperCamelCase : Optional[int]=1e-06 , __UpperCamelCase : Optional[int]=True , **__UpperCamelCase : Dict , ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = image_size _UpperCAmelCase = num_frames _UpperCAmelCase = tubelet_size _UpperCAmelCase = num_channels _UpperCAmelCase = qkv_bias super().__init__(**__UpperCamelCase )
19
"""simple docstring""" import argparse import json import math import os import time import traceback import zipfile from collections import Counter import requests def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return job_links except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{worflow_run_id}/artifacts?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) return artifacts except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A , _A , _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = requests.get(_A , headers=_A , allow_redirects=_A ) _UpperCAmelCase = result.headers["""Location"""] _UpperCAmelCase = requests.get(_A , allow_redirects=_A ) _UpperCAmelCase = os.path.join(_A , F"""{artifact_name}.zip""" ) with open(_A , """wb""" ) as fp: fp.write(response.content ) def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [] _UpperCAmelCase = None with zipfile.ZipFile(_A ) as z: for filename in z.namelist(): if not os.path.isdir(_A ): # read the file if filename in ["failures_line.txt", "summary_short.txt", "job_name.txt"]: with z.open(_A ) as f: for line in f: _UpperCAmelCase = line.decode("""UTF-8""" ).strip() if filename == "failures_line.txt": try: # `error_line` is the place where `error` occurs _UpperCAmelCase = line[: line.index(""": """ )] _UpperCAmelCase = line[line.index(""": """ ) + len(""": """ ) :] errors.append([error_line, error] ) except Exception: # skip un-related lines pass elif filename == "summary_short.txt" and line.startswith("""FAILED """ ): # `test` is the test method that failed _UpperCAmelCase = line[len("""FAILED """ ) :] failed_tests.append(_A ) elif filename == "job_name.txt": _UpperCAmelCase = line if len(_A ) != len(_A ): raise ValueError( F"""`errors` and `failed_tests` should have the same number of elements. Got {len(_A )} for `errors` """ F"""and {len(_A )} for `failed_tests` instead. The test reports in {artifact_zip_path} have some""" """ problem.""" ) _UpperCAmelCase = None if job_name and job_links: _UpperCAmelCase = job_links.get(_A , _A ) # A list with elements of the form (line of error, error, failed test) _UpperCAmelCase = [x + [y] + [job_link] for x, y in zip(_A , _A )] return result def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [os.path.join(_A , _A ) for p in os.listdir(_A ) if p.endswith(""".zip""" )] for p in paths: errors.extend(get_errors_from_single_artifact(_A , job_links=_A ) ) return errors def _UpperCamelCase ( _A , _A=None ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = Counter() counter.update([x[1] for x in logs] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {} for error, count in counts: if error_filter is None or error not in error_filter: _UpperCAmelCase = {"""count""": count, """failed_tests""": [(x[2], x[0]) for x in logs if x[1] == error]} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = test.split("""::""" )[0] if test.startswith("""tests/models/""" ): _UpperCAmelCase = test.split("""/""" )[2] else: _UpperCAmelCase = None return test def _UpperCamelCase ( _A , _A=None ) -> Any: """simple docstring""" _UpperCAmelCase = [(x[0], x[1], get_model(x[2] )) for x in logs] _UpperCAmelCase = [x for x in logs if x[2] is not None] _UpperCAmelCase = {x[2] for x in logs} _UpperCAmelCase = {} for test in tests: _UpperCAmelCase = Counter() # count by errors in `test` counter.update([x[1] for x in logs if x[2] == test] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {error: count for error, count in counts if (error_filter is None or error not in error_filter)} _UpperCAmelCase = sum(error_counts.values() ) if n_errors > 0: _UpperCAmelCase = {"""count""": n_errors, """errors""": error_counts} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = """| no. | error | status |""" _UpperCAmelCase = """|-:|:-|:-|""" _UpperCAmelCase = [header, sep] for error in reduced_by_error: _UpperCAmelCase = reduced_by_error[error]["""count"""] _UpperCAmelCase = F"""| {count} | {error[:1_0_0]} | |""" lines.append(_A ) return "\n".join(_A ) def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = """| model | no. of errors | major error | count |""" _UpperCAmelCase = """|-:|-:|-:|-:|""" _UpperCAmelCase = [header, sep] for model in reduced_by_model: _UpperCAmelCase = reduced_by_model[model]["""count"""] _UpperCAmelCase ,_UpperCAmelCase = list(reduced_by_model[model]["""errors"""].items() )[0] _UpperCAmelCase = F"""| {model} | {count} | {error[:6_0]} | {_count} |""" lines.append(_A ) return "\n".join(_A ) if __name__ == "__main__": a : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument('''--workflow_run_id''', type=str, required=True, help='''A GitHub Actions workflow run id.''') parser.add_argument( '''--output_dir''', type=str, required=True, help='''Where to store the downloaded artifacts and other result files.''', ) parser.add_argument('''--token''', default=None, type=str, help='''A token that has actions:read permission.''') a : Dict = parser.parse_args() os.makedirs(args.output_dir, exist_ok=True) a : Tuple = get_job_links(args.workflow_run_id, token=args.token) a : Tuple = {} # To deal with `workflow_call` event, where a job name is the combination of the job names in the caller and callee. # For example, `PyTorch 1.11 / Model tests (models/albert, single-gpu)`. if _job_links: for k, v in _job_links.items(): # This is how GitHub actions combine job names. if " / " in k: a : List[Any] = k.find(''' / ''') a : Tuple = k[index + len(''' / ''') :] a : int = v with open(os.path.join(args.output_dir, '''job_links.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(job_links, fp, ensure_ascii=False, indent=4) a : Tuple = get_artifacts_links(args.workflow_run_id, token=args.token) with open(os.path.join(args.output_dir, '''artifacts.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(artifacts, fp, ensure_ascii=False, indent=4) for idx, (name, url) in enumerate(artifacts.items()): download_artifact(name, url, args.output_dir, args.token) # Be gentle to GitHub time.sleep(1) a : Optional[int] = get_all_errors(args.output_dir, job_links=job_links) # `e[1]` is the error a : Union[str, Any] = Counter() counter.update([e[1] for e in errors]) # print the top 30 most common test errors a : Optional[int] = counter.most_common(3_0) for item in most_common: print(item) with open(os.path.join(args.output_dir, '''errors.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(errors, fp, ensure_ascii=False, indent=4) a : int = reduce_by_error(errors) a : str = reduce_by_model(errors) a : int = make_github_table(reduced_by_error) a : Optional[int] = make_github_table_per_model(reduced_by_model) with open(os.path.join(args.output_dir, '''reduced_by_error.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa) with open(os.path.join(args.output_dir, '''reduced_by_model.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa)
19
1
"""simple docstring""" 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 ) -> Any: """simple docstring""" _UpperCAmelCase = filter(lambda _A : p.requires_grad , model.parameters() ) _UpperCAmelCase = sum([np.prod(p.size() ) for p in model_parameters] ) return params a : Union[str, Any] = logging.getLogger(__name__) def _UpperCamelCase ( _A , _A ) -> Dict: """simple docstring""" if metric == "rouge2": _UpperCAmelCase = """{val_avg_rouge2:.4f}-{step_count}""" elif metric == "bleu": _UpperCAmelCase = """{val_avg_bleu:.4f}-{step_count}""" elif metric == "em": _UpperCAmelCase = """{val_avg_em:.4f}-{step_count}""" elif metric == "loss": _UpperCAmelCase = """{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.""" ) _UpperCAmelCase = 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 ) -> Tuple: """simple docstring""" return EarlyStopping( monitor=F"""val_{metric}""" , mode="""min""" if """loss""" in metric else """max""" , patience=_A , verbose=_A , ) class a_ ( pl.Callback ): def _snake_case ( self : Dict , __UpperCamelCase : Tuple , __UpperCamelCase : Tuple ) ->List[str]: '''simple docstring''' _UpperCAmelCase = {f"""lr_group_{i}""": param["""lr"""] for i, param in enumerate(pl_module.trainer.optimizers[0].param_groups )} pl_module.logger.log_metrics(__UpperCamelCase ) @rank_zero_only def _snake_case ( self : Optional[Any] , __UpperCamelCase : pl.Trainer , __UpperCamelCase : pl.LightningModule , __UpperCamelCase : str , __UpperCamelCase : str=True ) ->None: '''simple docstring''' logger.info(f"""***** {type_path} results at step {trainer.global_step:05d} *****""" ) _UpperCAmelCase = 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 _UpperCAmelCase = Path(pl_module.hparams.output_dir ) if type_path == "test": _UpperCAmelCase = od / """test_results.txt""" _UpperCAmelCase = 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. _UpperCAmelCase = od / f"""{type_path}_results/{trainer.global_step:05d}.txt""" _UpperCAmelCase = od / f"""{type_path}_generations/{trainer.global_step:05d}.txt""" results_file.parent.mkdir(exist_ok=__UpperCamelCase ) generations_file.parent.mkdir(exist_ok=__UpperCamelCase ) with open(__UpperCamelCase , """a+""" ) as writer: for key in sorted(__UpperCamelCase ): if key in ["log", "progress_bar", "preds"]: continue _UpperCAmelCase = metrics[key] if isinstance(__UpperCamelCase , torch.Tensor ): _UpperCAmelCase = val.item() _UpperCAmelCase = f"""{key}: {val:.6f}\n""" writer.write(__UpperCamelCase ) if not save_generations: return if "preds" in metrics: _UpperCAmelCase = """\n""".join(metrics["""preds"""] ) generations_file.open("""w+""" ).write(__UpperCamelCase ) @rank_zero_only def _snake_case ( self : Tuple , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] ) ->List[str]: '''simple docstring''' try: _UpperCAmelCase = pl_module.model.model.num_parameters() except AttributeError: _UpperCAmelCase = pl_module.model.num_parameters() _UpperCAmelCase = count_trainable_parameters(__UpperCamelCase ) # 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 _snake_case ( self : Optional[int] , __UpperCamelCase : pl.Trainer , __UpperCamelCase : pl.LightningModule ) ->Optional[Any]: '''simple docstring''' save_json(pl_module.metrics , pl_module.metrics_save_path ) return self._write_logs(__UpperCamelCase , __UpperCamelCase , """test""" ) @rank_zero_only def _snake_case ( self : List[Any] , __UpperCamelCase : pl.Trainer , __UpperCamelCase : Any ) ->str: '''simple docstring''' save_json(pl_module.metrics , pl_module.metrics_save_path ) # Uncommenting this will save val generations # return self._write_logs(trainer, pl_module, "valid")
19
"""simple docstring""" import re import warnings from contextlib import contextmanager from ...processing_utils import ProcessorMixin class a_ ( _UpperCAmelCase ): a : Any = ['image_processor', 'tokenizer'] a : Optional[int] = 'AutoImageProcessor' a : Any = 'AutoTokenizer' def __init__( self : List[str] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : List[str]=None , **__UpperCamelCase : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`""" """ instead.""" , __UpperCamelCase , ) _UpperCAmelCase = kwargs.pop("""feature_extractor""" ) _UpperCAmelCase = 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__(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def __call__( self : Union[str, Any] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->List[str]: '''simple docstring''' if self._in_target_context_manager: return self.current_processor(*__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""images""" , __UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""text""" , __UpperCamelCase ) if len(__UpperCamelCase ) > 0: _UpperCAmelCase = args[0] _UpperCAmelCase = args[1:] if images is None and text is None: raise ValueError("""You need to specify either an `images` or `text` input to process.""" ) if images is not None: _UpperCAmelCase = self.image_processor(__UpperCamelCase , *__UpperCamelCase , **__UpperCamelCase ) if text is not None: _UpperCAmelCase = self.tokenizer(__UpperCamelCase , **__UpperCamelCase ) if text is None: return inputs elif images is None: return encodings else: _UpperCAmelCase = encodings["""input_ids"""] return inputs def _snake_case ( self : Union[str, Any] , *__UpperCamelCase : int , **__UpperCamelCase : Tuple ) ->Tuple: '''simple docstring''' return self.tokenizer.batch_decode(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Tuple , *__UpperCamelCase : int , **__UpperCamelCase : Union[str, Any] ) ->int: '''simple docstring''' return self.tokenizer.decode(*__UpperCamelCase , **__UpperCamelCase ) @contextmanager def _snake_case ( self : Tuple ) ->Union[str, Any]: '''simple docstring''' warnings.warn( """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """ """labels by using the argument `text` of the regular `__call__` method (either in the same call as """ """your images inputs, or in a separate call.""" ) _UpperCAmelCase = True _UpperCAmelCase = self.tokenizer yield _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def _snake_case ( self : str , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any]=False , __UpperCamelCase : Union[str, Any]=None ) ->List[str]: '''simple docstring''' if added_vocab is None: _UpperCAmelCase = self.tokenizer.get_added_vocab() _UpperCAmelCase = {} while tokens: _UpperCAmelCase = re.search(r"""<s_(.*?)>""" , __UpperCamelCase , re.IGNORECASE ) if start_token is None: break _UpperCAmelCase = start_token.group(1 ) _UpperCAmelCase = re.search(rf"""</s_{key}>""" , __UpperCamelCase , re.IGNORECASE ) _UpperCAmelCase = start_token.group() if end_token is None: _UpperCAmelCase = tokens.replace(__UpperCamelCase , """""" ) else: _UpperCAmelCase = end_token.group() _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.search(f"""{start_token_escaped}(.*?){end_token_escaped}""" , __UpperCamelCase , re.IGNORECASE ) if content is not None: _UpperCAmelCase = content.group(1 ).strip() if r"<s_" in content and r"</s_" in content: # non-leaf node _UpperCAmelCase = self.tokenajson(__UpperCamelCase , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if value: if len(__UpperCamelCase ) == 1: _UpperCAmelCase = value[0] _UpperCAmelCase = value else: # leaf nodes _UpperCAmelCase = [] for leaf in content.split(r"""<sep/>""" ): _UpperCAmelCase = leaf.strip() if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>": _UpperCAmelCase = leaf[1:-2] # for categorical special tokens output[key].append(__UpperCamelCase ) if len(output[key] ) == 1: _UpperCAmelCase = output[key][0] _UpperCAmelCase = tokens[tokens.find(__UpperCamelCase ) + len(__UpperCamelCase ) :].strip() if tokens[:6] == r"<sep/>": # non-leaf nodes return [output] + self.tokenajson(tokens[6:] , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if len(__UpperCamelCase ): return [output] if is_inner_value else output else: return [] if is_inner_value else {"text_sequence": tokens} @property def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' warnings.warn( """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""" , __UpperCamelCase , ) return self.image_processor_class @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' warnings.warn( """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""" , __UpperCamelCase , ) return self.image_processor
19
1
"""simple docstring""" import re from filelock import FileLock try: import nltk a : str = True except (ImportError, ModuleNotFoundError): a : List[str] = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def _UpperCamelCase ( _A ) -> str: """simple docstring""" re.sub("""<n>""" , """""" , _A ) # 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(_A ) )
19
"""simple docstring""" import colorsys from PIL import Image # type: ignore def _UpperCamelCase ( _A , _A , _A ) -> float: """simple docstring""" _UpperCAmelCase = x _UpperCAmelCase = y for step in range(_A ): # noqa: B007 _UpperCAmelCase = a * a - b * b + x _UpperCAmelCase = 2 * a * b + y _UpperCAmelCase = a_new # divergence happens for all complex number with an absolute value # greater than 4 if a * a + b * b > 4: break return step / (max_step - 1) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return (2_5_5, 2_5_5, 2_5_5) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return tuple(round(i * 2_5_5 ) for i in colorsys.hsv_to_rgb(_A , 1 , 1 ) ) def _UpperCamelCase ( _A = 8_0_0 , _A = 6_0_0 , _A = -0.6 , _A = 0 , _A = 3.2 , _A = 5_0 , _A = True , ) -> Image.Image: """simple docstring""" _UpperCAmelCase = Image.new("""RGB""" , (image_width, image_height) ) _UpperCAmelCase = img.load() # loop through the image-coordinates for image_x in range(_A ): for image_y in range(_A ): # determine the figure-coordinates based on the image-coordinates _UpperCAmelCase = figure_width / image_width * image_height _UpperCAmelCase = figure_center_x + (image_x / image_width - 0.5) * figure_width _UpperCAmelCase = figure_center_y + (image_y / image_height - 0.5) * figure_height _UpperCAmelCase = get_distance(_A , _A , _A ) # color the corresponding pixel based on the selected coloring-function if use_distance_color_coding: _UpperCAmelCase = get_color_coded_rgb(_A ) else: _UpperCAmelCase = get_black_and_white_rgb(_A ) return img if __name__ == "__main__": import doctest doctest.testmod() # colored version, full figure a : List[str] = get_image() # uncomment for colored version, different section, zoomed in # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4, # figure_width = 0.8) # uncomment for black and white version, full figure # img = get_image(use_distance_color_coding = False) # uncomment to save the image # img.save("mandelbrot.png") img.show()
19
1
"""simple docstring""" from typing import Dict, List from nltk.translate import gleu_score import datasets from datasets import MetricInfo a : List[Any] = '''\ @misc{wu2016googles, title={Google\'s Neural Machine Translation System: Bridging the Gap between Human and Machine Translation}, author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes and Jeffrey Dean}, year={2016}, eprint={1609.08144}, archivePrefix={arXiv}, primaryClass={cs.CL} } ''' a : Any = '''\ The BLEU score has some undesirable properties when used for single sentences, as it was designed to be a corpus measure. We therefore use a slightly different score for our RL experiments which we call the \'GLEU score\'. For the GLEU score, we record all sub-sequences of 1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then compute a recall, which is the ratio of the number of matching n-grams to the number of total n-grams in the target (ground truth) sequence, and a precision, which is the ratio of the number of matching n-grams to the number of total n-grams in the generated output sequence. Then GLEU score is simply the minimum of recall and precision. This GLEU score\'s range is always between 0 (no matches) and 1 (all match) and it is symmetrical when switching output and target. According to our experiments, GLEU score correlates quite well with the BLEU metric on a corpus level but does not have its drawbacks for our per sentence reward objective. ''' a : str = '''\ Computes corpus-level Google BLEU (GLEU) score of translated segments against one or more references. Instead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching tokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values. Args: predictions (list of str): list of translations to score. Each translation should be tokenized into a list of tokens. references (list of list of str): list of lists of references for each translation. Each reference should be tokenized into a list of tokens. min_len (int): The minimum order of n-gram this function should extract. Defaults to 1. max_len (int): The maximum order of n-gram this function should extract. Defaults to 4. Returns: \'google_bleu\': google_bleu score Examples: Example 1: >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\', ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\', ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\'] >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\', ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\', ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\'] >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\', ... \'interested\', \'in\', \'world\', \'history\'] >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\', ... \'because\', \'he\', \'read\', \'the\', \'book\'] >>> list_of_references = [[ref1a], [ref2a]] >>> hypotheses = [hyp1, hyp2] >>> google_bleu = datasets.load_metric("google_bleu") >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references) >>> print(round(results["google_bleu"], 2)) 0.44 Example 2: >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\', ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\', ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\'] >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\', ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\', ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\'] >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\', ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\', ... \'heed\', \'the\', \'cat\', \'commands\'] >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\', ... \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\', ... \'of\', \'the\', \'cat\'] >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\', ... \'interested\', \'in\', \'world\', \'history\'] >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\', ... \'because\', \'he\', \'read\', \'the\', \'book\'] >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]] >>> hypotheses = [hyp1, hyp2] >>> google_bleu = datasets.load_metric("google_bleu") >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references) >>> print(round(results["google_bleu"], 2)) 0.61 Example 3: >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\', ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\', ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\'] >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\', ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\', ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\'] >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\', ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\', ... \'heed\', \'the\', \'cat\', \'commands\'] >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\', ... \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\', ... \'of\', \'the\', \'cat\'] >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\', ... \'interested\', \'in\', \'world\', \'history\'] >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\', ... \'because\', \'he\', \'read\', \'the\', \'book\'] >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]] >>> hypotheses = [hyp1, hyp2] >>> google_bleu = datasets.load_metric("google_bleu") >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2) >>> print(round(results["google_bleu"], 2)) 0.53 Example 4: >>> hyp1 = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'which\', ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'always\', ... \'disobeys\', \'the\', \'commands\', \'of\', \'the\', \'cat\'] >>> ref1a = [\'It\', \'is\', \'the\', \'guiding\', \'principle\', \'which\', ... \'guarantees\', \'the\', \'rubber\', \'duck\', \'forces\', \'never\', ... \'being\', \'under\', \'the\', \'command\', \'of\', \'the\', \'cat\'] >>> ref1b = [\'It\', \'is\', \'a\', \'guide\', \'to\', \'action\', \'that\', ... \'ensures\', \'that\', \'the\', \'rubber\', \'duck\', \'will\', \'never\', ... \'heed\', \'the\', \'cat\', \'commands\'] >>> ref1c = [\'It\', \'is\', \'the\', \'practical\', \'guide\', \'for\', \'the\', ... \'rubber\', \'duck\', \'army\', \'never\', \'to\', \'heed\', \'the\', \'directions\', ... \'of\', \'the\', \'cat\'] >>> hyp2 = [\'he\', \'read\', \'the\', \'book\', \'because\', \'he\', \'was\', ... \'interested\', \'in\', \'world\', \'history\'] >>> ref2a = [\'he\', \'was\', \'interested\', \'in\', \'world\', \'history\', ... \'because\', \'he\', \'read\', \'the\', \'book\'] >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]] >>> hypotheses = [hyp1, hyp2] >>> google_bleu = datasets.load_metric("google_bleu") >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6) >>> print(round(results["google_bleu"], 2)) 0.4 ''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a_ ( datasets.Metric ): def _snake_case ( self : Any ) ->MetricInfo: '''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""" ), } ) , ) def _snake_case ( self : Dict , __UpperCamelCase : List[List[List[str]]] , __UpperCamelCase : List[List[str]] , __UpperCamelCase : int = 1 , __UpperCamelCase : int = 4 , ) ->Dict[str, float]: '''simple docstring''' return { "google_bleu": gleu_score.corpus_gleu( list_of_references=__UpperCamelCase , hypotheses=__UpperCamelCase , min_len=__UpperCamelCase , max_len=__UpperCamelCase ) }
19
"""simple docstring""" from typing import Optional from torch import nn from .transformer_ad import TransformeraDModel, TransformeraDModelOutput class a_ ( nn.Module ): def __init__( self : List[str] , __UpperCamelCase : int = 16 , __UpperCamelCase : int = 88 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : int = 1 , __UpperCamelCase : float = 0.0 , __UpperCamelCase : int = 32 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : bool = False , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : str = "geglu" , __UpperCamelCase : Optional[int] = None , ) ->Dict: '''simple docstring''' super().__init__() _UpperCAmelCase = nn.ModuleList( [ TransformeraDModel( num_attention_heads=__UpperCamelCase , attention_head_dim=__UpperCamelCase , in_channels=__UpperCamelCase , num_layers=__UpperCamelCase , dropout=__UpperCamelCase , norm_num_groups=__UpperCamelCase , cross_attention_dim=__UpperCamelCase , attention_bias=__UpperCamelCase , sample_size=__UpperCamelCase , num_vector_embeds=__UpperCamelCase , activation_fn=__UpperCamelCase , num_embeds_ada_norm=__UpperCamelCase , ) for _ in range(2 ) ] ) # Variables that can be set by a pipeline: # The ratio of transformer1 to transformer2's output states to be combined during inference _UpperCAmelCase = 0.5 # The shape of `encoder_hidden_states` is expected to be # `(batch_size, condition_lengths[0]+condition_lengths[1], num_features)` _UpperCAmelCase = [77, 2_57] # Which transformer to use to encode which condition. # E.g. `(1, 0)` means that we'll use `transformers[1](conditions[0])` and `transformers[0](conditions[1])` _UpperCAmelCase = [1, 0] def _snake_case ( self : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : bool = True , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = hidden_states _UpperCAmelCase = [] _UpperCAmelCase = 0 # attention_mask is not used yet for i in range(2 ): # for each of the two transformers, pass the corresponding condition tokens _UpperCAmelCase = encoder_hidden_states[:, tokens_start : tokens_start + self.condition_lengths[i]] _UpperCAmelCase = self.transformer_index_for_condition[i] _UpperCAmelCase = self.transformers[transformer_index]( __UpperCamelCase , encoder_hidden_states=__UpperCamelCase , timestep=__UpperCamelCase , cross_attention_kwargs=__UpperCamelCase , return_dict=__UpperCamelCase , )[0] encoded_states.append(encoded_state - input_states ) tokens_start += self.condition_lengths[i] _UpperCAmelCase = encoded_states[0] * self.mix_ratio + encoded_states[1] * (1 - self.mix_ratio) _UpperCAmelCase = output_states + input_states if not return_dict: return (output_states,) return TransformeraDModelOutput(sample=__UpperCamelCase )
19
1
"""simple docstring""" 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() a : Union[str, Any] = logging.get_logger(__name__) a : 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''', } a : Optional[Any] = [ '''lm_head''', '''quantizer.weight_proj''', '''quantizer.codevectors''', '''project_q''', '''project_hid''', ] def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> List[Any]: """simple docstring""" for attribute in key.split(""".""" ): _UpperCAmelCase = getattr(_A , _A ) if weight_type is not None: _UpperCAmelCase = getattr(_A , _A ).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 _UpperCamelCase ( _A , _A ) -> Optional[int]: """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( _A , _A , _A , _A , 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(_A , _A , _A , _A ) _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(_A )[0].split(""".""" )[-2] _UpperCAmelCase = mapped_key.replace("""*""" , _A ) 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(_A , _A , _A , _A , _A ) continue if not is_used: unused_weights.append(_A ) logger.warning(F"""Unused weights: {unused_weights}""" ) def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> Union[str, Any]: """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(_A ) def _UpperCamelCase ( _A , _A , _A , _A ) -> Dict: """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(_A , _A ): 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(_A ) def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" _UpperCAmelCase ,_UpperCAmelCase = emb.weight.shape _UpperCAmelCase = nn.Linear(_A , _A , bias=_A ) _UpperCAmelCase = emb.weight.data return lin_layer @torch.no_grad() def _UpperCamelCase ( _A , _A , _A , _A , _A , _A , _A , _A , _A , _A , _A , ) -> List[str]: """simple docstring""" _UpperCAmelCase = WavaVecaConfig.from_pretrained( _A , add_adapter=_A , adapter_stride=_A , adapter_kernel_size=_A , use_auth_token=_A , output_hidden_size=_A , ) _UpperCAmelCase = MBartConfig.from_pretrained(_A ) # load model _UpperCAmelCase ,_UpperCAmelCase ,_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(_A , use_auth_token=_A ) # set weights for wav2vec2 encoder _UpperCAmelCase = WavaVecaModel(_A ) recursively_load_weights_wavaveca(model.encoder , _A ) # load decoder weights _UpperCAmelCase = MBartForCausalLM(_A ) _UpperCAmelCase ,_UpperCAmelCase = hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() , strict=_A ) 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=_A , decoder=_A ) _UpperCAmelCase = False _UpperCAmelCase = MBartaaTokenizer(_A ) tokenizer.save_pretrained(_A ) _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(_A ) hf_wavavec.save_pretrained(_A ) feature_extractor.save_pretrained(_A ) if __name__ == "__main__": a : List[Any] = 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''') a : Tuple = 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, )
19
"""simple docstring""" import argparse import torch from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert from transformers.utils import logging logging.set_verbosity_info() def _UpperCamelCase ( _A , _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = LxmertConfig.from_json_file(_A ) print(F"""Building PyTorch model from configuration: {config}""" ) _UpperCAmelCase = LxmertForPreTraining(_A ) # Load weights from tf checkpoint load_tf_weights_in_lxmert(_A , _A , _A ) # Save pytorch-model print(F"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict() , _A ) if __name__ == "__main__": a : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--config_file''', default=None, type=str, required=True, help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''', ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) a : Union[str, Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
19
1
"""simple docstring""" from timeit import timeit a : Any = { '''MALAYALAM''': True, '''String''': False, '''rotor''': True, '''level''': True, '''A''': True, '''BB''': True, '''ABC''': False, '''amanaplanacanalpanama''': True, # "a man a plan a canal panama" } # Ensure our test data is valid assert all((key == key[::-1]) is value for key, value in test_data.items()) def _UpperCamelCase ( _A ) -> bool: """simple docstring""" _UpperCAmelCase = 0 _UpperCAmelCase = len(_A ) - 1 while start_i < end_i: if s[start_i] == s[end_i]: start_i += 1 end_i -= 1 else: return False return True def _UpperCamelCase ( _A ) -> bool: """simple docstring""" _UpperCAmelCase = len(_A ) // 2 _UpperCAmelCase = len(_A ) # We need to traverse till half of the length of string # as we can get access of the i'th last element from # i'th index. # eg: [0,1,2,3,4,5] => 4th index can be accessed # with the help of 1st index (i==n-i-1) # where n is length of string return all(s[i] == s[n - i - 1] for i in range(_A ) ) def _UpperCamelCase ( _A ) -> bool: """simple docstring""" if len(_A ) <= 2: return True if s[0] == s[len(_A ) - 1]: return is_palindrome_recursive(s[1:-1] ) else: return False def _UpperCamelCase ( _A ) -> bool: """simple docstring""" return s == s[::-1] def _UpperCamelCase ( _A ) -> None: """simple docstring""" _UpperCAmelCase = F"""all({name}(key) is value for key, value in test_data.items())""" _UpperCAmelCase = F"""from __main__ import test_data, {name}""" _UpperCAmelCase = 5_0_0_0_0_0 _UpperCAmelCase = timeit(stmt=_A , setup=_A , number=_A ) print(F"""{name:<35} finished {number:,} runs in {result:.5f} seconds""" ) if __name__ == "__main__": for key, value in test_data.items(): assert is_palindrome(key) is is_palindrome_recursive(key) assert is_palindrome(key) is is_palindrome_slice(key) print(F"{key:21} {value}") print('''a man a plan a canal panama''') # finished 500,000 runs in 0.46793 seconds benchmark_function('''is_palindrome_slice''') # finished 500,000 runs in 0.85234 seconds benchmark_function('''is_palindrome''') # finished 500,000 runs in 1.32028 seconds benchmark_function('''is_palindrome_recursive''') # finished 500,000 runs in 2.08679 seconds benchmark_function('''is_palindrome_traversal''')
19
"""simple docstring""" import argparse import os import re import packaging.version a : str = '''examples/''' a : List[str] = { '''examples''': (re.compile(r'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''), '''init''': (re.compile(r'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''), '''setup''': (re.compile(r'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), r'''\1version="VERSION",'''), '''doc''': (re.compile(r'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''), } a : Tuple = { '''init''': '''src/diffusers/__init__.py''', '''setup''': '''setup.py''', } a : List[str] = '''README.md''' def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase ,_UpperCAmelCase = REPLACE_PATTERNS[pattern] _UpperCAmelCase = replace.replace("""VERSION""" , _A ) _UpperCAmelCase = re_pattern.sub(_A , _A ) with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.write(_A ) def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" for folder, directories, fnames in os.walk(_A ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("""research_projects""" ) if "legacy" in directories: directories.remove("""legacy""" ) for fname in fnames: if fname.endswith(""".py""" ): update_version_in_file(os.path.join(_A , _A ) , _A , pattern="""examples""" ) def _UpperCamelCase ( _A , _A=False ) -> int: """simple docstring""" for pattern, fname in REPLACE_FILES.items(): update_version_in_file(_A , _A , _A ) if not patch: update_version_in_examples(_A ) def _UpperCamelCase ( ) -> Any: """simple docstring""" _UpperCAmelCase = """🤗 Transformers currently provides the following architectures""" _UpperCAmelCase = """1. Want to contribute a new model?""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.readlines() # Find the start of the list. _UpperCAmelCase = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 _UpperCAmelCase = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("""1.""" ): _UpperCAmelCase = lines[index].replace( """https://huggingface.co/docs/diffusers/main/model_doc""" , """https://huggingface.co/docs/diffusers/model_doc""" , ) index += 1 with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.writelines(_A ) def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" with open(REPLACE_FILES["""init"""] , """r""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase = REPLACE_PATTERNS["""init"""][0].search(_A ).groups()[0] return packaging.version.parse(_A ) def _UpperCamelCase ( _A=False ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() if patch and default_version.is_devrelease: raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" ) if default_version.is_devrelease: _UpperCAmelCase = default_version.base_version elif patch: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}""" else: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor + 1}.0""" # Now let's ask nicely if that's the right one. _UpperCAmelCase = input(F"""Which version are you releasing? [{default_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = default_version print(F"""Updating version to {version}.""" ) global_version_update(_A , patch=_A ) def _UpperCamelCase ( ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() _UpperCAmelCase = F"""{current_version.major}.{current_version.minor + 1}.0.dev0""" _UpperCAmelCase = current_version.base_version # Check with the user we got that right. _UpperCAmelCase = input(F"""Which version are we developing now? [{dev_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = dev_version print(F"""Updating version to {version}.""" ) global_version_update(_A ) # print("Cleaning main README, don't forget to run `make fix-copies`.") # clean_main_ref_in_model_list() if __name__ == "__main__": a : Dict = argparse.ArgumentParser() parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''') parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''') a : Tuple = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('''Nothing to do after a patch :-)''') else: post_release_work()
19
1
"""simple docstring""" import argparse from pathlib import Path import fairseq import torch from fairseq.models.xmod import XMODModel as FairseqXmodModel from packaging import version from transformers import XmodConfig, XmodForMaskedLM, XmodForSequenceClassification from transformers.utils import logging if version.parse(fairseq.__version__) < version.parse('''0.12.2'''): raise Exception('''requires fairseq >= 0.12.2''') if version.parse(fairseq.__version__) > version.parse('''2'''): raise Exception('''requires fairseq < v2''') logging.set_verbosity_info() a : str = logging.get_logger(__name__) a : Tuple = '''Hello, World!''' a : Optional[Any] = '''en_XX''' def _UpperCamelCase ( _A , _A , _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = Path("""data_bin""" ) _UpperCAmelCase = FairseqXmodModel.from_pretrained( model_name_or_path=str(Path(_A ).parent ) , checkpoint_file=Path(_A ).name , _name="""xmod_base""" , arch="""xmod_base""" , task="""multilingual_masked_lm""" , data_name_or_path=str(_A ) , bpe="""sentencepiece""" , sentencepiece_model=str(Path(_A ).parent / """sentencepiece.bpe.model""" ) , src_dict=str(data_dir / """dict.txt""" ) , ) xmod.eval() # disable dropout print(_A ) _UpperCAmelCase = xmod.model.encoder.sentence_encoder _UpperCAmelCase = XmodConfig( vocab_size=xmod_sent_encoder.embed_tokens.num_embeddings , hidden_size=xmod.cfg.model.encoder_embed_dim , num_hidden_layers=xmod.cfg.model.encoder_layers , num_attention_heads=xmod.cfg.model.encoder_attention_heads , intermediate_size=xmod.cfg.model.encoder_ffn_embed_dim , max_position_embeddings=5_1_4 , type_vocab_size=1 , layer_norm_eps=1e-5 , pre_norm=xmod.cfg.model.encoder_normalize_before , adapter_reduction_factor=getattr(xmod.cfg.model , """bottleneck""" , 2 ) , adapter_layer_norm=xmod.cfg.model.adapter_layer_norm , adapter_reuse_layer_norm=xmod.cfg.model.adapter_reuse_layer_norm , ln_before_adapter=xmod.cfg.model.ln_before_adapter , languages=xmod.cfg.model.languages , ) if classification_head: _UpperCAmelCase = xmod.model.classification_heads["""mnli"""].out_proj.weight.shape[0] print("""Our X-MOD config:""" , _A ) _UpperCAmelCase = XmodForSequenceClassification(_A ) if classification_head else XmodForMaskedLM(_A ) model.eval() # Now let's copy all the weights. # Embeddings _UpperCAmelCase = xmod_sent_encoder.embed_tokens.weight _UpperCAmelCase = xmod_sent_encoder.embed_positions.weight _UpperCAmelCase = torch.zeros_like( model.roberta.embeddings.token_type_embeddings.weight ) # just zero them out b/c xmod doesn't use them. _UpperCAmelCase = xmod_sent_encoder.layernorm_embedding.weight _UpperCAmelCase = xmod_sent_encoder.layernorm_embedding.bias for i in range(config.num_hidden_layers ): # Encoder: start of layer _UpperCAmelCase = model.roberta.encoder.layer[i] _UpperCAmelCase = xmod_sent_encoder.layers[i] # self attention _UpperCAmelCase = layer.attention.self if not ( xmod_layer.self_attn.k_proj.weight.data.shape == xmod_layer.self_attn.q_proj.weight.data.shape == xmod_layer.self_attn.v_proj.weight.data.shape == torch.Size((config.hidden_size, config.hidden_size) ) ): raise AssertionError("""Dimensions of self-attention weights do not match.""" ) _UpperCAmelCase = xmod_layer.self_attn.q_proj.weight _UpperCAmelCase = xmod_layer.self_attn.q_proj.bias _UpperCAmelCase = xmod_layer.self_attn.k_proj.weight _UpperCAmelCase = xmod_layer.self_attn.k_proj.bias _UpperCAmelCase = xmod_layer.self_attn.v_proj.weight _UpperCAmelCase = xmod_layer.self_attn.v_proj.bias # self-attention output _UpperCAmelCase = layer.attention.output if self_output.dense.weight.shape != xmod_layer.self_attn.out_proj.weight.shape: raise AssertionError("""Dimensions of self-attention output weights do not match.""" ) _UpperCAmelCase = xmod_layer.self_attn.out_proj.weight _UpperCAmelCase = xmod_layer.self_attn.out_proj.bias _UpperCAmelCase = xmod_layer.self_attn_layer_norm.weight _UpperCAmelCase = xmod_layer.self_attn_layer_norm.bias # intermediate _UpperCAmelCase = layer.intermediate if intermediate.dense.weight.shape != xmod_layer.fca.weight.shape: raise AssertionError("""Dimensions of intermediate weights do not match.""" ) _UpperCAmelCase = xmod_layer.fca.weight _UpperCAmelCase = xmod_layer.fca.bias # output _UpperCAmelCase = layer.output if bert_output.dense.weight.shape != xmod_layer.fca.weight.shape: raise AssertionError("""Dimensions of feed-forward weights do not match.""" ) _UpperCAmelCase = xmod_layer.fca.weight _UpperCAmelCase = xmod_layer.fca.bias _UpperCAmelCase = xmod_layer.final_layer_norm.weight _UpperCAmelCase = xmod_layer.final_layer_norm.bias if bert_output.adapter_layer_norm is not None: _UpperCAmelCase = xmod_layer.adapter_layer_norm.weight _UpperCAmelCase = xmod_layer.adapter_layer_norm.bias if sorted(bert_output.adapter_modules.keys() ) != sorted(xmod_layer.adapter_modules.keys() ): raise AssertionError("""Lists of language adapters do not match.""" ) for lang_code, adapter in xmod_layer.adapter_modules.items(): _UpperCAmelCase = bert_output.adapter_modules[lang_code] _UpperCAmelCase = xmod_layer.adapter_modules[lang_code] _UpperCAmelCase = from_adapter.fca.weight _UpperCAmelCase = from_adapter.fca.bias _UpperCAmelCase = from_adapter.fca.weight _UpperCAmelCase = from_adapter.fca.bias # end of layer if xmod_sent_encoder.layer_norm is not None: _UpperCAmelCase = xmod_sent_encoder.layer_norm.weight _UpperCAmelCase = xmod_sent_encoder.layer_norm.bias if classification_head: _UpperCAmelCase = xmod.model.classification_heads["""mnli"""].dense.weight _UpperCAmelCase = xmod.model.classification_heads["""mnli"""].dense.bias _UpperCAmelCase = xmod.model.classification_heads["""mnli"""].out_proj.weight _UpperCAmelCase = xmod.model.classification_heads["""mnli"""].out_proj.bias else: # LM Head _UpperCAmelCase = xmod.model.encoder.lm_head.dense.weight _UpperCAmelCase = xmod.model.encoder.lm_head.dense.bias _UpperCAmelCase = xmod.model.encoder.lm_head.layer_norm.weight _UpperCAmelCase = xmod.model.encoder.lm_head.layer_norm.bias _UpperCAmelCase = xmod.model.encoder.lm_head.weight _UpperCAmelCase = xmod.model.encoder.lm_head.bias # Let's check that we get the same results. _UpperCAmelCase = xmod.encode(_A ).unsqueeze(0 ) # batch of size 1 model.roberta.set_default_language(_A ) _UpperCAmelCase = model(_A )[0] if classification_head: _UpperCAmelCase = xmod.model.classification_heads["""mnli"""](xmod.extract_features(_A ) ) else: _UpperCAmelCase = xmod.model(_A , lang_id=[SAMPLE_LANGUAGE] )[0] print(our_output.shape , their_output.shape ) _UpperCAmelCase = torch.max(torch.abs(our_output - their_output ) ).item() print(F"""max_absolute_diff = {max_absolute_diff}""" ) # ~ 1e-7 _UpperCAmelCase = torch.allclose(_A , _A , atol=1e-3 ) print("""Do both models output the same tensors?""" , """🔥""" if success else """💩""" ) if not success: raise Exception("""Something went wRoNg""" ) Path(_A ).mkdir(parents=_A , exist_ok=_A ) print(F"""Saving model to {pytorch_dump_folder_path}""" ) model.save_pretrained(_A ) if __name__ == "__main__": a : List[str] = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--xmod_checkpoint_path''', default=None, type=str, required=True, help='''Path the official PyTorch dump.''' ) parser.add_argument( '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) parser.add_argument( '''--classification_head''', action='''store_true''', help='''Whether to convert a final classification head.''' ) a : List[Any] = parser.parse_args() convert_xmod_checkpoint_to_pytorch( args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head )
19
"""simple docstring""" from __future__ import annotations def _UpperCamelCase ( _A ) -> None: """simple docstring""" create_state_space_tree(_A , [] , 0 , [0 for i in range(len(_A ) )] ) def _UpperCamelCase ( _A , _A , _A , _A , ) -> None: """simple docstring""" if index == len(_A ): print(_A ) return for i in range(len(_A ) ): if not index_used[i]: current_sequence.append(sequence[i] ) _UpperCAmelCase = True create_state_space_tree(_A , _A , index + 1 , _A ) current_sequence.pop() _UpperCAmelCase = False a : list[int | str] = [3, 1, 2, 4] generate_all_permutations(sequence) a : list[int | str] = ["A", "B", "C"] generate_all_permutations(sequence_a)
19
1
"""simple docstring""" from transformers import HfArgumentParser, TensorFlowBenchmark, TensorFlowBenchmarkArguments def _UpperCamelCase ( ) -> str: """simple docstring""" _UpperCAmelCase = HfArgumentParser(_A ) _UpperCAmelCase = parser.parse_args_into_dataclasses()[0] _UpperCAmelCase = TensorFlowBenchmark(args=_A ) try: _UpperCAmelCase = parser.parse_args_into_dataclasses()[0] except ValueError as e: _UpperCAmelCase = """Arg --no_{0} is no longer used, please use --no-{0} instead.""" _UpperCAmelCase = """ """.join(str(_A ).split(""" """ )[:-1] ) _UpperCAmelCase = """""" _UpperCAmelCase = eval(str(_A ).split(""" """ )[-1] ) _UpperCAmelCase = [] for arg in depreciated_args: # arg[2:] removes '--' if arg[2:] in TensorFlowBenchmark.deprecated_args: # arg[5:] removes '--no_' full_error_msg += arg_error_msg.format(arg[5:] ) else: wrong_args.append(_A ) if len(_A ) > 0: _UpperCAmelCase = full_error_msg + begin_error_msg + str(_A ) raise ValueError(_A ) benchmark.run() if __name__ == "__main__": main()
19
"""simple docstring""" import inspect import unittest from transformers import DPTConfig from transformers.file_utils import is_torch_available, is_vision_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, require_vision, slow, torch_device 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 MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import DPTImageProcessor class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int]=2 , __UpperCamelCase : int=32 , __UpperCamelCase : Tuple=16 , __UpperCamelCase : Dict=3 , __UpperCamelCase : Dict=True , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Optional[Any]=32 , __UpperCamelCase : Any=4 , __UpperCamelCase : Optional[int]=[0, 1, 2, 3] , __UpperCamelCase : str=4 , __UpperCamelCase : Optional[Any]=37 , __UpperCamelCase : str="gelu" , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : Any=0.1 , __UpperCamelCase : Any=0.0_2 , __UpperCamelCase : Optional[int]=3 , __UpperCamelCase : int=[1, 3_84, 24, 24] , __UpperCamelCase : Union[str, Any]=True , __UpperCamelCase : Any=None , ) ->Optional[Any]: '''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 = backbone_out_indices _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = backbone_featmap_shape _UpperCAmelCase = scope _UpperCAmelCase = is_hybrid # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token) _UpperCAmelCase = (image_size // patch_size) ** 2 _UpperCAmelCase = num_patches + 1 def _snake_case ( self : str ) ->int: '''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.image_size, self.image_size] , self.num_labels ) _UpperCAmelCase = self.get_config() return config, pixel_values, labels def _snake_case ( self : List[str] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = { """global_padding""": """same""", """layer_type""": """bottleneck""", """depths""": [3, 4, 9], """out_features""": ["""stage1""", """stage2""", """stage3"""], """embedding_dynamic_padding""": True, """hidden_sizes""": [96, 1_92, 3_84, 7_68], """num_groups""": 2, } return DPTConfig( 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 , backbone_out_indices=self.backbone_out_indices , 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 , is_hybrid=self.is_hybrid , backbone_config=__UpperCamelCase , backbone_featmap_shape=self.backbone_featmap_shape , ) def _snake_case ( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = DPTModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : str , __UpperCamelCase : List[Any] ) ->int: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.predicted_depth.shape , (self.batch_size, self.image_size, self.image_size) ) def _snake_case ( self : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForSemanticSegmentation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , labels=__UpperCamelCase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size, self.image_size) ) def _snake_case ( self : Tuple ) ->Any: '''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 a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : Dict = (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else () a : int = ( { 'depth-estimation': DPTForDepthEstimation, 'feature-extraction': DPTModel, 'image-segmentation': DPTForSemanticSegmentation, } if is_torch_available() else {} ) a : str = False a : List[str] = False a : Dict = False def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = DPTModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , has_text_modality=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : Optional[int] ) ->Any: '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason="""DPT does not use inputs_embeds""" ) def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' pass def _snake_case ( self : int ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) _UpperCAmelCase = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__UpperCamelCase , nn.Linear ) ) def _snake_case ( self : Optional[int] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , __UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCamelCase ) def _snake_case ( self : str ) ->int: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_depth_estimation(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCamelCase ) def _snake_case ( self : str ) ->Any: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ): continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = False _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ) or not model_class.supports_gradient_checkpointing: continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.gradient_checkpointing_enable() model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : Tuple ) ->List[str]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = _config_zero_init(__UpperCamelCase ) for model_class in self.all_model_classes: _UpperCAmelCase = model_class(config=__UpperCamelCase ) # Skip the check for the backbone _UpperCAmelCase = [] for name, module in model.named_modules(): if module.__class__.__name__ == "DPTViTHybridEmbeddings": _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""" , ) @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" ) def _snake_case ( self : Dict ) ->Tuple: '''simple docstring''' pass @slow def _snake_case ( self : Optional[int] ) ->List[Any]: '''simple docstring''' for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]: _UpperCAmelCase = DPTModel.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = """add""" with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) return image @require_torch @require_vision @slow class a_ ( unittest.TestCase ): def _snake_case ( self : Any ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = DPTImageProcessor.from_pretrained("""Intel/dpt-hybrid-midas""" ) _UpperCAmelCase = DPTForDepthEstimation.from_pretrained("""Intel/dpt-hybrid-midas""" ).to(__UpperCamelCase ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=__UpperCamelCase , return_tensors="""pt""" ).to(__UpperCamelCase ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**__UpperCamelCase ) _UpperCAmelCase = outputs.predicted_depth # verify the predicted depth _UpperCAmelCase = torch.Size((1, 3_84, 3_84) ) self.assertEqual(predicted_depth.shape , __UpperCamelCase ) _UpperCAmelCase = torch.tensor( [[[5.6_4_3_7, 5.6_1_4_6, 5.6_5_1_1], [5.4_3_7_1, 5.5_6_4_9, 5.5_9_5_8], [5.5_2_1_5, 5.5_1_8_4, 5.5_2_9_3]]] ).to(__UpperCamelCase ) self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 1_00 , __UpperCamelCase , atol=1e-4 ) )
19
1
"""simple docstring""" import warnings from ...utils import logging from .image_processing_deit import DeiTImageProcessor a : Any = logging.get_logger(__name__) class a_ ( _UpperCAmelCase ): def __init__( self : Optional[int] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[int] ) ->None: '''simple docstring''' warnings.warn( """The class DeiTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please""" """ use DeiTImageProcessor instead.""" , __UpperCamelCase , ) super().__init__(*__UpperCamelCase , **__UpperCamelCase )
19
"""simple docstring""" import enum import warnings from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING a : List[str] = logging.get_logger(__name__) class a_ ( enum.Enum ): a : Optional[Any] = 0 a : Dict = 1 @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'generated' def __init__( self : int , *__UpperCamelCase : Optional[int] , **__UpperCamelCase : str ) ->Any: '''simple docstring''' super().__init__(*__UpperCamelCase , **__UpperCamelCase ) self.check_model_type( TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if self.framework == """tf""" else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : int=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : Dict=None , **__UpperCamelCase : Any , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = {} if truncation is not None: _UpperCAmelCase = truncation _UpperCAmelCase = generate_kwargs _UpperCAmelCase = {} if return_tensors is not None and return_type is None: _UpperCAmelCase = ReturnType.TENSORS if return_tensors else ReturnType.TEXT if return_type is not None: _UpperCAmelCase = return_type if clean_up_tokenization_spaces is not None: _UpperCAmelCase = clean_up_tokenization_spaces if stop_sequence is not None: _UpperCAmelCase = self.tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) if len(__UpperCamelCase ) > 1: warnings.warn( """Stopping on a multiple token sequence is not yet supported on transformers. The first token of""" """ the stop sequence will be used as the stop sequence string in the interim.""" ) _UpperCAmelCase = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def _snake_case ( self : int , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' return True def _snake_case ( self : Optional[Any] , *__UpperCamelCase : Any , __UpperCamelCase : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model.config.prefix if self.model.config.prefix is not None else """""" if isinstance(args[0] , __UpperCamelCase ): if self.tokenizer.pad_token_id is None: raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" ) _UpperCAmelCase = ([prefix + arg for arg in args[0]],) _UpperCAmelCase = True elif isinstance(args[0] , __UpperCamelCase ): _UpperCAmelCase = (prefix + args[0],) _UpperCAmelCase = False else: raise ValueError( f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" ) _UpperCAmelCase = self.tokenizer(*__UpperCamelCase , padding=__UpperCamelCase , truncation=__UpperCamelCase , return_tensors=self.framework ) # This is produced by tokenizers but is an invalid generate kwargs if "token_type_ids" in inputs: del inputs["token_type_ids"] return inputs def __call__( self : Dict , *__UpperCamelCase : str , **__UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = super().__call__(*__UpperCamelCase , **__UpperCamelCase ) if ( isinstance(args[0] , __UpperCamelCase ) and all(isinstance(__UpperCamelCase , __UpperCamelCase ) for el in args[0] ) and all(len(__UpperCamelCase ) == 1 for res in result ) ): return [res[0] for res in result] return result def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : str=TruncationStrategy.DO_NOT_TRUNCATE , **__UpperCamelCase : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self._parse_and_tokenize(__UpperCamelCase , truncation=__UpperCamelCase , **__UpperCamelCase ) return inputs def _snake_case ( self : str , __UpperCamelCase : Dict , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' if self.framework == "pt": _UpperCAmelCase ,_UpperCAmelCase = model_inputs["""input_ids"""].shape elif self.framework == "tf": _UpperCAmelCase ,_UpperCAmelCase = tf.shape(model_inputs["""input_ids"""] ).numpy() _UpperCAmelCase = generate_kwargs.get("""min_length""" , self.model.config.min_length ) _UpperCAmelCase = generate_kwargs.get("""max_length""" , self.model.config.max_length ) self.check_inputs(__UpperCamelCase , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] ) _UpperCAmelCase = self.model.generate(**__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = output_ids.shape[0] if self.framework == "pt": _UpperCAmelCase = output_ids.reshape(__UpperCamelCase , out_b // in_b , *output_ids.shape[1:] ) elif self.framework == "tf": _UpperCAmelCase = tf.reshape(__UpperCamelCase , (in_b, out_b // in_b, *output_ids.shape[1:]) ) return {"output_ids": output_ids} def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : Union[str, Any]=ReturnType.TEXT , __UpperCamelCase : int=False ) ->Any: '''simple docstring''' _UpperCAmelCase = [] for output_ids in model_outputs["output_ids"][0]: if return_type == ReturnType.TENSORS: _UpperCAmelCase = {f"""{self.return_name}_token_ids""": output_ids} elif return_type == ReturnType.TEXT: _UpperCAmelCase = { f"""{self.return_name}_text""": self.tokenizer.decode( __UpperCamelCase , skip_special_tokens=__UpperCamelCase , clean_up_tokenization_spaces=__UpperCamelCase , ) } records.append(__UpperCamelCase ) return records @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'summary' def __call__( self : Optional[Any] , *__UpperCamelCase : Optional[Any] , **__UpperCamelCase : Optional[int] ) ->Any: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->bool: '''simple docstring''' if max_length < min_length: logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" ) if input_length < max_length: logger.warning( f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """ """a summarization task, where outputs shorter than the input are typically wanted, you might """ f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" ) @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : Optional[int] = 'translation' def _snake_case ( self : Union[str, Any] , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' if input_length > 0.9 * max_length: logger.warning( f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """ """increasing your max_length manually, e.g. translator('...', max_length=400)""" ) return True def _snake_case ( self : Tuple , *__UpperCamelCase : List[str] , __UpperCamelCase : Tuple=TruncationStrategy.DO_NOT_TRUNCATE , __UpperCamelCase : Tuple=None , __UpperCamelCase : Union[str, Any]=None ) ->Tuple: '''simple docstring''' if getattr(self.tokenizer , """_build_translation_inputs""" , __UpperCamelCase ): return self.tokenizer._build_translation_inputs( *__UpperCamelCase , return_tensors=self.framework , truncation=__UpperCamelCase , src_lang=__UpperCamelCase , tgt_lang=__UpperCamelCase ) else: return super()._parse_and_tokenize(*__UpperCamelCase , truncation=__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : int=None , __UpperCamelCase : int=None , **__UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = super()._sanitize_parameters(**__UpperCamelCase ) if src_lang is not None: _UpperCAmelCase = src_lang if tgt_lang is not None: _UpperCAmelCase = tgt_lang if src_lang is None and tgt_lang is None: # Backward compatibility, direct arguments use is preferred. _UpperCAmelCase = kwargs.get("""task""" , self.task ) _UpperCAmelCase = task.split("""_""" ) if task and len(__UpperCamelCase ) == 4: # translation, XX, to YY _UpperCAmelCase = items[1] _UpperCAmelCase = items[3] return preprocess_params, forward_params, postprocess_params def __call__( self : List[str] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->int: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase )
19
1
"""simple docstring""" def _UpperCamelCase ( _A , _A ) -> int: """simple docstring""" return int((input_a, input_a).count(0 ) != 0 ) def _UpperCamelCase ( ) -> None: """simple docstring""" assert nand_gate(0 , 0 ) == 1 assert nand_gate(0 , 1 ) == 1 assert nand_gate(1 , 0 ) == 1 assert nand_gate(1 , 1 ) == 0 if __name__ == "__main__": print(nand_gate(0, 0)) print(nand_gate(0, 1)) print(nand_gate(1, 0)) print(nand_gate(1, 1))
19
"""simple docstring""" import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class a_ ( unittest.TestCase ): @property def _snake_case ( self : Dict ) ->int: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") , up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") , ) return model @property def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = VQModel( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=3 , ) return model @property def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) return CLIPTextModel(__UpperCamelCase ) def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = self.dummy_vq_model _UpperCAmelCase = LDMPipeline(unet=__UpperCamelCase , vqvae=__UpperCamelCase , scheduler=__UpperCamelCase ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" ).images _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" , return_dict=__UpperCamelCase )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _UpperCAmelCase = np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < tolerance @slow @require_torch class a_ ( unittest.TestCase ): def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256""" ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=5 , output_type="""numpy""" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _UpperCAmelCase = np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance
19
1
"""simple docstring""" from pathlib import PurePosixPath from typing import Optional import fsspec from fsspec import AbstractFileSystem from huggingface_hub.hf_api import DatasetInfo from ..utils.file_utils import get_authentication_headers_for_url from ..utils.hub import hf_hub_url class a_ ( _UpperCAmelCase ): a : List[Any] = '' a : Union[str, Any] = 'hf-legacy' # "hf://"" is reserved for hffs def __init__( self : Tuple , __UpperCamelCase : Optional[DatasetInfo] = None , __UpperCamelCase : Optional[str] = None , **__UpperCamelCase : Any , ) ->Any: '''simple docstring''' super().__init__(self , **__UpperCamelCase ) _UpperCAmelCase = repo_info _UpperCAmelCase = token _UpperCAmelCase = None def _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' if self.dir_cache is None: _UpperCAmelCase = {} for hf_file in self.repo_info.siblings: # TODO(QL): add sizes _UpperCAmelCase = { """name""": hf_file.rfilename, """size""": None, """type""": """file""", } self.dir_cache.update( { str(__UpperCamelCase ): {"""name""": str(__UpperCamelCase ), """size""": None, """type""": """directory"""} for d in list(PurePosixPath(hf_file.rfilename ).parents )[:-1] } ) def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : str = "rb" , **__UpperCamelCase : Any , ) ->List[str]: '''simple docstring''' if not isinstance(self.repo_info , __UpperCamelCase ): raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}""" ) _UpperCAmelCase = hf_hub_url(self.repo_info.id , __UpperCamelCase , revision=self.repo_info.sha ) return fsspec.open( __UpperCamelCase , mode=__UpperCamelCase , headers=get_authentication_headers_for_url(__UpperCamelCase , use_auth_token=self.token ) , client_kwargs={"""trust_env""": True} , ).open() def _snake_case ( self : int , __UpperCamelCase : int , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' self._get_dirs() _UpperCAmelCase = self._strip_protocol(__UpperCamelCase ) if path in self.dir_cache: return self.dir_cache[path] else: raise FileNotFoundError(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple=False , **__UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' self._get_dirs() _UpperCAmelCase = PurePosixPath(path.strip("""/""" ) ) _UpperCAmelCase = {} for p, f in self.dir_cache.items(): _UpperCAmelCase = PurePosixPath(p.strip("""/""" ) ) _UpperCAmelCase = p.parent if root == path: _UpperCAmelCase = f _UpperCAmelCase = list(paths.values() ) if detail: return out else: return sorted(f["""name"""] for f in out )
19
"""simple docstring""" import re from filelock import FileLock try: import nltk a : str = True except (ImportError, ModuleNotFoundError): a : List[str] = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def _UpperCamelCase ( _A ) -> str: """simple docstring""" re.sub("""<n>""" , """""" , _A ) # 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(_A ) )
19
1
"""simple docstring""" import re import warnings from contextlib import contextmanager from ...processing_utils import ProcessorMixin class a_ ( _UpperCAmelCase ): a : Any = ['image_processor', 'tokenizer'] a : Optional[int] = 'AutoImageProcessor' a : Any = 'AutoTokenizer' def __init__( self : List[str] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : List[str]=None , **__UpperCamelCase : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`""" """ instead.""" , __UpperCamelCase , ) _UpperCAmelCase = kwargs.pop("""feature_extractor""" ) _UpperCAmelCase = 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__(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def __call__( self : Union[str, Any] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->List[str]: '''simple docstring''' if self._in_target_context_manager: return self.current_processor(*__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""images""" , __UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""text""" , __UpperCamelCase ) if len(__UpperCamelCase ) > 0: _UpperCAmelCase = args[0] _UpperCAmelCase = args[1:] if images is None and text is None: raise ValueError("""You need to specify either an `images` or `text` input to process.""" ) if images is not None: _UpperCAmelCase = self.image_processor(__UpperCamelCase , *__UpperCamelCase , **__UpperCamelCase ) if text is not None: _UpperCAmelCase = self.tokenizer(__UpperCamelCase , **__UpperCamelCase ) if text is None: return inputs elif images is None: return encodings else: _UpperCAmelCase = encodings["""input_ids"""] return inputs def _snake_case ( self : Union[str, Any] , *__UpperCamelCase : int , **__UpperCamelCase : Tuple ) ->Tuple: '''simple docstring''' return self.tokenizer.batch_decode(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Tuple , *__UpperCamelCase : int , **__UpperCamelCase : Union[str, Any] ) ->int: '''simple docstring''' return self.tokenizer.decode(*__UpperCamelCase , **__UpperCamelCase ) @contextmanager def _snake_case ( self : Tuple ) ->Union[str, Any]: '''simple docstring''' warnings.warn( """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """ """labels by using the argument `text` of the regular `__call__` method (either in the same call as """ """your images inputs, or in a separate call.""" ) _UpperCAmelCase = True _UpperCAmelCase = self.tokenizer yield _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def _snake_case ( self : str , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any]=False , __UpperCamelCase : Union[str, Any]=None ) ->List[str]: '''simple docstring''' if added_vocab is None: _UpperCAmelCase = self.tokenizer.get_added_vocab() _UpperCAmelCase = {} while tokens: _UpperCAmelCase = re.search(r"""<s_(.*?)>""" , __UpperCamelCase , re.IGNORECASE ) if start_token is None: break _UpperCAmelCase = start_token.group(1 ) _UpperCAmelCase = re.search(rf"""</s_{key}>""" , __UpperCamelCase , re.IGNORECASE ) _UpperCAmelCase = start_token.group() if end_token is None: _UpperCAmelCase = tokens.replace(__UpperCamelCase , """""" ) else: _UpperCAmelCase = end_token.group() _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.search(f"""{start_token_escaped}(.*?){end_token_escaped}""" , __UpperCamelCase , re.IGNORECASE ) if content is not None: _UpperCAmelCase = content.group(1 ).strip() if r"<s_" in content and r"</s_" in content: # non-leaf node _UpperCAmelCase = self.tokenajson(__UpperCamelCase , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if value: if len(__UpperCamelCase ) == 1: _UpperCAmelCase = value[0] _UpperCAmelCase = value else: # leaf nodes _UpperCAmelCase = [] for leaf in content.split(r"""<sep/>""" ): _UpperCAmelCase = leaf.strip() if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>": _UpperCAmelCase = leaf[1:-2] # for categorical special tokens output[key].append(__UpperCamelCase ) if len(output[key] ) == 1: _UpperCAmelCase = output[key][0] _UpperCAmelCase = tokens[tokens.find(__UpperCamelCase ) + len(__UpperCamelCase ) :].strip() if tokens[:6] == r"<sep/>": # non-leaf nodes return [output] + self.tokenajson(tokens[6:] , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if len(__UpperCamelCase ): return [output] if is_inner_value else output else: return [] if is_inner_value else {"text_sequence": tokens} @property def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' warnings.warn( """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""" , __UpperCamelCase , ) return self.image_processor_class @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' warnings.warn( """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""" , __UpperCamelCase , ) return self.image_processor
19
"""simple docstring""" import unittest from transformers import PegasusConfig, PegasusTokenizer, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_configuration_common import ConfigTester 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 : str = '''platform''' import jax import jax.numpy as jnp import numpy as np from transformers import FlaxPegasusForConditionalGeneration, FlaxPegasusModel @require_flax class a_ : a : List[Any] = PegasusConfig a : Dict = {} a : List[Any] = 'gelu' def __init__( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Tuple=13 , __UpperCamelCase : Tuple=7 , __UpperCamelCase : Tuple=True , __UpperCamelCase : Any=False , __UpperCamelCase : Any=99 , __UpperCamelCase : Optional[int]=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : List[str]=4 , __UpperCamelCase : Dict=37 , __UpperCamelCase : int=0.1 , __UpperCamelCase : Dict=0.1 , __UpperCamelCase : Optional[Any]=20 , __UpperCamelCase : Tuple=2 , __UpperCamelCase : Optional[int]=1 , __UpperCamelCase : Tuple=0 , ) ->int: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = bos_token_id def _snake_case ( self : Union[str, Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ).clip(3 , self.vocab_size ) _UpperCAmelCase = np.expand_dims(np.array([self.eos_token_id] * self.batch_size ) , 1 ) _UpperCAmelCase = np.concatenate([input_ids, eos_tensor] , axis=1 ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) _UpperCAmelCase = prepare_pegasus_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, inputs_dict def _snake_case ( self : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) , dtype="""i4""" ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _snake_case ( self : Any , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] , axis=-1 , ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_attention_mask=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _UpperCamelCase ( _A , _A , _A , _A=None , _A=None , ) -> int: """simple docstring""" if attention_mask is None: _UpperCAmelCase = np.not_equal(_A , config.pad_token_id ).astype(np.inta ) if decoder_attention_mask is None: _UpperCAmelCase = np.concatenate( [ np.ones(decoder_input_ids[:, :1].shape , dtype=np.inta ), np.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id ).astype(np.inta ), ] , axis=-1 , ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, } @require_flax class a_ ( _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( ( FlaxPegasusForConditionalGeneration, FlaxPegasusModel, ) if is_flax_available() else () ) a : Any = (FlaxPegasusForConditionalGeneration,) if is_flax_available() else () a : Any = True a : int = False a : Union[str, Any] = False a : Optional[int] = False def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->List[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model_class(__UpperCamelCase ) @jax.jit def encode_jitted(__UpperCamelCase : List[Any] , __UpperCamelCase : str=None , **__UpperCamelCase : int ): return model.encode(input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] , inputs_dict["""attention_mask"""] ) _UpperCAmelCase = { """decoder_input_ids""": inputs_dict["""decoder_input_ids"""], """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""], """encoder_outputs""": encoder_outputs, } @jax.jit def decode_jitted(__UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple ): return model.decode( decoder_input_ids=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , encoder_outputs=__UpperCamelCase , ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) @slow def _snake_case ( self : int ) ->int: '''simple docstring''' for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained("""google/pegasus-large""" , from_pt=__UpperCamelCase ) _UpperCAmelCase = np.ones((1, 1) ) _UpperCAmelCase = model(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) @slow def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusForConditionalGeneration.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = PegasusTokenizer.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = [ """ PG&E stated it scheduled the blackouts in response to forecasts for high winds amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow.""", """ The London trio are up for best UK act and best album, as well as getting two nominations in the best song category.\"We got told like this morning 'Oh I think you're nominated'\", said Dappy.\"And I was like 'Oh yeah, which one?' And now we've got nominated for four awards. I mean, wow!\"Bandmate Fazer added: \"We thought it's best of us to come down and mingle with everyone and say hello to the cameras. And now we find we've got four nominations.\"The band have two shots at the best song prize, getting the nod for their Tynchy Stryder collaboration Number One, and single Strong Again.Their album Uncle B will also go up against records by the likes of Beyonce and Kanye West.N-Dubz picked up the best newcomer Mobo in 2007, but female member Tulisa said they wouldn't be too disappointed if they didn't win this time around.\"At the end of the day we're grateful to be where we are in our careers.\"If it don't happen then it don't happen - live to fight another day and keep on making albums and hits for the fans.\"Dappy also revealed they could be performing live several times on the night.The group will be doing Number One and also a possible rendition of the War Child single, I Got Soul.The charity song is a re-working of The Killers' All These Things That I've Done and is set to feature artists like Chipmunk, Ironik and Pixie Lott.This year's Mobos will be held outside of London for the first time, in Glasgow on 30 September.N-Dubz said they were looking forward to performing for their Scottish fans and boasted about their recent shows north of the border.\"We just done Edinburgh the other day,\" said Dappy.\"We smashed up an N-Dubz show over there. We done Aberdeen about three or four months ago - we smashed up that show over there! Everywhere we go we smash it up!\" """, ] _UpperCAmelCase = [ """California's largest electricity provider has turned off power to hundreds of thousands of customers.""", """Pop group N-Dubz have revealed they were surprised to get four nominations for this year's Mobo Awards.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""np""" , truncation=__UpperCamelCase , max_length=5_12 , padding=__UpperCamelCase ) _UpperCAmelCase = model.generate(**__UpperCamelCase , num_beams=2 ).sequences _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase , skip_special_tokens=__UpperCamelCase ) assert tgt_text == decoded
19
1
"""simple docstring""" import datasets from .nmt_bleu import compute_bleu # From: https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py a : Optional[int] = '''\ @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", } ''' a : Tuple = '''\ 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. ''' a : Optional[Any] = ''' 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 a_ ( datasets.Metric ): def _snake_case ( self : Optional[int] ) ->str: '''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 _snake_case ( self : Dict , __UpperCamelCase : Dict , __UpperCamelCase : int , __UpperCamelCase : str=4 , __UpperCamelCase : Optional[int]=False ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = compute_bleu( reference_corpus=__UpperCamelCase , translation_corpus=__UpperCamelCase , max_order=__UpperCamelCase , smooth=__UpperCamelCase ) ((_UpperCAmelCase) ,(_UpperCAmelCase) ,(_UpperCAmelCase) ,(_UpperCAmelCase) ,(_UpperCAmelCase) ,(_UpperCAmelCase)) = score return { "bleu": bleu, "precisions": precisions, "brevity_penalty": bp, "length_ratio": ratio, "translation_length": translation_length, "reference_length": reference_length, }
19
"""simple docstring""" import tempfile import unittest from transformers import TaConfig, is_torch_available from transformers.testing_utils import ( require_sentencepiece, require_tokenizers, require_torch, slow, torch_device, ) from ...generation.test_utils import GenerationTesterMixin from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel class a_ : def __init__( self : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : List[Any]=99 , __UpperCamelCase : Optional[int]=13 , __UpperCamelCase : List[str]=7 , __UpperCamelCase : List[Any]=9 , __UpperCamelCase : List[Any]=True , __UpperCamelCase : str=True , __UpperCamelCase : int=False , __UpperCamelCase : int=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : Optional[int]=4 , __UpperCamelCase : Any=37 , __UpperCamelCase : List[Any]=8 , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : str=0.0_0_2 , __UpperCamelCase : Union[str, Any]=1 , __UpperCamelCase : List[Any]=0 , __UpperCamelCase : Tuple=0 , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Any=None , ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = encoder_seq_length _UpperCAmelCase = decoder_seq_length # For common tests _UpperCAmelCase = self.decoder_seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = d_ff _UpperCAmelCase = relative_attention_num_buckets _UpperCAmelCase = dropout_rate _UpperCAmelCase = initializer_factor _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = decoder_start_token_id _UpperCAmelCase = None _UpperCAmelCase = decoder_layers def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' return TaConfig.from_pretrained("""google/umt5-base""" ) def _snake_case ( self : List[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Tuple=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : str=None , ) ->int: '''simple docstring''' if attention_mask is None: _UpperCAmelCase = input_ids.ne(config.pad_token_id ) if decoder_attention_mask is None: _UpperCAmelCase = decoder_input_ids.ne(config.pad_token_id ) if head_mask is None: _UpperCAmelCase = torch.ones(config.num_hidden_layers , config.num_attention_heads , device=__UpperCamelCase ) if decoder_head_mask is None: _UpperCAmelCase = torch.ones(config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) if cross_attn_head_mask is None: _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.encoder_seq_length] , self.vocab_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size ) # we need to clamp the input ids here to avoid having pad token in between # this is because for NllbMoe the position_ids are prepared such that # all pad tokens have pos id = 2 and rest are between 2..seq_length # and the seq_length here is seq_length - num_pad_tokens # but when using past, there is no way of knowing if the past input ids had # pad tokens in them, which results in incorrect seq_lenth and which in turn results in # position_ids being off by num_pad_tokens in past input _UpperCAmelCase = input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = decoder_input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = self.get_config() _UpperCAmelCase = config.num_attention_heads _UpperCAmelCase = self.prepare_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, input_dict def _snake_case ( self : Union[str, Any] ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' return TaConfig( vocab_size=1_66 , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : Tuple ) ->Dict: '''simple docstring''' return TaConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[str] , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model( input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , ) _UpperCAmelCase = model(input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase ) _UpperCAmelCase = result.last_hidden_state _UpperCAmelCase = result.past_key_values _UpperCAmelCase = result.encoder_last_hidden_state self.parent.assertEqual(encoder_output.size() , (self.batch_size, self.encoder_seq_length, self.hidden_size) ) self.parent.assertEqual(decoder_output.size() , (self.batch_size, self.decoder_seq_length, self.hidden_size) ) # There should be `num_layers` key value embeddings stored in decoder_past self.parent.assertEqual(len(__UpperCamelCase ) , config.num_layers ) # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple self.parent.assertEqual(len(decoder_past[0] ) , 4 ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] , ) ->str: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).get_decoder().to(__UpperCamelCase ).eval() # first forward pass _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) + 1 ) _UpperCAmelCase ,_UpperCAmelCase = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids _UpperCAmelCase = ids_tensor((self.batch_size, 1) , config.vocab_size ) # append to next input_ids and _UpperCAmelCase = torch.cat([input_ids, next_tokens] , dim=-1 ) _UpperCAmelCase = model(__UpperCamelCase )["""last_hidden_state"""] _UpperCAmelCase = model(__UpperCamelCase , past_key_values=__UpperCamelCase )["""last_hidden_state"""] # select random slice _UpperCAmelCase = ids_tensor((1,) , output_from_past.shape[-1] ).item() _UpperCAmelCase = output_from_no_past[:, -1, random_slice_idx].detach() _UpperCAmelCase = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(__UpperCamelCase , __UpperCamelCase , atol=1e-3 ) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : int , __UpperCamelCase : Dict , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).to(__UpperCamelCase ).half().eval() _UpperCAmelCase = model(**__UpperCamelCase )["""last_hidden_state"""] self.parent.assertFalse(torch.isnan(__UpperCamelCase ).any().item() ) @require_torch class a_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else () ) a : Tuple = (UMTaForConditionalGeneration,) if is_torch_available() else () a : Optional[Any] = ( { 'conversational': UMTaForConditionalGeneration, 'feature-extraction': UMTaModel, 'summarization': UMTaForConditionalGeneration, 'text2text-generation': UMTaForConditionalGeneration, 'translation': UMTaForConditionalGeneration, 'question-answering': UMTaForQuestionAnswering, } if is_torch_available() else {} ) a : Any = True a : Optional[int] = False a : Any = False a : Optional[int] = True a : Optional[Any] = True # The small UMT5 model needs higher percentages for CPU/MP tests a : int = [0.8, 0.9] def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = UMTaModelTester(self ) @unittest.skip("""Test has a segmentation fault on torch 1.8.0""" ) def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = UMTaModel(config_and_inputs[0] ).to(__UpperCamelCase ) with tempfile.TemporaryDirectory() as tmpdirname: torch.onnx.export( __UpperCamelCase , (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) , f"""{tmpdirname}/t5_test.onnx""" , export_params=__UpperCamelCase , opset_version=9 , input_names=["""input_ids""", """decoder_input_ids"""] , ) @unittest.skipIf(torch_device == """cpu""" , """Cant do half precision""" ) def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model_fpaa_forward(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = ["""encoder_attentions""", """decoder_attentions""", """cross_attentions"""] _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = config_and_inputs[0] _UpperCAmelCase = UMTaForConditionalGeneration(__UpperCamelCase ).eval() model.to(__UpperCamelCase ) _UpperCAmelCase = { """head_mask""": torch.zeros(config.num_layers , config.num_heads , device=__UpperCamelCase ), """decoder_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), """cross_attn_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), } for attn_name, (name, mask) in zip(__UpperCamelCase , head_masking.items() ): _UpperCAmelCase = {name: mask} # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified if name == "head_mask": _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ) _UpperCAmelCase = model.generate( config_and_inputs[1]["""input_ids"""] , num_beams=1 , max_length=3 , output_attentions=__UpperCamelCase , return_dict_in_generate=__UpperCamelCase , **__UpperCamelCase , ) # We check the state of decoder_attentions and cross_attentions just from the last step _UpperCAmelCase = out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1] self.assertEqual(sum([w.sum().item() for w in attn_weights] ) , 0.0 ) @unittest.skip("""Does not work on the tiny model as we keep hitting edge cases.""" ) def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' pass @require_torch @require_sentencepiece @require_tokenizers class a_ ( unittest.TestCase ): @slow @unittest.skip( """Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged""" ) def _snake_case ( self : Optional[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = UMTaForConditionalGeneration.from_pretrained("""google/umt5-small""" , return_dict=__UpperCamelCase ).to(__UpperCamelCase ) _UpperCAmelCase = AutoTokenizer.from_pretrained("""google/umt5-small""" , use_fast=__UpperCamelCase , legacy=__UpperCamelCase ) _UpperCAmelCase = [ """Bonjour monsieur <extra_id_0> bien <extra_id_1>.""", """No se como puedo <extra_id_0>.""", """This is the reason why we <extra_id_0> them.""", """The <extra_id_0> walks in <extra_id_1>, seats""", """A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""pt""" , padding=__UpperCamelCase ).input_ids # fmt: off _UpperCAmelCase = torch.tensor( [ [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0], [ 5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1], ] ) # fmt: on torch.testing.assert_allclose(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model.generate(input_ids.to(__UpperCamelCase ) ) _UpperCAmelCase = [ """<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>""", """<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", ] _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase ) self.assertEqual(__UpperCamelCase , __UpperCamelCase )
19
1
"""simple docstring""" import math def _UpperCamelCase ( _A ) -> bool: """simple docstring""" _UpperCAmelCase = math.loga(math.sqrt(4 * positive_integer + 1 ) / 2 + 1 / 2 ) return exponent == int(_A ) def _UpperCamelCase ( _A = 1 / 1_2_3_4_5 ) -> int: """simple docstring""" _UpperCAmelCase = 0 _UpperCAmelCase = 0 _UpperCAmelCase = 3 while True: _UpperCAmelCase = (integer**2 - 1) / 4 # if candidate is an integer, then there is a partition for k if partition_candidate == int(_A ): _UpperCAmelCase = int(_A ) total_partitions += 1 if check_partition_perfect(_A ): perfect_partitions += 1 if perfect_partitions > 0: if perfect_partitions / total_partitions < max_proportion: return int(_A ) integer += 1 if __name__ == "__main__": print(F"{solution() = }")
19
"""simple docstring""" import copy import os import tempfile from unittest import TestCase from unittest.mock import patch import numpy as np import pyarrow as pa import pyarrow.parquet as pq import pytest from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence from datasets.features import ArrayaD, ClassLabel, Features, Image, Value from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects from datasets.keyhash import DuplicatedKeysError, InvalidKeyError from .utils import require_pil class a_ ( _UpperCAmelCase ): def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : Any ) ->List[str]: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) , type=pa.intaa() ) def _snake_case ( self : Optional[int] ) ->Tuple: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""bool""" ) , type=Value("""int64""" ) ) ) def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : str ) ->Dict: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=Value("""int64""" ) ) ) def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : List[str] ) ->Any: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=Value("""int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) def _snake_case ( self : List[Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=ArrayaD((1, 3) , """int64""" ) ) ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : Optional[int] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) @require_pil def _snake_case ( self : str ) ->Optional[Any]: '''simple docstring''' import PIL.Image _UpperCAmelCase = PIL.Image.fromarray(np.arange(10 , dtype=np.uinta ).reshape(2 , 5 ) ) with patch( """datasets.arrow_writer.cast_to_python_objects""" , side_effect=__UpperCamelCase ) as mock_cast_to_python_objects: _UpperCAmelCase = pa.array(TypedSequence([{"""path""": None, """bytes""": b"""image_bytes"""}, pil_image] , type=Image() ) ) _UpperCAmelCase ,_UpperCAmelCase = mock_cast_to_python_objects.call_args_list[-1] self.assertIn("""optimize_list_casting""" , __UpperCamelCase ) self.assertFalse(kwargs["""optimize_list_casting"""] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferReader(_A ) if isinstance(_A , pa.Buffer ) else pa.memory_map(_A ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() assert len(pa_table.to_batches() ) == expected_num_chunks assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} del pa_table @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} ) with ArrowWriter(stream=_A , features=_A ) as writer: writer.write({"""labels""": 0} ) writer.write({"""labels""": 1} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == features.arrow_schema assert writer._schema.metadata == features.arrow_schema.metadata _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() _UpperCAmelCase = pa_table.schema assert pa_table.num_rows == 2 assert schema == features.arrow_schema assert schema.metadata == features.arrow_schema.metadata assert features == Features.from_arrow_schema(_A ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=[1, 2] ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1_0 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=1_0 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=2 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) writer.write_batch({"""col_1""": [], """col_2""": []} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) ) writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> str: """simple docstring""" with tempfile.TemporaryDirectory() as tmp_dir: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} _UpperCAmelCase = os.path.join(_A , """test.arrow""" ) with ArrowWriter(path=_A , schema=pa.schema(_A ) ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(_A , 1 ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" if pa.types.is_list(_A ): return get_base_dtype(arr_type.value_type ) else: return arr_type def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" if isinstance(lst[0] , _A ): change_first_primitive_element_in_list(lst[0] , _A ) else: _UpperCAmelCase = value @pytest.mark.parametrize("""optimized_int_type, expected_dtype""" , [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.array(TypedSequence(_A , optimized_int_type=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype @pytest.mark.parametrize( """col, expected_dtype""" , [ ("""attention_mask""", pa.inta()), ("""special_tokens_mask""", pa.inta()), ("""token_type_ids""", pa.inta()), ("""input_ids""", pa.intaa()), ("""other""", pa.intaa()), ] , ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> str: """simple docstring""" _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype # not in range if col != "other": # avoids errors due to in-place modifications _UpperCAmelCase = copy.deepcopy(_A ) _UpperCAmelCase = np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1 change_first_primitive_element_in_list(_A , _A ) _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == pa.intaa() @pytest.mark.parametrize("""raise_exception""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = str(tmp_path / """dataset-train.arrow""" ) try: with ArrowWriter(path=_A ) as writer: if raise_exception: raise pa.lib.ArrowInvalid() else: writer.stream.close() except pa.lib.ArrowInvalid: pass finally: assert writer.stream.closed def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = """mock://dataset-train.arrow""" with ArrowWriter(path=_A , storage_options=mockfs.storage_options ) as writer: assert isinstance(writer._fs , type(_A ) ) assert writer._fs.storage_options == mockfs.storage_options writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert mockfs.exists(_A ) def _UpperCamelCase ( ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter(stream=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} @require_pil @pytest.mark.parametrize("""embed_local_files""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" import PIL.Image _UpperCAmelCase = str(tmp_path / """test_image_rgb.jpg""" ) PIL.Image.fromarray(np.zeros((5, 5) , dtype=np.uinta ) ).save(_A , format="""png""" ) _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter( stream=_A , features=Features({"""image""": Image()} ) , embed_local_files=_A ) as writer: writer.write({"""image""": image_path} ) writer.finalize() _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) _UpperCAmelCase = pa_table.to_pydict() if embed_local_files: assert isinstance(out["""image"""][0]["""path"""] , _A ) with open(_A , """rb""" ) as f: assert out["image"][0]["bytes"] == f.read() else: assert out["image"][0]["path"] == image_path assert out["image"][0]["bytes"] is None def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = pa.schema([pa.field("""col_1""" , pa.string() , nullable=_A )] ) _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter(stream=_A ) as writer: writer._build_writer(inferred_schema=_A ) assert writer._schema == pa.schema([pa.field("""col_1""" , pa.string() )] )
19
1
"""simple docstring""" from typing import Dict, List, Optional, Union import numpy as np from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict from ...image_transforms import ( center_crop, get_resize_output_image_size, normalize, rescale, resize, to_channel_dimension_format, ) from ...image_utils import ( IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD, ChannelDimension, ImageInput, PILImageResampling, is_valid_image, to_numpy_array, valid_images, ) from ...utils import TensorType, is_vision_available, logging if is_vision_available(): import PIL a : Union[str, Any] = logging.get_logger(__name__) def _UpperCamelCase ( _A ) -> List[List[ImageInput]]: """simple docstring""" if isinstance(_A , (list, tuple) ) and isinstance(videos[0] , (list, tuple) ) and is_valid_image(videos[0][0] ): return videos elif isinstance(_A , (list, tuple) ) and is_valid_image(videos[0] ): return [videos] elif is_valid_image(_A ): return [[videos]] raise ValueError(F"""Could not make batched video from {videos}""" ) class a_ ( _UpperCAmelCase ): a : List[str] = ['pixel_values'] def __init__( self : Dict , __UpperCamelCase : bool = True , __UpperCamelCase : Dict[str, int] = None , __UpperCamelCase : PILImageResampling = PILImageResampling.BILINEAR , __UpperCamelCase : bool = True , __UpperCamelCase : Dict[str, int] = None , __UpperCamelCase : bool = True , __UpperCamelCase : Union[int, float] = 1 / 2_55 , __UpperCamelCase : bool = True , __UpperCamelCase : Optional[Union[float, List[float]]] = None , __UpperCamelCase : Optional[Union[float, List[float]]] = None , **__UpperCamelCase : Optional[int] , ) ->None: '''simple docstring''' super().__init__(**__UpperCamelCase ) _UpperCAmelCase = size if size is not None else {"""shortest_edge""": 2_24} _UpperCAmelCase = get_size_dict(__UpperCamelCase , default_to_square=__UpperCamelCase ) _UpperCAmelCase = crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24} _UpperCAmelCase = get_size_dict(__UpperCamelCase , param_name="""crop_size""" ) _UpperCAmelCase = do_resize _UpperCAmelCase = size _UpperCAmelCase = do_center_crop _UpperCAmelCase = crop_size _UpperCAmelCase = resample _UpperCAmelCase = do_rescale _UpperCAmelCase = rescale_factor _UpperCAmelCase = do_normalize _UpperCAmelCase = image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN _UpperCAmelCase = image_std if image_std is not None else IMAGENET_STANDARD_STD def _snake_case ( self : Dict , __UpperCamelCase : np.ndarray , __UpperCamelCase : Dict[str, int] , __UpperCamelCase : PILImageResampling = PILImageResampling.BILINEAR , __UpperCamelCase : Optional[Union[str, ChannelDimension]] = None , **__UpperCamelCase : List[Any] , ) ->np.ndarray: '''simple docstring''' _UpperCAmelCase = get_size_dict(__UpperCamelCase , default_to_square=__UpperCamelCase ) if "shortest_edge" in size: _UpperCAmelCase = get_resize_output_image_size(__UpperCamelCase , size["""shortest_edge"""] , default_to_square=__UpperCamelCase ) elif "height" in size and "width" in size: _UpperCAmelCase = (size["""height"""], size["""width"""]) else: raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}""" ) return resize(__UpperCamelCase , size=__UpperCamelCase , resample=__UpperCamelCase , data_format=__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : np.ndarray , __UpperCamelCase : Dict[str, int] , __UpperCamelCase : Optional[Union[str, ChannelDimension]] = None , **__UpperCamelCase : List[str] , ) ->np.ndarray: '''simple docstring''' _UpperCAmelCase = get_size_dict(__UpperCamelCase ) if "height" not in size or "width" not in size: raise ValueError(f"""Size must have 'height' and 'width' as keys. Got {size.keys()}""" ) return center_crop(__UpperCamelCase , size=(size["""height"""], size["""width"""]) , data_format=__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : np.ndarray , __UpperCamelCase : Union[int, float] , __UpperCamelCase : Optional[Union[str, ChannelDimension]] = None , **__UpperCamelCase : Any , ) ->int: '''simple docstring''' return rescale(__UpperCamelCase , scale=__UpperCamelCase , data_format=__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Dict , __UpperCamelCase : np.ndarray , __UpperCamelCase : Union[float, List[float]] , __UpperCamelCase : Union[float, List[float]] , __UpperCamelCase : Optional[Union[str, ChannelDimension]] = None , **__UpperCamelCase : List[Any] , ) ->np.ndarray: '''simple docstring''' return normalize(__UpperCamelCase , mean=__UpperCamelCase , std=__UpperCamelCase , data_format=__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Any , __UpperCamelCase : ImageInput , __UpperCamelCase : bool = None , __UpperCamelCase : Dict[str, int] = None , __UpperCamelCase : PILImageResampling = None , __UpperCamelCase : bool = None , __UpperCamelCase : Dict[str, int] = None , __UpperCamelCase : bool = None , __UpperCamelCase : float = None , __UpperCamelCase : bool = None , __UpperCamelCase : Optional[Union[float, List[float]]] = None , __UpperCamelCase : Optional[Union[float, List[float]]] = None , __UpperCamelCase : Optional[ChannelDimension] = ChannelDimension.FIRST , ) ->np.ndarray: '''simple docstring''' if do_resize and size is None or resample is None: raise ValueError("""Size and resample must be specified if do_resize is True.""" ) if do_center_crop and crop_size is None: raise ValueError("""Crop size must be specified if do_center_crop is True.""" ) if do_rescale and rescale_factor is None: raise ValueError("""Rescale factor must be specified if do_rescale is True.""" ) if do_normalize and (image_mean is None or image_std is None): raise ValueError("""Image mean and std must be specified if do_normalize is True.""" ) # All transformations expect numpy arrays. _UpperCAmelCase = to_numpy_array(__UpperCamelCase ) if do_resize: _UpperCAmelCase = self.resize(image=__UpperCamelCase , size=__UpperCamelCase , resample=__UpperCamelCase ) if do_center_crop: _UpperCAmelCase = self.center_crop(__UpperCamelCase , size=__UpperCamelCase ) if do_rescale: _UpperCAmelCase = self.rescale(image=__UpperCamelCase , scale=__UpperCamelCase ) if do_normalize: _UpperCAmelCase = self.normalize(image=__UpperCamelCase , mean=__UpperCamelCase , std=__UpperCamelCase ) _UpperCAmelCase = to_channel_dimension_format(__UpperCamelCase , __UpperCamelCase ) return image def _snake_case ( self : Optional[int] , __UpperCamelCase : ImageInput , __UpperCamelCase : bool = None , __UpperCamelCase : Dict[str, int] = None , __UpperCamelCase : PILImageResampling = None , __UpperCamelCase : bool = None , __UpperCamelCase : Dict[str, int] = None , __UpperCamelCase : bool = None , __UpperCamelCase : float = None , __UpperCamelCase : bool = None , __UpperCamelCase : Optional[Union[float, List[float]]] = None , __UpperCamelCase : Optional[Union[float, List[float]]] = None , __UpperCamelCase : Optional[Union[str, TensorType]] = None , __UpperCamelCase : ChannelDimension = ChannelDimension.FIRST , **__UpperCamelCase : Optional[Any] , ) ->PIL.Image.Image: '''simple docstring''' _UpperCAmelCase = do_resize if do_resize is not None else self.do_resize _UpperCAmelCase = resample if resample is not None else self.resample _UpperCAmelCase = do_center_crop if do_center_crop is not None else self.do_center_crop _UpperCAmelCase = do_rescale if do_rescale is not None else self.do_rescale _UpperCAmelCase = rescale_factor if rescale_factor is not None else self.rescale_factor _UpperCAmelCase = do_normalize if do_normalize is not None else self.do_normalize _UpperCAmelCase = image_mean if image_mean is not None else self.image_mean _UpperCAmelCase = image_std if image_std is not None else self.image_std _UpperCAmelCase = size if size is not None else self.size _UpperCAmelCase = get_size_dict(__UpperCamelCase , default_to_square=__UpperCamelCase ) _UpperCAmelCase = crop_size if crop_size is not None else self.crop_size _UpperCAmelCase = get_size_dict(__UpperCamelCase , param_name="""crop_size""" ) if not valid_images(__UpperCamelCase ): raise ValueError( """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """ """torch.Tensor, tf.Tensor or jax.ndarray.""" ) _UpperCAmelCase = make_batched(__UpperCamelCase ) _UpperCAmelCase = [ [ self._preprocess_image( image=__UpperCamelCase , do_resize=__UpperCamelCase , size=__UpperCamelCase , resample=__UpperCamelCase , do_center_crop=__UpperCamelCase , crop_size=__UpperCamelCase , do_rescale=__UpperCamelCase , rescale_factor=__UpperCamelCase , do_normalize=__UpperCamelCase , image_mean=__UpperCamelCase , image_std=__UpperCamelCase , data_format=__UpperCamelCase , ) for img in video ] for video in videos ] _UpperCAmelCase = {"""pixel_values""": videos} return BatchFeature(data=__UpperCamelCase , tensor_type=__UpperCamelCase )
19
"""simple docstring""" # Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING, Dict, Optional import numpy as np import pyarrow as pa from .. import config from ..utils.logging import get_logger from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import jax import jaxlib a : List[Any] = get_logger() a : Optional[dict] = None class a_ ( TensorFormatter[Mapping, 'jax.Array', Mapping] ): def __init__( self : int , __UpperCamelCase : List[str]=None , __UpperCamelCase : Optional[int]=None , **__UpperCamelCase : int ) ->Tuple: '''simple docstring''' super().__init__(features=__UpperCamelCase ) import jax from jaxlib.xla_client import Device if isinstance(__UpperCamelCase , __UpperCamelCase ): raise ValueError( f"""Expected {device} to be a `str` not {type(__UpperCamelCase )}, as `jaxlib.xla_extension.Device` """ """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """ """the device with `str()` to get its string identifier that will be internally mapped """ """to the actual `jaxlib.xla_extension.Device`.""" ) _UpperCAmelCase = device if isinstance(__UpperCamelCase , __UpperCamelCase ) else str(jax.devices()[0] ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() if self.device not in list(DEVICE_MAPPING.keys() ): logger.warning( f"""Device with string identifier {self.device} not listed among the available """ f"""devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default """ f"""device: {str(jax.devices()[0] )}.""" ) _UpperCAmelCase = str(jax.devices()[0] ) _UpperCAmelCase = jnp_array_kwargs @staticmethod def _snake_case ( ) ->Dict[str, "jaxlib.xla_extension.Device"]: '''simple docstring''' import jax return {str(__UpperCamelCase ): device for device in jax.devices()} def _snake_case ( self : Dict , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , __UpperCamelCase ) and column: if all( isinstance(__UpperCamelCase , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return jnp.stack(__UpperCamelCase , axis=0 ) return column def _snake_case ( self : List[str] , __UpperCamelCase : Any ) ->Optional[int]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , (str, bytes, type(__UpperCamelCase )) ): return value elif isinstance(__UpperCamelCase , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() _UpperCAmelCase = {} if isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): # the default int precision depends on the jax config # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision if jax.config.jax_enable_xaa: _UpperCAmelCase = {"""dtype""": jnp.intaa} else: _UpperCAmelCase = {"""dtype""": jnp.intaa} elif isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): _UpperCAmelCase = {"""dtype""": jnp.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(__UpperCamelCase , PIL.Image.Image ): _UpperCAmelCase = np.asarray(__UpperCamelCase ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() with jax.default_device(DEVICE_MAPPING[self.device] ): # calling jnp.array on a np.ndarray does copy the data # see https://github.com/google/jax/issues/4486 return jnp.array(__UpperCamelCase , **{**default_dtype, **self.jnp_array_kwargs} ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->Any: '''simple docstring''' import jax # support for torch, tf, jax etc. if config.TORCH_AVAILABLE and "torch" in sys.modules: import torch if isinstance(__UpperCamelCase , torch.Tensor ): return self._tensorize(data_struct.detach().cpu().numpy()[()] ) if hasattr(__UpperCamelCase , """__array__""" ) and not isinstance(__UpperCamelCase , jax.Array ): _UpperCAmelCase = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(__UpperCamelCase , np.ndarray ): if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) elif isinstance(__UpperCamelCase , (list, tuple) ): return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) return self._tensorize(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : dict ) ->int: '''simple docstring''' return map_nested(self._recursive_tensorize , __UpperCamelCase , map_list=__UpperCamelCase ) def _snake_case ( self : Dict , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_row(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_row(__UpperCamelCase ) return self.recursive_tensorize(__UpperCamelCase ) def _snake_case ( self : Optional[int] , __UpperCamelCase : pa.Table ) ->"jax.Array": '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_column(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_column(__UpperCamelCase , pa_table.column_names[0] ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) _UpperCAmelCase = self._consolidate(__UpperCamelCase ) return column def _snake_case ( self : Optional[Any] , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_batch(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_batch(__UpperCamelCase ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) for column_name in batch: _UpperCAmelCase = self._consolidate(batch[column_name] ) return batch
19
1
"""simple docstring""" def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = 1 for i in range(1 , num + 1 ): fact *= i return fact def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = 0 while number > 0: _UpperCAmelCase = number % 1_0 sum_of_digits += last_digit _UpperCAmelCase = number // 1_0 # Removing the last_digit from the given number return sum_of_digits def _UpperCamelCase ( _A = 1_0_0 ) -> int: """simple docstring""" _UpperCAmelCase = factorial(_A ) _UpperCAmelCase = split_and_add(_A ) return result if __name__ == "__main__": print(solution(int(input('''Enter the Number: ''').strip())))
19
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a : Tuple = { '''configuration_pegasus_x''': ['''PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PegasusXConfig'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : List[str] = [ '''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 : Dict = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
1
"""simple docstring""" from typing import Optional, Tuple, Union import flax import flax.linen as nn import jax import jax.numpy as jnp from flax.core.frozen_dict import FrozenDict from ..configuration_utils import ConfigMixin, flax_register_to_config from ..utils import BaseOutput from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps from .modeling_flax_utils import FlaxModelMixin from .unet_ad_blocks_flax import ( FlaxCrossAttnDownBlockaD, FlaxCrossAttnUpBlockaD, FlaxDownBlockaD, FlaxUNetMidBlockaDCrossAttn, FlaxUpBlockaD, ) @flax.struct.dataclass class a_ ( _UpperCAmelCase ): a : jnp.ndarray @flax_register_to_config class a_ ( nn.Module , _UpperCAmelCase , _UpperCAmelCase ): a : int = 32 a : int = 4 a : int = 4 a : Tuple[str] = ( "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D", ) a : Tuple[str] = ("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D") a : Union[bool, Tuple[bool]] = False a : Tuple[int] = (320, 640, 1280, 1280) a : int = 2 a : Union[int, Tuple[int]] = 8 a : Optional[Union[int, Tuple[int]]] = None a : int = 1280 a : float = 0.0 a : bool = False a : jnp.dtype = jnp.floataa a : bool = True a : int = 0 a : bool = False def _snake_case ( self : Tuple , __UpperCamelCase : jax.random.KeyArray ) ->FrozenDict: '''simple docstring''' _UpperCAmelCase = (1, self.in_channels, self.sample_size, self.sample_size) _UpperCAmelCase = jnp.zeros(__UpperCamelCase , dtype=jnp.floataa ) _UpperCAmelCase = jnp.ones((1,) , dtype=jnp.intaa ) _UpperCAmelCase = jnp.zeros((1, 1, self.cross_attention_dim) , dtype=jnp.floataa ) _UpperCAmelCase ,_UpperCAmelCase = jax.random.split(__UpperCamelCase ) _UpperCAmelCase = {"""params""": params_rng, """dropout""": dropout_rng} return self.init(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase )["params"] def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = self.block_out_channels _UpperCAmelCase = block_out_channels[0] * 4 if self.num_attention_heads is not None: raise ValueError( """At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue as described in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131. Passing `num_attention_heads` will only be supported in diffusers v0.19.""" ) # If `num_attention_heads` is not defined (which is the case for most models) # it will default to `attention_head_dim`. This looks weird upon first reading it and it is. # The reason for this behavior is to correct for incorrectly named variables that were introduced # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131 # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking # which is why we correct for the naming here. _UpperCAmelCase = self.num_attention_heads or self.attention_head_dim # input _UpperCAmelCase = nn.Conv( block_out_channels[0] , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) # time _UpperCAmelCase = FlaxTimesteps( block_out_channels[0] , flip_sin_to_cos=self.flip_sin_to_cos , freq_shift=self.config.freq_shift ) _UpperCAmelCase = FlaxTimestepEmbedding(__UpperCamelCase , dtype=self.dtype ) _UpperCAmelCase = self.only_cross_attention if isinstance(__UpperCamelCase , __UpperCamelCase ): _UpperCAmelCase = (only_cross_attention,) * len(self.down_block_types ) if isinstance(__UpperCamelCase , __UpperCamelCase ): _UpperCAmelCase = (num_attention_heads,) * len(self.down_block_types ) # down _UpperCAmelCase = [] _UpperCAmelCase = block_out_channels[0] for i, down_block_type in enumerate(self.down_block_types ): _UpperCAmelCase = output_channel _UpperCAmelCase = block_out_channels[i] _UpperCAmelCase = i == len(__UpperCamelCase ) - 1 if down_block_type == "CrossAttnDownBlock2D": _UpperCAmelCase = FlaxCrossAttnDownBlockaD( in_channels=__UpperCamelCase , out_channels=__UpperCamelCase , dropout=self.dropout , num_layers=self.layers_per_block , num_attention_heads=num_attention_heads[i] , add_downsample=not is_final_block , use_linear_projection=self.use_linear_projection , only_cross_attention=only_cross_attention[i] , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) else: _UpperCAmelCase = FlaxDownBlockaD( in_channels=__UpperCamelCase , out_channels=__UpperCamelCase , dropout=self.dropout , num_layers=self.layers_per_block , add_downsample=not is_final_block , dtype=self.dtype , ) down_blocks.append(__UpperCamelCase ) _UpperCAmelCase = down_blocks # mid _UpperCAmelCase = FlaxUNetMidBlockaDCrossAttn( in_channels=block_out_channels[-1] , dropout=self.dropout , num_attention_heads=num_attention_heads[-1] , use_linear_projection=self.use_linear_projection , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) # up _UpperCAmelCase = [] _UpperCAmelCase = list(reversed(__UpperCamelCase ) ) _UpperCAmelCase = list(reversed(__UpperCamelCase ) ) _UpperCAmelCase = list(reversed(__UpperCamelCase ) ) _UpperCAmelCase = reversed_block_out_channels[0] for i, up_block_type in enumerate(self.up_block_types ): _UpperCAmelCase = output_channel _UpperCAmelCase = reversed_block_out_channels[i] _UpperCAmelCase = reversed_block_out_channels[min(i + 1 , len(__UpperCamelCase ) - 1 )] _UpperCAmelCase = i == len(__UpperCamelCase ) - 1 if up_block_type == "CrossAttnUpBlock2D": _UpperCAmelCase = FlaxCrossAttnUpBlockaD( in_channels=__UpperCamelCase , out_channels=__UpperCamelCase , prev_output_channel=__UpperCamelCase , num_layers=self.layers_per_block + 1 , num_attention_heads=reversed_num_attention_heads[i] , add_upsample=not is_final_block , dropout=self.dropout , use_linear_projection=self.use_linear_projection , only_cross_attention=only_cross_attention[i] , use_memory_efficient_attention=self.use_memory_efficient_attention , dtype=self.dtype , ) else: _UpperCAmelCase = FlaxUpBlockaD( in_channels=__UpperCamelCase , out_channels=__UpperCamelCase , prev_output_channel=__UpperCamelCase , num_layers=self.layers_per_block + 1 , add_upsample=not is_final_block , dropout=self.dropout , dtype=self.dtype , ) up_blocks.append(__UpperCamelCase ) _UpperCAmelCase = output_channel _UpperCAmelCase = up_blocks # out _UpperCAmelCase = nn.GroupNorm(num_groups=32 , epsilon=1e-5 ) _UpperCAmelCase = nn.Conv( self.out_channels , kernel_size=(3, 3) , strides=(1, 1) , padding=((1, 1), (1, 1)) , dtype=self.dtype , ) def __call__( self : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : int=None , __UpperCamelCase : Any=None , __UpperCamelCase : bool = True , __UpperCamelCase : bool = False , ) ->Union[FlaxUNetaDConditionOutput, Tuple]: '''simple docstring''' if not isinstance(__UpperCamelCase , jnp.ndarray ): _UpperCAmelCase = jnp.array([timesteps] , dtype=jnp.intaa ) elif isinstance(__UpperCamelCase , jnp.ndarray ) and len(timesteps.shape ) == 0: _UpperCAmelCase = timesteps.astype(dtype=jnp.floataa ) _UpperCAmelCase = jnp.expand_dims(__UpperCamelCase , 0 ) _UpperCAmelCase = self.time_proj(__UpperCamelCase ) _UpperCAmelCase = self.time_embedding(__UpperCamelCase ) # 2. pre-process _UpperCAmelCase = jnp.transpose(__UpperCamelCase , (0, 2, 3, 1) ) _UpperCAmelCase = self.conv_in(__UpperCamelCase ) # 3. down _UpperCAmelCase = (sample,) for down_block in self.down_blocks: if isinstance(__UpperCamelCase , __UpperCamelCase ): _UpperCAmelCase ,_UpperCAmelCase = down_block(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , deterministic=not train ) else: _UpperCAmelCase ,_UpperCAmelCase = down_block(__UpperCamelCase , __UpperCamelCase , deterministic=not train ) down_block_res_samples += res_samples if down_block_additional_residuals is not None: _UpperCAmelCase = () for down_block_res_sample, down_block_additional_residual in zip( __UpperCamelCase , __UpperCamelCase ): down_block_res_sample += down_block_additional_residual new_down_block_res_samples += (down_block_res_sample,) _UpperCAmelCase = new_down_block_res_samples # 4. mid _UpperCAmelCase = self.mid_block(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , deterministic=not train ) if mid_block_additional_residual is not None: sample += mid_block_additional_residual # 5. up for up_block in self.up_blocks: _UpperCAmelCase = down_block_res_samples[-(self.layers_per_block + 1) :] _UpperCAmelCase = down_block_res_samples[: -(self.layers_per_block + 1)] if isinstance(__UpperCamelCase , __UpperCamelCase ): _UpperCAmelCase = up_block( __UpperCamelCase , temb=__UpperCamelCase , encoder_hidden_states=__UpperCamelCase , res_hidden_states_tuple=__UpperCamelCase , deterministic=not train , ) else: _UpperCAmelCase = up_block(__UpperCamelCase , temb=__UpperCamelCase , res_hidden_states_tuple=__UpperCamelCase , deterministic=not train ) # 6. post-process _UpperCAmelCase = self.conv_norm_out(__UpperCamelCase ) _UpperCAmelCase = nn.silu(__UpperCamelCase ) _UpperCAmelCase = self.conv_out(__UpperCamelCase ) _UpperCAmelCase = jnp.transpose(__UpperCamelCase , (0, 3, 1, 2) ) if not return_dict: return (sample,) return FlaxUNetaDConditionOutput(sample=__UpperCamelCase )
19
"""simple docstring""" import collections import json import math import os import re import time from fnmatch import fnmatch from typing import Dict import requests from slack_sdk import WebClient a : int = WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN''']) def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = test_results.split(""" """ ) _UpperCAmelCase = 0 _UpperCAmelCase = 0 # When the output is short enough, the output is surrounded by = signs: "== OUTPUT ==" # When it is too long, those signs are not present. _UpperCAmelCase = expressions[-2] if """=""" in expressions[-1] else expressions[-1] for i, expression in enumerate(_A ): if "failed" in expression: failed += int(expressions[i - 1] ) if "passed" in expression: success += int(expressions[i - 1] ) return failed, success, time_spent def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = {} _UpperCAmelCase = None _UpperCAmelCase = False for line in failures_short_lines.split("""\n""" ): if re.search(R"""_ \[doctest\]""" , _A ): _UpperCAmelCase = True _UpperCAmelCase = line.split(""" """ )[2] elif in_error and not line.split(""" """ )[0].isdigit(): _UpperCAmelCase = line _UpperCAmelCase = False return failures class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = title _UpperCAmelCase = doc_test_results["""time_spent"""].split(""",""" )[0] _UpperCAmelCase = doc_test_results["""success"""] _UpperCAmelCase = doc_test_results["""failures"""] _UpperCAmelCase = self.n_success + self.n_failures # Failures and success of the modeling tests _UpperCAmelCase = doc_test_results @property def _snake_case ( self : int ) ->str: '''simple docstring''' _UpperCAmelCase = [self._time_spent] _UpperCAmelCase = 0 for time in time_spent: _UpperCAmelCase = time.split(""":""" ) # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute. if len(__UpperCamelCase ) == 1: _UpperCAmelCase = [0, 0, time_parts[0]] _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = int(time_parts[0] ), int(time_parts[1] ), float(time_parts[2] ) total_secs += hours * 36_00 + minutes * 60 + seconds _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60 return f"""{int(__UpperCamelCase )}h{int(__UpperCamelCase )}m{int(__UpperCamelCase )}s""" @property def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' return {"type": "header", "text": {"type": "plain_text", "text": self.title}} @property def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": f"""🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.""", "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": ( f"""There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in""" f""" {self.time}.""" ), "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = 40 _UpperCAmelCase = {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase , __UpperCamelCase )} _UpperCAmelCase = """""" for category, failures in category_failures.items(): if len(__UpperCamelCase ) == 0: continue if report != "": report += "\n\n" report += f"""*{category} failures*:""".ljust(line_length // 2 ).rjust(line_length // 2 ) + "\n" report += "`" report += "`\n`".join(__UpperCamelCase ) report += "`" return { "type": "section", "text": { "type": "mrkdwn", "text": f"""The following examples had failures:\n\n\n{report}\n""", }, } @property def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = [self.header] if self.n_failures > 0: blocks.append(self.failures ) if self.n_failures > 0: blocks.extend([self.category_failures] ) if self.n_failures == 0: blocks.append(self.no_failures ) return json.dumps(__UpperCamelCase ) @staticmethod def _snake_case ( ) ->Any: '''simple docstring''' _UpperCAmelCase = [ { """type""": """section""", """text""": { """type""": """plain_text""", """text""": """There was an issue running the tests.""", }, """accessory""": { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """Check Action results""", """emoji""": True}, """url""": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } ] print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(__UpperCamelCase )} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text="""There was an issue running the tests.""" , blocks=__UpperCamelCase , ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(self.payload )} ) ) _UpperCAmelCase = f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed.""" _UpperCAmelCase = client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , blocks=self.payload , text=__UpperCamelCase , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Any , __UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = """""" for key, value in failures.items(): _UpperCAmelCase = value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase ) > 2_50 else value failures_text += f"""*{key}*\n_{value}_\n\n""" _UpperCAmelCase = job_name _UpperCAmelCase = {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}} if job_link is not None: _UpperCAmelCase = { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """GitHub Action job""", """emoji""": True}, """url""": job_link, } return [ {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}}, content, {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}}, ] def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' if self.thread_ts is None: raise ValueError("""Can only post reply if a post has been made.""" ) _UpperCAmelCase = self.doc_test_results.pop("""job_link""" ) self.doc_test_results.pop("""failures""" ) self.doc_test_results.pop("""success""" ) self.doc_test_results.pop("""time_spent""" ) _UpperCAmelCase = sorted(self.doc_test_results.items() , key=lambda __UpperCamelCase : t[0] ) for job, job_result in sorted_dict: if len(job_result["""failures"""] ): _UpperCAmelCase = f"""*Num failures* :{len(job_result["failed"] )} \n""" _UpperCAmelCase = job_result["""failures"""] _UpperCAmelCase = self.get_reply_blocks(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , text=__UpperCamelCase ) print("""Sending the following reply""" ) print(json.dumps({"""blocks""": blocks} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text=f"""Results for {job}""" , blocks=__UpperCamelCase , thread_ts=self.thread_ts["""ts"""] , ) time.sleep(1 ) def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = os.environ["""GITHUB_RUN_ID"""] _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A ).json() _UpperCAmelCase = {} try: jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" ).json() jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return jobs except Exception as e: print("""Unknown error, could not fetch links.""" , _A ) return {} def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = {} if os.path.exists(_A ): _UpperCAmelCase = os.listdir(_A ) for file in files: try: with open(os.path.join(_A , _A ) , encoding="""utf-8""" ) as f: _UpperCAmelCase = f.read() except UnicodeDecodeError as e: raise ValueError(F"""Could not open {os.path.join(_A , _A )}.""" ) from e return _artifact def _UpperCamelCase ( ) -> int: """simple docstring""" class a_ : def __init__( self : List[Any] , __UpperCamelCase : str ) ->Tuple: '''simple docstring''' _UpperCAmelCase = name _UpperCAmelCase = [] def __str__( self : int ) ->Optional[Any]: '''simple docstring''' return self.name def _snake_case ( self : Dict , __UpperCamelCase : str ) ->int: '''simple docstring''' self.paths.append({"""name""": self.name, """path""": path} ) _UpperCAmelCase = {} _UpperCAmelCase = filter(os.path.isdir , os.listdir() ) for directory in directories: _UpperCAmelCase = directory if artifact_name not in _available_artifacts: _UpperCAmelCase = Artifact(_A ) _available_artifacts[artifact_name].add_path(_A ) return _available_artifacts if __name__ == "__main__": a : Dict = get_job_links() a : Dict = retrieve_available_artifacts() a : Optional[int] = collections.OrderedDict( [ ('''*.py''', '''API Examples'''), ('''*.md''', '''MD Examples'''), ] ) # This dict will contain all the information relative to each doc test category: # - failed: list of failed tests # - failures: dict in the format 'test': 'error_message' a : Dict = { v: { '''failed''': [], '''failures''': {}, } for v in docs.values() } # Link to the GitHub Action job a : int = github_actions_job_links.get('''run_doctests''') a : Tuple = available_artifacts['''doc_tests_gpu_test_reports'''].paths[0] a : Optional[Any] = retrieve_artifact(artifact_path['''name''']) if "stats" in artifact: a , a , a : str = handle_test_results(artifact['''stats''']) a : Tuple = failed a : int = success a : Any = time_spent[1:-1] + ''', ''' a : Dict = extract_first_line_failure(artifact['''failures_short''']) for line in artifact["summary_short"].split('''\n'''): if re.search('''FAILED''', line): a : List[Any] = line.replace('''FAILED ''', '''''') a : Tuple = line.split()[0].replace('''\n''', '''''') if "::" in line: a , a : Union[str, Any] = line.split('''::''') else: a , a : Optional[Any] = line, line for file_regex in docs.keys(): if fnmatch(file_path, file_regex): a : List[Any] = docs[file_regex] doc_test_results[category]["failed"].append(test) a : Optional[Any] = all_failures[test] if test in all_failures else '''N/A''' a : List[str] = failure break a : List[Any] = Message('''🤗 Results of the doc tests.''', doc_test_results) message.post() message.post_reply()
19
1
"""simple docstring""" import warnings from ...utils import is_sklearn_available, requires_backends if is_sklearn_available(): from scipy.stats import pearsonr, spearmanr from sklearn.metrics import fa_score, matthews_corrcoef a : int = ( '''This metric will be removed from the library soon, metrics should be handled with the 🤗 Evaluate ''' '''library. You can have a look at this example script for pointers: ''' '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py''' ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" warnings.warn(_A , _A ) requires_backends(_A , """sklearn""" ) return (preds == labels).mean() def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" warnings.warn(_A , _A ) requires_backends(_A , """sklearn""" ) _UpperCAmelCase = simple_accuracy(_A , _A ) _UpperCAmelCase = fa_score(y_true=_A , y_pred=_A ) return { "acc": acc, "f1": fa, "acc_and_f1": (acc + fa) / 2, } def _UpperCamelCase ( _A , _A ) -> List[str]: """simple docstring""" warnings.warn(_A , _A ) requires_backends(_A , """sklearn""" ) _UpperCAmelCase = pearsonr(_A , _A )[0] _UpperCAmelCase = spearmanr(_A , _A )[0] return { "pearson": pearson_corr, "spearmanr": spearman_corr, "corr": (pearson_corr + spearman_corr) / 2, } def _UpperCamelCase ( _A , _A , _A ) -> Optional[Any]: """simple docstring""" warnings.warn(_A , _A ) requires_backends(_A , """sklearn""" ) assert len(_A ) == len(_A ), F"""Predictions and labels have mismatched lengths {len(_A )} and {len(_A )}""" if task_name == "cola": return {"mcc": matthews_corrcoef(_A , _A )} elif task_name == "sst-2": return {"acc": simple_accuracy(_A , _A )} elif task_name == "mrpc": return acc_and_fa(_A , _A ) elif task_name == "sts-b": return pearson_and_spearman(_A , _A ) elif task_name == "qqp": return acc_and_fa(_A , _A ) elif task_name == "mnli": return {"mnli/acc": simple_accuracy(_A , _A )} elif task_name == "mnli-mm": return {"mnli-mm/acc": simple_accuracy(_A , _A )} elif task_name == "qnli": return {"acc": simple_accuracy(_A , _A )} elif task_name == "rte": return {"acc": simple_accuracy(_A , _A )} elif task_name == "wnli": return {"acc": simple_accuracy(_A , _A )} elif task_name == "hans": return {"acc": simple_accuracy(_A , _A )} else: raise KeyError(_A ) def _UpperCamelCase ( _A , _A , _A ) -> Optional[int]: """simple docstring""" warnings.warn(_A , _A ) requires_backends(_A , """sklearn""" ) if len(_A ) != len(_A ): raise ValueError(F"""Predictions and labels have mismatched lengths {len(_A )} and {len(_A )}""" ) if task_name == "xnli": return {"acc": simple_accuracy(_A , _A )} else: raise KeyError(_A )
19
"""simple docstring""" import asyncio import os import re import sys import tempfile import unittest from contextlib import contextmanager from copy import deepcopy from distutils.util import strtobool from enum import Enum from importlib.util import find_spec from pathlib import Path from unittest.mock import patch import pyarrow as pa import pytest import requests from packaging import version from datasets import config if config.PY_VERSION < version.parse('''3.8'''): import importlib_metadata else: import importlib.metadata as importlib_metadata def _UpperCamelCase ( _A , _A=False ) -> str: """simple docstring""" try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_A ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"""If set, {key} must be yes or no.""" ) return _value a : Union[str, Any] = parse_flag_from_env('''RUN_SLOW''', default=False) a : Tuple = parse_flag_from_env('''RUN_REMOTE''', default=False) a : Union[str, Any] = parse_flag_from_env('''RUN_LOCAL''', default=True) a : int = parse_flag_from_env('''RUN_PACKAGED''', default=True) # Compression a : List[Any] = pytest.mark.skipif(not config.LZ4_AVAILABLE, reason='''test requires lz4''') a : List[Any] = pytest.mark.skipif(not config.PY7ZR_AVAILABLE, reason='''test requires py7zr''') a : Optional[Any] = pytest.mark.skipif(not config.ZSTANDARD_AVAILABLE, reason='''test requires zstandard''') # Audio a : int = pytest.mark.skipif( # On Windows and OS X, soundfile installs sndfile find_spec('''soundfile''') is None or version.parse(importlib_metadata.version('''soundfile''')) < version.parse('''0.12.0'''), reason='''test requires sndfile>=0.12.1: \'pip install \"soundfile>=0.12.1\"\'; ''', ) # Beam a : Tuple = pytest.mark.skipif( not config.BEAM_AVAILABLE or config.DILL_VERSION >= version.parse('''0.3.2'''), reason='''test requires apache-beam and a compatible dill version''', ) # Dill-cloudpickle compatibility a : Any = pytest.mark.skipif( config.DILL_VERSION <= version.parse('''0.3.2'''), reason='''test requires dill>0.3.2 for cloudpickle compatibility''', ) # Windows a : int = pytest.mark.skipif( sys.platform == '''win32''', reason='''test should not be run on Windows''', ) def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import faiss # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires faiss""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" try: import regex # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires regex""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" try: import elasticsearch # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires elasticsearch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" try: import sqlalchemy # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires sqlalchemy""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" if not config.TORCH_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires PyTorch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" if not config.TF_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires TensorFlow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" if not config.JAX_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires JAX""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not config.PIL_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires Pillow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import transformers # noqa F401 except ImportError: return unittest.skip("""test requires transformers""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import tiktoken # noqa F401 except ImportError: return unittest.skip("""test requires tiktoken""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import spacy # noqa F401 except ImportError: return unittest.skip("""test requires spacy""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> int: """simple docstring""" def _require_spacy_model(_A ): try: import spacy # noqa F401 spacy.load(_A ) except ImportError: return unittest.skip("""test requires spacy""" )(_A ) except OSError: return unittest.skip("""test requires spacy model '{}'""".format(_A ) )(_A ) else: return test_case return _require_spacy_model def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import pyspark # noqa F401 except ImportError: return unittest.skip("""test requires pyspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import joblibspark # noqa F401 except ImportError: return unittest.skip("""test requires joblibspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_slow_tests or _run_slow_tests == 0: _UpperCAmelCase = unittest.skip("""test is slow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_local_tests or _run_local_tests == 0: _UpperCAmelCase = unittest.skip("""test is local""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" if not _run_packaged_tests or _run_packaged_tests == 0: _UpperCAmelCase = unittest.skip("""test is packaged""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not _run_remote_tests or _run_remote_tests == 0: _UpperCAmelCase = unittest.skip("""test requires remote""" )(_A ) return test_case def _UpperCamelCase ( *_A ) -> Dict: """simple docstring""" def decorate(cls ): for name, fn in cls.__dict__.items(): if callable(_A ) and name.startswith("""test""" ): for decorator in decorators: _UpperCAmelCase = decorator(_A ) setattr(cls , _A , _A ) return cls return decorate class a_ ( _UpperCAmelCase ): pass class a_ ( _UpperCAmelCase ): a : Any = 0 a : Optional[Any] = 1 a : int = 2 @contextmanager def _UpperCamelCase ( _A=OfflineSimulationMode.CONNECTION_FAILS , _A=1e-16 ) -> List[Any]: """simple docstring""" _UpperCAmelCase = requests.Session().request def timeout_request(_A , _A , _A , **_A ): # Change the url to an invalid url so that the connection hangs _UpperCAmelCase = """https://10.255.255.1""" if kwargs.get("""timeout""" ) is None: raise RequestWouldHangIndefinitelyError( F"""Tried a call to {url} in offline mode with no timeout set. Please set a timeout.""" ) _UpperCAmelCase = timeout try: return online_request(_A , _A , **_A ) except Exception as e: # The following changes in the error are just here to make the offline timeout error prettier _UpperCAmelCase = url _UpperCAmelCase = e.args[0] _UpperCAmelCase = (max_retry_error.args[0].replace("""10.255.255.1""" , F"""OfflineMock[{url}]""" ),) _UpperCAmelCase = (max_retry_error,) raise def raise_connection_error(_A , _A , **_A ): raise requests.ConnectionError("""Offline mode is enabled.""" , request=_A ) if mode is OfflineSimulationMode.CONNECTION_FAILS: with patch("""requests.Session.send""" , _A ): yield elif mode is OfflineSimulationMode.CONNECTION_TIMES_OUT: # inspired from https://stackoverflow.com/a/904609 with patch("""requests.Session.request""" , _A ): yield elif mode is OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1: with patch("""datasets.config.HF_DATASETS_OFFLINE""" , _A ): yield else: raise ValueError("""Please use a value from the OfflineSimulationMode enum.""" ) @contextmanager def _UpperCamelCase ( *_A , **_A ) -> str: """simple docstring""" _UpperCAmelCase = str(Path().resolve() ) with tempfile.TemporaryDirectory(*_A , **_A ) as tmp_dir: try: os.chdir(_A ) yield finally: os.chdir(_A ) @contextmanager def _UpperCamelCase ( ) -> Any: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory > 0, "Arrow memory didn't increase." @contextmanager def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory <= 0, "Arrow memory wasn't expected to increase." def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" return deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() == deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" import decorator from requests.exceptions import HTTPError def _wrapper(_A , *_A , **_A ): try: return func(*_A , **_A ) except HTTPError as err: if str(_A ).startswith("""500""" ) or str(_A ).startswith("""502""" ): pytest.xfail(str(_A ) ) raise err return decorator.decorator(_wrapper , _A ) class a_ : def __init__( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def _UpperCamelCase ( _A , _A ) -> Union[str, Any]: """simple docstring""" while True: _UpperCAmelCase = await stream.readline() if line: callback(_A ) else: break async def _UpperCamelCase ( _A , _A=None , _A=None , _A=None , _A=False , _A=False ) -> _RunOutput: """simple docstring""" if echo: print("""\nRunning: """ , """ """.join(_A ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_A , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_A , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_A , _A , _A , _A="" ): _UpperCAmelCase = line.decode("""utf-8""" ).rstrip() sink.append(_A ) if not quiet: print(_A , _A , file=_A ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ _read_stream(p.stdout , lambda _A : tee(_A , _A , sys.stdout , label="""stdout:""" ) ), _read_stream(p.stderr , lambda _A : tee(_A , _A , sys.stderr , label="""stderr:""" ) ), ] , timeout=_A , ) return _RunOutput(await p.wait() , _A , _A ) def _UpperCamelCase ( _A , _A=None , _A=None , _A=1_8_0 , _A=False , _A=True ) -> _RunOutput: """simple docstring""" _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_A , env=_A , stdin=_A , timeout=_A , quiet=_A , echo=_A ) ) _UpperCAmelCase = """ """.join(_A ) if result.returncode > 0: _UpperCAmelCase = """\n""".join(result.stderr ) raise RuntimeError( F"""'{cmd_str}' failed with returncode {result.returncode}\n\n""" F"""The combined stderr from workers follows:\n{stderr}""" ) # check that the subprocess actually did run and produced some output, should the test rely on # the remote side to do the testing if not result.stdout and not result.stderr: raise RuntimeError(F"""'{cmd_str}' produced no output.""" ) return result def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = os.environ.get("""PYTEST_XDIST_WORKER""" , """gw0""" ) _UpperCAmelCase = re.sub(R"""^gw""" , """""" , _A , 0 , re.M ) return int(_A ) def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = 2_9_5_0_0 _UpperCAmelCase = pytest_xdist_worker_id() return port + uniq_delta
19
1
"""simple docstring""" import random import torch from huggingface_hub import HfApi from diffusers import UNetaDModel a : List[Any] = HfApi() a : Optional[int] = {} # fmt: off a : Optional[Any] = torch.tensor([ -0.75_15, -1.68_83, 0.24_20, 0.03_00, 0.63_47, 1.34_33, -1.17_43, -3.74_67, 1.23_42, -2.24_85, 0.46_36, 0.80_76, -0.79_91, 0.39_69, 0.84_98, 0.91_89, -1.88_87, -3.35_22, 0.76_39, 0.20_40, 0.62_71, -2.71_48, -1.63_16, 3.08_39, 0.31_86, 0.27_21, -0.97_59, -1.24_61, 2.62_57, 1.35_57 ]) a : str = torch.tensor([ -2.36_39, -2.53_44, 0.00_54, -0.66_74, 1.59_90, 1.01_58, 0.31_24, -2.14_36, 1.87_95, -2.54_29, -0.15_66, -0.39_73, 1.24_90, 2.64_47, 1.22_83, -0.52_08, -2.81_54, -3.51_19, 2.38_38, 1.20_33, 1.72_01, -2.12_56, -1.45_76, 2.79_48, 2.42_04, -0.97_52, -1.25_46, 0.80_27, 3.27_58, 3.13_65 ]) a : int = torch.tensor([ -0.65_31, -0.68_91, -0.31_72, -0.53_75, -0.91_40, -0.53_67, -0.11_75, -0.78_69, -0.38_08, -0.45_13, -0.20_98, -0.00_83, 0.31_83, 0.51_40, 0.22_47, -0.13_04, -0.13_02, -0.28_02, -0.20_84, -0.20_25, -0.49_67, -0.48_73, -0.08_61, 0.69_25, 0.02_50, 0.12_90, -0.15_43, 0.63_16, 1.04_60, 1.49_43 ]) a : str = torch.tensor([ 0.09_11, 0.11_07, 0.01_82, 0.04_35, -0.08_05, -0.06_08, 0.03_81, 0.21_72, -0.02_80, 0.13_27, -0.02_99, -0.02_55, -0.00_50, -0.11_70, -0.10_46, 0.03_09, 0.13_67, 0.17_28, -0.05_33, -0.07_48, -0.05_34, 0.16_24, 0.03_84, -0.18_05, -0.07_07, 0.06_42, 0.02_20, -0.01_34, -0.13_33, -0.15_05 ]) a : List[str] = torch.tensor([ 0.13_21, 0.13_37, 0.04_40, 0.06_22, -0.05_91, -0.03_70, 0.05_03, 0.21_33, -0.01_77, 0.14_15, -0.01_16, -0.01_12, 0.00_44, -0.09_80, -0.07_89, 0.03_95, 0.15_02, 0.17_85, -0.04_88, -0.05_14, -0.04_04, 0.15_39, 0.04_54, -0.15_59, -0.06_65, 0.06_59, 0.03_83, -0.00_05, -0.12_66, -0.13_86 ]) a : Union[str, Any] = torch.tensor([ 0.11_54, 0.12_18, 0.03_07, 0.05_26, -0.07_11, -0.05_41, 0.03_66, 0.20_78, -0.02_67, 0.13_17, -0.02_26, -0.01_93, -0.00_14, -0.10_55, -0.09_02, 0.03_30, 0.13_91, 0.17_09, -0.05_62, -0.06_93, -0.05_60, 0.14_82, 0.03_81, -0.16_83, -0.06_81, 0.06_61, 0.03_31, -0.00_46, -0.12_68, -0.14_31 ]) a : Union[str, Any] = torch.tensor([ 0.11_92, 0.12_40, 0.04_14, 0.06_06, -0.05_57, -0.04_12, 0.04_30, 0.20_42, -0.02_00, 0.13_85, -0.01_15, -0.01_32, 0.00_17, -0.09_65, -0.08_02, 0.03_98, 0.14_33, 0.17_47, -0.04_58, -0.05_33, -0.04_07, 0.15_45, 0.04_19, -0.15_74, -0.06_45, 0.06_26, 0.03_41, -0.00_10, -0.11_99, -0.13_90 ]) a : Dict = torch.tensor([ 0.10_75, 0.10_74, 0.02_05, 0.04_31, -0.07_74, -0.06_07, 0.02_98, 0.20_42, -0.03_20, 0.12_67, -0.02_81, -0.02_50, -0.00_64, -0.10_91, -0.09_46, 0.02_90, 0.13_28, 0.16_50, -0.05_80, -0.07_38, -0.05_86, 0.14_40, 0.03_37, -0.17_46, -0.07_12, 0.06_05, 0.02_50, -0.00_99, -0.13_16, -0.14_73 ]) a : Tuple = torch.tensor([ -1.45_72, -2.04_81, -0.04_14, -0.60_05, 1.41_36, 0.58_48, 0.40_28, -2.73_30, 1.22_12, -2.12_28, 0.21_55, 0.40_39, 0.76_62, 2.05_35, 0.74_77, -0.32_43, -2.17_58, -2.76_48, 1.69_47, 0.70_26, 1.23_38, -1.60_78, -0.86_82, 2.28_10, 1.85_74, -0.57_18, -0.55_86, -0.01_86, 2.34_15, 2.12_51]) a : Any = torch.tensor([ -1.36_90, -1.97_20, -0.40_90, -0.69_66, 1.46_60, 0.99_38, -0.13_85, -2.73_24, 0.77_36, -1.89_17, 0.29_23, 0.42_93, 0.16_93, 1.41_12, 1.18_87, -0.31_81, -2.21_60, -2.63_81, 1.31_70, 0.81_63, 0.92_40, -1.65_44, -0.60_99, 2.52_59, 1.64_30, -0.90_90, -0.93_92, -0.01_26, 2.42_68, 2.32_66 ]) a : Any = torch.tensor([ -1.35_25, -1.96_28, -0.39_56, -0.68_60, 1.46_64, 1.00_14, -0.12_59, -2.72_12, 0.77_72, -1.88_11, 0.29_96, 0.43_88, 0.17_04, 1.40_29, 1.17_01, -0.30_27, -2.20_53, -2.62_87, 1.33_50, 0.81_31, 0.92_74, -1.62_92, -0.60_98, 2.51_31, 1.65_05, -0.89_58, -0.92_98, -0.01_51, 2.42_57, 2.33_55 ]) a : Union[str, Any] = torch.tensor([ -2.05_85, -2.78_97, -0.28_50, -0.89_40, 1.90_52, 0.57_02, 0.63_45, -3.89_59, 1.59_32, -3.23_19, 0.19_74, 0.02_87, 1.75_66, 2.65_43, 0.83_87, -0.53_51, -3.27_36, -4.33_75, 2.90_29, 1.63_90, 1.46_40, -2.17_01, -1.90_13, 2.93_41, 3.49_81, -0.62_55, -1.16_44, -0.15_91, 3.70_97, 3.20_66 ]) a : Optional[Any] = torch.tensor([ -2.31_39, -2.55_94, -0.01_97, -0.67_85, 1.70_01, 1.16_06, 0.30_75, -2.17_40, 1.80_71, -2.56_30, -0.09_26, -0.38_11, 1.21_16, 2.62_46, 1.27_31, -0.53_98, -2.81_53, -3.61_40, 2.38_93, 1.32_62, 1.62_58, -2.18_56, -1.32_67, 2.83_95, 2.37_79, -1.06_23, -1.24_68, 0.89_59, 3.33_67, 3.22_43 ]) a : Dict = torch.tensor([ -2.06_28, -2.76_67, -0.20_89, -0.82_63, 2.05_39, 0.59_92, 0.64_95, -3.83_36, 1.60_25, -3.28_17, 0.17_21, -0.06_33, 1.75_16, 2.70_39, 0.81_00, -0.59_08, -3.21_13, -4.43_43, 2.92_57, 1.36_32, 1.55_62, -2.14_89, -1.98_94, 3.05_60, 3.33_96, -0.73_28, -1.04_17, 0.03_83, 3.70_93, 3.23_43 ]) a : Any = torch.tensor([ -1.45_74, -2.05_69, -0.04_73, -0.61_17, 1.40_18, 0.57_69, 0.41_29, -2.73_44, 1.22_41, -2.13_97, 0.20_00, 0.39_37, 0.76_16, 2.04_53, 0.73_24, -0.33_91, -2.17_46, -2.77_44, 1.69_63, 0.69_21, 1.21_87, -1.61_72, -0.88_77, 2.24_39, 1.84_71, -0.58_39, -0.56_05, -0.04_64, 2.32_50, 2.12_19 ]) # fmt: on a : List[Any] = api.list_models(filter='''diffusers''') for mod in models: if "google" in mod.author or mod.modelId == "CompVis/ldm-celebahq-256": a : Optional[Any] = '''/home/patrick/google_checkpoints/''' + mod.modelId.split('''/''')[-1] print(F"Started running {mod.modelId}!!!") if mod.modelId.startswith('''CompVis'''): a : List[Any] = UNetaDModel.from_pretrained(local_checkpoint, subfolder='''unet''') else: a : List[Any] = UNetaDModel.from_pretrained(local_checkpoint) torch.manual_seed(0) random.seed(0) a : str = torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size) a : Any = torch.tensor([1_0] * noise.shape[0]) with torch.no_grad(): a : List[str] = model(noise, time_step).sample assert torch.allclose( logits[0, 0, 0, :3_0], results['''_'''.join('''_'''.join(mod.modelId.split('''/''')).split('''-'''))], atol=1E-3 ) print(F"{mod.modelId} has passed successfully!!!")
19
"""simple docstring""" from pathlib import PurePosixPath from typing import Optional import fsspec from fsspec import AbstractFileSystem from huggingface_hub.hf_api import DatasetInfo from ..utils.file_utils import get_authentication_headers_for_url from ..utils.hub import hf_hub_url class a_ ( _UpperCAmelCase ): a : List[Any] = '' a : Union[str, Any] = 'hf-legacy' # "hf://"" is reserved for hffs def __init__( self : Tuple , __UpperCamelCase : Optional[DatasetInfo] = None , __UpperCamelCase : Optional[str] = None , **__UpperCamelCase : Any , ) ->Any: '''simple docstring''' super().__init__(self , **__UpperCamelCase ) _UpperCAmelCase = repo_info _UpperCAmelCase = token _UpperCAmelCase = None def _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' if self.dir_cache is None: _UpperCAmelCase = {} for hf_file in self.repo_info.siblings: # TODO(QL): add sizes _UpperCAmelCase = { """name""": hf_file.rfilename, """size""": None, """type""": """file""", } self.dir_cache.update( { str(__UpperCamelCase ): {"""name""": str(__UpperCamelCase ), """size""": None, """type""": """directory"""} for d in list(PurePosixPath(hf_file.rfilename ).parents )[:-1] } ) def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : str = "rb" , **__UpperCamelCase : Any , ) ->List[str]: '''simple docstring''' if not isinstance(self.repo_info , __UpperCamelCase ): raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}""" ) _UpperCAmelCase = hf_hub_url(self.repo_info.id , __UpperCamelCase , revision=self.repo_info.sha ) return fsspec.open( __UpperCamelCase , mode=__UpperCamelCase , headers=get_authentication_headers_for_url(__UpperCamelCase , use_auth_token=self.token ) , client_kwargs={"""trust_env""": True} , ).open() def _snake_case ( self : int , __UpperCamelCase : int , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' self._get_dirs() _UpperCAmelCase = self._strip_protocol(__UpperCamelCase ) if path in self.dir_cache: return self.dir_cache[path] else: raise FileNotFoundError(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple=False , **__UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' self._get_dirs() _UpperCAmelCase = PurePosixPath(path.strip("""/""" ) ) _UpperCAmelCase = {} for p, f in self.dir_cache.items(): _UpperCAmelCase = PurePosixPath(p.strip("""/""" ) ) _UpperCAmelCase = p.parent if root == path: _UpperCAmelCase = f _UpperCAmelCase = list(paths.values() ) if detail: return out else: return sorted(f["""name"""] for f in out )
19
1
"""simple docstring""" import os import unicodedata from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple import sentencepiece as spm from ...tokenization_utils import AddedToken, PreTrainedTokenizer from ...utils import SPIECE_UNDERLINE, logging a : str = logging.get_logger(__name__) a : List[str] = {'''vocab_file''': '''spiece.model'''} a : Optional[int] = { '''vocab_file''': { '''TsinghuaAI/CPM-Generate''': '''https://huggingface.co/TsinghuaAI/CPM-Generate/resolve/main/spiece.model''', } } class a_ ( _UpperCAmelCase ): def __init__( self : Optional[Any] , __UpperCamelCase : Tuple , __UpperCamelCase : int=False , __UpperCamelCase : str=True , __UpperCamelCase : Optional[int]=False , __UpperCamelCase : Optional[Any]="<s>" , __UpperCamelCase : Union[str, Any]="</s>" , __UpperCamelCase : int="<unk>" , __UpperCamelCase : List[Any]="<sep>" , __UpperCamelCase : Optional[int]="<pad>" , __UpperCamelCase : List[str]="<cls>" , __UpperCamelCase : Optional[int]="<mask>" , __UpperCamelCase : List[Any]=["<eop>", "<eod>"] , __UpperCamelCase : Optional[Dict[str, Any]] = None , **__UpperCamelCase : Any , ) ->None: '''simple docstring''' _UpperCAmelCase = AddedToken(__UpperCamelCase , lstrip=__UpperCamelCase , rstrip=__UpperCamelCase ) if isinstance(__UpperCamelCase , __UpperCamelCase ) else mask_token _UpperCAmelCase = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( do_lower_case=__UpperCamelCase , remove_space=__UpperCamelCase , keep_accents=__UpperCamelCase , bos_token=__UpperCamelCase , eos_token=__UpperCamelCase , unk_token=__UpperCamelCase , sep_token=__UpperCamelCase , pad_token=__UpperCamelCase , cls_token=__UpperCamelCase , mask_token=__UpperCamelCase , additional_special_tokens=__UpperCamelCase , sp_model_kwargs=self.sp_model_kwargs , **__UpperCamelCase , ) _UpperCAmelCase = 3 _UpperCAmelCase = do_lower_case _UpperCAmelCase = remove_space _UpperCAmelCase = keep_accents _UpperCAmelCase = vocab_file _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(__UpperCamelCase ) try: import jieba except ModuleNotFoundError as error: raise error.__class__( """You need to install jieba to use CpmTokenizer or CpmTokenizerFast. """ """See https://pypi.org/project/jieba/ for installation.""" ) _UpperCAmelCase = jieba _UpperCAmelCase = str.maketrans(""" \n""" , """\u2582\u2583""" ) @property # Copied from transformers.models.xlnet.tokenization_xlnet.XLNetTokenizer.vocab_size def _snake_case ( self : Any ) ->List[str]: '''simple docstring''' return len(self.sp_model ) def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = {self.convert_ids_to_tokens(__UpperCamelCase ): i for i in range(self.vocab_size )} vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.__dict__.copy() _UpperCAmelCase = None return state def __setstate__( self : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): _UpperCAmelCase = {} _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : List[str] ) ->int: '''simple docstring''' if self.remove_space: _UpperCAmelCase = """ """.join(inputs.strip().split() ) else: _UpperCAmelCase = inputs _UpperCAmelCase = outputs.replace("""``""" , """\"""" ).replace("""''""" , """\"""" ) if not self.keep_accents: _UpperCAmelCase = unicodedata.normalize("""NFKD""" , __UpperCamelCase ) _UpperCAmelCase = """""".join([c for c in outputs if not unicodedata.combining(__UpperCamelCase )] ) if self.do_lower_case: _UpperCAmelCase = outputs.lower() return outputs def _snake_case ( self : Union[str, Any] , __UpperCamelCase : str ) ->List[str]: '''simple docstring''' _UpperCAmelCase = self.preprocess_text(__UpperCamelCase ) _UpperCAmelCase = self.sp_model.encode(__UpperCamelCase , out_type=__UpperCamelCase ) _UpperCAmelCase = [] for piece in pieces: if len(__UpperCamelCase ) > 1 and piece[-1] == str(""",""" ) and piece[-2].isdigit(): _UpperCAmelCase = self.sp_model.EncodeAsPieces(piece[:-1].replace(__UpperCamelCase , """""" ) ) if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE: if len(cur_pieces[0] ) == 1: _UpperCAmelCase = cur_pieces[1:] else: _UpperCAmelCase = cur_pieces[0][1:] cur_pieces.append(piece[-1] ) new_pieces.extend(__UpperCamelCase ) else: new_pieces.append(__UpperCamelCase ) return new_pieces def _snake_case ( self : int , __UpperCamelCase : str ) ->str: '''simple docstring''' return self.sp_model.PieceToId(__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : Optional[int] ) ->Optional[Any]: '''simple docstring''' return self.sp_model.IdToPiece(__UpperCamelCase ) def _snake_case ( self : Tuple , __UpperCamelCase : Union[str, Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = """""".join(__UpperCamelCase ).replace(__UpperCamelCase , """ """ ).strip() return out_string def _snake_case ( self : int , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None ) ->List[int]: '''simple docstring''' _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [self.cls_token_id] if token_ids_a is None: return token_ids_a + sep + cls return token_ids_a + sep + token_ids_a + sep + cls def _snake_case ( self : Optional[Any] , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None , __UpperCamelCase : bool = False ) ->List[int]: '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=__UpperCamelCase , token_ids_a=__UpperCamelCase , already_has_special_tokens=__UpperCamelCase ) if token_ids_a is not None: return ([0] * len(__UpperCamelCase )) + [1] + ([0] * len(__UpperCamelCase )) + [1, 1] return ([0] * len(__UpperCamelCase )) + [1, 1] def _snake_case ( self : Any , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None ) ->List[int]: '''simple docstring''' _UpperCAmelCase = [self.sep_token_id] _UpperCAmelCase = [2] if token_ids_a is None: return len(token_ids_a + sep ) * [0] + cls_segment_id return len(token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1] + cls_segment_id def _snake_case ( self : Optional[int] , __UpperCamelCase : str , __UpperCamelCase : Optional[str] = None ) ->Tuple[str]: '''simple docstring''' if not os.path.isdir(__UpperCamelCase ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" ) return _UpperCAmelCase = os.path.join( __UpperCamelCase , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(__UpperCamelCase ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , __UpperCamelCase ) elif not os.path.isfile(self.vocab_file ): with open(__UpperCamelCase , """wb""" ) as fi: _UpperCAmelCase = self.sp_model.serialized_model_proto() fi.write(__UpperCamelCase ) return (out_vocab_file,) def _snake_case ( self : Union[str, Any] , *__UpperCamelCase : int , **__UpperCamelCase : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = super()._decode(*__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = text.replace(""" """ , """""" ).replace("""\u2582""" , """ """ ).replace("""\u2583""" , """\n""" ) return text
19
"""simple docstring""" import itertools import os from collections import Counter, defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed import numpy as np import datasets from .execute import check_correctness a : Optional[Any] = '''\ @misc{chen2021evaluating, title={Evaluating Large Language Models Trained on Code}, author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \ and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \ and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \ and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \ and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \ and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \ and Mohammad Bavarian and Clemens Winter and Philippe Tillet \ and Felipe Petroski Such and Dave Cummings and Matthias Plappert \ and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \ and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \ and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \ and William Saunders and Christopher Hesse and Andrew N. Carr \ and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \ and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \ and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \ and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba}, year={2021}, eprint={2107.03374}, archivePrefix={arXiv}, primaryClass={cs.LG} } ''' a : List[str] = '''\ This metric implements the evaluation harness for the HumanEval problem solving dataset described in the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). ''' a : Any = ''' Calculates how good are predictions given some references, using certain scores Args: predictions: list of candidates to evaluate. Each candidates should be a list of strings with several code candidates to solve the problem. references: a list with a test for each prediction. Each test should evaluate the correctness of a code candidate. k: number of code candidates to consider in the evaluation (Default: [1, 10, 100]) num_workers: number of workers used to evaluate the canidate programs (Default: 4). timeout: Returns: pass_at_k: dict with pass rates for each k results: dict with granular results of each unittest Examples: >>> code_eval = datasets.load_metric("code_eval") >>> test_cases = ["assert add(2,3)==5"] >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]] >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2]) >>> print(pass_at_k) {\'pass@1\': 0.5, \'pass@2\': 1.0} ''' a : int = ''' ################################################################################ !!!WARNING!!! ################################################################################ The "code_eval" metric executes untrusted model-generated code in Python. Although it is highly unlikely that model-generated code will do something overtly malicious in response to this test suite, model-generated code may act destructively due to a lack of model capability or alignment. Users are strongly encouraged to sandbox this evaluation suite so that it does not perform destructive actions on their host or network. For more information on how OpenAI sandboxes its code, see the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). Once you have read this disclaimer and taken appropriate precautions, set the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this with: >>> import os >>> os.environ["HF_ALLOW_CODE_EVAL"] = "1" ################################################################################\ ''' a : List[Any] = '''The MIT License Copyright (c) OpenAI (https://openai.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a_ ( datasets.Metric ): def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' return datasets.MetricInfo( # This is the description that will appear on the metrics page. description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Sequence(datasets.Value("""string""" ) ), """references""": datasets.Value("""string""" ), } ) , homepage="""https://github.com/openai/human-eval""" , codebase_urls=["""https://github.com/openai/human-eval"""] , reference_urls=["""https://github.com/openai/human-eval"""] , license=_LICENSE , ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any]=[1, 10, 1_00] , __UpperCamelCase : Dict=4 , __UpperCamelCase : Tuple=3.0 ) ->Union[str, Any]: '''simple docstring''' if os.getenv("""HF_ALLOW_CODE_EVAL""" , 0 ) != "1": raise ValueError(_WARNING ) if os.name == "nt": raise NotImplementedError("""This metric is currently not supported on Windows.""" ) with ThreadPoolExecutor(max_workers=__UpperCamelCase ) as executor: _UpperCAmelCase = [] _UpperCAmelCase = Counter() _UpperCAmelCase = 0 _UpperCAmelCase = defaultdict(__UpperCamelCase ) for task_id, (candidates, test_case) in enumerate(zip(__UpperCamelCase , __UpperCamelCase ) ): for candidate in candidates: _UpperCAmelCase = candidate + """\n""" + test_case _UpperCAmelCase = (test_program, timeout, task_id, completion_id[task_id]) _UpperCAmelCase = executor.submit(__UpperCamelCase , *__UpperCamelCase ) futures.append(__UpperCamelCase ) completion_id[task_id] += 1 n_samples += 1 for future in as_completed(__UpperCamelCase ): _UpperCAmelCase = future.result() results[result["task_id"]].append((result["""completion_id"""], result) ) _UpperCAmelCase ,_UpperCAmelCase = [], [] for result in results.values(): result.sort() _UpperCAmelCase = [r[1]["""passed"""] for r in result] total.append(len(__UpperCamelCase ) ) correct.append(sum(__UpperCamelCase ) ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = k _UpperCAmelCase = {f"""pass@{k}""": estimate_pass_at_k(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ).mean() for k in ks if (total >= k).all()} return pass_at_k, results def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" def estimator(_A , _A , _A ) -> float: if n - c < k: return 1.0 return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1 , n + 1 ) ) if isinstance(_A , _A ): _UpperCAmelCase = itertools.repeat(_A , len(_A ) ) else: assert len(_A ) == len(_A ) _UpperCAmelCase = iter(_A ) return np.array([estimator(int(_A ) , int(_A ) , _A ) for n, c in zip(_A , _A )] )
19
1
"""simple docstring""" import json import os from pathlib import Path from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple, Union import sentencepiece from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging a : Optional[Any] = logging.get_logger(__name__) a : Optional[int] = '''▁''' a : Dict = { '''vocab_file''': '''vocab.json''', '''spm_file''': '''sentencepiece.bpe.model''', } a : Tuple = { '''vocab_file''': { '''facebook/s2t-small-librispeech-asr''': ( '''https://huggingface.co/facebook/s2t-small-librispeech-asr/resolve/main/vocab.json''' ), }, '''spm_file''': { '''facebook/s2t-small-librispeech-asr''': ( '''https://huggingface.co/facebook/s2t-small-librispeech-asr/resolve/main/sentencepiece.bpe.model''' ) }, } a : Dict = { '''facebook/s2t-small-librispeech-asr''': 1_0_2_4, } a : Optional[int] = ['''pt''', '''fr''', '''ru''', '''nl''', '''ro''', '''it''', '''es''', '''de'''] a : List[Any] = {'''mustc''': MUSTC_LANGS} class a_ ( _UpperCAmelCase ): a : Optional[int] = VOCAB_FILES_NAMES a : Tuple = PRETRAINED_VOCAB_FILES_MAP a : Optional[int] = MAX_MODEL_INPUT_SIZES a : Tuple = ['input_ids', 'attention_mask'] a : List[int] = [] def __init__( self : Any , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[str]="<s>" , __UpperCamelCase : Tuple="</s>" , __UpperCamelCase : Any="<pad>" , __UpperCamelCase : Optional[int]="<unk>" , __UpperCamelCase : Any=False , __UpperCamelCase : Dict=False , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : Optional[Dict[str, Any]] = None , **__UpperCamelCase : List[str] , ) ->None: '''simple docstring''' _UpperCAmelCase = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( bos_token=__UpperCamelCase , eos_token=__UpperCamelCase , unk_token=__UpperCamelCase , pad_token=__UpperCamelCase , do_upper_case=__UpperCamelCase , do_lower_case=__UpperCamelCase , tgt_lang=__UpperCamelCase , lang_codes=__UpperCamelCase , sp_model_kwargs=self.sp_model_kwargs , **__UpperCamelCase , ) _UpperCAmelCase = do_upper_case _UpperCAmelCase = do_lower_case _UpperCAmelCase = load_json(__UpperCamelCase ) _UpperCAmelCase = {v: k for k, v in self.encoder.items()} _UpperCAmelCase = spm_file _UpperCAmelCase = load_spm(__UpperCamelCase , self.sp_model_kwargs ) if lang_codes is not None: _UpperCAmelCase = lang_codes _UpperCAmelCase = LANGUAGES[lang_codes] _UpperCAmelCase = [f"""<lang:{lang}>""" for lang in self.langs] _UpperCAmelCase = {lang: self.sp_model.PieceToId(f"""<lang:{lang}>""" ) for lang in self.langs} _UpperCAmelCase = self.lang_tokens _UpperCAmelCase = tgt_lang if tgt_lang is not None else self.langs[0] self.set_tgt_lang_special_tokens(self._tgt_lang ) else: _UpperCAmelCase = {} @property def _snake_case ( self : int ) ->int: '''simple docstring''' return len(self.encoder ) @property def _snake_case ( self : List[str] ) ->str: '''simple docstring''' return self._tgt_lang @tgt_lang.setter def _snake_case ( self : int , __UpperCamelCase : Any ) ->None: '''simple docstring''' _UpperCAmelCase = new_tgt_lang self.set_tgt_lang_special_tokens(__UpperCamelCase ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : str ) ->None: '''simple docstring''' _UpperCAmelCase = self.lang_code_to_id[tgt_lang] _UpperCAmelCase = [lang_code_id] def _snake_case ( self : List[Any] , __UpperCamelCase : str ) ->List[str]: '''simple docstring''' return self.sp_model.encode(__UpperCamelCase , out_type=__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : List[str] ) ->Optional[int]: '''simple docstring''' return self.encoder.get(__UpperCamelCase , self.encoder[self.unk_token] ) def _snake_case ( self : Optional[int] , __UpperCamelCase : int ) ->str: '''simple docstring''' return self.decoder.get(__UpperCamelCase , self.unk_token ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = [] _UpperCAmelCase = """""" for token in tokens: # make sure that special tokens are not decoded using sentencepiece model if token in self.all_special_tokens: _UpperCAmelCase = self.sp_model.decode(__UpperCamelCase ) out_string += (decoded.upper() if self.do_upper_case else decoded) + token + " " _UpperCAmelCase = [] else: current_sub_tokens.append(__UpperCamelCase ) _UpperCAmelCase = self.sp_model.decode(__UpperCamelCase ) out_string += decoded.upper() if self.do_upper_case else decoded return out_string.strip() def _snake_case ( self : Optional[int] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[Any]=None ) ->List[int]: '''simple docstring''' if token_ids_a is None: return self.prefix_tokens + token_ids_a + [self.eos_token_id] # We don't expect to process pairs, but leave the pair logic for API consistency return self.prefix_tokens + token_ids_a + token_ids_a + [self.eos_token_id] def _snake_case ( self : Dict , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None , __UpperCamelCase : bool = False ) ->List[int]: '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=__UpperCamelCase , token_ids_a=__UpperCamelCase , already_has_special_tokens=__UpperCamelCase ) _UpperCAmelCase = [1] * len(self.prefix_tokens ) _UpperCAmelCase = [1] if token_ids_a is None: return prefix_ones + ([0] * len(__UpperCamelCase )) + suffix_ones return prefix_ones + ([0] * len(__UpperCamelCase )) + ([0] * len(__UpperCamelCase )) + suffix_ones def _snake_case ( self : int ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.encoder.copy() vocab.update(self.added_tokens_encoder ) return vocab def __getstate__( self : Any ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.__dict__.copy() _UpperCAmelCase = None return state def __setstate__( self : Union[str, Any] , __UpperCamelCase : Dict ) ->None: '''simple docstring''' _UpperCAmelCase = d # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): _UpperCAmelCase = {} _UpperCAmelCase = load_spm(self.spm_file , self.sp_model_kwargs ) def _snake_case ( self : List[str] , __UpperCamelCase : str , __UpperCamelCase : Optional[str] = None ) ->Tuple[str]: '''simple docstring''' _UpperCAmelCase = Path(__UpperCamelCase ) assert save_dir.is_dir(), f"""{save_directory} should be a directory""" _UpperCAmelCase = save_dir / ( (filename_prefix + """-""" if filename_prefix else """""") + self.vocab_files_names["""vocab_file"""] ) _UpperCAmelCase = save_dir / ( (filename_prefix + """-""" if filename_prefix else """""") + self.vocab_files_names["""spm_file"""] ) save_json(self.encoder , __UpperCamelCase ) if os.path.abspath(self.spm_file ) != os.path.abspath(__UpperCamelCase ) and os.path.isfile(self.spm_file ): copyfile(self.spm_file , __UpperCamelCase ) elif not os.path.isfile(self.spm_file ): with open(__UpperCamelCase , """wb""" ) as fi: _UpperCAmelCase = self.sp_model.serialized_model_proto() fi.write(__UpperCamelCase ) return (str(__UpperCamelCase ), str(__UpperCamelCase )) def _UpperCamelCase ( _A , _A ) -> sentencepiece.SentencePieceProcessor: """simple docstring""" _UpperCAmelCase = sentencepiece.SentencePieceProcessor(**_A ) spm.Load(str(_A ) ) return spm def _UpperCamelCase ( _A ) -> Union[Dict, List]: """simple docstring""" with open(_A , """r""" ) as f: return json.load(_A ) def _UpperCamelCase ( _A , _A ) -> None: """simple docstring""" with open(_A , """w""" ) as f: json.dump(_A , _A , indent=2 )
19
"""simple docstring""" from collections.abc import Callable import numpy as np def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> np.array: """simple docstring""" _UpperCAmelCase = int(np.ceil((x_end - xa) / step_size ) ) _UpperCAmelCase = np.zeros((n + 1,) ) _UpperCAmelCase = ya _UpperCAmelCase = xa for k in range(_A ): _UpperCAmelCase = y[k] + step_size * ode_func(_A , y[k] ) _UpperCAmelCase = y[k] + ( (step_size / 2) * (ode_func(_A , y[k] ) + ode_func(x + step_size , _A )) ) x += step_size return y if __name__ == "__main__": import doctest doctest.testmod()
19
1
"""simple docstring""" from __future__ import annotations import unittest from transformers import RoFormerConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import ( TFRoFormerForCausalLM, TFRoFormerForMaskedLM, TFRoFormerForMultipleChoice, TFRoFormerForQuestionAnswering, TFRoFormerForSequenceClassification, TFRoFormerForTokenClassification, TFRoFormerModel, ) from transformers.models.roformer.modeling_tf_roformer import ( TFRoFormerSelfAttention, TFRoFormerSinusoidalPositionalEmbedding, ) class a_ : def __init__( self : Any , __UpperCamelCase : int , __UpperCamelCase : List[str]=13 , __UpperCamelCase : str=7 , __UpperCamelCase : List[Any]=True , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Optional[int]=True , __UpperCamelCase : Any=99 , __UpperCamelCase : List[str]=32 , __UpperCamelCase : Union[str, Any]=2 , __UpperCamelCase : Any=4 , __UpperCamelCase : Dict=37 , __UpperCamelCase : Optional[Any]="gelu" , __UpperCamelCase : Union[str, Any]=0.1 , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : List[str]=5_12 , __UpperCamelCase : List[Any]=16 , __UpperCamelCase : str=2 , __UpperCamelCase : Optional[int]=0.0_2 , __UpperCamelCase : List[Any]=3 , __UpperCamelCase : List[Any]=4 , __UpperCamelCase : str=None , ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = 13 _UpperCAmelCase = 7 _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = 99 _UpperCAmelCase = 32 _UpperCAmelCase = 2 _UpperCAmelCase = 4 _UpperCAmelCase = 37 _UpperCAmelCase = """gelu""" _UpperCAmelCase = 0.1 _UpperCAmelCase = 0.1 _UpperCAmelCase = 5_12 _UpperCAmelCase = 16 _UpperCAmelCase = 2 _UpperCAmelCase = 0.0_2 _UpperCAmelCase = 3 _UpperCAmelCase = 4 _UpperCAmelCase = None def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = None if self.use_input_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_choices ) _UpperCAmelCase = RoFormerConfig( 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 , initializer_range=self.initializer_range , return_dict=__UpperCamelCase , ) return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict ) ->List[str]: '''simple docstring''' _UpperCAmelCase = TFRoFormerModel(config=__UpperCamelCase ) _UpperCAmelCase = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} _UpperCAmelCase = [input_ids, input_mask] _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : Tuple , __UpperCamelCase : List[Any] , __UpperCamelCase : int , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Tuple ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = True _UpperCAmelCase = TFRoFormerForCausalLM(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase )["""logits"""] self.parent.assertListEqual( list(prediction_scores.numpy().shape ) , [self.batch_size, self.seq_length, self.vocab_size] ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : Dict , __UpperCamelCase : int , __UpperCamelCase : Any , __UpperCamelCase : List[str] , __UpperCamelCase : Union[str, Any] ) ->List[str]: '''simple docstring''' _UpperCAmelCase = TFRoFormerForMaskedLM(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : str , __UpperCamelCase : str , __UpperCamelCase : Any , __UpperCamelCase : Tuple , __UpperCamelCase : Optional[int] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = TFRoFormerForSequenceClassification(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def _snake_case ( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : int , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any , __UpperCamelCase : List[str] , __UpperCamelCase : Tuple , __UpperCamelCase : Union[str, Any] ) ->int: '''simple docstring''' _UpperCAmelCase = self.num_choices _UpperCAmelCase = TFRoFormerForMultipleChoice(config=__UpperCamelCase ) _UpperCAmelCase = tf.tile(tf.expand_dims(__UpperCamelCase , 1 ) , (1, self.num_choices, 1) ) _UpperCAmelCase = tf.tile(tf.expand_dims(__UpperCamelCase , 1 ) , (1, self.num_choices, 1) ) _UpperCAmelCase = tf.tile(tf.expand_dims(__UpperCamelCase , 1 ) , (1, self.num_choices, 1) ) _UpperCAmelCase = { """input_ids""": multiple_choice_inputs_ids, """attention_mask""": multiple_choice_input_mask, """token_type_ids""": multiple_choice_token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_choices) ) def _snake_case ( self : str , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : str , __UpperCamelCase : Tuple ) ->str: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = TFRoFormerForTokenClassification(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def _snake_case ( self : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Optional[Any] , __UpperCamelCase : int , __UpperCamelCase : Any , __UpperCamelCase : Optional[int] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = TFRoFormerForQuestionAnswering(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask} return config, inputs_dict @require_tf class a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : Any = ( ( TFRoFormerModel, TFRoFormerForCausalLM, TFRoFormerForMaskedLM, TFRoFormerForQuestionAnswering, TFRoFormerForSequenceClassification, TFRoFormerForTokenClassification, TFRoFormerForMultipleChoice, ) if is_tf_available() else () ) a : int = ( { 'feature-extraction': TFRoFormerModel, 'fill-mask': TFRoFormerForMaskedLM, 'question-answering': TFRoFormerForQuestionAnswering, 'text-classification': TFRoFormerForSequenceClassification, 'text-generation': TFRoFormerForCausalLM, 'token-classification': TFRoFormerForTokenClassification, 'zero-shot': TFRoFormerForSequenceClassification, } if is_tf_available() else {} ) a : Tuple = False a : Optional[Any] = False def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : Optional[int] , __UpperCamelCase : int , __UpperCamelCase : Any , __UpperCamelCase : Union[str, Any] ) ->List[str]: '''simple docstring''' if pipeline_test_casse_name == "TextGenerationPipelineTests": return True return False def _snake_case ( self : int ) ->Dict: '''simple docstring''' _UpperCAmelCase = TFRoFormerModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : str ) ->Dict: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : str ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->Any: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_lm_head(*__UpperCamelCase ) def _snake_case ( self : List[str] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_multiple_choice(*__UpperCamelCase ) def _snake_case ( self : str ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase ) def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase ) @slow def _snake_case ( self : Dict ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = TFRoFormerModel.from_pretrained("""junnyu/roformer_chinese_base""" ) self.assertIsNotNone(__UpperCamelCase ) @require_tf class a_ ( unittest.TestCase ): @slow def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' _UpperCAmelCase = TFRoFormerForMaskedLM.from_pretrained("""junnyu/roformer_chinese_base""" ) _UpperCAmelCase = tf.constant([[0, 1, 2, 3, 4, 5]] ) _UpperCAmelCase = model(__UpperCamelCase )[0] # TODO Replace vocab size _UpperCAmelCase = 5_00_00 _UpperCAmelCase = [1, 6, vocab_size] self.assertEqual(output.shape , __UpperCamelCase ) print(output[:, :3, :3] ) # TODO Replace values below with what was printed above. _UpperCAmelCase = tf.constant( [ [ [-0.1_2_0_5_3_3_4_1, -1.0_2_6_4_9_0_1, 0.2_9_2_2_1_9_4_6], [-1.5_1_3_3_7_8_3, 0.1_9_7_4_3_3, 0.1_5_1_9_0_6_0_7], [-5.0_1_3_5_4_0_3, -3.9_0_0_2_5_6, -0.8_4_0_3_8_7_6_4], ] ] ) tf.debugging.assert_near(output[:, :3, :3] , __UpperCamelCase , atol=1e-4 ) @require_tf class a_ ( unittest.TestCase ): a : Union[str, Any] = 1e-4 def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = tf.constant([[4, 10]] ) _UpperCAmelCase = TFRoFormerSinusoidalPositionalEmbedding(num_positions=6 , embedding_dim=6 ) _UpperCAmelCase = emba(input_ids.shape ) _UpperCAmelCase = tf.constant( [[0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0], [0.8_4_1_5, 0.0_4_6_4, 0.0_0_2_2, 0.5_4_0_3, 0.9_9_8_9, 1.0_0_0_0]] ) tf.debugging.assert_near(__UpperCamelCase , __UpperCamelCase , atol=self.tolerance ) def _snake_case ( self : Tuple ) ->int: '''simple docstring''' _UpperCAmelCase = tf.constant( [ [0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0], [0.8_4_1_5, 0.8_2_1_9, 0.8_0_2_0, 0.7_8_1_9, 0.7_6_1_7], [0.9_0_9_3, 0.9_3_6_4, 0.9_5_8_1, 0.9_7_4_9, 0.9_8_7_0], ] ) _UpperCAmelCase = TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_12 , embedding_dim=5_12 ) emba([2, 16, 5_12] ) _UpperCAmelCase = emba.weight[:3, :5] tf.debugging.assert_near(__UpperCamelCase , __UpperCamelCase , atol=self.tolerance ) @require_tf class a_ ( unittest.TestCase ): a : List[str] = 1e-4 def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = tf.reshape(tf.range(2 * 12 * 16 * 64 , dtype=tf.floataa ) , shape=(2, 12, 16, 64) ) / 1_00 _UpperCAmelCase = -tf.reshape(tf.range(2 * 12 * 16 * 64 , dtype=tf.floataa ) , shape=(2, 12, 16, 64) ) / 1_00 _UpperCAmelCase = TFRoFormerSinusoidalPositionalEmbedding(num_positions=32 , embedding_dim=64 ) _UpperCAmelCase = embed_positions([2, 16, 7_68] )[None, None, :, :] _UpperCAmelCase ,_UpperCAmelCase = TFRoFormerSelfAttention.apply_rotary_position_embeddings( __UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = tf.constant( [ [0.0_0_0_0, 0.0_1_0_0, 0.0_2_0_0, 0.0_3_0_0, 0.0_4_0_0, 0.0_5_0_0, 0.0_6_0_0, 0.0_7_0_0], [-0.2_0_1_2, 0.8_8_9_7, 0.0_2_6_3, 0.9_4_0_1, 0.2_0_7_4, 0.9_4_6_3, 0.3_4_8_1, 0.9_3_4_3], [-1.7_0_5_7, 0.6_2_7_1, -1.2_1_4_5, 1.3_8_9_7, -0.6_3_0_3, 1.7_6_4_7, -0.1_1_7_3, 1.8_9_8_5], [-2.1_7_3_1, -1.6_3_9_7, -2.7_3_5_8, 0.2_8_5_4, -2.1_8_4_0, 1.7_1_8_3, -1.3_0_1_8, 2.4_8_7_1], [0.2_7_1_7, -3.6_1_7_3, -2.9_2_0_6, -2.1_9_8_8, -3.6_6_3_8, 0.3_8_5_8, -2.9_1_5_5, 2.2_9_8_0], [3.9_8_5_9, -2.1_5_8_0, -0.7_9_8_4, -4.4_9_0_4, -4.1_1_8_1, -2.0_2_5_2, -4.4_7_8_2, 1.1_2_5_3], ] ) _UpperCAmelCase = tf.constant( [ [0.0_0_0_0, -0.0_1_0_0, -0.0_2_0_0, -0.0_3_0_0, -0.0_4_0_0, -0.0_5_0_0, -0.0_6_0_0, -0.0_7_0_0], [0.2_0_1_2, -0.8_8_9_7, -0.0_2_6_3, -0.9_4_0_1, -0.2_0_7_4, -0.9_4_6_3, -0.3_4_8_1, -0.9_3_4_3], [1.7_0_5_7, -0.6_2_7_1, 1.2_1_4_5, -1.3_8_9_7, 0.6_3_0_3, -1.7_6_4_7, 0.1_1_7_3, -1.8_9_8_5], [2.1_7_3_1, 1.6_3_9_7, 2.7_3_5_8, -0.2_8_5_4, 2.1_8_4_0, -1.7_1_8_3, 1.3_0_1_8, -2.4_8_7_1], [-0.2_7_1_7, 3.6_1_7_3, 2.9_2_0_6, 2.1_9_8_8, 3.6_6_3_8, -0.3_8_5_8, 2.9_1_5_5, -2.2_9_8_0], [-3.9_8_5_9, 2.1_5_8_0, 0.7_9_8_4, 4.4_9_0_4, 4.1_1_8_1, 2.0_2_5_2, 4.4_7_8_2, -1.1_2_5_3], ] ) tf.debugging.assert_near(query_layer[0, 0, :6, :8] , __UpperCamelCase , atol=self.tolerance ) tf.debugging.assert_near(key_layer[0, 0, :6, :8] , __UpperCamelCase , atol=self.tolerance )
19
"""simple docstring""" import argparse import logging import os import sys import numpy as np import onnxruntime import torch from bart_onnx.generation_onnx import BARTBeamSearchGenerator from bart_onnx.reduce_onnx_size import remove_dup_initializers import transformers from transformers import BartForConditionalGeneration, BartTokenizer logging.basicConfig( format='''%(asctime)s | %(levelname)s | %(name)s | [%(filename)s:%(lineno)d] %(message)s''', datefmt='''%Y-%m-%d %H:%M:%S''', level=os.environ.get('''LOGLEVEL''', '''INFO''').upper(), stream=sys.stdout, ) a : List[str] = logging.getLogger(__name__) a : int = {'''facebook/bart-base''': BartForConditionalGeneration} a : Dict = {'''facebook/bart-base''': BartTokenizer} def _UpperCamelCase ( ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = argparse.ArgumentParser(description="""Export Bart model + Beam Search to ONNX graph.""" ) parser.add_argument( """--validation_file""" , type=_A , default=_A , help="""A csv or a json file containing the validation data.""" ) parser.add_argument( """--max_length""" , type=_A , default=5 , help="""The maximum total input sequence length after tokenization.""" , ) parser.add_argument( """--num_beams""" , type=_A , default=_A , help=( """Number of beams to use for evaluation. This argument will be """ """passed to ``model.generate``, which is used during ``evaluate`` and ``predict``.""" ) , ) parser.add_argument( """--model_name_or_path""" , type=_A , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=_A , ) parser.add_argument( """--config_name""" , type=_A , default=_A , help="""Pretrained config name or path if not the same as model_name""" , ) parser.add_argument( """--device""" , type=_A , default="""cpu""" , help="""Device where the model will be run""" , ) parser.add_argument("""--output_file_path""" , type=_A , default=_A , help="""Where to store the final ONNX file.""" ) _UpperCAmelCase = parser.parse_args() return args def _UpperCamelCase ( _A , _A="cpu" ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = model_dict[model_name].from_pretrained(_A ).to(_A ) _UpperCAmelCase = tokenizer_dict[model_name].from_pretrained(_A ) if model_name in ["facebook/bart-base"]: _UpperCAmelCase = 0 _UpperCAmelCase = None _UpperCAmelCase = 0 return huggingface_model, tokenizer def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> Optional[int]: """simple docstring""" model.eval() _UpperCAmelCase = None _UpperCAmelCase = torch.jit.script(BARTBeamSearchGenerator(_A ) ) with torch.no_grad(): _UpperCAmelCase = """My friends are cool but they eat too many carbs.""" _UpperCAmelCase = tokenizer([ARTICLE_TO_SUMMARIZE] , max_length=1_0_2_4 , return_tensors="""pt""" ).to(model.device ) _UpperCAmelCase = model.generate( inputs["""input_ids"""] , attention_mask=inputs["""attention_mask"""] , num_beams=_A , max_length=_A , early_stopping=_A , decoder_start_token_id=model.config.decoder_start_token_id , ) torch.onnx.export( _A , ( inputs["""input_ids"""], inputs["""attention_mask"""], num_beams, max_length, model.config.decoder_start_token_id, ) , _A , opset_version=1_4 , input_names=["""input_ids""", """attention_mask""", """num_beams""", """max_length""", """decoder_start_token_id"""] , output_names=["""output_ids"""] , dynamic_axes={ """input_ids""": {0: """batch""", 1: """seq"""}, """output_ids""": {0: """batch""", 1: """seq_out"""}, } , example_outputs=_A , ) logger.info("""Model exported to {}""".format(_A ) ) _UpperCAmelCase = remove_dup_initializers(os.path.abspath(_A ) ) logger.info("""Deduplicated and optimized model written to {}""".format(_A ) ) _UpperCAmelCase = onnxruntime.InferenceSession(_A ) _UpperCAmelCase = ort_sess.run( _A , { """input_ids""": inputs["""input_ids"""].cpu().numpy(), """attention_mask""": inputs["""attention_mask"""].cpu().numpy(), """num_beams""": np.array(_A ), """max_length""": np.array(_A ), """decoder_start_token_id""": np.array(model.config.decoder_start_token_id ), } , ) np.testing.assert_allclose(summary_ids.cpu().numpy() , ort_out[0] , rtol=1e-3 , atol=1e-3 ) logger.info("""Model outputs from torch and ONNX Runtime are similar.""" ) logger.info("""Success.""" ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = parse_args() _UpperCAmelCase = 5 _UpperCAmelCase = 4 # Make one log on every process with the configuration for debugging. logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , level=logging.INFO , ) logger.setLevel(logging.INFO ) transformers.utils.logging.set_verbosity_error() _UpperCAmelCase = torch.device(args.device ) _UpperCAmelCase ,_UpperCAmelCase = load_model_tokenizer(args.model_name_or_path , _A ) if model.config.decoder_start_token_id is None: raise ValueError("""Make sure that `config.decoder_start_token_id` is correctly defined""" ) model.to(_A ) if args.max_length: _UpperCAmelCase = args.max_length if args.num_beams: _UpperCAmelCase = args.num_beams if args.output_file_path: _UpperCAmelCase = args.output_file_path else: _UpperCAmelCase = """BART.onnx""" logger.info("""Exporting model to ONNX""" ) export_and_validate_model(_A , _A , _A , _A , _A ) if __name__ == "__main__": main()
19
1
"""simple docstring""" from __future__ import annotations import unittest from transformers import is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import numpy import tensorflow as tf from transformers import ( TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST, TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST, BertConfig, DPRConfig, TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, ) class a_ : def __init__( self : List[str] , __UpperCamelCase : List[str] , __UpperCamelCase : List[str]=13 , __UpperCamelCase : Optional[int]=7 , __UpperCamelCase : Any=True , __UpperCamelCase : Optional[int]=True , __UpperCamelCase : int=True , __UpperCamelCase : Any=True , __UpperCamelCase : Dict=99 , __UpperCamelCase : str=32 , __UpperCamelCase : List[Any]=2 , __UpperCamelCase : List[str]=4 , __UpperCamelCase : Tuple=37 , __UpperCamelCase : int="gelu" , __UpperCamelCase : str=0.1 , __UpperCamelCase : Union[str, Any]=0.1 , __UpperCamelCase : List[str]=5_12 , __UpperCamelCase : Union[str, Any]=16 , __UpperCamelCase : Optional[Any]=2 , __UpperCamelCase : Union[str, Any]=0.0_2 , __UpperCamelCase : Tuple=3 , __UpperCamelCase : List[Any]=4 , __UpperCamelCase : List[Any]=None , __UpperCamelCase : Dict=0 , ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_input_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = num_choices _UpperCAmelCase = scope _UpperCAmelCase = projection_dim def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = None if self.use_input_mask: # follow test_modeling_tf_ctrl.py _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _UpperCAmelCase = ids_tensor([self.batch_size] , self.num_choices ) _UpperCAmelCase = BertConfig( 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 , ) _UpperCAmelCase = DPRConfig(projection_dim=self.projection_dim , **config.to_dict() ) return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def _snake_case ( self : Optional[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Any , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int] ) ->int: '''simple docstring''' _UpperCAmelCase = TFDPRContextEncoder(config=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , attention_mask=__UpperCamelCase , token_type_ids=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , token_type_ids=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.projection_dim or self.hidden_size) ) def _snake_case ( self : List[str] , __UpperCamelCase : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Dict , __UpperCamelCase : int , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = TFDPRQuestionEncoder(config=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , attention_mask=__UpperCamelCase , token_type_ids=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , token_type_ids=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.pooler_output.shape , (self.batch_size, self.projection_dim or self.hidden_size) ) def _snake_case ( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = TFDPRReader(config=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , attention_mask=__UpperCamelCase ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.relevance_logits.shape , (self.batch_size,) ) def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = {"""input_ids""": input_ids} return config, inputs_dict @require_tf class a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : str = ( ( TFDPRContextEncoder, TFDPRQuestionEncoder, TFDPRReader, ) if is_tf_available() else () ) a : Optional[int] = {'feature-extraction': TFDPRQuestionEncoder} if is_tf_available() else {} a : Tuple = False a : List[str] = False a : int = False a : List[Any] = False a : Any = False def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = TFDPRModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : int ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_dpr_context_encoder(*__UpperCamelCase ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_dpr_question_encoder(*__UpperCamelCase ) def _snake_case ( self : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_dpr_reader(*__UpperCamelCase ) @slow def _snake_case ( self : Tuple ) ->str: '''simple docstring''' for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = TFDPRContextEncoder.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = TFDPRContextEncoder.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = TFDPRQuestionEncoder.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = TFDPRReader.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) @require_tf class a_ ( unittest.TestCase ): @slow def _snake_case ( self : int ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = TFDPRQuestionEncoder.from_pretrained("""facebook/dpr-question_encoder-single-nq-base""" ) _UpperCAmelCase = tf.constant( [[1_01, 75_92, 10_10, 20_03, 20_26, 38_99, 1_01_40, 10_29, 1_02]] ) # [CLS] hello, is my dog cute? [SEP] _UpperCAmelCase = model(__UpperCamelCase )[0] # embedding shape = (1, 768) # compare the actual values for a slice. _UpperCAmelCase = tf.constant( [ [ 0.0_3_2_3_6_2_5_3, 0.1_2_7_5_3_3_3_5, 0.1_6_8_1_8_5_0_9, 0.0_0_2_7_9_7_8_6, 0.3_8_9_6_9_3_3, 0.2_4_2_6_4_9_4_5, 0.2_1_7_8_9_7_1, -0.0_2_3_3_5_2_2_7, -0.0_8_4_8_1_9_5_9, -0.1_4_3_2_4_1_1_7, ] ] ) self.assertTrue(numpy.allclose(output[:, :10].numpy() , expected_slice.numpy() , atol=1e-4 ) )
19
"""simple docstring""" import argparse import json import math import os import time import traceback import zipfile from collections import Counter import requests def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return job_links except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{worflow_run_id}/artifacts?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) return artifacts except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A , _A , _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = requests.get(_A , headers=_A , allow_redirects=_A ) _UpperCAmelCase = result.headers["""Location"""] _UpperCAmelCase = requests.get(_A , allow_redirects=_A ) _UpperCAmelCase = os.path.join(_A , F"""{artifact_name}.zip""" ) with open(_A , """wb""" ) as fp: fp.write(response.content ) def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [] _UpperCAmelCase = None with zipfile.ZipFile(_A ) as z: for filename in z.namelist(): if not os.path.isdir(_A ): # read the file if filename in ["failures_line.txt", "summary_short.txt", "job_name.txt"]: with z.open(_A ) as f: for line in f: _UpperCAmelCase = line.decode("""UTF-8""" ).strip() if filename == "failures_line.txt": try: # `error_line` is the place where `error` occurs _UpperCAmelCase = line[: line.index(""": """ )] _UpperCAmelCase = line[line.index(""": """ ) + len(""": """ ) :] errors.append([error_line, error] ) except Exception: # skip un-related lines pass elif filename == "summary_short.txt" and line.startswith("""FAILED """ ): # `test` is the test method that failed _UpperCAmelCase = line[len("""FAILED """ ) :] failed_tests.append(_A ) elif filename == "job_name.txt": _UpperCAmelCase = line if len(_A ) != len(_A ): raise ValueError( F"""`errors` and `failed_tests` should have the same number of elements. Got {len(_A )} for `errors` """ F"""and {len(_A )} for `failed_tests` instead. The test reports in {artifact_zip_path} have some""" """ problem.""" ) _UpperCAmelCase = None if job_name and job_links: _UpperCAmelCase = job_links.get(_A , _A ) # A list with elements of the form (line of error, error, failed test) _UpperCAmelCase = [x + [y] + [job_link] for x, y in zip(_A , _A )] return result def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [os.path.join(_A , _A ) for p in os.listdir(_A ) if p.endswith(""".zip""" )] for p in paths: errors.extend(get_errors_from_single_artifact(_A , job_links=_A ) ) return errors def _UpperCamelCase ( _A , _A=None ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = Counter() counter.update([x[1] for x in logs] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {} for error, count in counts: if error_filter is None or error not in error_filter: _UpperCAmelCase = {"""count""": count, """failed_tests""": [(x[2], x[0]) for x in logs if x[1] == error]} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = test.split("""::""" )[0] if test.startswith("""tests/models/""" ): _UpperCAmelCase = test.split("""/""" )[2] else: _UpperCAmelCase = None return test def _UpperCamelCase ( _A , _A=None ) -> Any: """simple docstring""" _UpperCAmelCase = [(x[0], x[1], get_model(x[2] )) for x in logs] _UpperCAmelCase = [x for x in logs if x[2] is not None] _UpperCAmelCase = {x[2] for x in logs} _UpperCAmelCase = {} for test in tests: _UpperCAmelCase = Counter() # count by errors in `test` counter.update([x[1] for x in logs if x[2] == test] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {error: count for error, count in counts if (error_filter is None or error not in error_filter)} _UpperCAmelCase = sum(error_counts.values() ) if n_errors > 0: _UpperCAmelCase = {"""count""": n_errors, """errors""": error_counts} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = """| no. | error | status |""" _UpperCAmelCase = """|-:|:-|:-|""" _UpperCAmelCase = [header, sep] for error in reduced_by_error: _UpperCAmelCase = reduced_by_error[error]["""count"""] _UpperCAmelCase = F"""| {count} | {error[:1_0_0]} | |""" lines.append(_A ) return "\n".join(_A ) def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = """| model | no. of errors | major error | count |""" _UpperCAmelCase = """|-:|-:|-:|-:|""" _UpperCAmelCase = [header, sep] for model in reduced_by_model: _UpperCAmelCase = reduced_by_model[model]["""count"""] _UpperCAmelCase ,_UpperCAmelCase = list(reduced_by_model[model]["""errors"""].items() )[0] _UpperCAmelCase = F"""| {model} | {count} | {error[:6_0]} | {_count} |""" lines.append(_A ) return "\n".join(_A ) if __name__ == "__main__": a : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument('''--workflow_run_id''', type=str, required=True, help='''A GitHub Actions workflow run id.''') parser.add_argument( '''--output_dir''', type=str, required=True, help='''Where to store the downloaded artifacts and other result files.''', ) parser.add_argument('''--token''', default=None, type=str, help='''A token that has actions:read permission.''') a : Dict = parser.parse_args() os.makedirs(args.output_dir, exist_ok=True) a : Tuple = get_job_links(args.workflow_run_id, token=args.token) a : Tuple = {} # To deal with `workflow_call` event, where a job name is the combination of the job names in the caller and callee. # For example, `PyTorch 1.11 / Model tests (models/albert, single-gpu)`. if _job_links: for k, v in _job_links.items(): # This is how GitHub actions combine job names. if " / " in k: a : List[Any] = k.find(''' / ''') a : Tuple = k[index + len(''' / ''') :] a : int = v with open(os.path.join(args.output_dir, '''job_links.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(job_links, fp, ensure_ascii=False, indent=4) a : Tuple = get_artifacts_links(args.workflow_run_id, token=args.token) with open(os.path.join(args.output_dir, '''artifacts.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(artifacts, fp, ensure_ascii=False, indent=4) for idx, (name, url) in enumerate(artifacts.items()): download_artifact(name, url, args.output_dir, args.token) # Be gentle to GitHub time.sleep(1) a : Optional[int] = get_all_errors(args.output_dir, job_links=job_links) # `e[1]` is the error a : Union[str, Any] = Counter() counter.update([e[1] for e in errors]) # print the top 30 most common test errors a : Optional[int] = counter.most_common(3_0) for item in most_common: print(item) with open(os.path.join(args.output_dir, '''errors.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(errors, fp, ensure_ascii=False, indent=4) a : int = reduce_by_error(errors) a : str = reduce_by_model(errors) a : int = make_github_table(reduced_by_error) a : Optional[int] = make_github_table_per_model(reduced_by_model) with open(os.path.join(args.output_dir, '''reduced_by_error.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa) with open(os.path.join(args.output_dir, '''reduced_by_model.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa)
19
1
"""simple docstring""" a : List[Any] = ''' # Transformers installation ! pip install transformers datasets # To install from source instead of the last release, comment the command above and uncomment the following one. # ! pip install git+https://github.com/huggingface/transformers.git ''' a : Union[str, Any] = [{'''type''': '''code''', '''content''': INSTALL_CONTENT}] a : Union[str, Any] = { '''{processor_class}''': '''FakeProcessorClass''', '''{model_class}''': '''FakeModelClass''', '''{object_class}''': '''FakeObjectClass''', }
19
"""simple docstring""" import re import warnings from contextlib import contextmanager from ...processing_utils import ProcessorMixin class a_ ( _UpperCAmelCase ): a : Any = ['image_processor', 'tokenizer'] a : Optional[int] = 'AutoImageProcessor' a : Any = 'AutoTokenizer' def __init__( self : List[str] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : List[str]=None , **__UpperCamelCase : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`""" """ instead.""" , __UpperCamelCase , ) _UpperCAmelCase = kwargs.pop("""feature_extractor""" ) _UpperCAmelCase = 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__(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def __call__( self : Union[str, Any] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->List[str]: '''simple docstring''' if self._in_target_context_manager: return self.current_processor(*__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""images""" , __UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""text""" , __UpperCamelCase ) if len(__UpperCamelCase ) > 0: _UpperCAmelCase = args[0] _UpperCAmelCase = args[1:] if images is None and text is None: raise ValueError("""You need to specify either an `images` or `text` input to process.""" ) if images is not None: _UpperCAmelCase = self.image_processor(__UpperCamelCase , *__UpperCamelCase , **__UpperCamelCase ) if text is not None: _UpperCAmelCase = self.tokenizer(__UpperCamelCase , **__UpperCamelCase ) if text is None: return inputs elif images is None: return encodings else: _UpperCAmelCase = encodings["""input_ids"""] return inputs def _snake_case ( self : Union[str, Any] , *__UpperCamelCase : int , **__UpperCamelCase : Tuple ) ->Tuple: '''simple docstring''' return self.tokenizer.batch_decode(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Tuple , *__UpperCamelCase : int , **__UpperCamelCase : Union[str, Any] ) ->int: '''simple docstring''' return self.tokenizer.decode(*__UpperCamelCase , **__UpperCamelCase ) @contextmanager def _snake_case ( self : Tuple ) ->Union[str, Any]: '''simple docstring''' warnings.warn( """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """ """labels by using the argument `text` of the regular `__call__` method (either in the same call as """ """your images inputs, or in a separate call.""" ) _UpperCAmelCase = True _UpperCAmelCase = self.tokenizer yield _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def _snake_case ( self : str , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any]=False , __UpperCamelCase : Union[str, Any]=None ) ->List[str]: '''simple docstring''' if added_vocab is None: _UpperCAmelCase = self.tokenizer.get_added_vocab() _UpperCAmelCase = {} while tokens: _UpperCAmelCase = re.search(r"""<s_(.*?)>""" , __UpperCamelCase , re.IGNORECASE ) if start_token is None: break _UpperCAmelCase = start_token.group(1 ) _UpperCAmelCase = re.search(rf"""</s_{key}>""" , __UpperCamelCase , re.IGNORECASE ) _UpperCAmelCase = start_token.group() if end_token is None: _UpperCAmelCase = tokens.replace(__UpperCamelCase , """""" ) else: _UpperCAmelCase = end_token.group() _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.search(f"""{start_token_escaped}(.*?){end_token_escaped}""" , __UpperCamelCase , re.IGNORECASE ) if content is not None: _UpperCAmelCase = content.group(1 ).strip() if r"<s_" in content and r"</s_" in content: # non-leaf node _UpperCAmelCase = self.tokenajson(__UpperCamelCase , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if value: if len(__UpperCamelCase ) == 1: _UpperCAmelCase = value[0] _UpperCAmelCase = value else: # leaf nodes _UpperCAmelCase = [] for leaf in content.split(r"""<sep/>""" ): _UpperCAmelCase = leaf.strip() if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>": _UpperCAmelCase = leaf[1:-2] # for categorical special tokens output[key].append(__UpperCamelCase ) if len(output[key] ) == 1: _UpperCAmelCase = output[key][0] _UpperCAmelCase = tokens[tokens.find(__UpperCamelCase ) + len(__UpperCamelCase ) :].strip() if tokens[:6] == r"<sep/>": # non-leaf nodes return [output] + self.tokenajson(tokens[6:] , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if len(__UpperCamelCase ): return [output] if is_inner_value else output else: return [] if is_inner_value else {"text_sequence": tokens} @property def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' warnings.warn( """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""" , __UpperCamelCase , ) return self.image_processor_class @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' warnings.warn( """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""" , __UpperCamelCase , ) return self.image_processor
19
1
"""simple docstring""" import argparse import os import re import packaging.version a : List[Any] = '''examples/''' a : int = { '''examples''': (re.compile(r'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''), '''init''': (re.compile(r'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''), '''setup''': (re.compile(r'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), r'''\1version="VERSION",'''), '''doc''': (re.compile(r'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''), } a : int = { '''init''': '''src/transformers/__init__.py''', '''setup''': '''setup.py''', } a : Any = '''README.md''' def _UpperCamelCase ( _A , _A , _A ) -> Union[str, Any]: """simple docstring""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase ,_UpperCAmelCase = REPLACE_PATTERNS[pattern] _UpperCAmelCase = replace.replace("""VERSION""" , _A ) _UpperCAmelCase = re_pattern.sub(_A , _A ) with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.write(_A ) def _UpperCamelCase ( _A ) -> str: """simple docstring""" for folder, directories, fnames in os.walk(_A ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("""research_projects""" ) if "legacy" in directories: directories.remove("""legacy""" ) for fname in fnames: if fname.endswith(""".py""" ): update_version_in_file(os.path.join(_A , _A ) , _A , pattern="""examples""" ) def _UpperCamelCase ( _A , _A=False ) -> Tuple: """simple docstring""" for pattern, fname in REPLACE_FILES.items(): update_version_in_file(_A , _A , _A ) if not patch: update_version_in_examples(_A ) def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = """🤗 Transformers currently provides the following architectures""" _UpperCAmelCase = """1. Want to contribute a new model?""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.readlines() # Find the start of the list. _UpperCAmelCase = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 _UpperCAmelCase = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("""1.""" ): _UpperCAmelCase = lines[index].replace( """https://huggingface.co/docs/transformers/main/model_doc""" , """https://huggingface.co/docs/transformers/model_doc""" , ) index += 1 with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.writelines(_A ) def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" with open(REPLACE_FILES["""init"""] , """r""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase = REPLACE_PATTERNS["""init"""][0].search(_A ).groups()[0] return packaging.version.parse(_A ) def _UpperCamelCase ( _A=False ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = get_version() if patch and default_version.is_devrelease: raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" ) if default_version.is_devrelease: _UpperCAmelCase = default_version.base_version elif patch: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}""" else: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor + 1}.0""" # Now let's ask nicely if that's the right one. _UpperCAmelCase = input(F"""Which version are you releasing? [{default_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = default_version print(F"""Updating version to {version}.""" ) global_version_update(_A , patch=_A ) if not patch: print("""Cleaning main README, don't forget to run `make fix-copies`.""" ) clean_main_ref_in_model_list() def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = get_version() _UpperCAmelCase = F"""{current_version.major}.{current_version.minor + 1}.0.dev0""" _UpperCAmelCase = current_version.base_version # Check with the user we got that right. _UpperCAmelCase = input(F"""Which version are we developing now? [{dev_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = dev_version print(F"""Updating version to {version}.""" ) global_version_update(_A ) print("""Cleaning main README, don't forget to run `make fix-copies`.""" ) clean_main_ref_in_model_list() if __name__ == "__main__": a : str = argparse.ArgumentParser() parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''') parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''') a : int = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('''Nothing to do after a patch :-)''') else: post_release_work()
19
"""simple docstring""" import colorsys from PIL import Image # type: ignore def _UpperCamelCase ( _A , _A , _A ) -> float: """simple docstring""" _UpperCAmelCase = x _UpperCAmelCase = y for step in range(_A ): # noqa: B007 _UpperCAmelCase = a * a - b * b + x _UpperCAmelCase = 2 * a * b + y _UpperCAmelCase = a_new # divergence happens for all complex number with an absolute value # greater than 4 if a * a + b * b > 4: break return step / (max_step - 1) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return (2_5_5, 2_5_5, 2_5_5) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return tuple(round(i * 2_5_5 ) for i in colorsys.hsv_to_rgb(_A , 1 , 1 ) ) def _UpperCamelCase ( _A = 8_0_0 , _A = 6_0_0 , _A = -0.6 , _A = 0 , _A = 3.2 , _A = 5_0 , _A = True , ) -> Image.Image: """simple docstring""" _UpperCAmelCase = Image.new("""RGB""" , (image_width, image_height) ) _UpperCAmelCase = img.load() # loop through the image-coordinates for image_x in range(_A ): for image_y in range(_A ): # determine the figure-coordinates based on the image-coordinates _UpperCAmelCase = figure_width / image_width * image_height _UpperCAmelCase = figure_center_x + (image_x / image_width - 0.5) * figure_width _UpperCAmelCase = figure_center_y + (image_y / image_height - 0.5) * figure_height _UpperCAmelCase = get_distance(_A , _A , _A ) # color the corresponding pixel based on the selected coloring-function if use_distance_color_coding: _UpperCAmelCase = get_color_coded_rgb(_A ) else: _UpperCAmelCase = get_black_and_white_rgb(_A ) return img if __name__ == "__main__": import doctest doctest.testmod() # colored version, full figure a : List[str] = get_image() # uncomment for colored version, different section, zoomed in # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4, # figure_width = 0.8) # uncomment for black and white version, full figure # img = get_image(use_distance_color_coding = False) # uncomment to save the image # img.save("mandelbrot.png") img.show()
19
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available, is_torch_available, ) a : Any = {} try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Tuple = ['''NllbTokenizer'''] try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Any = ['''NllbTokenizerFast'''] if TYPE_CHECKING: try: if not is_sentencepiece_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_nllb import NllbTokenizer try: if not is_tokenizers_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: from .tokenization_nllb_fast import NllbTokenizerFast else: import sys a : List[Any] = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
"""simple docstring""" from typing import Optional from torch import nn from .transformer_ad import TransformeraDModel, TransformeraDModelOutput class a_ ( nn.Module ): def __init__( self : List[str] , __UpperCamelCase : int = 16 , __UpperCamelCase : int = 88 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : int = 1 , __UpperCamelCase : float = 0.0 , __UpperCamelCase : int = 32 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : bool = False , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : str = "geglu" , __UpperCamelCase : Optional[int] = None , ) ->Dict: '''simple docstring''' super().__init__() _UpperCAmelCase = nn.ModuleList( [ TransformeraDModel( num_attention_heads=__UpperCamelCase , attention_head_dim=__UpperCamelCase , in_channels=__UpperCamelCase , num_layers=__UpperCamelCase , dropout=__UpperCamelCase , norm_num_groups=__UpperCamelCase , cross_attention_dim=__UpperCamelCase , attention_bias=__UpperCamelCase , sample_size=__UpperCamelCase , num_vector_embeds=__UpperCamelCase , activation_fn=__UpperCamelCase , num_embeds_ada_norm=__UpperCamelCase , ) for _ in range(2 ) ] ) # Variables that can be set by a pipeline: # The ratio of transformer1 to transformer2's output states to be combined during inference _UpperCAmelCase = 0.5 # The shape of `encoder_hidden_states` is expected to be # `(batch_size, condition_lengths[0]+condition_lengths[1], num_features)` _UpperCAmelCase = [77, 2_57] # Which transformer to use to encode which condition. # E.g. `(1, 0)` means that we'll use `transformers[1](conditions[0])` and `transformers[0](conditions[1])` _UpperCAmelCase = [1, 0] def _snake_case ( self : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : bool = True , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = hidden_states _UpperCAmelCase = [] _UpperCAmelCase = 0 # attention_mask is not used yet for i in range(2 ): # for each of the two transformers, pass the corresponding condition tokens _UpperCAmelCase = encoder_hidden_states[:, tokens_start : tokens_start + self.condition_lengths[i]] _UpperCAmelCase = self.transformer_index_for_condition[i] _UpperCAmelCase = self.transformers[transformer_index]( __UpperCamelCase , encoder_hidden_states=__UpperCamelCase , timestep=__UpperCamelCase , cross_attention_kwargs=__UpperCamelCase , return_dict=__UpperCamelCase , )[0] encoded_states.append(encoded_state - input_states ) tokens_start += self.condition_lengths[i] _UpperCAmelCase = encoded_states[0] * self.mix_ratio + encoded_states[1] * (1 - self.mix_ratio) _UpperCAmelCase = output_states + input_states if not return_dict: return (output_states,) return TransformeraDModelOutput(sample=__UpperCamelCase )
19
1
"""simple docstring""" import random def _UpperCamelCase ( _A , _A , _A ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = a[left_index] _UpperCAmelCase = left_index + 1 for j in range(left_index + 1 , _A ): if a[j] < pivot: _UpperCAmelCase ,_UpperCAmelCase = a[i], a[j] i += 1 _UpperCAmelCase ,_UpperCAmelCase = a[i - 1], a[left_index] return i - 1 def _UpperCamelCase ( _A , _A , _A ) -> List[Any]: """simple docstring""" if left < right: _UpperCAmelCase = random.randint(_A , right - 1 ) _UpperCAmelCase ,_UpperCAmelCase = ( a[left], a[pivot], ) # switches the pivot with the left most bound _UpperCAmelCase = partition(_A , _A , _A ) quick_sort_random( _A , _A , _A ) # recursive quicksort to the left of the pivot point quick_sort_random( _A , pivot_index + 1 , _A ) # recursive quicksort to the right of the pivot point def _UpperCamelCase ( ) -> str: """simple docstring""" _UpperCAmelCase = input("""Enter numbers separated by a comma:\n""" ).strip() _UpperCAmelCase = [int(_A ) for item in user_input.split(""",""" )] quick_sort_random(_A , 0 , len(_A ) ) print(_A ) if __name__ == "__main__": main()
19
"""simple docstring""" import argparse import torch from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert from transformers.utils import logging logging.set_verbosity_info() def _UpperCamelCase ( _A , _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = LxmertConfig.from_json_file(_A ) print(F"""Building PyTorch model from configuration: {config}""" ) _UpperCAmelCase = LxmertForPreTraining(_A ) # Load weights from tf checkpoint load_tf_weights_in_lxmert(_A , _A , _A ) # Save pytorch-model print(F"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict() , _A ) if __name__ == "__main__": a : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--config_file''', default=None, type=str, required=True, help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''', ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) a : Union[str, Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
19
1
"""simple docstring""" # Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING, Dict, Optional import numpy as np import pyarrow as pa from .. import config from ..utils.logging import get_logger from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import jax import jaxlib a : List[Any] = get_logger() a : Optional[dict] = None class a_ ( TensorFormatter[Mapping, 'jax.Array', Mapping] ): def __init__( self : int , __UpperCamelCase : List[str]=None , __UpperCamelCase : Optional[int]=None , **__UpperCamelCase : int ) ->Tuple: '''simple docstring''' super().__init__(features=__UpperCamelCase ) import jax from jaxlib.xla_client import Device if isinstance(__UpperCamelCase , __UpperCamelCase ): raise ValueError( f"""Expected {device} to be a `str` not {type(__UpperCamelCase )}, as `jaxlib.xla_extension.Device` """ """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """ """the device with `str()` to get its string identifier that will be internally mapped """ """to the actual `jaxlib.xla_extension.Device`.""" ) _UpperCAmelCase = device if isinstance(__UpperCamelCase , __UpperCamelCase ) else str(jax.devices()[0] ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() if self.device not in list(DEVICE_MAPPING.keys() ): logger.warning( f"""Device with string identifier {self.device} not listed among the available """ f"""devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default """ f"""device: {str(jax.devices()[0] )}.""" ) _UpperCAmelCase = str(jax.devices()[0] ) _UpperCAmelCase = jnp_array_kwargs @staticmethod def _snake_case ( ) ->Dict[str, "jaxlib.xla_extension.Device"]: '''simple docstring''' import jax return {str(__UpperCamelCase ): device for device in jax.devices()} def _snake_case ( self : Dict , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , __UpperCamelCase ) and column: if all( isinstance(__UpperCamelCase , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return jnp.stack(__UpperCamelCase , axis=0 ) return column def _snake_case ( self : List[str] , __UpperCamelCase : Any ) ->Optional[int]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , (str, bytes, type(__UpperCamelCase )) ): return value elif isinstance(__UpperCamelCase , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() _UpperCAmelCase = {} if isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): # the default int precision depends on the jax config # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision if jax.config.jax_enable_xaa: _UpperCAmelCase = {"""dtype""": jnp.intaa} else: _UpperCAmelCase = {"""dtype""": jnp.intaa} elif isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): _UpperCAmelCase = {"""dtype""": jnp.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(__UpperCamelCase , PIL.Image.Image ): _UpperCAmelCase = np.asarray(__UpperCamelCase ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() with jax.default_device(DEVICE_MAPPING[self.device] ): # calling jnp.array on a np.ndarray does copy the data # see https://github.com/google/jax/issues/4486 return jnp.array(__UpperCamelCase , **{**default_dtype, **self.jnp_array_kwargs} ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->Any: '''simple docstring''' import jax # support for torch, tf, jax etc. if config.TORCH_AVAILABLE and "torch" in sys.modules: import torch if isinstance(__UpperCamelCase , torch.Tensor ): return self._tensorize(data_struct.detach().cpu().numpy()[()] ) if hasattr(__UpperCamelCase , """__array__""" ) and not isinstance(__UpperCamelCase , jax.Array ): _UpperCAmelCase = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(__UpperCamelCase , np.ndarray ): if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) elif isinstance(__UpperCamelCase , (list, tuple) ): return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) return self._tensorize(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : dict ) ->int: '''simple docstring''' return map_nested(self._recursive_tensorize , __UpperCamelCase , map_list=__UpperCamelCase ) def _snake_case ( self : Dict , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_row(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_row(__UpperCamelCase ) return self.recursive_tensorize(__UpperCamelCase ) def _snake_case ( self : Optional[int] , __UpperCamelCase : pa.Table ) ->"jax.Array": '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_column(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_column(__UpperCamelCase , pa_table.column_names[0] ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) _UpperCAmelCase = self._consolidate(__UpperCamelCase ) return column def _snake_case ( self : Optional[Any] , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_batch(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_batch(__UpperCamelCase ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) for column_name in batch: _UpperCAmelCase = self._consolidate(batch[column_name] ) return batch
19
"""simple docstring""" import argparse import os import re import packaging.version a : str = '''examples/''' a : List[str] = { '''examples''': (re.compile(r'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''), '''init''': (re.compile(r'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''), '''setup''': (re.compile(r'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), r'''\1version="VERSION",'''), '''doc''': (re.compile(r'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''), } a : Tuple = { '''init''': '''src/diffusers/__init__.py''', '''setup''': '''setup.py''', } a : List[str] = '''README.md''' def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase ,_UpperCAmelCase = REPLACE_PATTERNS[pattern] _UpperCAmelCase = replace.replace("""VERSION""" , _A ) _UpperCAmelCase = re_pattern.sub(_A , _A ) with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.write(_A ) def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" for folder, directories, fnames in os.walk(_A ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("""research_projects""" ) if "legacy" in directories: directories.remove("""legacy""" ) for fname in fnames: if fname.endswith(""".py""" ): update_version_in_file(os.path.join(_A , _A ) , _A , pattern="""examples""" ) def _UpperCamelCase ( _A , _A=False ) -> int: """simple docstring""" for pattern, fname in REPLACE_FILES.items(): update_version_in_file(_A , _A , _A ) if not patch: update_version_in_examples(_A ) def _UpperCamelCase ( ) -> Any: """simple docstring""" _UpperCAmelCase = """🤗 Transformers currently provides the following architectures""" _UpperCAmelCase = """1. Want to contribute a new model?""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.readlines() # Find the start of the list. _UpperCAmelCase = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 _UpperCAmelCase = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("""1.""" ): _UpperCAmelCase = lines[index].replace( """https://huggingface.co/docs/diffusers/main/model_doc""" , """https://huggingface.co/docs/diffusers/model_doc""" , ) index += 1 with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.writelines(_A ) def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" with open(REPLACE_FILES["""init"""] , """r""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase = REPLACE_PATTERNS["""init"""][0].search(_A ).groups()[0] return packaging.version.parse(_A ) def _UpperCamelCase ( _A=False ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() if patch and default_version.is_devrelease: raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" ) if default_version.is_devrelease: _UpperCAmelCase = default_version.base_version elif patch: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}""" else: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor + 1}.0""" # Now let's ask nicely if that's the right one. _UpperCAmelCase = input(F"""Which version are you releasing? [{default_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = default_version print(F"""Updating version to {version}.""" ) global_version_update(_A , patch=_A ) def _UpperCamelCase ( ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() _UpperCAmelCase = F"""{current_version.major}.{current_version.minor + 1}.0.dev0""" _UpperCAmelCase = current_version.base_version # Check with the user we got that right. _UpperCAmelCase = input(F"""Which version are we developing now? [{dev_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = dev_version print(F"""Updating version to {version}.""" ) global_version_update(_A ) # print("Cleaning main README, don't forget to run `make fix-copies`.") # clean_main_ref_in_model_list() if __name__ == "__main__": a : Dict = argparse.ArgumentParser() parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''') parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''') a : Tuple = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('''Nothing to do after a patch :-)''') else: post_release_work()
19
1
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available a : str = { '''configuration_mask2former''': [ '''MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Mask2FormerConfig''', ], } try: if not is_vision_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Union[str, Any] = ['''Mask2FormerImageProcessor'''] try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Any = [ '''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 a : Tuple = _LazyModule(__name__, globals()['''__file__'''], _import_structure)
19
"""simple docstring""" from __future__ import annotations def _UpperCamelCase ( _A ) -> None: """simple docstring""" create_state_space_tree(_A , [] , 0 , [0 for i in range(len(_A ) )] ) def _UpperCamelCase ( _A , _A , _A , _A , ) -> None: """simple docstring""" if index == len(_A ): print(_A ) return for i in range(len(_A ) ): if not index_used[i]: current_sequence.append(sequence[i] ) _UpperCAmelCase = True create_state_space_tree(_A , _A , index + 1 , _A ) current_sequence.pop() _UpperCAmelCase = False a : list[int | str] = [3, 1, 2, 4] generate_all_permutations(sequence) a : list[int | str] = ["A", "B", "C"] generate_all_permutations(sequence_a)
19
1
"""simple docstring""" from typing import Any class a_ : def __init__( self : int , __UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase = data _UpperCAmelCase = None class a_ : def __init__( self : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = None def _snake_case ( self : str ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.head while temp is not None: print(temp.data , end=""" """ ) _UpperCAmelCase = temp.next print() def _snake_case ( self : Union[str, Any] , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = Node(__UpperCamelCase ) _UpperCAmelCase = self.head _UpperCAmelCase = new_node def _snake_case ( self : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : Union[str, Any] ) ->Optional[Any]: '''simple docstring''' if node_data_a == node_data_a: return else: _UpperCAmelCase = self.head while node_a is not None and node_a.data != node_data_a: _UpperCAmelCase = node_a.next _UpperCAmelCase = self.head while node_a is not None and node_a.data != node_data_a: _UpperCAmelCase = node_a.next if node_a is None or node_a is None: return _UpperCAmelCase ,_UpperCAmelCase = node_a.data, node_a.data if __name__ == "__main__": a : Any = LinkedList() for i in range(5, 0, -1): ll.push(i) ll.print_list() ll.swap_nodes(1, 4) print('''After swapping''') ll.print_list()
19
"""simple docstring""" import inspect import unittest from transformers import DPTConfig from transformers.file_utils import is_torch_available, is_vision_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, require_vision, slow, torch_device 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 MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import DPTImageProcessor class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int]=2 , __UpperCamelCase : int=32 , __UpperCamelCase : Tuple=16 , __UpperCamelCase : Dict=3 , __UpperCamelCase : Dict=True , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Optional[Any]=32 , __UpperCamelCase : Any=4 , __UpperCamelCase : Optional[int]=[0, 1, 2, 3] , __UpperCamelCase : str=4 , __UpperCamelCase : Optional[Any]=37 , __UpperCamelCase : str="gelu" , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : Any=0.1 , __UpperCamelCase : Any=0.0_2 , __UpperCamelCase : Optional[int]=3 , __UpperCamelCase : int=[1, 3_84, 24, 24] , __UpperCamelCase : Union[str, Any]=True , __UpperCamelCase : Any=None , ) ->Optional[Any]: '''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 = backbone_out_indices _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = backbone_featmap_shape _UpperCAmelCase = scope _UpperCAmelCase = is_hybrid # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token) _UpperCAmelCase = (image_size // patch_size) ** 2 _UpperCAmelCase = num_patches + 1 def _snake_case ( self : str ) ->int: '''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.image_size, self.image_size] , self.num_labels ) _UpperCAmelCase = self.get_config() return config, pixel_values, labels def _snake_case ( self : List[str] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = { """global_padding""": """same""", """layer_type""": """bottleneck""", """depths""": [3, 4, 9], """out_features""": ["""stage1""", """stage2""", """stage3"""], """embedding_dynamic_padding""": True, """hidden_sizes""": [96, 1_92, 3_84, 7_68], """num_groups""": 2, } return DPTConfig( 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 , backbone_out_indices=self.backbone_out_indices , 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 , is_hybrid=self.is_hybrid , backbone_config=__UpperCamelCase , backbone_featmap_shape=self.backbone_featmap_shape , ) def _snake_case ( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = DPTModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : str , __UpperCamelCase : List[Any] ) ->int: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.predicted_depth.shape , (self.batch_size, self.image_size, self.image_size) ) def _snake_case ( self : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForSemanticSegmentation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , labels=__UpperCamelCase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size, self.image_size) ) def _snake_case ( self : Tuple ) ->Any: '''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 a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : Dict = (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else () a : int = ( { 'depth-estimation': DPTForDepthEstimation, 'feature-extraction': DPTModel, 'image-segmentation': DPTForSemanticSegmentation, } if is_torch_available() else {} ) a : str = False a : List[str] = False a : Dict = False def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = DPTModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , has_text_modality=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : Optional[int] ) ->Any: '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason="""DPT does not use inputs_embeds""" ) def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' pass def _snake_case ( self : int ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) _UpperCAmelCase = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__UpperCamelCase , nn.Linear ) ) def _snake_case ( self : Optional[int] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , __UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCamelCase ) def _snake_case ( self : str ) ->int: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_depth_estimation(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCamelCase ) def _snake_case ( self : str ) ->Any: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ): continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = False _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ) or not model_class.supports_gradient_checkpointing: continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.gradient_checkpointing_enable() model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : Tuple ) ->List[str]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = _config_zero_init(__UpperCamelCase ) for model_class in self.all_model_classes: _UpperCAmelCase = model_class(config=__UpperCamelCase ) # Skip the check for the backbone _UpperCAmelCase = [] for name, module in model.named_modules(): if module.__class__.__name__ == "DPTViTHybridEmbeddings": _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""" , ) @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" ) def _snake_case ( self : Dict ) ->Tuple: '''simple docstring''' pass @slow def _snake_case ( self : Optional[int] ) ->List[Any]: '''simple docstring''' for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]: _UpperCAmelCase = DPTModel.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = """add""" with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) return image @require_torch @require_vision @slow class a_ ( unittest.TestCase ): def _snake_case ( self : Any ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = DPTImageProcessor.from_pretrained("""Intel/dpt-hybrid-midas""" ) _UpperCAmelCase = DPTForDepthEstimation.from_pretrained("""Intel/dpt-hybrid-midas""" ).to(__UpperCamelCase ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=__UpperCamelCase , return_tensors="""pt""" ).to(__UpperCamelCase ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**__UpperCamelCase ) _UpperCAmelCase = outputs.predicted_depth # verify the predicted depth _UpperCAmelCase = torch.Size((1, 3_84, 3_84) ) self.assertEqual(predicted_depth.shape , __UpperCamelCase ) _UpperCAmelCase = torch.tensor( [[[5.6_4_3_7, 5.6_1_4_6, 5.6_5_1_1], [5.4_3_7_1, 5.5_6_4_9, 5.5_9_5_8], [5.5_2_1_5, 5.5_1_8_4, 5.5_2_9_3]]] ).to(__UpperCamelCase ) self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 1_00 , __UpperCamelCase , atol=1e-4 ) )
19
1
"""simple docstring""" import torch from diffusers import DPMSolverSDEScheduler from diffusers.utils import torch_device from diffusers.utils.testing_utils import require_torchsde from .test_schedulers import SchedulerCommonTest @require_torchsde class a_ ( _UpperCAmelCase ): a : Union[str, Any] = (DPMSolverSDEScheduler,) a : Any = 10 def _snake_case ( self : Optional[int] , **__UpperCamelCase : int ) ->List[str]: '''simple docstring''' _UpperCAmelCase = { """num_train_timesteps""": 11_00, """beta_start""": 0.0_0_0_1, """beta_end""": 0.0_2, """beta_schedule""": """linear""", """noise_sampler_seed""": 0, } config.update(**__UpperCamelCase ) return config def _snake_case ( self : Optional[int] ) ->List[str]: '''simple docstring''' for timesteps in [10, 50, 1_00, 10_00]: self.check_over_configs(num_train_timesteps=__UpperCamelCase ) def _snake_case ( self : Dict ) ->Any: '''simple docstring''' for beta_start, beta_end in zip([0.0_0_0_0_1, 0.0_0_0_1, 0.0_0_1] , [0.0_0_0_2, 0.0_0_2, 0.0_2] ): self.check_over_configs(beta_start=__UpperCamelCase , beta_end=__UpperCamelCase ) def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' for schedule in ["linear", "scaled_linear"]: self.check_over_configs(beta_schedule=__UpperCamelCase ) def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' for prediction_type in ["epsilon", "v_prediction"]: self.check_over_configs(prediction_type=__UpperCamelCase ) def _snake_case ( self : Any ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) scheduler.set_timesteps(self.num_inference_steps ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter * scheduler.init_noise_sigma _UpperCAmelCase = sample.to(__UpperCamelCase ) for i, t in enumerate(scheduler.timesteps ): _UpperCAmelCase = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = output.prev_sample _UpperCAmelCase = torch.sum(torch.abs(__UpperCamelCase ) ) _UpperCAmelCase = torch.mean(torch.abs(__UpperCamelCase ) ) if torch_device in ["mps"]: assert abs(result_sum.item() - 1_6_7.4_7_8_2_1_0_4_4_9_2_1_8_7_5 ) < 1e-2 assert abs(result_mean.item() - 0.2_1_7_8_7_0_5_9_6_4_5_6_5_2_7_7 ) < 1e-3 elif torch_device in ["cuda"]: assert abs(result_sum.item() - 1_7_1.5_9_3_5_2_1_1_1_8_1_6_4_0_6 ) < 1e-2 assert abs(result_mean.item() - 0.2_2_3_4_2_9_0_6_8_9_2_2_9_9_6_5_2 ) < 1e-3 else: assert abs(result_sum.item() - 1_6_2.5_2_3_8_3_4_2_2_8_5_1_5_6_2 ) < 1e-2 assert abs(result_mean.item() - 0.2_1_1_6_1_9_5_7_0_8_5_1_3_2_6 ) < 1e-3 def _snake_case ( self : Optional[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config(prediction_type="""v_prediction""" ) _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) scheduler.set_timesteps(self.num_inference_steps ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter * scheduler.init_noise_sigma _UpperCAmelCase = sample.to(__UpperCamelCase ) for i, t in enumerate(scheduler.timesteps ): _UpperCAmelCase = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = output.prev_sample _UpperCAmelCase = torch.sum(torch.abs(__UpperCamelCase ) ) _UpperCAmelCase = torch.mean(torch.abs(__UpperCamelCase ) ) if torch_device in ["mps"]: assert abs(result_sum.item() - 1_2_4.7_7_1_4_9_2_0_0_4_3_9_4_5_3 ) < 1e-2 assert abs(result_mean.item() - 0.1_6_2_2_6_2_8_9_0_1_4_8_1_6_2_8_4 ) < 1e-3 elif torch_device in ["cuda"]: assert abs(result_sum.item() - 1_2_8.1_6_6_3_3_6_0_5_9_5_7_0_3 ) < 1e-2 assert abs(result_mean.item() - 0.1_6_6_8_8_3_2_6_0_0_1_1_6_7_2_9_7 ) < 1e-3 else: assert abs(result_sum.item() - 1_1_9.8_4_8_7_5_4_8_8_2_8_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.1_5_6_0_5_3_0_6_6_2_5_3_6_6_2_1 ) < 1e-3 def _snake_case ( self : Union[str, Any] ) ->List[str]: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase ) scheduler.set_timesteps(self.num_inference_steps , device=__UpperCamelCase ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter.to(__UpperCamelCase ) * scheduler.init_noise_sigma for t in scheduler.timesteps: _UpperCAmelCase = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = output.prev_sample _UpperCAmelCase = torch.sum(torch.abs(__UpperCamelCase ) ) _UpperCAmelCase = torch.mean(torch.abs(__UpperCamelCase ) ) if torch_device in ["mps"]: assert abs(result_sum.item() - 1_6_7.4_6_9_5_7_3_9_7_4_6_0_9_3_8 ) < 1e-2 assert abs(result_mean.item() - 0.2_1_8_0_5_9_3_4_6_0_7_9_8_2_6_3_5 ) < 1e-3 elif torch_device in ["cuda"]: assert abs(result_sum.item() - 1_7_1.5_9_3_5_3_6_3_7_6_9_5_3_1_2 ) < 1e-2 assert abs(result_mean.item() - 0.2_2_3_4_2_9_0_8_3_8_2_4_1_5_7_7_1 ) < 1e-3 else: assert abs(result_sum.item() - 1_6_2.5_2_3_8_3_4_2_2_8_5_1_5_6_2 ) < 1e-2 assert abs(result_mean.item() - 0.2_1_1_6_1_9_5_7_0_8_5_1_3_2_6 ) < 1e-3 def _snake_case ( self : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.scheduler_classes[0] _UpperCAmelCase = self.get_scheduler_config() _UpperCAmelCase = scheduler_class(**__UpperCamelCase , use_karras_sigmas=__UpperCamelCase ) scheduler.set_timesteps(self.num_inference_steps , device=__UpperCamelCase ) _UpperCAmelCase = self.dummy_model() _UpperCAmelCase = self.dummy_sample_deter.to(__UpperCamelCase ) * scheduler.init_noise_sigma _UpperCAmelCase = sample.to(__UpperCamelCase ) for t in scheduler.timesteps: _UpperCAmelCase = scheduler.scale_model_input(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = scheduler.step(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = output.prev_sample _UpperCAmelCase = torch.sum(torch.abs(__UpperCamelCase ) ) _UpperCAmelCase = torch.mean(torch.abs(__UpperCamelCase ) ) if torch_device in ["mps"]: assert abs(result_sum.item() - 1_7_6.6_6_9_7_4_1_3_5_7_4_2_1_8_8 ) < 1e-2 assert abs(result_mean.item() - 0.2_3_0_0_3_8_7_2_7_3_0_9_8_1_8_1_1 ) < 1e-2 elif torch_device in ["cuda"]: assert abs(result_sum.item() - 1_7_7.6_3_6_5_3_5_6_4_4_5_3_1_2_5 ) < 1e-2 assert abs(result_mean.item() - 0.2_3_0_0_3_8_7_2_7_3_0_9_8_1_8_1_1 ) < 1e-2 else: assert abs(result_sum.item() - 1_7_0.3_1_3_5_2_2_3_3_8_8_6_7_2 ) < 1e-2 assert abs(result_mean.item() - 0.2_3_0_0_3_8_7_2_7_3_0_9_8_1_8_1_1 ) < 1e-2
19
"""simple docstring""" import enum import warnings from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING a : List[str] = logging.get_logger(__name__) class a_ ( enum.Enum ): a : Optional[Any] = 0 a : Dict = 1 @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'generated' def __init__( self : int , *__UpperCamelCase : Optional[int] , **__UpperCamelCase : str ) ->Any: '''simple docstring''' super().__init__(*__UpperCamelCase , **__UpperCamelCase ) self.check_model_type( TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if self.framework == """tf""" else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : int=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : Dict=None , **__UpperCamelCase : Any , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = {} if truncation is not None: _UpperCAmelCase = truncation _UpperCAmelCase = generate_kwargs _UpperCAmelCase = {} if return_tensors is not None and return_type is None: _UpperCAmelCase = ReturnType.TENSORS if return_tensors else ReturnType.TEXT if return_type is not None: _UpperCAmelCase = return_type if clean_up_tokenization_spaces is not None: _UpperCAmelCase = clean_up_tokenization_spaces if stop_sequence is not None: _UpperCAmelCase = self.tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) if len(__UpperCamelCase ) > 1: warnings.warn( """Stopping on a multiple token sequence is not yet supported on transformers. The first token of""" """ the stop sequence will be used as the stop sequence string in the interim.""" ) _UpperCAmelCase = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def _snake_case ( self : int , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' return True def _snake_case ( self : Optional[Any] , *__UpperCamelCase : Any , __UpperCamelCase : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model.config.prefix if self.model.config.prefix is not None else """""" if isinstance(args[0] , __UpperCamelCase ): if self.tokenizer.pad_token_id is None: raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" ) _UpperCAmelCase = ([prefix + arg for arg in args[0]],) _UpperCAmelCase = True elif isinstance(args[0] , __UpperCamelCase ): _UpperCAmelCase = (prefix + args[0],) _UpperCAmelCase = False else: raise ValueError( f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" ) _UpperCAmelCase = self.tokenizer(*__UpperCamelCase , padding=__UpperCamelCase , truncation=__UpperCamelCase , return_tensors=self.framework ) # This is produced by tokenizers but is an invalid generate kwargs if "token_type_ids" in inputs: del inputs["token_type_ids"] return inputs def __call__( self : Dict , *__UpperCamelCase : str , **__UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = super().__call__(*__UpperCamelCase , **__UpperCamelCase ) if ( isinstance(args[0] , __UpperCamelCase ) and all(isinstance(__UpperCamelCase , __UpperCamelCase ) for el in args[0] ) and all(len(__UpperCamelCase ) == 1 for res in result ) ): return [res[0] for res in result] return result def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : str=TruncationStrategy.DO_NOT_TRUNCATE , **__UpperCamelCase : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self._parse_and_tokenize(__UpperCamelCase , truncation=__UpperCamelCase , **__UpperCamelCase ) return inputs def _snake_case ( self : str , __UpperCamelCase : Dict , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' if self.framework == "pt": _UpperCAmelCase ,_UpperCAmelCase = model_inputs["""input_ids"""].shape elif self.framework == "tf": _UpperCAmelCase ,_UpperCAmelCase = tf.shape(model_inputs["""input_ids"""] ).numpy() _UpperCAmelCase = generate_kwargs.get("""min_length""" , self.model.config.min_length ) _UpperCAmelCase = generate_kwargs.get("""max_length""" , self.model.config.max_length ) self.check_inputs(__UpperCamelCase , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] ) _UpperCAmelCase = self.model.generate(**__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = output_ids.shape[0] if self.framework == "pt": _UpperCAmelCase = output_ids.reshape(__UpperCamelCase , out_b // in_b , *output_ids.shape[1:] ) elif self.framework == "tf": _UpperCAmelCase = tf.reshape(__UpperCamelCase , (in_b, out_b // in_b, *output_ids.shape[1:]) ) return {"output_ids": output_ids} def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : Union[str, Any]=ReturnType.TEXT , __UpperCamelCase : int=False ) ->Any: '''simple docstring''' _UpperCAmelCase = [] for output_ids in model_outputs["output_ids"][0]: if return_type == ReturnType.TENSORS: _UpperCAmelCase = {f"""{self.return_name}_token_ids""": output_ids} elif return_type == ReturnType.TEXT: _UpperCAmelCase = { f"""{self.return_name}_text""": self.tokenizer.decode( __UpperCamelCase , skip_special_tokens=__UpperCamelCase , clean_up_tokenization_spaces=__UpperCamelCase , ) } records.append(__UpperCamelCase ) return records @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'summary' def __call__( self : Optional[Any] , *__UpperCamelCase : Optional[Any] , **__UpperCamelCase : Optional[int] ) ->Any: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->bool: '''simple docstring''' if max_length < min_length: logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" ) if input_length < max_length: logger.warning( f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """ """a summarization task, where outputs shorter than the input are typically wanted, you might """ f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" ) @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : Optional[int] = 'translation' def _snake_case ( self : Union[str, Any] , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' if input_length > 0.9 * max_length: logger.warning( f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """ """increasing your max_length manually, e.g. translator('...', max_length=400)""" ) return True def _snake_case ( self : Tuple , *__UpperCamelCase : List[str] , __UpperCamelCase : Tuple=TruncationStrategy.DO_NOT_TRUNCATE , __UpperCamelCase : Tuple=None , __UpperCamelCase : Union[str, Any]=None ) ->Tuple: '''simple docstring''' if getattr(self.tokenizer , """_build_translation_inputs""" , __UpperCamelCase ): return self.tokenizer._build_translation_inputs( *__UpperCamelCase , return_tensors=self.framework , truncation=__UpperCamelCase , src_lang=__UpperCamelCase , tgt_lang=__UpperCamelCase ) else: return super()._parse_and_tokenize(*__UpperCamelCase , truncation=__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : int=None , __UpperCamelCase : int=None , **__UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = super()._sanitize_parameters(**__UpperCamelCase ) if src_lang is not None: _UpperCAmelCase = src_lang if tgt_lang is not None: _UpperCAmelCase = tgt_lang if src_lang is None and tgt_lang is None: # Backward compatibility, direct arguments use is preferred. _UpperCAmelCase = kwargs.get("""task""" , self.task ) _UpperCAmelCase = task.split("""_""" ) if task and len(__UpperCamelCase ) == 4: # translation, XX, to YY _UpperCAmelCase = items[1] _UpperCAmelCase = items[3] return preprocess_params, forward_params, postprocess_params def __call__( self : List[str] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->int: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase )
19
1
"""simple docstring""" import requests a : List[str] = '''YOUR API KEY''' def _UpperCamelCase ( _A , _A = giphy_api_key ) -> list: """simple docstring""" _UpperCAmelCase = """+""".join(query.split() ) _UpperCAmelCase = F"""https://api.giphy.com/v1/gifs/search?q={formatted_query}&api_key={api_key}""" _UpperCAmelCase = requests.get(_A ).json()["""data"""] return [gif["url"] for gif in gifs] if __name__ == "__main__": print('''\n'''.join(get_gifs('''space ship''')))
19
"""simple docstring""" import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class a_ ( unittest.TestCase ): @property def _snake_case ( self : Dict ) ->int: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") , up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") , ) return model @property def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = VQModel( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=3 , ) return model @property def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) return CLIPTextModel(__UpperCamelCase ) def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = self.dummy_vq_model _UpperCAmelCase = LDMPipeline(unet=__UpperCamelCase , vqvae=__UpperCamelCase , scheduler=__UpperCamelCase ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" ).images _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" , return_dict=__UpperCamelCase )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _UpperCAmelCase = np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < tolerance @slow @require_torch class a_ ( unittest.TestCase ): def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256""" ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=5 , output_type="""numpy""" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _UpperCAmelCase = np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance
19
1
"""simple docstring""" import os import socket from contextlib import contextmanager import torch from ..commands.config.default import write_basic_config # noqa: F401 from ..state import PartialState from .dataclasses import DistributedType from .imports import is_deepspeed_available, is_tpu_available from .transformer_engine import convert_model from .versions import is_torch_version if is_deepspeed_available(): from deepspeed import DeepSpeedEngine if is_tpu_available(check_device=False): import torch_xla.core.xla_model as xm def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" if is_torch_version("""<""" , """2.0.0""" ) or not hasattr(_A , """_dynamo""" ): return False return isinstance(_A , torch._dynamo.eval_frame.OptimizedModule ) def _UpperCamelCase ( _A , _A = True ) -> List[str]: """simple docstring""" _UpperCAmelCase = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel) _UpperCAmelCase = is_compiled_module(_A ) if is_compiled: _UpperCAmelCase = model _UpperCAmelCase = model._orig_mod if is_deepspeed_available(): options += (DeepSpeedEngine,) while isinstance(_A , _A ): _UpperCAmelCase = model.module if not keep_fpaa_wrapper: _UpperCAmelCase = getattr(_A , """forward""" ) _UpperCAmelCase = model.__dict__.pop("""_original_forward""" , _A ) if original_forward is not None: while hasattr(_A , """__wrapped__""" ): _UpperCAmelCase = forward.__wrapped__ if forward == original_forward: break _UpperCAmelCase = forward if getattr(_A , """_converted_to_transformer_engine""" , _A ): convert_model(_A , to_transformer_engine=_A ) if is_compiled: _UpperCAmelCase = model _UpperCAmelCase = compiled_model return model def _UpperCamelCase ( ) -> str: """simple docstring""" PartialState().wait_for_everyone() def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" if PartialState().distributed_type == DistributedType.TPU: xm.save(_A , _A ) elif PartialState().local_process_index == 0: torch.save(_A , _A ) @contextmanager def _UpperCamelCase ( **_A ) -> List[str]: """simple docstring""" for key, value in kwargs.items(): _UpperCAmelCase = str(_A ) yield for key in kwargs: if key.upper() in os.environ: del os.environ[key.upper()] def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" if not hasattr(_A , """__qualname__""" ) and not hasattr(_A , """__name__""" ): _UpperCAmelCase = getattr(_A , """__class__""" , _A ) if hasattr(_A , """__qualname__""" ): return obj.__qualname__ if hasattr(_A , """__name__""" ): return obj.__name__ return str(_A ) def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" for key, value in source.items(): if isinstance(_A , _A ): _UpperCAmelCase = destination.setdefault(_A , {} ) merge_dicts(_A , _A ) else: _UpperCAmelCase = value return destination def _UpperCamelCase ( _A = None ) -> bool: """simple docstring""" if port is None: _UpperCAmelCase = 2_9_5_0_0 with socket.socket(socket.AF_INET , socket.SOCK_STREAM ) as s: return s.connect_ex(("""localhost""", port) ) == 0
19
"""simple docstring""" import re from filelock import FileLock try: import nltk a : str = True except (ImportError, ModuleNotFoundError): a : List[str] = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def _UpperCamelCase ( _A ) -> str: """simple docstring""" re.sub("""<n>""" , """""" , _A ) # 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(_A ) )
19
1
"""simple docstring""" def _UpperCamelCase ( _A = 1_0 ) -> str: """simple docstring""" if not isinstance(_A , _A ) or n < 0: raise ValueError("""Invalid input""" ) _UpperCAmelCase = 1_0**n _UpperCAmelCase = 2_8_4_3_3 * (pow(2 , 7_8_3_0_4_5_7 , _A )) + 1 return str(number % modulus ) if __name__ == "__main__": from doctest import testmod testmod() print(F"{solution(1_0) = }")
19
"""simple docstring""" import unittest from transformers import PegasusConfig, PegasusTokenizer, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_configuration_common import ConfigTester 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 : str = '''platform''' import jax import jax.numpy as jnp import numpy as np from transformers import FlaxPegasusForConditionalGeneration, FlaxPegasusModel @require_flax class a_ : a : List[Any] = PegasusConfig a : Dict = {} a : List[Any] = 'gelu' def __init__( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Tuple=13 , __UpperCamelCase : Tuple=7 , __UpperCamelCase : Tuple=True , __UpperCamelCase : Any=False , __UpperCamelCase : Any=99 , __UpperCamelCase : Optional[int]=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : List[str]=4 , __UpperCamelCase : Dict=37 , __UpperCamelCase : int=0.1 , __UpperCamelCase : Dict=0.1 , __UpperCamelCase : Optional[Any]=20 , __UpperCamelCase : Tuple=2 , __UpperCamelCase : Optional[int]=1 , __UpperCamelCase : Tuple=0 , ) ->int: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = bos_token_id def _snake_case ( self : Union[str, Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ).clip(3 , self.vocab_size ) _UpperCAmelCase = np.expand_dims(np.array([self.eos_token_id] * self.batch_size ) , 1 ) _UpperCAmelCase = np.concatenate([input_ids, eos_tensor] , axis=1 ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) _UpperCAmelCase = prepare_pegasus_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, inputs_dict def _snake_case ( self : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) , dtype="""i4""" ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _snake_case ( self : Any , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] , axis=-1 , ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_attention_mask=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _UpperCamelCase ( _A , _A , _A , _A=None , _A=None , ) -> int: """simple docstring""" if attention_mask is None: _UpperCAmelCase = np.not_equal(_A , config.pad_token_id ).astype(np.inta ) if decoder_attention_mask is None: _UpperCAmelCase = np.concatenate( [ np.ones(decoder_input_ids[:, :1].shape , dtype=np.inta ), np.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id ).astype(np.inta ), ] , axis=-1 , ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, } @require_flax class a_ ( _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( ( FlaxPegasusForConditionalGeneration, FlaxPegasusModel, ) if is_flax_available() else () ) a : Any = (FlaxPegasusForConditionalGeneration,) if is_flax_available() else () a : Any = True a : int = False a : Union[str, Any] = False a : Optional[int] = False def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->List[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model_class(__UpperCamelCase ) @jax.jit def encode_jitted(__UpperCamelCase : List[Any] , __UpperCamelCase : str=None , **__UpperCamelCase : int ): return model.encode(input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] , inputs_dict["""attention_mask"""] ) _UpperCAmelCase = { """decoder_input_ids""": inputs_dict["""decoder_input_ids"""], """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""], """encoder_outputs""": encoder_outputs, } @jax.jit def decode_jitted(__UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple ): return model.decode( decoder_input_ids=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , encoder_outputs=__UpperCamelCase , ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) @slow def _snake_case ( self : int ) ->int: '''simple docstring''' for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained("""google/pegasus-large""" , from_pt=__UpperCamelCase ) _UpperCAmelCase = np.ones((1, 1) ) _UpperCAmelCase = model(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) @slow def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusForConditionalGeneration.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = PegasusTokenizer.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = [ """ PG&E stated it scheduled the blackouts in response to forecasts for high winds amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow.""", """ The London trio are up for best UK act and best album, as well as getting two nominations in the best song category.\"We got told like this morning 'Oh I think you're nominated'\", said Dappy.\"And I was like 'Oh yeah, which one?' And now we've got nominated for four awards. I mean, wow!\"Bandmate Fazer added: \"We thought it's best of us to come down and mingle with everyone and say hello to the cameras. And now we find we've got four nominations.\"The band have two shots at the best song prize, getting the nod for their Tynchy Stryder collaboration Number One, and single Strong Again.Their album Uncle B will also go up against records by the likes of Beyonce and Kanye West.N-Dubz picked up the best newcomer Mobo in 2007, but female member Tulisa said they wouldn't be too disappointed if they didn't win this time around.\"At the end of the day we're grateful to be where we are in our careers.\"If it don't happen then it don't happen - live to fight another day and keep on making albums and hits for the fans.\"Dappy also revealed they could be performing live several times on the night.The group will be doing Number One and also a possible rendition of the War Child single, I Got Soul.The charity song is a re-working of The Killers' All These Things That I've Done and is set to feature artists like Chipmunk, Ironik and Pixie Lott.This year's Mobos will be held outside of London for the first time, in Glasgow on 30 September.N-Dubz said they were looking forward to performing for their Scottish fans and boasted about their recent shows north of the border.\"We just done Edinburgh the other day,\" said Dappy.\"We smashed up an N-Dubz show over there. We done Aberdeen about three or four months ago - we smashed up that show over there! Everywhere we go we smash it up!\" """, ] _UpperCAmelCase = [ """California's largest electricity provider has turned off power to hundreds of thousands of customers.""", """Pop group N-Dubz have revealed they were surprised to get four nominations for this year's Mobo Awards.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""np""" , truncation=__UpperCamelCase , max_length=5_12 , padding=__UpperCamelCase ) _UpperCAmelCase = model.generate(**__UpperCamelCase , num_beams=2 ).sequences _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase , skip_special_tokens=__UpperCamelCase ) assert tgt_text == decoded
19
1
"""simple docstring""" import argparse import random import joblib import numpy as np import torch from igf.igf import ( SecondaryLearner, collect_objective_set, compute_perplexity, generate_datasets, load_gpta, recopy_gpta, set_seed, train_secondary_learner, ) from torch.utils.data import DataLoader, RandomSampler from transformers import GPTaLMHeadModel def _UpperCamelCase ( _A=3_2 , _A=1_0 , _A=1_0_0 , _A=1_0_2_6 , _A=True , _A="data/tokenized_stories_train_wikitext103.jbl" , _A="igf_context_pairs.jbl" , ) -> List[str]: """simple docstring""" set_seed(3 ) # generate train_data and objective_set _UpperCAmelCase ,_UpperCAmelCase = generate_datasets( _A , _A , number=_A , min_len=1_0_2_6 , trim=_A ) # keeps model same across runs set_seed(4 ) # model, lm_optimizer, lm_scheduler = recopy_gpt2(model, device, max_steps) # store original model weights # can we train on GPU? _UpperCAmelCase = torch.device("""cuda:0""" if torch.cuda.is_available() else """cpu""" ) # load pretrained model _UpperCAmelCase = load_gpta("""gpt2""" ).to(_A ) print("""computing perplexity on objective set""" ) _UpperCAmelCase = compute_perplexity(_A , _A , _A ).item() print("""perplexity on objective set:""" , _A ) # collect igf pairs and save to file demo.jbl collect_objective_set(_A , _A , _A , _A , _A , _A , _A , _A ) # clean up, delete model and data we don't need anymore del model, train_data, objective_set torch.cuda.empty_cache() def _UpperCamelCase ( _A , _A=1_5 , _A=1_2_8 , _A=1_0_0 , _A="igf_model.pt" , ) -> Any: """simple docstring""" set_seed(4_2 ) # Load pre-trained model _UpperCAmelCase = GPTaLMHeadModel.from_pretrained("""gpt2""" ) # Initialize secondary learner to use embedding weights of model _UpperCAmelCase = SecondaryLearner(_A ) # Train secondary learner _UpperCAmelCase = train_secondary_learner( _A , _A , max_epochs=_A , batch_size=_A , eval_freq=1_0_0 , igf_model_path=_A , ) del model, secondary_learner_train_data torch.cuda.empty_cache() return secondary_learner def _UpperCamelCase ( _A , _A , _A , _A=3_2 , _A=1_0_0_0 , _A=1_6 , _A=1.0 , _A=recopy_gpta , _A=None , _A=1_0 , _A="gpt2_finetuned.pt" , ) -> List[Any]: """simple docstring""" _UpperCAmelCase = torch.device("""cuda:0""" if torch.cuda.is_available() else """cpu""" ) _UpperCAmelCase = RandomSampler(_A ) _UpperCAmelCase = DataLoader(_A , sampler=_A ) _UpperCAmelCase = max_steps // (len(_A )) + 1 _UpperCAmelCase = 0 _UpperCAmelCase = torch.zeros((1, context_len) , dtype=torch.long , device=_A ) _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = recopy_model(_A , _A , _A ) model.train() if secondary_learner is not None: secondary_learner.to(_A ) secondary_learner.eval() _UpperCAmelCase = [] _UpperCAmelCase = 0 _UpperCAmelCase = [] _UpperCAmelCase = [] # Compute the performance of the transformer model at the beginning _UpperCAmelCase = compute_perplexity(_A , _A , _A ) test_perps.append(_A ) print("""Test perplexity, step""" , _A , """:""" , _A ) for epoch in range(int(_A ) ): for step, example in enumerate(_A ): torch.cuda.empty_cache() _UpperCAmelCase = random.randint(0 , example.size(2 ) - context_len - 1 ) _UpperCAmelCase = example[0, 0, start : start + context_len] lm_optimizer.zero_grad() _UpperCAmelCase = model(_A , labels=_A ) _UpperCAmelCase = True if secondary_learner is not None: _UpperCAmelCase = secondary_learner.forward( torch.tensor(_A , dtype=torch.long , device=_A ).unsqueeze(0 ) )[0].item() observed_qs.append(float(_A ) ) # Here we implement the simple non-constant threshold for the predicted IG(X) value # We will decay the selectivity of our secondary learner filter from # 1 standard deviation above average to 1 below average after 10 batches. if global_step == 1_0: _UpperCAmelCase = -1 if predicted_q < threshold: _UpperCAmelCase = False # If we passed the filter, add the context to the batch! if do_backprop: contexts.append(np.array(context.cpu() ) ) _UpperCAmelCase = outputs[0] lm_loss.backward() examples += 1 del outputs # Once the batch is filled with enough contexts, backprop on the batch. if examples == batch_size: torch.cuda.empty_cache() _UpperCAmelCase = 0 # Do LM backprop torch.nn.utils.clip_grad_norm_(model.parameters() , 3.0 ) lm_optimizer.step() lm_scheduler.step() # Update learning rate schedule global_step += 1 # Compute the performance of the transformer model at this batch if global_step % eval_interval == 0: _UpperCAmelCase = compute_perplexity(_A , _A , _A ) test_perps.append(_A ) print("""Test perplexity, step""" , _A , """:""" , _A ) # Break out of the loop after 60 batches if max_steps > 0 and global_step > 6_0: break if max_steps > 0 and global_step > 6_0: break # save finetuned transformer model torch.save(model.state_dict() , _A ) torch.cuda.empty_cache() # Do some cleaning up so we can reinitialize for the next run of this function del lm_optimizer del lm_scheduler return model def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = argparse.ArgumentParser(description="""Fine-tune a transformer model with IGF on a language modeling task""" ) # Required parameters parser.add_argument( """--data_dir""" , default=_A , type=_A , required=_A , help="""The input data dir. Should contain data files for WikiText.""" , ) parser.add_argument( """--model_name_or_path""" , default=_A , type=_A , required=_A , help="""Path to pretrained model or model identifier from huggingface.co/models""" , ) parser.add_argument( """--data_file""" , type=_A , default=_A , help=( """A jbl file containing tokenized data which can be split as objective dataset, """ """train_dataset and test_dataset.""" ) , ) parser.add_argument( """--igf_data_file""" , type=_A , default=_A , help="""A jbl file containing the context and information gain pairs to train secondary learner.""" , ) parser.add_argument( """--output_dir""" , default=_A , type=_A , required=_A , help="""The output directory where the final fine-tuned model is stored.""" , ) parser.add_argument( """--tokenizer_name""" , default=_A , type=_A , help="""Pretrained tokenizer name or path if not the same as model_name""" , ) parser.add_argument("""--seed""" , type=_A , default=_A , help="""A seed for reproducible training.""" ) parser.add_argument( """--context_len""" , default=3_2 , type=_A , help=( """The maximum total input sequence length after tokenization. Sequences longer """ """than this will be truncated, sequences shorter will be padded.""" ) , ) parser.add_argument( """--size_objective_set""" , default=1_0_0 , type=_A , help="""number of articles that are long enough to be used as our objective set""" , ) parser.add_argument( """--eval_freq""" , default=1_0_0 , type=_A , help="""secondary model evaluation is triggered at eval_freq""" ) parser.add_argument("""--max_steps""" , default=1_0_0_0 , type=_A , help="""To calculate training epochs""" ) parser.add_argument( """--secondary_learner_batch_size""" , default=1_2_8 , type=_A , help="""batch size of training data for secondary learner""" , ) parser.add_argument( """--batch_size""" , default=1_6 , type=_A , help="""batch size of training data of language model(gpt2) """ ) parser.add_argument( """--eval_interval""" , default=1_0 , type=_A , help=( """decay the selectivity of our secondary learner filter from""" """1 standard deviation above average to 1 below average after 10 batches""" ) , ) parser.add_argument( """--number""" , default=1_0_0 , type=_A , help="""The number of examples split to be used as objective_set/test_data""" ) parser.add_argument( """--min_len""" , default=1_0_2_6 , type=_A , help="""The minimum length of the article to be used as objective set""" ) parser.add_argument( """--secondary_learner_max_epochs""" , default=1_5 , type=_A , help="""number of epochs to train secondary learner""" ) parser.add_argument("""--trim""" , default=_A , type=_A , help="""truncate the example if it exceeds context length""" ) parser.add_argument( """--threshold""" , default=1.0 , type=_A , help=( """The threshold value used by secondary learner to filter the train_data and allow only""" """ informative data as input to the model""" ) , ) parser.add_argument("""--finetuned_model_name""" , default="""gpt2_finetuned.pt""" , type=_A , help="""finetuned_model_name""" ) parser.add_argument( """--recopy_model""" , default=_A , type=_A , help="""Reset the model to the original pretrained GPT-2 weights after each iteration""" , ) # function calls # Collecting *n* pairs of context and information gain(X, IG(X)) for training the secondary learner generate_n_pairs( context_len=3_2 , max_steps=1_0 , size_objective_set=1_0_0 , min_len=1_0_2_6 , trim=_A , data_file="""data/tokenized_stories_train_wikitext103.jbl""" , igf_data_file="""igf_context_pairs.jbl""" , ) # Load train data for secondary learner _UpperCAmelCase = joblib.load("""data/IGF_values.jbl""" ) # Train secondary learner _UpperCAmelCase = training_secondary_learner( _A , secondary_learner_max_epochs=1_5 , secondary_learner_batch_size=1_2_8 , eval_freq=1_0_0 , igf_model_path="""igf_model.pt""" , ) # load pretrained gpt2 model _UpperCAmelCase = GPTaLMHeadModel.from_pretrained("""gpt2""" ) set_seed(4_2 ) # Generate train and test data to train and evaluate gpt2 model _UpperCAmelCase ,_UpperCAmelCase = generate_datasets( context_len=3_2 , file="""data/tokenized_stories_train_wikitext103.jbl""" , number=1_0_0 , min_len=1_0_2_6 , trim=_A ) # fine-tuning of the gpt2 model using igf (Information Gain Filtration) finetune( _A , _A , _A , context_len=3_2 , max_steps=1_0_0_0 , batch_size=1_6 , threshold=1.0 , recopy_model=_A , secondary_learner=_A , eval_interval=1_0 , finetuned_model_name="""gpt2_finetuned.pt""" , ) if __name__ == "__main__": main()
19
"""simple docstring""" import tempfile import unittest from transformers import TaConfig, is_torch_available from transformers.testing_utils import ( require_sentencepiece, require_tokenizers, require_torch, slow, torch_device, ) from ...generation.test_utils import GenerationTesterMixin from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel class a_ : def __init__( self : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : List[Any]=99 , __UpperCamelCase : Optional[int]=13 , __UpperCamelCase : List[str]=7 , __UpperCamelCase : List[Any]=9 , __UpperCamelCase : List[Any]=True , __UpperCamelCase : str=True , __UpperCamelCase : int=False , __UpperCamelCase : int=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : Optional[int]=4 , __UpperCamelCase : Any=37 , __UpperCamelCase : List[Any]=8 , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : str=0.0_0_2 , __UpperCamelCase : Union[str, Any]=1 , __UpperCamelCase : List[Any]=0 , __UpperCamelCase : Tuple=0 , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Any=None , ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = encoder_seq_length _UpperCAmelCase = decoder_seq_length # For common tests _UpperCAmelCase = self.decoder_seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = d_ff _UpperCAmelCase = relative_attention_num_buckets _UpperCAmelCase = dropout_rate _UpperCAmelCase = initializer_factor _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = decoder_start_token_id _UpperCAmelCase = None _UpperCAmelCase = decoder_layers def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' return TaConfig.from_pretrained("""google/umt5-base""" ) def _snake_case ( self : List[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Tuple=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : str=None , ) ->int: '''simple docstring''' if attention_mask is None: _UpperCAmelCase = input_ids.ne(config.pad_token_id ) if decoder_attention_mask is None: _UpperCAmelCase = decoder_input_ids.ne(config.pad_token_id ) if head_mask is None: _UpperCAmelCase = torch.ones(config.num_hidden_layers , config.num_attention_heads , device=__UpperCamelCase ) if decoder_head_mask is None: _UpperCAmelCase = torch.ones(config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) if cross_attn_head_mask is None: _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.encoder_seq_length] , self.vocab_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size ) # we need to clamp the input ids here to avoid having pad token in between # this is because for NllbMoe the position_ids are prepared such that # all pad tokens have pos id = 2 and rest are between 2..seq_length # and the seq_length here is seq_length - num_pad_tokens # but when using past, there is no way of knowing if the past input ids had # pad tokens in them, which results in incorrect seq_lenth and which in turn results in # position_ids being off by num_pad_tokens in past input _UpperCAmelCase = input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = decoder_input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = self.get_config() _UpperCAmelCase = config.num_attention_heads _UpperCAmelCase = self.prepare_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, input_dict def _snake_case ( self : Union[str, Any] ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' return TaConfig( vocab_size=1_66 , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : Tuple ) ->Dict: '''simple docstring''' return TaConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[str] , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model( input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , ) _UpperCAmelCase = model(input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase ) _UpperCAmelCase = result.last_hidden_state _UpperCAmelCase = result.past_key_values _UpperCAmelCase = result.encoder_last_hidden_state self.parent.assertEqual(encoder_output.size() , (self.batch_size, self.encoder_seq_length, self.hidden_size) ) self.parent.assertEqual(decoder_output.size() , (self.batch_size, self.decoder_seq_length, self.hidden_size) ) # There should be `num_layers` key value embeddings stored in decoder_past self.parent.assertEqual(len(__UpperCamelCase ) , config.num_layers ) # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple self.parent.assertEqual(len(decoder_past[0] ) , 4 ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] , ) ->str: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).get_decoder().to(__UpperCamelCase ).eval() # first forward pass _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) + 1 ) _UpperCAmelCase ,_UpperCAmelCase = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids _UpperCAmelCase = ids_tensor((self.batch_size, 1) , config.vocab_size ) # append to next input_ids and _UpperCAmelCase = torch.cat([input_ids, next_tokens] , dim=-1 ) _UpperCAmelCase = model(__UpperCamelCase )["""last_hidden_state"""] _UpperCAmelCase = model(__UpperCamelCase , past_key_values=__UpperCamelCase )["""last_hidden_state"""] # select random slice _UpperCAmelCase = ids_tensor((1,) , output_from_past.shape[-1] ).item() _UpperCAmelCase = output_from_no_past[:, -1, random_slice_idx].detach() _UpperCAmelCase = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(__UpperCamelCase , __UpperCamelCase , atol=1e-3 ) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : int , __UpperCamelCase : Dict , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).to(__UpperCamelCase ).half().eval() _UpperCAmelCase = model(**__UpperCamelCase )["""last_hidden_state"""] self.parent.assertFalse(torch.isnan(__UpperCamelCase ).any().item() ) @require_torch class a_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else () ) a : Tuple = (UMTaForConditionalGeneration,) if is_torch_available() else () a : Optional[Any] = ( { 'conversational': UMTaForConditionalGeneration, 'feature-extraction': UMTaModel, 'summarization': UMTaForConditionalGeneration, 'text2text-generation': UMTaForConditionalGeneration, 'translation': UMTaForConditionalGeneration, 'question-answering': UMTaForQuestionAnswering, } if is_torch_available() else {} ) a : Any = True a : Optional[int] = False a : Any = False a : Optional[int] = True a : Optional[Any] = True # The small UMT5 model needs higher percentages for CPU/MP tests a : int = [0.8, 0.9] def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = UMTaModelTester(self ) @unittest.skip("""Test has a segmentation fault on torch 1.8.0""" ) def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = UMTaModel(config_and_inputs[0] ).to(__UpperCamelCase ) with tempfile.TemporaryDirectory() as tmpdirname: torch.onnx.export( __UpperCamelCase , (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) , f"""{tmpdirname}/t5_test.onnx""" , export_params=__UpperCamelCase , opset_version=9 , input_names=["""input_ids""", """decoder_input_ids"""] , ) @unittest.skipIf(torch_device == """cpu""" , """Cant do half precision""" ) def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model_fpaa_forward(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = ["""encoder_attentions""", """decoder_attentions""", """cross_attentions"""] _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = config_and_inputs[0] _UpperCAmelCase = UMTaForConditionalGeneration(__UpperCamelCase ).eval() model.to(__UpperCamelCase ) _UpperCAmelCase = { """head_mask""": torch.zeros(config.num_layers , config.num_heads , device=__UpperCamelCase ), """decoder_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), """cross_attn_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), } for attn_name, (name, mask) in zip(__UpperCamelCase , head_masking.items() ): _UpperCAmelCase = {name: mask} # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified if name == "head_mask": _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ) _UpperCAmelCase = model.generate( config_and_inputs[1]["""input_ids"""] , num_beams=1 , max_length=3 , output_attentions=__UpperCamelCase , return_dict_in_generate=__UpperCamelCase , **__UpperCamelCase , ) # We check the state of decoder_attentions and cross_attentions just from the last step _UpperCAmelCase = out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1] self.assertEqual(sum([w.sum().item() for w in attn_weights] ) , 0.0 ) @unittest.skip("""Does not work on the tiny model as we keep hitting edge cases.""" ) def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' pass @require_torch @require_sentencepiece @require_tokenizers class a_ ( unittest.TestCase ): @slow @unittest.skip( """Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged""" ) def _snake_case ( self : Optional[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = UMTaForConditionalGeneration.from_pretrained("""google/umt5-small""" , return_dict=__UpperCamelCase ).to(__UpperCamelCase ) _UpperCAmelCase = AutoTokenizer.from_pretrained("""google/umt5-small""" , use_fast=__UpperCamelCase , legacy=__UpperCamelCase ) _UpperCAmelCase = [ """Bonjour monsieur <extra_id_0> bien <extra_id_1>.""", """No se como puedo <extra_id_0>.""", """This is the reason why we <extra_id_0> them.""", """The <extra_id_0> walks in <extra_id_1>, seats""", """A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""pt""" , padding=__UpperCamelCase ).input_ids # fmt: off _UpperCAmelCase = torch.tensor( [ [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0], [ 5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1], ] ) # fmt: on torch.testing.assert_allclose(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model.generate(input_ids.to(__UpperCamelCase ) ) _UpperCAmelCase = [ """<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>""", """<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", ] _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase ) self.assertEqual(__UpperCamelCase , __UpperCamelCase )
19
1
"""simple docstring""" from __future__ import annotations import unittest from transformers import DebertaVaConfig, is_tf_available from transformers.testing_utils import require_tf, slow from ...test_configuration_common import ConfigTester from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask from ...test_pipeline_mixin import PipelineTesterMixin if is_tf_available(): import tensorflow as tf from transformers import ( TFDebertaVaForMaskedLM, TFDebertaVaForQuestionAnswering, TFDebertaVaForSequenceClassification, TFDebertaVaForTokenClassification, TFDebertaVaModel, ) class a_ : def __init__( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : Tuple=13 , __UpperCamelCase : Union[str, Any]=7 , __UpperCamelCase : Union[str, Any]=True , __UpperCamelCase : Tuple=True , __UpperCamelCase : Any=True , __UpperCamelCase : Dict=True , __UpperCamelCase : Optional[int]=99 , __UpperCamelCase : int=32 , __UpperCamelCase : List[Any]=2 , __UpperCamelCase : Optional[Any]=4 , __UpperCamelCase : Optional[Any]=37 , __UpperCamelCase : int="gelu" , __UpperCamelCase : Any=0.1 , __UpperCamelCase : str=0.1 , __UpperCamelCase : Tuple=5_12 , __UpperCamelCase : List[Any]=16 , __UpperCamelCase : Union[str, Any]=2 , __UpperCamelCase : Union[str, Any]=0.0_2 , __UpperCamelCase : int=False , __UpperCamelCase : Any=True , __UpperCamelCase : int="None" , __UpperCamelCase : Optional[Any]=3 , __UpperCamelCase : str=4 , __UpperCamelCase : Tuple=None , ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_input_mask _UpperCAmelCase = use_token_type_ids _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = num_choices _UpperCAmelCase = relative_attention _UpperCAmelCase = position_biased_input _UpperCAmelCase = pos_att_type _UpperCAmelCase = scope def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = None if self.use_input_mask: _UpperCAmelCase = random_attention_mask([self.batch_size, self.seq_length] ) _UpperCAmelCase = None if self.use_token_type_ids: _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.type_vocab_size ) _UpperCAmelCase = None _UpperCAmelCase = None _UpperCAmelCase = None if self.use_labels: _UpperCAmelCase = ids_tensor([self.batch_size] , self.type_sequence_label_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.num_labels ) _UpperCAmelCase = DebertaVaConfig( 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 , relative_attention=self.relative_attention , position_biased_input=self.position_biased_input , initializer_range=self.initializer_range , return_dict=__UpperCamelCase , ) return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[str] , __UpperCamelCase : str , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : int , __UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' _UpperCAmelCase = TFDebertaVaModel(config=__UpperCamelCase ) _UpperCAmelCase = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids} _UpperCAmelCase = [input_ids, input_mask] _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : int , __UpperCamelCase : Tuple , __UpperCamelCase : List[str] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : int , __UpperCamelCase : str ) ->Any: '''simple docstring''' _UpperCAmelCase = TFDebertaVaForMaskedLM(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.vocab_size) ) def _snake_case ( self : str , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Tuple , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple , __UpperCamelCase : str , __UpperCamelCase : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = TFDebertaVaForSequenceClassification(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_labels) ) def _snake_case ( self : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int] , __UpperCamelCase : List[str] , __UpperCamelCase : str , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = TFDebertaVaForTokenClassification(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.logits.shape , (self.batch_size, self.seq_length, self.num_labels) ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : int , __UpperCamelCase : str , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = TFDebertaVaForQuestionAnswering(config=__UpperCamelCase ) _UpperCAmelCase = { """input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids, } _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.start_logits.shape , (self.batch_size, self.seq_length) ) self.parent.assertEqual(result.end_logits.shape , (self.batch_size, self.seq_length) ) def _snake_case ( self : str ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.prepare_config_and_inputs() ( ( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) ,( _UpperCAmelCase ) , ) = config_and_inputs _UpperCAmelCase = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask} return config, inputs_dict @require_tf class a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( ( TFDebertaVaModel, TFDebertaVaForMaskedLM, TFDebertaVaForQuestionAnswering, TFDebertaVaForSequenceClassification, TFDebertaVaForTokenClassification, ) if is_tf_available() else () ) a : str = ( { 'feature-extraction': TFDebertaVaModel, 'fill-mask': TFDebertaVaForMaskedLM, 'question-answering': TFDebertaVaForQuestionAnswering, 'text-classification': TFDebertaVaForSequenceClassification, 'token-classification': TFDebertaVaForTokenClassification, 'zero-shot': TFDebertaVaForSequenceClassification, } if is_tf_available() else {} ) a : int = False a : Tuple = False def _snake_case ( self : Optional[Any] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = TFDebertaVaModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : Optional[Any] ) ->List[Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase ) def _snake_case ( self : Tuple ) ->int: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase ) @slow def _snake_case ( self : Dict ) ->Any: '''simple docstring''' _UpperCAmelCase = TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge""" ) self.assertIsNotNone(__UpperCamelCase ) @require_tf class a_ ( unittest.TestCase ): @unittest.skip(reason="""Model not available yet""" ) def _snake_case ( self : int ) ->Dict: '''simple docstring''' pass @slow def _snake_case ( self : Optional[int] ) ->int: '''simple docstring''' _UpperCAmelCase = TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge""" ) _UpperCAmelCase = tf.constant([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]] ) _UpperCAmelCase = tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] ) _UpperCAmelCase = model(__UpperCamelCase , attention_mask=__UpperCamelCase )[0] _UpperCAmelCase = tf.constant( [[[0.2_3_5_6, 0.1_9_4_8, 0.0_3_6_9], [-0.1_0_6_3, 0.3_5_8_6, -0.5_1_5_2], [-0.6_3_9_9, -0.0_2_5_9, -0.2_5_2_5]]] ) tf.debugging.assert_near(output[:, 1:4, 1:4] , __UpperCamelCase , atol=1e-4 )
19
"""simple docstring""" import copy import os import tempfile from unittest import TestCase from unittest.mock import patch import numpy as np import pyarrow as pa import pyarrow.parquet as pq import pytest from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence from datasets.features import ArrayaD, ClassLabel, Features, Image, Value from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects from datasets.keyhash import DuplicatedKeysError, InvalidKeyError from .utils import require_pil class a_ ( _UpperCAmelCase ): def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : Any ) ->List[str]: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) , type=pa.intaa() ) def _snake_case ( self : Optional[int] ) ->Tuple: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""bool""" ) , type=Value("""int64""" ) ) ) def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : str ) ->Dict: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=Value("""int64""" ) ) ) def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : List[str] ) ->Any: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=Value("""int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) def _snake_case ( self : List[Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=ArrayaD((1, 3) , """int64""" ) ) ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : Optional[int] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) @require_pil def _snake_case ( self : str ) ->Optional[Any]: '''simple docstring''' import PIL.Image _UpperCAmelCase = PIL.Image.fromarray(np.arange(10 , dtype=np.uinta ).reshape(2 , 5 ) ) with patch( """datasets.arrow_writer.cast_to_python_objects""" , side_effect=__UpperCamelCase ) as mock_cast_to_python_objects: _UpperCAmelCase = pa.array(TypedSequence([{"""path""": None, """bytes""": b"""image_bytes"""}, pil_image] , type=Image() ) ) _UpperCAmelCase ,_UpperCAmelCase = mock_cast_to_python_objects.call_args_list[-1] self.assertIn("""optimize_list_casting""" , __UpperCamelCase ) self.assertFalse(kwargs["""optimize_list_casting"""] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferReader(_A ) if isinstance(_A , pa.Buffer ) else pa.memory_map(_A ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() assert len(pa_table.to_batches() ) == expected_num_chunks assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} del pa_table @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} ) with ArrowWriter(stream=_A , features=_A ) as writer: writer.write({"""labels""": 0} ) writer.write({"""labels""": 1} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == features.arrow_schema assert writer._schema.metadata == features.arrow_schema.metadata _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() _UpperCAmelCase = pa_table.schema assert pa_table.num_rows == 2 assert schema == features.arrow_schema assert schema.metadata == features.arrow_schema.metadata assert features == Features.from_arrow_schema(_A ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=[1, 2] ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1_0 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=1_0 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=2 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) writer.write_batch({"""col_1""": [], """col_2""": []} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) ) writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> str: """simple docstring""" with tempfile.TemporaryDirectory() as tmp_dir: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} _UpperCAmelCase = os.path.join(_A , """test.arrow""" ) with ArrowWriter(path=_A , schema=pa.schema(_A ) ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(_A , 1 ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" if pa.types.is_list(_A ): return get_base_dtype(arr_type.value_type ) else: return arr_type def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" if isinstance(lst[0] , _A ): change_first_primitive_element_in_list(lst[0] , _A ) else: _UpperCAmelCase = value @pytest.mark.parametrize("""optimized_int_type, expected_dtype""" , [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.array(TypedSequence(_A , optimized_int_type=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype @pytest.mark.parametrize( """col, expected_dtype""" , [ ("""attention_mask""", pa.inta()), ("""special_tokens_mask""", pa.inta()), ("""token_type_ids""", pa.inta()), ("""input_ids""", pa.intaa()), ("""other""", pa.intaa()), ] , ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> str: """simple docstring""" _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype # not in range if col != "other": # avoids errors due to in-place modifications _UpperCAmelCase = copy.deepcopy(_A ) _UpperCAmelCase = np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1 change_first_primitive_element_in_list(_A , _A ) _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == pa.intaa() @pytest.mark.parametrize("""raise_exception""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = str(tmp_path / """dataset-train.arrow""" ) try: with ArrowWriter(path=_A ) as writer: if raise_exception: raise pa.lib.ArrowInvalid() else: writer.stream.close() except pa.lib.ArrowInvalid: pass finally: assert writer.stream.closed def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = """mock://dataset-train.arrow""" with ArrowWriter(path=_A , storage_options=mockfs.storage_options ) as writer: assert isinstance(writer._fs , type(_A ) ) assert writer._fs.storage_options == mockfs.storage_options writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert mockfs.exists(_A ) def _UpperCamelCase ( ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter(stream=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} @require_pil @pytest.mark.parametrize("""embed_local_files""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" import PIL.Image _UpperCAmelCase = str(tmp_path / """test_image_rgb.jpg""" ) PIL.Image.fromarray(np.zeros((5, 5) , dtype=np.uinta ) ).save(_A , format="""png""" ) _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter( stream=_A , features=Features({"""image""": Image()} ) , embed_local_files=_A ) as writer: writer.write({"""image""": image_path} ) writer.finalize() _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) _UpperCAmelCase = pa_table.to_pydict() if embed_local_files: assert isinstance(out["""image"""][0]["""path"""] , _A ) with open(_A , """rb""" ) as f: assert out["image"][0]["bytes"] == f.read() else: assert out["image"][0]["path"] == image_path assert out["image"][0]["bytes"] is None def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = pa.schema([pa.field("""col_1""" , pa.string() , nullable=_A )] ) _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter(stream=_A ) as writer: writer._build_writer(inferred_schema=_A ) assert writer._schema == pa.schema([pa.field("""col_1""" , pa.string() )] )
19
1
"""simple docstring""" import enum import warnings from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING a : List[str] = logging.get_logger(__name__) class a_ ( enum.Enum ): a : Optional[Any] = 0 a : Dict = 1 @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'generated' def __init__( self : int , *__UpperCamelCase : Optional[int] , **__UpperCamelCase : str ) ->Any: '''simple docstring''' super().__init__(*__UpperCamelCase , **__UpperCamelCase ) self.check_model_type( TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if self.framework == """tf""" else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : int=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : Dict=None , **__UpperCamelCase : Any , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = {} if truncation is not None: _UpperCAmelCase = truncation _UpperCAmelCase = generate_kwargs _UpperCAmelCase = {} if return_tensors is not None and return_type is None: _UpperCAmelCase = ReturnType.TENSORS if return_tensors else ReturnType.TEXT if return_type is not None: _UpperCAmelCase = return_type if clean_up_tokenization_spaces is not None: _UpperCAmelCase = clean_up_tokenization_spaces if stop_sequence is not None: _UpperCAmelCase = self.tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) if len(__UpperCamelCase ) > 1: warnings.warn( """Stopping on a multiple token sequence is not yet supported on transformers. The first token of""" """ the stop sequence will be used as the stop sequence string in the interim.""" ) _UpperCAmelCase = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def _snake_case ( self : int , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' return True def _snake_case ( self : Optional[Any] , *__UpperCamelCase : Any , __UpperCamelCase : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model.config.prefix if self.model.config.prefix is not None else """""" if isinstance(args[0] , __UpperCamelCase ): if self.tokenizer.pad_token_id is None: raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" ) _UpperCAmelCase = ([prefix + arg for arg in args[0]],) _UpperCAmelCase = True elif isinstance(args[0] , __UpperCamelCase ): _UpperCAmelCase = (prefix + args[0],) _UpperCAmelCase = False else: raise ValueError( f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" ) _UpperCAmelCase = self.tokenizer(*__UpperCamelCase , padding=__UpperCamelCase , truncation=__UpperCamelCase , return_tensors=self.framework ) # This is produced by tokenizers but is an invalid generate kwargs if "token_type_ids" in inputs: del inputs["token_type_ids"] return inputs def __call__( self : Dict , *__UpperCamelCase : str , **__UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = super().__call__(*__UpperCamelCase , **__UpperCamelCase ) if ( isinstance(args[0] , __UpperCamelCase ) and all(isinstance(__UpperCamelCase , __UpperCamelCase ) for el in args[0] ) and all(len(__UpperCamelCase ) == 1 for res in result ) ): return [res[0] for res in result] return result def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : str=TruncationStrategy.DO_NOT_TRUNCATE , **__UpperCamelCase : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self._parse_and_tokenize(__UpperCamelCase , truncation=__UpperCamelCase , **__UpperCamelCase ) return inputs def _snake_case ( self : str , __UpperCamelCase : Dict , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' if self.framework == "pt": _UpperCAmelCase ,_UpperCAmelCase = model_inputs["""input_ids"""].shape elif self.framework == "tf": _UpperCAmelCase ,_UpperCAmelCase = tf.shape(model_inputs["""input_ids"""] ).numpy() _UpperCAmelCase = generate_kwargs.get("""min_length""" , self.model.config.min_length ) _UpperCAmelCase = generate_kwargs.get("""max_length""" , self.model.config.max_length ) self.check_inputs(__UpperCamelCase , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] ) _UpperCAmelCase = self.model.generate(**__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = output_ids.shape[0] if self.framework == "pt": _UpperCAmelCase = output_ids.reshape(__UpperCamelCase , out_b // in_b , *output_ids.shape[1:] ) elif self.framework == "tf": _UpperCAmelCase = tf.reshape(__UpperCamelCase , (in_b, out_b // in_b, *output_ids.shape[1:]) ) return {"output_ids": output_ids} def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : Union[str, Any]=ReturnType.TEXT , __UpperCamelCase : int=False ) ->Any: '''simple docstring''' _UpperCAmelCase = [] for output_ids in model_outputs["output_ids"][0]: if return_type == ReturnType.TENSORS: _UpperCAmelCase = {f"""{self.return_name}_token_ids""": output_ids} elif return_type == ReturnType.TEXT: _UpperCAmelCase = { f"""{self.return_name}_text""": self.tokenizer.decode( __UpperCamelCase , skip_special_tokens=__UpperCamelCase , clean_up_tokenization_spaces=__UpperCamelCase , ) } records.append(__UpperCamelCase ) return records @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'summary' def __call__( self : Optional[Any] , *__UpperCamelCase : Optional[Any] , **__UpperCamelCase : Optional[int] ) ->Any: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->bool: '''simple docstring''' if max_length < min_length: logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" ) if input_length < max_length: logger.warning( f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """ """a summarization task, where outputs shorter than the input are typically wanted, you might """ f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" ) @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : Optional[int] = 'translation' def _snake_case ( self : Union[str, Any] , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' if input_length > 0.9 * max_length: logger.warning( f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """ """increasing your max_length manually, e.g. translator('...', max_length=400)""" ) return True def _snake_case ( self : Tuple , *__UpperCamelCase : List[str] , __UpperCamelCase : Tuple=TruncationStrategy.DO_NOT_TRUNCATE , __UpperCamelCase : Tuple=None , __UpperCamelCase : Union[str, Any]=None ) ->Tuple: '''simple docstring''' if getattr(self.tokenizer , """_build_translation_inputs""" , __UpperCamelCase ): return self.tokenizer._build_translation_inputs( *__UpperCamelCase , return_tensors=self.framework , truncation=__UpperCamelCase , src_lang=__UpperCamelCase , tgt_lang=__UpperCamelCase ) else: return super()._parse_and_tokenize(*__UpperCamelCase , truncation=__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : int=None , __UpperCamelCase : int=None , **__UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = super()._sanitize_parameters(**__UpperCamelCase ) if src_lang is not None: _UpperCAmelCase = src_lang if tgt_lang is not None: _UpperCAmelCase = tgt_lang if src_lang is None and tgt_lang is None: # Backward compatibility, direct arguments use is preferred. _UpperCAmelCase = kwargs.get("""task""" , self.task ) _UpperCAmelCase = task.split("""_""" ) if task and len(__UpperCamelCase ) == 4: # translation, XX, to YY _UpperCAmelCase = items[1] _UpperCAmelCase = items[3] return preprocess_params, forward_params, postprocess_params def __call__( self : List[str] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->int: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase )
19
"""simple docstring""" # Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING, Dict, Optional import numpy as np import pyarrow as pa from .. import config from ..utils.logging import get_logger from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import jax import jaxlib a : List[Any] = get_logger() a : Optional[dict] = None class a_ ( TensorFormatter[Mapping, 'jax.Array', Mapping] ): def __init__( self : int , __UpperCamelCase : List[str]=None , __UpperCamelCase : Optional[int]=None , **__UpperCamelCase : int ) ->Tuple: '''simple docstring''' super().__init__(features=__UpperCamelCase ) import jax from jaxlib.xla_client import Device if isinstance(__UpperCamelCase , __UpperCamelCase ): raise ValueError( f"""Expected {device} to be a `str` not {type(__UpperCamelCase )}, as `jaxlib.xla_extension.Device` """ """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """ """the device with `str()` to get its string identifier that will be internally mapped """ """to the actual `jaxlib.xla_extension.Device`.""" ) _UpperCAmelCase = device if isinstance(__UpperCamelCase , __UpperCamelCase ) else str(jax.devices()[0] ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() if self.device not in list(DEVICE_MAPPING.keys() ): logger.warning( f"""Device with string identifier {self.device} not listed among the available """ f"""devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default """ f"""device: {str(jax.devices()[0] )}.""" ) _UpperCAmelCase = str(jax.devices()[0] ) _UpperCAmelCase = jnp_array_kwargs @staticmethod def _snake_case ( ) ->Dict[str, "jaxlib.xla_extension.Device"]: '''simple docstring''' import jax return {str(__UpperCamelCase ): device for device in jax.devices()} def _snake_case ( self : Dict , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , __UpperCamelCase ) and column: if all( isinstance(__UpperCamelCase , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return jnp.stack(__UpperCamelCase , axis=0 ) return column def _snake_case ( self : List[str] , __UpperCamelCase : Any ) ->Optional[int]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , (str, bytes, type(__UpperCamelCase )) ): return value elif isinstance(__UpperCamelCase , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() _UpperCAmelCase = {} if isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): # the default int precision depends on the jax config # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision if jax.config.jax_enable_xaa: _UpperCAmelCase = {"""dtype""": jnp.intaa} else: _UpperCAmelCase = {"""dtype""": jnp.intaa} elif isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): _UpperCAmelCase = {"""dtype""": jnp.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(__UpperCamelCase , PIL.Image.Image ): _UpperCAmelCase = np.asarray(__UpperCamelCase ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() with jax.default_device(DEVICE_MAPPING[self.device] ): # calling jnp.array on a np.ndarray does copy the data # see https://github.com/google/jax/issues/4486 return jnp.array(__UpperCamelCase , **{**default_dtype, **self.jnp_array_kwargs} ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->Any: '''simple docstring''' import jax # support for torch, tf, jax etc. if config.TORCH_AVAILABLE and "torch" in sys.modules: import torch if isinstance(__UpperCamelCase , torch.Tensor ): return self._tensorize(data_struct.detach().cpu().numpy()[()] ) if hasattr(__UpperCamelCase , """__array__""" ) and not isinstance(__UpperCamelCase , jax.Array ): _UpperCAmelCase = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(__UpperCamelCase , np.ndarray ): if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) elif isinstance(__UpperCamelCase , (list, tuple) ): return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) return self._tensorize(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : dict ) ->int: '''simple docstring''' return map_nested(self._recursive_tensorize , __UpperCamelCase , map_list=__UpperCamelCase ) def _snake_case ( self : Dict , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_row(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_row(__UpperCamelCase ) return self.recursive_tensorize(__UpperCamelCase ) def _snake_case ( self : Optional[int] , __UpperCamelCase : pa.Table ) ->"jax.Array": '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_column(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_column(__UpperCamelCase , pa_table.column_names[0] ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) _UpperCAmelCase = self._consolidate(__UpperCamelCase ) return column def _snake_case ( self : Optional[Any] , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_batch(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_batch(__UpperCamelCase ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) for column_name in batch: _UpperCAmelCase = self._consolidate(batch[column_name] ) return batch
19
1
"""simple docstring""" import logging import os import threading import time try: import warnings except ImportError: a : Optional[int] = None try: import msvcrt except ImportError: a : Optional[Any] = None try: import fcntl except ImportError: a : List[str] = None # Backward compatibility # ------------------------------------------------ try: TimeoutError except NameError: a : Optional[Any] = OSError # Data # ------------------------------------------------ a : List[Any] = [ '''Timeout''', '''BaseFileLock''', '''WindowsFileLock''', '''UnixFileLock''', '''SoftFileLock''', '''FileLock''', ] a : int = '''3.0.12''' a : Dict = None def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" global _logger _UpperCAmelCase = _logger or logging.getLogger(__name__ ) return _logger class a_ ( _UpperCAmelCase ): def __init__( self : Any , __UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' _UpperCAmelCase = lock_file return None def __str__( self : List[str] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = f"""The file lock '{self.lock_file}' could not be acquired.""" return temp class a_ : def __init__( self : Tuple , __UpperCamelCase : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = lock return None def __enter__( self : Any ) ->str: '''simple docstring''' return self.lock def __exit__( self : List[Any] , __UpperCamelCase : int , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[int] ) ->List[str]: '''simple docstring''' self.lock.release() return None class a_ : def __init__( self : Optional[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict=-1 , __UpperCamelCase : Union[str, Any]=None ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = max_filename_length if max_filename_length is not None else 2_55 # Hash the filename if it's too long _UpperCAmelCase = self.hash_filename_if_too_long(__UpperCamelCase , __UpperCamelCase ) # The path to the lock file. _UpperCAmelCase = lock_file # The file descriptor for the *_lock_file* as it is returned by the # os.open() function. # This file lock is only NOT None, if the object currently holds the # lock. _UpperCAmelCase = None # The default timeout value. _UpperCAmelCase = timeout # We use this lock primarily for the lock counter. _UpperCAmelCase = threading.Lock() # The lock counter is used for implementing the nested locking # mechanism. Whenever the lock is acquired, the counter is increased and # the lock is only released, when this value is 0 again. _UpperCAmelCase = 0 return None @property def _snake_case ( self : Union[str, Any] ) ->Optional[Any]: '''simple docstring''' return self._lock_file @property def _snake_case ( self : Tuple ) ->Any: '''simple docstring''' return self._timeout @timeout.setter def _snake_case ( self : Union[str, Any] , __UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase = float(__UpperCamelCase ) return None def _snake_case ( self : Optional[int] ) ->List[Any]: '''simple docstring''' raise NotImplementedError() def _snake_case ( self : str ) ->str: '''simple docstring''' raise NotImplementedError() @property def _snake_case ( self : Optional[int] ) ->int: '''simple docstring''' return self._lock_file_fd is not None def _snake_case ( self : Any , __UpperCamelCase : List[Any]=None , __UpperCamelCase : int=0.0_5 ) ->Tuple: '''simple docstring''' if timeout is None: _UpperCAmelCase = self.timeout # Increment the number right at the beginning. # We can still undo it, if something fails. with self._thread_lock: self._lock_counter += 1 _UpperCAmelCase = id(self ) _UpperCAmelCase = self._lock_file _UpperCAmelCase = time.time() try: while True: with self._thread_lock: if not self.is_locked: logger().debug(f"""Attempting to acquire lock {lock_id} on {lock_filename}""" ) self._acquire() if self.is_locked: logger().debug(f"""Lock {lock_id} acquired on {lock_filename}""" ) break elif timeout >= 0 and time.time() - start_time > timeout: logger().debug(f"""Timeout on acquiring lock {lock_id} on {lock_filename}""" ) raise Timeout(self._lock_file ) else: logger().debug( f"""Lock {lock_id} not acquired on {lock_filename}, waiting {poll_intervall} seconds ...""" ) time.sleep(__UpperCamelCase ) except: # noqa # Something did go wrong, so decrement the counter. with self._thread_lock: _UpperCAmelCase = max(0 , self._lock_counter - 1 ) raise return _Acquire_ReturnProxy(lock=self ) def _snake_case ( self : str , __UpperCamelCase : Tuple=False ) ->Dict: '''simple docstring''' with self._thread_lock: if self.is_locked: self._lock_counter -= 1 if self._lock_counter == 0 or force: _UpperCAmelCase = id(self ) _UpperCAmelCase = self._lock_file logger().debug(f"""Attempting to release lock {lock_id} on {lock_filename}""" ) self._release() _UpperCAmelCase = 0 logger().debug(f"""Lock {lock_id} released on {lock_filename}""" ) return None def __enter__( self : str ) ->Dict: '''simple docstring''' self.acquire() return self def __exit__( self : int , __UpperCamelCase : Dict , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] ) ->Optional[Any]: '''simple docstring''' self.release() return None def __del__( self : Any ) ->Tuple: '''simple docstring''' self.release(force=__UpperCamelCase ) return None def _snake_case ( self : int , __UpperCamelCase : str , __UpperCamelCase : int ) ->str: '''simple docstring''' _UpperCAmelCase = os.path.basename(__UpperCamelCase ) if len(__UpperCamelCase ) > max_length and max_length > 0: _UpperCAmelCase = os.path.dirname(__UpperCamelCase ) _UpperCAmelCase = str(hash(__UpperCamelCase ) ) _UpperCAmelCase = filename[: max_length - len(__UpperCamelCase ) - 8] + """...""" + hashed_filename + """.lock""" return os.path.join(__UpperCamelCase , __UpperCamelCase ) else: return path class a_ ( _UpperCAmelCase ): def __init__( self : Optional[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple=-1 , __UpperCamelCase : Dict=None ) ->int: '''simple docstring''' from .file_utils import relative_to_absolute_path super().__init__(__UpperCamelCase , timeout=__UpperCamelCase , max_filename_length=__UpperCamelCase ) _UpperCAmelCase = """\\\\?\\""" + relative_to_absolute_path(self.lock_file ) def _snake_case ( self : List[str] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = os.O_RDWR | os.O_CREAT | os.O_TRUNC try: _UpperCAmelCase = os.open(self._lock_file , __UpperCamelCase ) except OSError: pass else: try: msvcrt.locking(__UpperCamelCase , msvcrt.LK_NBLCK , 1 ) except OSError: os.close(__UpperCamelCase ) else: _UpperCAmelCase = fd return None def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self._lock_file_fd _UpperCAmelCase = None msvcrt.locking(__UpperCamelCase , msvcrt.LK_UNLCK , 1 ) os.close(__UpperCamelCase ) try: os.remove(self._lock_file ) # Probably another instance of the application # that acquired the file lock. except OSError: pass return None class a_ ( _UpperCAmelCase ): def __init__( self : Any , __UpperCamelCase : Any , __UpperCamelCase : Tuple=-1 , __UpperCamelCase : Union[str, Any]=None ) ->Any: '''simple docstring''' _UpperCAmelCase = os.statvfs(os.path.dirname(__UpperCamelCase ) ).f_namemax super().__init__(__UpperCamelCase , timeout=__UpperCamelCase , max_filename_length=__UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = os.O_RDWR | os.O_CREAT | os.O_TRUNC _UpperCAmelCase = os.open(self._lock_file , __UpperCamelCase ) try: fcntl.flock(__UpperCamelCase , fcntl.LOCK_EX | fcntl.LOCK_NB ) except OSError: os.close(__UpperCamelCase ) else: _UpperCAmelCase = fd return None def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self._lock_file_fd _UpperCAmelCase = None fcntl.flock(__UpperCamelCase , fcntl.LOCK_UN ) os.close(__UpperCamelCase ) return None class a_ ( _UpperCAmelCase ): def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC try: _UpperCAmelCase = os.open(self._lock_file , __UpperCamelCase ) except OSError: pass else: _UpperCAmelCase = fd return None def _snake_case ( self : str ) ->List[str]: '''simple docstring''' os.close(self._lock_file_fd ) _UpperCAmelCase = None try: os.remove(self._lock_file ) # The file is already deleted and that's what we want. except OSError: pass return None a : str = None if msvcrt: a : Optional[int] = WindowsFileLock elif fcntl: a : Tuple = UnixFileLock else: a : Any = SoftFileLock if warnings is not None: warnings.warn('''only soft file lock is available''')
19
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a : Tuple = { '''configuration_pegasus_x''': ['''PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PegasusXConfig'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : List[str] = [ '''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 : Dict = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
1
"""simple docstring""" import collections import json import math import os import re import time from fnmatch import fnmatch from typing import Dict import requests from slack_sdk import WebClient a : int = WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN''']) def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = test_results.split(""" """ ) _UpperCAmelCase = 0 _UpperCAmelCase = 0 # When the output is short enough, the output is surrounded by = signs: "== OUTPUT ==" # When it is too long, those signs are not present. _UpperCAmelCase = expressions[-2] if """=""" in expressions[-1] else expressions[-1] for i, expression in enumerate(_A ): if "failed" in expression: failed += int(expressions[i - 1] ) if "passed" in expression: success += int(expressions[i - 1] ) return failed, success, time_spent def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = {} _UpperCAmelCase = None _UpperCAmelCase = False for line in failures_short_lines.split("""\n""" ): if re.search(R"""_ \[doctest\]""" , _A ): _UpperCAmelCase = True _UpperCAmelCase = line.split(""" """ )[2] elif in_error and not line.split(""" """ )[0].isdigit(): _UpperCAmelCase = line _UpperCAmelCase = False return failures class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = title _UpperCAmelCase = doc_test_results["""time_spent"""].split(""",""" )[0] _UpperCAmelCase = doc_test_results["""success"""] _UpperCAmelCase = doc_test_results["""failures"""] _UpperCAmelCase = self.n_success + self.n_failures # Failures and success of the modeling tests _UpperCAmelCase = doc_test_results @property def _snake_case ( self : int ) ->str: '''simple docstring''' _UpperCAmelCase = [self._time_spent] _UpperCAmelCase = 0 for time in time_spent: _UpperCAmelCase = time.split(""":""" ) # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute. if len(__UpperCamelCase ) == 1: _UpperCAmelCase = [0, 0, time_parts[0]] _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = int(time_parts[0] ), int(time_parts[1] ), float(time_parts[2] ) total_secs += hours * 36_00 + minutes * 60 + seconds _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60 return f"""{int(__UpperCamelCase )}h{int(__UpperCamelCase )}m{int(__UpperCamelCase )}s""" @property def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' return {"type": "header", "text": {"type": "plain_text", "text": self.title}} @property def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": f"""🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.""", "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": ( f"""There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in""" f""" {self.time}.""" ), "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = 40 _UpperCAmelCase = {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase , __UpperCamelCase )} _UpperCAmelCase = """""" for category, failures in category_failures.items(): if len(__UpperCamelCase ) == 0: continue if report != "": report += "\n\n" report += f"""*{category} failures*:""".ljust(line_length // 2 ).rjust(line_length // 2 ) + "\n" report += "`" report += "`\n`".join(__UpperCamelCase ) report += "`" return { "type": "section", "text": { "type": "mrkdwn", "text": f"""The following examples had failures:\n\n\n{report}\n""", }, } @property def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = [self.header] if self.n_failures > 0: blocks.append(self.failures ) if self.n_failures > 0: blocks.extend([self.category_failures] ) if self.n_failures == 0: blocks.append(self.no_failures ) return json.dumps(__UpperCamelCase ) @staticmethod def _snake_case ( ) ->Any: '''simple docstring''' _UpperCAmelCase = [ { """type""": """section""", """text""": { """type""": """plain_text""", """text""": """There was an issue running the tests.""", }, """accessory""": { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """Check Action results""", """emoji""": True}, """url""": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } ] print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(__UpperCamelCase )} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text="""There was an issue running the tests.""" , blocks=__UpperCamelCase , ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(self.payload )} ) ) _UpperCAmelCase = f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed.""" _UpperCAmelCase = client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , blocks=self.payload , text=__UpperCamelCase , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Any , __UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = """""" for key, value in failures.items(): _UpperCAmelCase = value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase ) > 2_50 else value failures_text += f"""*{key}*\n_{value}_\n\n""" _UpperCAmelCase = job_name _UpperCAmelCase = {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}} if job_link is not None: _UpperCAmelCase = { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """GitHub Action job""", """emoji""": True}, """url""": job_link, } return [ {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}}, content, {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}}, ] def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' if self.thread_ts is None: raise ValueError("""Can only post reply if a post has been made.""" ) _UpperCAmelCase = self.doc_test_results.pop("""job_link""" ) self.doc_test_results.pop("""failures""" ) self.doc_test_results.pop("""success""" ) self.doc_test_results.pop("""time_spent""" ) _UpperCAmelCase = sorted(self.doc_test_results.items() , key=lambda __UpperCamelCase : t[0] ) for job, job_result in sorted_dict: if len(job_result["""failures"""] ): _UpperCAmelCase = f"""*Num failures* :{len(job_result["failed"] )} \n""" _UpperCAmelCase = job_result["""failures"""] _UpperCAmelCase = self.get_reply_blocks(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , text=__UpperCamelCase ) print("""Sending the following reply""" ) print(json.dumps({"""blocks""": blocks} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text=f"""Results for {job}""" , blocks=__UpperCamelCase , thread_ts=self.thread_ts["""ts"""] , ) time.sleep(1 ) def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = os.environ["""GITHUB_RUN_ID"""] _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A ).json() _UpperCAmelCase = {} try: jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" ).json() jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return jobs except Exception as e: print("""Unknown error, could not fetch links.""" , _A ) return {} def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = {} if os.path.exists(_A ): _UpperCAmelCase = os.listdir(_A ) for file in files: try: with open(os.path.join(_A , _A ) , encoding="""utf-8""" ) as f: _UpperCAmelCase = f.read() except UnicodeDecodeError as e: raise ValueError(F"""Could not open {os.path.join(_A , _A )}.""" ) from e return _artifact def _UpperCamelCase ( ) -> int: """simple docstring""" class a_ : def __init__( self : List[Any] , __UpperCamelCase : str ) ->Tuple: '''simple docstring''' _UpperCAmelCase = name _UpperCAmelCase = [] def __str__( self : int ) ->Optional[Any]: '''simple docstring''' return self.name def _snake_case ( self : Dict , __UpperCamelCase : str ) ->int: '''simple docstring''' self.paths.append({"""name""": self.name, """path""": path} ) _UpperCAmelCase = {} _UpperCAmelCase = filter(os.path.isdir , os.listdir() ) for directory in directories: _UpperCAmelCase = directory if artifact_name not in _available_artifacts: _UpperCAmelCase = Artifact(_A ) _available_artifacts[artifact_name].add_path(_A ) return _available_artifacts if __name__ == "__main__": a : Dict = get_job_links() a : Dict = retrieve_available_artifacts() a : Optional[int] = collections.OrderedDict( [ ('''*.py''', '''API Examples'''), ('''*.md''', '''MD Examples'''), ] ) # This dict will contain all the information relative to each doc test category: # - failed: list of failed tests # - failures: dict in the format 'test': 'error_message' a : Dict = { v: { '''failed''': [], '''failures''': {}, } for v in docs.values() } # Link to the GitHub Action job a : int = github_actions_job_links.get('''run_doctests''') a : Tuple = available_artifacts['''doc_tests_gpu_test_reports'''].paths[0] a : Optional[Any] = retrieve_artifact(artifact_path['''name''']) if "stats" in artifact: a , a , a : str = handle_test_results(artifact['''stats''']) a : Tuple = failed a : int = success a : Any = time_spent[1:-1] + ''', ''' a : Dict = extract_first_line_failure(artifact['''failures_short''']) for line in artifact["summary_short"].split('''\n'''): if re.search('''FAILED''', line): a : List[Any] = line.replace('''FAILED ''', '''''') a : Tuple = line.split()[0].replace('''\n''', '''''') if "::" in line: a , a : Union[str, Any] = line.split('''::''') else: a , a : Optional[Any] = line, line for file_regex in docs.keys(): if fnmatch(file_path, file_regex): a : List[Any] = docs[file_regex] doc_test_results[category]["failed"].append(test) a : Optional[Any] = all_failures[test] if test in all_failures else '''N/A''' a : List[str] = failure break a : List[Any] = Message('''🤗 Results of the doc tests.''', doc_test_results) message.post() message.post_reply()
19
"""simple docstring""" import collections import json import math import os import re import time from fnmatch import fnmatch from typing import Dict import requests from slack_sdk import WebClient a : int = WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN''']) def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = test_results.split(""" """ ) _UpperCAmelCase = 0 _UpperCAmelCase = 0 # When the output is short enough, the output is surrounded by = signs: "== OUTPUT ==" # When it is too long, those signs are not present. _UpperCAmelCase = expressions[-2] if """=""" in expressions[-1] else expressions[-1] for i, expression in enumerate(_A ): if "failed" in expression: failed += int(expressions[i - 1] ) if "passed" in expression: success += int(expressions[i - 1] ) return failed, success, time_spent def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = {} _UpperCAmelCase = None _UpperCAmelCase = False for line in failures_short_lines.split("""\n""" ): if re.search(R"""_ \[doctest\]""" , _A ): _UpperCAmelCase = True _UpperCAmelCase = line.split(""" """ )[2] elif in_error and not line.split(""" """ )[0].isdigit(): _UpperCAmelCase = line _UpperCAmelCase = False return failures class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = title _UpperCAmelCase = doc_test_results["""time_spent"""].split(""",""" )[0] _UpperCAmelCase = doc_test_results["""success"""] _UpperCAmelCase = doc_test_results["""failures"""] _UpperCAmelCase = self.n_success + self.n_failures # Failures and success of the modeling tests _UpperCAmelCase = doc_test_results @property def _snake_case ( self : int ) ->str: '''simple docstring''' _UpperCAmelCase = [self._time_spent] _UpperCAmelCase = 0 for time in time_spent: _UpperCAmelCase = time.split(""":""" ) # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute. if len(__UpperCamelCase ) == 1: _UpperCAmelCase = [0, 0, time_parts[0]] _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = int(time_parts[0] ), int(time_parts[1] ), float(time_parts[2] ) total_secs += hours * 36_00 + minutes * 60 + seconds _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60 return f"""{int(__UpperCamelCase )}h{int(__UpperCamelCase )}m{int(__UpperCamelCase )}s""" @property def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' return {"type": "header", "text": {"type": "plain_text", "text": self.title}} @property def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": f"""🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.""", "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": ( f"""There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in""" f""" {self.time}.""" ), "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = 40 _UpperCAmelCase = {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase , __UpperCamelCase )} _UpperCAmelCase = """""" for category, failures in category_failures.items(): if len(__UpperCamelCase ) == 0: continue if report != "": report += "\n\n" report += f"""*{category} failures*:""".ljust(line_length // 2 ).rjust(line_length // 2 ) + "\n" report += "`" report += "`\n`".join(__UpperCamelCase ) report += "`" return { "type": "section", "text": { "type": "mrkdwn", "text": f"""The following examples had failures:\n\n\n{report}\n""", }, } @property def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = [self.header] if self.n_failures > 0: blocks.append(self.failures ) if self.n_failures > 0: blocks.extend([self.category_failures] ) if self.n_failures == 0: blocks.append(self.no_failures ) return json.dumps(__UpperCamelCase ) @staticmethod def _snake_case ( ) ->Any: '''simple docstring''' _UpperCAmelCase = [ { """type""": """section""", """text""": { """type""": """plain_text""", """text""": """There was an issue running the tests.""", }, """accessory""": { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """Check Action results""", """emoji""": True}, """url""": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } ] print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(__UpperCamelCase )} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text="""There was an issue running the tests.""" , blocks=__UpperCamelCase , ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(self.payload )} ) ) _UpperCAmelCase = f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed.""" _UpperCAmelCase = client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , blocks=self.payload , text=__UpperCamelCase , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Any , __UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = """""" for key, value in failures.items(): _UpperCAmelCase = value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase ) > 2_50 else value failures_text += f"""*{key}*\n_{value}_\n\n""" _UpperCAmelCase = job_name _UpperCAmelCase = {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}} if job_link is not None: _UpperCAmelCase = { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """GitHub Action job""", """emoji""": True}, """url""": job_link, } return [ {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}}, content, {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}}, ] def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' if self.thread_ts is None: raise ValueError("""Can only post reply if a post has been made.""" ) _UpperCAmelCase = self.doc_test_results.pop("""job_link""" ) self.doc_test_results.pop("""failures""" ) self.doc_test_results.pop("""success""" ) self.doc_test_results.pop("""time_spent""" ) _UpperCAmelCase = sorted(self.doc_test_results.items() , key=lambda __UpperCamelCase : t[0] ) for job, job_result in sorted_dict: if len(job_result["""failures"""] ): _UpperCAmelCase = f"""*Num failures* :{len(job_result["failed"] )} \n""" _UpperCAmelCase = job_result["""failures"""] _UpperCAmelCase = self.get_reply_blocks(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , text=__UpperCamelCase ) print("""Sending the following reply""" ) print(json.dumps({"""blocks""": blocks} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text=f"""Results for {job}""" , blocks=__UpperCamelCase , thread_ts=self.thread_ts["""ts"""] , ) time.sleep(1 ) def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = os.environ["""GITHUB_RUN_ID"""] _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A ).json() _UpperCAmelCase = {} try: jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" ).json() jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return jobs except Exception as e: print("""Unknown error, could not fetch links.""" , _A ) return {} def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = {} if os.path.exists(_A ): _UpperCAmelCase = os.listdir(_A ) for file in files: try: with open(os.path.join(_A , _A ) , encoding="""utf-8""" ) as f: _UpperCAmelCase = f.read() except UnicodeDecodeError as e: raise ValueError(F"""Could not open {os.path.join(_A , _A )}.""" ) from e return _artifact def _UpperCamelCase ( ) -> int: """simple docstring""" class a_ : def __init__( self : List[Any] , __UpperCamelCase : str ) ->Tuple: '''simple docstring''' _UpperCAmelCase = name _UpperCAmelCase = [] def __str__( self : int ) ->Optional[Any]: '''simple docstring''' return self.name def _snake_case ( self : Dict , __UpperCamelCase : str ) ->int: '''simple docstring''' self.paths.append({"""name""": self.name, """path""": path} ) _UpperCAmelCase = {} _UpperCAmelCase = filter(os.path.isdir , os.listdir() ) for directory in directories: _UpperCAmelCase = directory if artifact_name not in _available_artifacts: _UpperCAmelCase = Artifact(_A ) _available_artifacts[artifact_name].add_path(_A ) return _available_artifacts if __name__ == "__main__": a : Dict = get_job_links() a : Dict = retrieve_available_artifacts() a : Optional[int] = collections.OrderedDict( [ ('''*.py''', '''API Examples'''), ('''*.md''', '''MD Examples'''), ] ) # This dict will contain all the information relative to each doc test category: # - failed: list of failed tests # - failures: dict in the format 'test': 'error_message' a : Dict = { v: { '''failed''': [], '''failures''': {}, } for v in docs.values() } # Link to the GitHub Action job a : int = github_actions_job_links.get('''run_doctests''') a : Tuple = available_artifacts['''doc_tests_gpu_test_reports'''].paths[0] a : Optional[Any] = retrieve_artifact(artifact_path['''name''']) if "stats" in artifact: a , a , a : str = handle_test_results(artifact['''stats''']) a : Tuple = failed a : int = success a : Any = time_spent[1:-1] + ''', ''' a : Dict = extract_first_line_failure(artifact['''failures_short''']) for line in artifact["summary_short"].split('''\n'''): if re.search('''FAILED''', line): a : List[Any] = line.replace('''FAILED ''', '''''') a : Tuple = line.split()[0].replace('''\n''', '''''') if "::" in line: a , a : Union[str, Any] = line.split('''::''') else: a , a : Optional[Any] = line, line for file_regex in docs.keys(): if fnmatch(file_path, file_regex): a : List[Any] = docs[file_regex] doc_test_results[category]["failed"].append(test) a : Optional[Any] = all_failures[test] if test in all_failures else '''N/A''' a : List[str] = failure break a : List[Any] = Message('''🤗 Results of the doc tests.''', doc_test_results) message.post() message.post_reply()
19
1
"""simple docstring""" import inspect import unittest from huggingface_hub import hf_hub_download from transformers import ConvNextConfig, UperNetConfig from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device from transformers.utils import is_torch_available, is_vision_available from ...test_configuration_common import ConfigTester from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import UperNetForSemanticSegmentation from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import AutoImageProcessor class a_ : def __init__( self : List[Any] , __UpperCamelCase : int , __UpperCamelCase : int=13 , __UpperCamelCase : str=32 , __UpperCamelCase : List[Any]=3 , __UpperCamelCase : Union[str, Any]=4 , __UpperCamelCase : Tuple=[10, 20, 30, 40] , __UpperCamelCase : Optional[int]=[2, 2, 3, 2] , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Any=True , __UpperCamelCase : Dict=37 , __UpperCamelCase : Optional[Any]="gelu" , __UpperCamelCase : str=10 , __UpperCamelCase : List[Any]=0.0_2 , __UpperCamelCase : Optional[int]=["stage2", "stage3", "stage4"] , __UpperCamelCase : Optional[int]=3 , __UpperCamelCase : str=None , ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = image_size _UpperCAmelCase = num_channels _UpperCAmelCase = num_stages _UpperCAmelCase = hidden_sizes _UpperCAmelCase = depths _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = type_sequence_label_size _UpperCAmelCase = initializer_range _UpperCAmelCase = out_features _UpperCAmelCase = num_labels _UpperCAmelCase = scope _UpperCAmelCase = num_stages def _snake_case ( self : int ) ->Dict: '''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 _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' return ConvNextConfig( num_channels=self.num_channels , num_stages=self.num_stages , hidden_sizes=self.hidden_sizes , depths=self.depths , is_training=self.is_training , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , out_features=self.out_features , ) def _snake_case ( self : Optional[int] ) ->List[Any]: '''simple docstring''' return UperNetConfig( backbone_config=self.get_backbone_config() , hidden_size=5_12 , pool_scales=[1, 2, 3, 6] , use_auxiliary_head=__UpperCamelCase , auxiliary_loss_weight=0.4 , auxiliary_in_channels=40 , auxiliary_channels=2_56 , auxiliary_num_convs=1 , auxiliary_concat_input=__UpperCamelCase , loss_ignore_index=2_55 , num_labels=self.num_labels , ) def _snake_case ( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UperNetForSemanticSegmentation(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size, self.image_size) ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''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 a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : int = (UperNetForSemanticSegmentation,) if is_torch_available() else () a : List[Any] = {'image-segmentation': UperNetForSemanticSegmentation} if is_torch_available() else {} a : Optional[int] = False a : Dict = False a : List[Any] = False a : Optional[Any] = False a : List[Any] = False a : Optional[Any] = False def _snake_case ( self : str ) ->int: '''simple docstring''' _UpperCAmelCase = UperNetModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , has_text_modality=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' self.create_and_test_config_common_properties() self.config_tester.create_and_test_config_to_json_string() self.config_tester.create_and_test_config_to_json_file() self.config_tester.create_and_test_config_from_and_save_pretrained() self.config_tester.create_and_test_config_with_num_labels() self.config_tester.check_config_can_be_init_without_params() self.config_tester.check_config_arguments_init() def _snake_case ( self : Dict ) ->Optional[Any]: '''simple docstring''' return def _snake_case ( self : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , __UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCamelCase ) @unittest.skip(reason="""UperNet does not use inputs_embeds""" ) def _snake_case ( self : Optional[int] ) ->Optional[int]: '''simple docstring''' pass @unittest.skip(reason="""UperNet does not support input and output embeddings""" ) def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' pass @unittest.skip(reason="""UperNet does not have a base model""" ) def _snake_case ( self : Dict ) ->List[Any]: '''simple docstring''' pass @unittest.skip(reason="""UperNet does not have a base model""" ) def _snake_case ( self : int ) ->List[Any]: '''simple docstring''' pass @require_torch_multi_gpu @unittest.skip(reason="""UperNet has some layers using `add_module` which doesn't work well with `nn.DataParallel`""" ) def _snake_case ( self : Dict ) ->Any: '''simple docstring''' pass @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" ) def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' pass def _snake_case ( self : Dict ) ->int: '''simple docstring''' def check_hidden_states_output(__UpperCamelCase : int , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Dict ): _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(__UpperCamelCase , __UpperCamelCase ) ) _UpperCAmelCase = outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states _UpperCAmelCase = self.model_tester.num_stages self.assertEqual(len(__UpperCamelCase ) , expected_num_stages + 1 ) # ConvNext's feature maps are of shape (batch_size, num_channels, height, width) self.assertListEqual( list(hidden_states[0].shape[-2:] ) , [self.model_tester.image_size // 4, self.model_tester.image_size // 4] , ) _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = True check_hidden_states_output(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _UpperCAmelCase = True check_hidden_states_output(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Any ) ->Dict: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = _config_zero_init(__UpperCamelCase ) _UpperCAmelCase = _config_zero_init(configs_no_init.backbone_config ) for model_class in self.all_model_classes: _UpperCAmelCase = model_class(config=__UpperCamelCase ) for name, param in model.named_parameters(): if param.requires_grad: self.assertIn( ((param.data.mean() * 1e9).round() / 1e9).item() , [0.0, 1.0] , msg=f"""Parameter {name} of model {model_class} seems not properly initialized""" , ) @unittest.skip(reason="""UperNet does not have tied weights""" ) def _snake_case ( self : int ) ->Dict: '''simple docstring''' pass @slow def _snake_case ( self : Optional[Any] ) ->Optional[int]: '''simple docstring''' for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = UperNetForSemanticSegmentation.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) def _UpperCamelCase ( ) -> Any: """simple docstring""" _UpperCAmelCase = hf_hub_download( repo_id="""hf-internal-testing/fixtures_ade20k""" , repo_type="""dataset""" , filename="""ADE_val_00000001.jpg""" ) _UpperCAmelCase = Image.open(_A ).convert("""RGB""" ) return image @require_torch @require_vision @slow class a_ ( unittest.TestCase ): def _snake_case ( self : Tuple ) ->Dict: '''simple docstring''' _UpperCAmelCase = AutoImageProcessor.from_pretrained("""openmmlab/upernet-swin-tiny""" ) _UpperCAmelCase = UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-swin-tiny""" ).to(__UpperCamelCase ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = processor(images=__UpperCamelCase , return_tensors="""pt""" ).to(__UpperCamelCase ) with torch.no_grad(): _UpperCAmelCase = model(**__UpperCamelCase ) _UpperCAmelCase = torch.Size((1, model.config.num_labels, 5_12, 5_12) ) self.assertEqual(outputs.logits.shape , __UpperCamelCase ) _UpperCAmelCase = torch.tensor( [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]] ).to(__UpperCamelCase ) self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] , __UpperCamelCase , atol=1e-4 ) ) def _snake_case ( self : str ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = AutoImageProcessor.from_pretrained("""openmmlab/upernet-convnext-tiny""" ) _UpperCAmelCase = UperNetForSemanticSegmentation.from_pretrained("""openmmlab/upernet-convnext-tiny""" ).to(__UpperCamelCase ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = processor(images=__UpperCamelCase , return_tensors="""pt""" ).to(__UpperCamelCase ) with torch.no_grad(): _UpperCAmelCase = model(**__UpperCamelCase ) _UpperCAmelCase = torch.Size((1, model.config.num_labels, 5_12, 5_12) ) self.assertEqual(outputs.logits.shape , __UpperCamelCase ) _UpperCAmelCase = torch.tensor( [[-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.7_7_4_6, -8.7_7_4_6, -8.6_1_3_0]] ).to(__UpperCamelCase ) self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3] , __UpperCamelCase , atol=1e-4 ) )
19
"""simple docstring""" import asyncio import os import re import sys import tempfile import unittest from contextlib import contextmanager from copy import deepcopy from distutils.util import strtobool from enum import Enum from importlib.util import find_spec from pathlib import Path from unittest.mock import patch import pyarrow as pa import pytest import requests from packaging import version from datasets import config if config.PY_VERSION < version.parse('''3.8'''): import importlib_metadata else: import importlib.metadata as importlib_metadata def _UpperCamelCase ( _A , _A=False ) -> str: """simple docstring""" try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_A ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"""If set, {key} must be yes or no.""" ) return _value a : Union[str, Any] = parse_flag_from_env('''RUN_SLOW''', default=False) a : Tuple = parse_flag_from_env('''RUN_REMOTE''', default=False) a : Union[str, Any] = parse_flag_from_env('''RUN_LOCAL''', default=True) a : int = parse_flag_from_env('''RUN_PACKAGED''', default=True) # Compression a : List[Any] = pytest.mark.skipif(not config.LZ4_AVAILABLE, reason='''test requires lz4''') a : List[Any] = pytest.mark.skipif(not config.PY7ZR_AVAILABLE, reason='''test requires py7zr''') a : Optional[Any] = pytest.mark.skipif(not config.ZSTANDARD_AVAILABLE, reason='''test requires zstandard''') # Audio a : int = pytest.mark.skipif( # On Windows and OS X, soundfile installs sndfile find_spec('''soundfile''') is None or version.parse(importlib_metadata.version('''soundfile''')) < version.parse('''0.12.0'''), reason='''test requires sndfile>=0.12.1: \'pip install \"soundfile>=0.12.1\"\'; ''', ) # Beam a : Tuple = pytest.mark.skipif( not config.BEAM_AVAILABLE or config.DILL_VERSION >= version.parse('''0.3.2'''), reason='''test requires apache-beam and a compatible dill version''', ) # Dill-cloudpickle compatibility a : Any = pytest.mark.skipif( config.DILL_VERSION <= version.parse('''0.3.2'''), reason='''test requires dill>0.3.2 for cloudpickle compatibility''', ) # Windows a : int = pytest.mark.skipif( sys.platform == '''win32''', reason='''test should not be run on Windows''', ) def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import faiss # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires faiss""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" try: import regex # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires regex""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" try: import elasticsearch # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires elasticsearch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" try: import sqlalchemy # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires sqlalchemy""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" if not config.TORCH_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires PyTorch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" if not config.TF_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires TensorFlow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" if not config.JAX_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires JAX""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not config.PIL_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires Pillow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import transformers # noqa F401 except ImportError: return unittest.skip("""test requires transformers""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import tiktoken # noqa F401 except ImportError: return unittest.skip("""test requires tiktoken""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import spacy # noqa F401 except ImportError: return unittest.skip("""test requires spacy""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> int: """simple docstring""" def _require_spacy_model(_A ): try: import spacy # noqa F401 spacy.load(_A ) except ImportError: return unittest.skip("""test requires spacy""" )(_A ) except OSError: return unittest.skip("""test requires spacy model '{}'""".format(_A ) )(_A ) else: return test_case return _require_spacy_model def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import pyspark # noqa F401 except ImportError: return unittest.skip("""test requires pyspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import joblibspark # noqa F401 except ImportError: return unittest.skip("""test requires joblibspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_slow_tests or _run_slow_tests == 0: _UpperCAmelCase = unittest.skip("""test is slow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_local_tests or _run_local_tests == 0: _UpperCAmelCase = unittest.skip("""test is local""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" if not _run_packaged_tests or _run_packaged_tests == 0: _UpperCAmelCase = unittest.skip("""test is packaged""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not _run_remote_tests or _run_remote_tests == 0: _UpperCAmelCase = unittest.skip("""test requires remote""" )(_A ) return test_case def _UpperCamelCase ( *_A ) -> Dict: """simple docstring""" def decorate(cls ): for name, fn in cls.__dict__.items(): if callable(_A ) and name.startswith("""test""" ): for decorator in decorators: _UpperCAmelCase = decorator(_A ) setattr(cls , _A , _A ) return cls return decorate class a_ ( _UpperCAmelCase ): pass class a_ ( _UpperCAmelCase ): a : Any = 0 a : Optional[Any] = 1 a : int = 2 @contextmanager def _UpperCamelCase ( _A=OfflineSimulationMode.CONNECTION_FAILS , _A=1e-16 ) -> List[Any]: """simple docstring""" _UpperCAmelCase = requests.Session().request def timeout_request(_A , _A , _A , **_A ): # Change the url to an invalid url so that the connection hangs _UpperCAmelCase = """https://10.255.255.1""" if kwargs.get("""timeout""" ) is None: raise RequestWouldHangIndefinitelyError( F"""Tried a call to {url} in offline mode with no timeout set. Please set a timeout.""" ) _UpperCAmelCase = timeout try: return online_request(_A , _A , **_A ) except Exception as e: # The following changes in the error are just here to make the offline timeout error prettier _UpperCAmelCase = url _UpperCAmelCase = e.args[0] _UpperCAmelCase = (max_retry_error.args[0].replace("""10.255.255.1""" , F"""OfflineMock[{url}]""" ),) _UpperCAmelCase = (max_retry_error,) raise def raise_connection_error(_A , _A , **_A ): raise requests.ConnectionError("""Offline mode is enabled.""" , request=_A ) if mode is OfflineSimulationMode.CONNECTION_FAILS: with patch("""requests.Session.send""" , _A ): yield elif mode is OfflineSimulationMode.CONNECTION_TIMES_OUT: # inspired from https://stackoverflow.com/a/904609 with patch("""requests.Session.request""" , _A ): yield elif mode is OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1: with patch("""datasets.config.HF_DATASETS_OFFLINE""" , _A ): yield else: raise ValueError("""Please use a value from the OfflineSimulationMode enum.""" ) @contextmanager def _UpperCamelCase ( *_A , **_A ) -> str: """simple docstring""" _UpperCAmelCase = str(Path().resolve() ) with tempfile.TemporaryDirectory(*_A , **_A ) as tmp_dir: try: os.chdir(_A ) yield finally: os.chdir(_A ) @contextmanager def _UpperCamelCase ( ) -> Any: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory > 0, "Arrow memory didn't increase." @contextmanager def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory <= 0, "Arrow memory wasn't expected to increase." def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" return deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() == deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" import decorator from requests.exceptions import HTTPError def _wrapper(_A , *_A , **_A ): try: return func(*_A , **_A ) except HTTPError as err: if str(_A ).startswith("""500""" ) or str(_A ).startswith("""502""" ): pytest.xfail(str(_A ) ) raise err return decorator.decorator(_wrapper , _A ) class a_ : def __init__( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def _UpperCamelCase ( _A , _A ) -> Union[str, Any]: """simple docstring""" while True: _UpperCAmelCase = await stream.readline() if line: callback(_A ) else: break async def _UpperCamelCase ( _A , _A=None , _A=None , _A=None , _A=False , _A=False ) -> _RunOutput: """simple docstring""" if echo: print("""\nRunning: """ , """ """.join(_A ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_A , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_A , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_A , _A , _A , _A="" ): _UpperCAmelCase = line.decode("""utf-8""" ).rstrip() sink.append(_A ) if not quiet: print(_A , _A , file=_A ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ _read_stream(p.stdout , lambda _A : tee(_A , _A , sys.stdout , label="""stdout:""" ) ), _read_stream(p.stderr , lambda _A : tee(_A , _A , sys.stderr , label="""stderr:""" ) ), ] , timeout=_A , ) return _RunOutput(await p.wait() , _A , _A ) def _UpperCamelCase ( _A , _A=None , _A=None , _A=1_8_0 , _A=False , _A=True ) -> _RunOutput: """simple docstring""" _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_A , env=_A , stdin=_A , timeout=_A , quiet=_A , echo=_A ) ) _UpperCAmelCase = """ """.join(_A ) if result.returncode > 0: _UpperCAmelCase = """\n""".join(result.stderr ) raise RuntimeError( F"""'{cmd_str}' failed with returncode {result.returncode}\n\n""" F"""The combined stderr from workers follows:\n{stderr}""" ) # check that the subprocess actually did run and produced some output, should the test rely on # the remote side to do the testing if not result.stdout and not result.stderr: raise RuntimeError(F"""'{cmd_str}' produced no output.""" ) return result def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = os.environ.get("""PYTEST_XDIST_WORKER""" , """gw0""" ) _UpperCAmelCase = re.sub(R"""^gw""" , """""" , _A , 0 , re.M ) return int(_A ) def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = 2_9_5_0_0 _UpperCAmelCase = pytest_xdist_worker_id() return port + uniq_delta
19
1
"""simple docstring""" def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = [3_1, 2_8, 3_1, 3_0, 3_1, 3_0, 3_1, 3_1, 3_0, 3_1, 3_0, 3_1] _UpperCAmelCase = 6 _UpperCAmelCase = 1 _UpperCAmelCase = 1_9_0_1 _UpperCAmelCase = 0 while year < 2_0_0_1: day += 7 if (year % 4 == 0 and year % 1_0_0 != 0) or (year % 4_0_0 == 0): if day > days_per_month[month - 1] and month != 2: month += 1 _UpperCAmelCase = day - days_per_month[month - 2] elif day > 2_9 and month == 2: month += 1 _UpperCAmelCase = day - 2_9 else: if day > days_per_month[month - 1]: month += 1 _UpperCAmelCase = day - days_per_month[month - 2] if month > 1_2: year += 1 _UpperCAmelCase = 1 if year < 2_0_0_1 and day == 1: sundays += 1 return sundays if __name__ == "__main__": print(solution())
19
"""simple docstring""" from pathlib import PurePosixPath from typing import Optional import fsspec from fsspec import AbstractFileSystem from huggingface_hub.hf_api import DatasetInfo from ..utils.file_utils import get_authentication_headers_for_url from ..utils.hub import hf_hub_url class a_ ( _UpperCAmelCase ): a : List[Any] = '' a : Union[str, Any] = 'hf-legacy' # "hf://"" is reserved for hffs def __init__( self : Tuple , __UpperCamelCase : Optional[DatasetInfo] = None , __UpperCamelCase : Optional[str] = None , **__UpperCamelCase : Any , ) ->Any: '''simple docstring''' super().__init__(self , **__UpperCamelCase ) _UpperCAmelCase = repo_info _UpperCAmelCase = token _UpperCAmelCase = None def _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' if self.dir_cache is None: _UpperCAmelCase = {} for hf_file in self.repo_info.siblings: # TODO(QL): add sizes _UpperCAmelCase = { """name""": hf_file.rfilename, """size""": None, """type""": """file""", } self.dir_cache.update( { str(__UpperCamelCase ): {"""name""": str(__UpperCamelCase ), """size""": None, """type""": """directory"""} for d in list(PurePosixPath(hf_file.rfilename ).parents )[:-1] } ) def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : str = "rb" , **__UpperCamelCase : Any , ) ->List[str]: '''simple docstring''' if not isinstance(self.repo_info , __UpperCamelCase ): raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}""" ) _UpperCAmelCase = hf_hub_url(self.repo_info.id , __UpperCamelCase , revision=self.repo_info.sha ) return fsspec.open( __UpperCamelCase , mode=__UpperCamelCase , headers=get_authentication_headers_for_url(__UpperCamelCase , use_auth_token=self.token ) , client_kwargs={"""trust_env""": True} , ).open() def _snake_case ( self : int , __UpperCamelCase : int , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' self._get_dirs() _UpperCAmelCase = self._strip_protocol(__UpperCamelCase ) if path in self.dir_cache: return self.dir_cache[path] else: raise FileNotFoundError(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple=False , **__UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' self._get_dirs() _UpperCAmelCase = PurePosixPath(path.strip("""/""" ) ) _UpperCAmelCase = {} for p, f in self.dir_cache.items(): _UpperCAmelCase = PurePosixPath(p.strip("""/""" ) ) _UpperCAmelCase = p.parent if root == path: _UpperCAmelCase = f _UpperCAmelCase = list(paths.values() ) if detail: return out else: return sorted(f["""name"""] for f in out )
19
1
"""simple docstring""" from diffusers.utils.testing_utils import require_onnxruntime @require_onnxruntime class a_ : pass
19
"""simple docstring""" import itertools import os from collections import Counter, defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed import numpy as np import datasets from .execute import check_correctness a : Optional[Any] = '''\ @misc{chen2021evaluating, title={Evaluating Large Language Models Trained on Code}, author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \ and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \ and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \ and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \ and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \ and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \ and Mohammad Bavarian and Clemens Winter and Philippe Tillet \ and Felipe Petroski Such and Dave Cummings and Matthias Plappert \ and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \ and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \ and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \ and William Saunders and Christopher Hesse and Andrew N. Carr \ and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \ and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \ and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \ and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba}, year={2021}, eprint={2107.03374}, archivePrefix={arXiv}, primaryClass={cs.LG} } ''' a : List[str] = '''\ This metric implements the evaluation harness for the HumanEval problem solving dataset described in the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). ''' a : Any = ''' Calculates how good are predictions given some references, using certain scores Args: predictions: list of candidates to evaluate. Each candidates should be a list of strings with several code candidates to solve the problem. references: a list with a test for each prediction. Each test should evaluate the correctness of a code candidate. k: number of code candidates to consider in the evaluation (Default: [1, 10, 100]) num_workers: number of workers used to evaluate the canidate programs (Default: 4). timeout: Returns: pass_at_k: dict with pass rates for each k results: dict with granular results of each unittest Examples: >>> code_eval = datasets.load_metric("code_eval") >>> test_cases = ["assert add(2,3)==5"] >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]] >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2]) >>> print(pass_at_k) {\'pass@1\': 0.5, \'pass@2\': 1.0} ''' a : int = ''' ################################################################################ !!!WARNING!!! ################################################################################ The "code_eval" metric executes untrusted model-generated code in Python. Although it is highly unlikely that model-generated code will do something overtly malicious in response to this test suite, model-generated code may act destructively due to a lack of model capability or alignment. Users are strongly encouraged to sandbox this evaluation suite so that it does not perform destructive actions on their host or network. For more information on how OpenAI sandboxes its code, see the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). Once you have read this disclaimer and taken appropriate precautions, set the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this with: >>> import os >>> os.environ["HF_ALLOW_CODE_EVAL"] = "1" ################################################################################\ ''' a : List[Any] = '''The MIT License Copyright (c) OpenAI (https://openai.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a_ ( datasets.Metric ): def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' return datasets.MetricInfo( # This is the description that will appear on the metrics page. description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Sequence(datasets.Value("""string""" ) ), """references""": datasets.Value("""string""" ), } ) , homepage="""https://github.com/openai/human-eval""" , codebase_urls=["""https://github.com/openai/human-eval"""] , reference_urls=["""https://github.com/openai/human-eval"""] , license=_LICENSE , ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any]=[1, 10, 1_00] , __UpperCamelCase : Dict=4 , __UpperCamelCase : Tuple=3.0 ) ->Union[str, Any]: '''simple docstring''' if os.getenv("""HF_ALLOW_CODE_EVAL""" , 0 ) != "1": raise ValueError(_WARNING ) if os.name == "nt": raise NotImplementedError("""This metric is currently not supported on Windows.""" ) with ThreadPoolExecutor(max_workers=__UpperCamelCase ) as executor: _UpperCAmelCase = [] _UpperCAmelCase = Counter() _UpperCAmelCase = 0 _UpperCAmelCase = defaultdict(__UpperCamelCase ) for task_id, (candidates, test_case) in enumerate(zip(__UpperCamelCase , __UpperCamelCase ) ): for candidate in candidates: _UpperCAmelCase = candidate + """\n""" + test_case _UpperCAmelCase = (test_program, timeout, task_id, completion_id[task_id]) _UpperCAmelCase = executor.submit(__UpperCamelCase , *__UpperCamelCase ) futures.append(__UpperCamelCase ) completion_id[task_id] += 1 n_samples += 1 for future in as_completed(__UpperCamelCase ): _UpperCAmelCase = future.result() results[result["task_id"]].append((result["""completion_id"""], result) ) _UpperCAmelCase ,_UpperCAmelCase = [], [] for result in results.values(): result.sort() _UpperCAmelCase = [r[1]["""passed"""] for r in result] total.append(len(__UpperCamelCase ) ) correct.append(sum(__UpperCamelCase ) ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = k _UpperCAmelCase = {f"""pass@{k}""": estimate_pass_at_k(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ).mean() for k in ks if (total >= k).all()} return pass_at_k, results def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" def estimator(_A , _A , _A ) -> float: if n - c < k: return 1.0 return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1 , n + 1 ) ) if isinstance(_A , _A ): _UpperCAmelCase = itertools.repeat(_A , len(_A ) ) else: assert len(_A ) == len(_A ) _UpperCAmelCase = iter(_A ) return np.array([estimator(int(_A ) , int(_A ) , _A ) for n, c in zip(_A , _A )] )
19
1
"""simple docstring""" import warnings from typing import List import numpy as np from ...processing_utils import ProcessorMixin from ...tokenization_utils_base import BatchEncoding from ...utils import is_flax_available, is_tf_available, is_torch_available class a_ ( _UpperCAmelCase ): a : List[Any] = ['image_processor', 'tokenizer'] a : Any = 'OwlViTImageProcessor' a : int = ('CLIPTokenizer', 'CLIPTokenizerFast') def __init__( self : Optional[int] , __UpperCamelCase : Any=None , __UpperCamelCase : Optional[int]=None , **__UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`""" """ instead.""" , __UpperCamelCase , ) _UpperCAmelCase = kwargs.pop("""feature_extractor""" ) _UpperCAmelCase = 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__(__UpperCamelCase , __UpperCamelCase ) def __call__( self : str , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : List[str]=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Any="max_length" , __UpperCamelCase : List[str]="np" , **__UpperCamelCase : Dict ) ->str: '''simple docstring''' if text is None and query_images is None and images is None: raise ValueError( """You have to specify at least one text or query image or image. All three cannot be none.""" ) if text is not None: if isinstance(__UpperCamelCase , __UpperCamelCase ) or (isinstance(__UpperCamelCase , __UpperCamelCase ) and not isinstance(text[0] , __UpperCamelCase )): _UpperCAmelCase = [self.tokenizer(__UpperCamelCase , padding=__UpperCamelCase , return_tensors=__UpperCamelCase , **__UpperCamelCase )] elif isinstance(__UpperCamelCase , __UpperCamelCase ) and isinstance(text[0] , __UpperCamelCase ): _UpperCAmelCase = [] # Maximum number of queries across batch _UpperCAmelCase = max([len(__UpperCamelCase ) for t in text] ) # Pad all batch samples to max number of text queries for t in text: if len(__UpperCamelCase ) != max_num_queries: _UpperCAmelCase = t + [""" """] * (max_num_queries - len(__UpperCamelCase )) _UpperCAmelCase = self.tokenizer(__UpperCamelCase , padding=__UpperCamelCase , return_tensors=__UpperCamelCase , **__UpperCamelCase ) encodings.append(__UpperCamelCase ) else: raise TypeError("""Input text should be a string, a list of strings or a nested list of strings""" ) if return_tensors == "np": _UpperCAmelCase = np.concatenate([encoding["""input_ids"""] for encoding in encodings] , axis=0 ) _UpperCAmelCase = np.concatenate([encoding["""attention_mask"""] for encoding in encodings] , axis=0 ) elif return_tensors == "jax" and is_flax_available(): import jax.numpy as jnp _UpperCAmelCase = jnp.concatenate([encoding["""input_ids"""] for encoding in encodings] , axis=0 ) _UpperCAmelCase = jnp.concatenate([encoding["""attention_mask"""] for encoding in encodings] , axis=0 ) elif return_tensors == "pt" and is_torch_available(): import torch _UpperCAmelCase = torch.cat([encoding["""input_ids"""] for encoding in encodings] , dim=0 ) _UpperCAmelCase = torch.cat([encoding["""attention_mask"""] for encoding in encodings] , dim=0 ) elif return_tensors == "tf" and is_tf_available(): import tensorflow as tf _UpperCAmelCase = tf.stack([encoding["""input_ids"""] for encoding in encodings] , axis=0 ) _UpperCAmelCase = tf.stack([encoding["""attention_mask"""] for encoding in encodings] , axis=0 ) else: raise ValueError("""Target return tensor type could not be returned""" ) _UpperCAmelCase = BatchEncoding() _UpperCAmelCase = input_ids _UpperCAmelCase = attention_mask if query_images is not None: _UpperCAmelCase = BatchEncoding() _UpperCAmelCase = self.image_processor( __UpperCamelCase , return_tensors=__UpperCamelCase , **__UpperCamelCase ).pixel_values _UpperCAmelCase = query_pixel_values if images is not None: _UpperCAmelCase = self.image_processor(__UpperCamelCase , return_tensors=__UpperCamelCase , **__UpperCamelCase ) if text is not None and images is not None: _UpperCAmelCase = image_features.pixel_values return encoding elif query_images is not None and images is not None: _UpperCAmelCase = image_features.pixel_values return encoding elif text is not None or query_images is not None: return encoding else: return BatchEncoding(data=dict(**__UpperCamelCase ) , tensor_type=__UpperCamelCase ) def _snake_case ( self : Optional[int] , *__UpperCamelCase : Dict , **__UpperCamelCase : Optional[int] ) ->List[str]: '''simple docstring''' return self.image_processor.post_process(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Optional[Any] , *__UpperCamelCase : Union[str, Any] , **__UpperCamelCase : Any ) ->Optional[int]: '''simple docstring''' return self.image_processor.post_process_object_detection(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Union[str, Any] , *__UpperCamelCase : Optional[int] , **__UpperCamelCase : List[str] ) ->Dict: '''simple docstring''' return self.image_processor.post_process_image_guided_detection(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Optional[int] , *__UpperCamelCase : List[Any] , **__UpperCamelCase : Union[str, Any] ) ->Tuple: '''simple docstring''' return self.tokenizer.batch_decode(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Any , *__UpperCamelCase : Tuple , **__UpperCamelCase : Dict ) ->Dict: '''simple docstring''' return self.tokenizer.decode(*__UpperCamelCase , **__UpperCamelCase ) @property def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' warnings.warn( """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""" , __UpperCamelCase , ) return self.image_processor_class @property def _snake_case ( self : Dict ) ->Any: '''simple docstring''' warnings.warn( """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""" , __UpperCamelCase , ) return self.image_processor
19
"""simple docstring""" from collections.abc import Callable import numpy as np def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> np.array: """simple docstring""" _UpperCAmelCase = int(np.ceil((x_end - xa) / step_size ) ) _UpperCAmelCase = np.zeros((n + 1,) ) _UpperCAmelCase = ya _UpperCAmelCase = xa for k in range(_A ): _UpperCAmelCase = y[k] + step_size * ode_func(_A , y[k] ) _UpperCAmelCase = y[k] + ( (step_size / 2) * (ode_func(_A , y[k] ) + ode_func(x + step_size , _A )) ) x += step_size return y if __name__ == "__main__": import doctest doctest.testmod()
19
1
"""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 : str , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any=13 , __UpperCamelCase : int=10 , __UpperCamelCase : int=3 , __UpperCamelCase : List[str]=2 , __UpperCamelCase : Tuple=2 , __UpperCamelCase : Optional[Any]=2 , __UpperCamelCase : str=True , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Tuple=32 , __UpperCamelCase : Optional[int]=5 , __UpperCamelCase : Any=4 , __UpperCamelCase : Union[str, Any]=37 , __UpperCamelCase : Dict="gelu" , __UpperCamelCase : List[str]=0.1 , __UpperCamelCase : Optional[Any]=0.1 , __UpperCamelCase : Union[str, Any]=10 , __UpperCamelCase : Dict=0.0_2 , __UpperCamelCase : Optional[Any]=0.9 , __UpperCamelCase : int=None , ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = image_size _UpperCAmelCase = num_channels _UpperCAmelCase = patch_size _UpperCAmelCase = tubelet_size _UpperCAmelCase = num_frames _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 = mask_ratio _UpperCAmelCase = scope # in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame _UpperCAmelCase = (image_size // patch_size) ** 2 _UpperCAmelCase = (num_frames // tubelet_size) * self.num_patches_per_frame # use this variable to define bool_masked_pos _UpperCAmelCase = int(mask_ratio * self.seq_length ) def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = floats_tensor( [self.batch_size, self.num_frames, 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 _snake_case ( self : Dict ) ->List[Any]: '''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=A__ , initializer_range=self.initializer_range , ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = VideoMAEModel(config=A__ ) model.to(A__ ) model.eval() _UpperCAmelCase = model(A__ ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : Dict , __UpperCamelCase : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : str ) ->int: '''simple docstring''' _UpperCAmelCase = VideoMAEForPreTraining(A__ ) model.to(A__ ) 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 _UpperCAmelCase = torch.ones((self.num_masks,) ) _UpperCAmelCase = torch.cat([mask, torch.zeros(self.seq_length - mask.size(0 ) )] ) _UpperCAmelCase = mask.expand(self.batch_size , -1 ).bool() _UpperCAmelCase = model(A__ , A__ ) # model only returns predictions for masked patches _UpperCAmelCase = mask.sum().item() _UpperCAmelCase = 3 * self.tubelet_size * self.patch_size**2 self.parent.assertEqual(result.logits.shape , (self.batch_size, num_masked_patches, decoder_num_labels) ) def _snake_case ( self : Optional[int] ) ->Optional[int]: '''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 a_ ( _lowerCamelCase , _lowerCamelCase , unittest.TestCase ): a : Optional[Any] = ( (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else () ) a : Optional[int] = ( {'feature-extraction': VideoMAEModel, 'video-classification': VideoMAEForVideoClassification} if is_torch_available() else {} ) a : Any = False a : Dict = False a : Optional[int] = False a : Any = False def _snake_case ( self : str ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = VideoMAEModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=A__ , has_text_modality=A__ , hidden_size=37 ) def _snake_case ( self : Any , __UpperCamelCase : Optional[int] , __UpperCamelCase : str , __UpperCamelCase : str=False ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = copy.deepcopy(A__ ) 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 _UpperCAmelCase = torch.ones((self.model_tester.num_masks,) ) _UpperCAmelCase = torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0 ) )] ) _UpperCAmelCase = mask.expand(self.model_tester.batch_size , -1 ).bool() _UpperCAmelCase = bool_masked_pos.to(A__ ) if return_labels: if model_class in [ *get_values(A__ ), ]: _UpperCAmelCase = torch.zeros( self.model_tester.batch_size , dtype=torch.long , device=A__ ) return inputs_dict def _snake_case ( self : Dict ) ->int: '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason="""VideoMAE does not use inputs_embeds""" ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' pass def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(A__ ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) _UpperCAmelCase = model.get_output_embeddings() self.assertTrue(x is None or isinstance(A__ , nn.Linear ) ) def _snake_case ( self : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(A__ ) _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] , A__ ) def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*A__ ) def _snake_case ( self : str ) ->Any: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_pretraining(*A__ ) @slow def _snake_case ( self : Optional[Any] ) ->Optional[int]: '''simple docstring''' for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]: _UpperCAmelCase = VideoMAEModel.from_pretrained(A__ ) self.assertIsNotNone(A__ ) def _snake_case ( self : Tuple ) ->int: '''simple docstring''' if not self.has_attentions: pass else: _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True for model_class in self.all_model_classes: _UpperCAmelCase = self.model_tester.seq_length - self.model_tester.num_masks _UpperCAmelCase = ( num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length ) _UpperCAmelCase = True _UpperCAmelCase = False _UpperCAmelCase = True _UpperCAmelCase = model_class(A__ ) model.to(A__ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(A__ , A__ ) ) _UpperCAmelCase = outputs.attentions self.assertEqual(len(A__ ) , self.model_tester.num_hidden_layers ) # check that output_attentions also work using config del inputs_dict["output_attentions"] _UpperCAmelCase = True _UpperCAmelCase = model_class(A__ ) model.to(A__ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(A__ , A__ ) ) _UpperCAmelCase = outputs.attentions self.assertEqual(len(A__ ) , self.model_tester.num_hidden_layers ) self.assertListEqual( list(attentions[0].shape[-3:] ) , [self.model_tester.num_attention_heads, seq_len, seq_len] , ) _UpperCAmelCase = len(A__ ) # Check attention is always last and order is fine _UpperCAmelCase = True _UpperCAmelCase = True _UpperCAmelCase = model_class(A__ ) model.to(A__ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(A__ , A__ ) ) self.assertEqual(out_len + 1 , len(A__ ) ) _UpperCAmelCase = outputs.attentions self.assertEqual(len(A__ ) , 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 _snake_case ( self : Tuple ) ->Dict: '''simple docstring''' def check_hidden_states_output(__UpperCamelCase : Optional[int] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] ): _UpperCAmelCase = model_class(A__ ) model.to(A__ ) model.eval() with torch.no_grad(): _UpperCAmelCase = model(**self._prepare_for_class(A__ , A__ ) ) _UpperCAmelCase = outputs.hidden_states _UpperCAmelCase = self.model_tester.num_hidden_layers + 1 self.assertEqual(len(A__ ) , A__ ) _UpperCAmelCase = self.model_tester.seq_length - self.model_tester.num_masks _UpperCAmelCase = 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] , ) _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = True check_hidden_states_output(A__ , A__ , A__ ) # check that output_hidden_states also work using config del inputs_dict["output_hidden_states"] _UpperCAmelCase = True check_hidden_states_output(A__ , A__ , A__ ) @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" ) def _snake_case ( self : Any ) ->List[Any]: '''simple docstring''' pass def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = hf_hub_download( repo_id="""hf-internal-testing/spaghetti-video""" , filename="""eating_spaghetti.npy""" , repo_type="""dataset""" ) _UpperCAmelCase = np.load(SCREAMING_SNAKE_CASE_ ) return list(SCREAMING_SNAKE_CASE_ ) @require_torch @require_vision class a_ ( unittest.TestCase ): @cached_property def _snake_case ( self : List[Any] ) ->str: '''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 _snake_case ( self : int ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = VideoMAEForVideoClassification.from_pretrained("""MCG-NJU/videomae-base-finetuned-kinetics""" ).to( A__ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_video() _UpperCAmelCase = image_processor(A__ , return_tensors="""pt""" ).to(A__ ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**A__ ) # verify the logits _UpperCAmelCase = torch.Size((1, 4_00) ) self.assertEqual(outputs.logits.shape , A__ ) _UpperCAmelCase = torch.tensor([0.3_6_6_9, -0.0_6_8_8, -0.2_4_2_1] ).to(A__ ) self.assertTrue(torch.allclose(outputs.logits[0, :3] , A__ , atol=1e-4 ) ) @slow def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = VideoMAEForPreTraining.from_pretrained("""MCG-NJU/videomae-base-short""" ).to(A__ ) _UpperCAmelCase = self.default_image_processor _UpperCAmelCase = prepare_video() _UpperCAmelCase = image_processor(A__ , return_tensors="""pt""" ).to(A__ ) # add boolean mask, indicating which patches to mask _UpperCAmelCase = hf_hub_download(repo_id="""hf-internal-testing/bool-masked-pos""" , filename="""bool_masked_pos.pt""" ) _UpperCAmelCase = torch.load(A__ ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**A__ ) # verify the logits _UpperCAmelCase = torch.Size([1, 14_08, 15_36] ) _UpperCAmelCase = 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=A__ ) self.assertEqual(outputs.logits.shape , A__ ) self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] , A__ , atol=1e-4 ) ) # verify the loss (`config.norm_pix_loss` = `True`) _UpperCAmelCase = torch.tensor([0.5_1_4_2] , device=A__ ) self.assertTrue(torch.allclose(outputs.loss , A__ , atol=1e-4 ) ) # verify the loss (`config.norm_pix_loss` = `False`) _UpperCAmelCase = VideoMAEForPreTraining.from_pretrained("""MCG-NJU/videomae-base-short""" , norm_pix_loss=A__ ).to( A__ ) with torch.no_grad(): _UpperCAmelCase = model(**A__ ) _UpperCAmelCase = torch.tensor(torch.tensor([0.6_4_6_9] ) , device=A__ ) self.assertTrue(torch.allclose(outputs.loss , A__ , atol=1e-4 ) )
700
"""simple docstring""" import argparse import logging import os import sys import numpy as np import onnxruntime import torch from bart_onnx.generation_onnx import BARTBeamSearchGenerator from bart_onnx.reduce_onnx_size import remove_dup_initializers import transformers from transformers import BartForConditionalGeneration, BartTokenizer logging.basicConfig( format='''%(asctime)s | %(levelname)s | %(name)s | [%(filename)s:%(lineno)d] %(message)s''', datefmt='''%Y-%m-%d %H:%M:%S''', level=os.environ.get('''LOGLEVEL''', '''INFO''').upper(), stream=sys.stdout, ) a : List[str] = logging.getLogger(__name__) a : int = {'''facebook/bart-base''': BartForConditionalGeneration} a : Dict = {'''facebook/bart-base''': BartTokenizer} def _UpperCamelCase ( ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = argparse.ArgumentParser(description="""Export Bart model + Beam Search to ONNX graph.""" ) parser.add_argument( """--validation_file""" , type=_A , default=_A , help="""A csv or a json file containing the validation data.""" ) parser.add_argument( """--max_length""" , type=_A , default=5 , help="""The maximum total input sequence length after tokenization.""" , ) parser.add_argument( """--num_beams""" , type=_A , default=_A , help=( """Number of beams to use for evaluation. This argument will be """ """passed to ``model.generate``, which is used during ``evaluate`` and ``predict``.""" ) , ) parser.add_argument( """--model_name_or_path""" , type=_A , help="""Path to pretrained model or model identifier from huggingface.co/models.""" , required=_A , ) parser.add_argument( """--config_name""" , type=_A , default=_A , help="""Pretrained config name or path if not the same as model_name""" , ) parser.add_argument( """--device""" , type=_A , default="""cpu""" , help="""Device where the model will be run""" , ) parser.add_argument("""--output_file_path""" , type=_A , default=_A , help="""Where to store the final ONNX file.""" ) _UpperCAmelCase = parser.parse_args() return args def _UpperCamelCase ( _A , _A="cpu" ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = model_dict[model_name].from_pretrained(_A ).to(_A ) _UpperCAmelCase = tokenizer_dict[model_name].from_pretrained(_A ) if model_name in ["facebook/bart-base"]: _UpperCAmelCase = 0 _UpperCAmelCase = None _UpperCAmelCase = 0 return huggingface_model, tokenizer def _UpperCamelCase ( _A , _A , _A , _A , _A ) -> Optional[int]: """simple docstring""" model.eval() _UpperCAmelCase = None _UpperCAmelCase = torch.jit.script(BARTBeamSearchGenerator(_A ) ) with torch.no_grad(): _UpperCAmelCase = """My friends are cool but they eat too many carbs.""" _UpperCAmelCase = tokenizer([ARTICLE_TO_SUMMARIZE] , max_length=1_0_2_4 , return_tensors="""pt""" ).to(model.device ) _UpperCAmelCase = model.generate( inputs["""input_ids"""] , attention_mask=inputs["""attention_mask"""] , num_beams=_A , max_length=_A , early_stopping=_A , decoder_start_token_id=model.config.decoder_start_token_id , ) torch.onnx.export( _A , ( inputs["""input_ids"""], inputs["""attention_mask"""], num_beams, max_length, model.config.decoder_start_token_id, ) , _A , opset_version=1_4 , input_names=["""input_ids""", """attention_mask""", """num_beams""", """max_length""", """decoder_start_token_id"""] , output_names=["""output_ids"""] , dynamic_axes={ """input_ids""": {0: """batch""", 1: """seq"""}, """output_ids""": {0: """batch""", 1: """seq_out"""}, } , example_outputs=_A , ) logger.info("""Model exported to {}""".format(_A ) ) _UpperCAmelCase = remove_dup_initializers(os.path.abspath(_A ) ) logger.info("""Deduplicated and optimized model written to {}""".format(_A ) ) _UpperCAmelCase = onnxruntime.InferenceSession(_A ) _UpperCAmelCase = ort_sess.run( _A , { """input_ids""": inputs["""input_ids"""].cpu().numpy(), """attention_mask""": inputs["""attention_mask"""].cpu().numpy(), """num_beams""": np.array(_A ), """max_length""": np.array(_A ), """decoder_start_token_id""": np.array(model.config.decoder_start_token_id ), } , ) np.testing.assert_allclose(summary_ids.cpu().numpy() , ort_out[0] , rtol=1e-3 , atol=1e-3 ) logger.info("""Model outputs from torch and ONNX Runtime are similar.""" ) logger.info("""Success.""" ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = parse_args() _UpperCAmelCase = 5 _UpperCAmelCase = 4 # Make one log on every process with the configuration for debugging. logging.basicConfig( format="""%(asctime)s - %(levelname)s - %(name)s - %(message)s""" , datefmt="""%m/%d/%Y %H:%M:%S""" , level=logging.INFO , ) logger.setLevel(logging.INFO ) transformers.utils.logging.set_verbosity_error() _UpperCAmelCase = torch.device(args.device ) _UpperCAmelCase ,_UpperCAmelCase = load_model_tokenizer(args.model_name_or_path , _A ) if model.config.decoder_start_token_id is None: raise ValueError("""Make sure that `config.decoder_start_token_id` is correctly defined""" ) model.to(_A ) if args.max_length: _UpperCAmelCase = args.max_length if args.num_beams: _UpperCAmelCase = args.num_beams if args.output_file_path: _UpperCAmelCase = args.output_file_path else: _UpperCAmelCase = """BART.onnx""" logger.info("""Exporting model to ONNX""" ) export_and_validate_model(_A , _A , _A , _A , _A ) if __name__ == "__main__": main()
19
0
"""simple docstring""" import collections import os from shutil import copyfile from typing import Any, Dict, List, Optional, Tuple from ...tokenization_utils import PreTrainedTokenizer from ...utils import logging a : Union[str, Any] = logging.get_logger(__name__) a : List[str] = '''▁''' a : Dict = {'''vocab_file''': '''prophetnet.tokenizer'''} a : Dict = { '''vocab_file''': { '''microsoft/xprophetnet-large-wiki100-cased''': ( '''https://huggingface.co/microsoft/xprophetnet-large-wiki100-cased/resolve/main/prophetnet.tokenizer''' ), } } a : int = { '''microsoft/xprophetnet-large-wiki100-cased''': {'''do_lower_case''': False}, } a : Dict = { '''microsoft/xprophetnet-large-wiki100-cased''': 5_1_2, } def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = collections.OrderedDict() with open(__A , """r""" , encoding="""utf-8""" ) as reader: _UpperCAmelCase = reader.readlines() for index, token in enumerate(__A ): _UpperCAmelCase = token.rstrip("""\n""" ) _UpperCAmelCase = index return vocab class a_ ( _snake_case ): a : Dict = VOCAB_FILES_NAMES a : Union[str, Any] = PRETRAINED_VOCAB_FILES_MAP a : Dict = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES a : Union[str, Any] = ['input_ids', 'attention_mask'] def __init__( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : Optional[Any]="[SEP]" , __UpperCamelCase : Any="[SEP]" , __UpperCamelCase : Tuple="[SEP]" , __UpperCamelCase : List[Any]="[UNK]" , __UpperCamelCase : Dict="[PAD]" , __UpperCamelCase : Tuple="[CLS]" , __UpperCamelCase : str="[MASK]" , __UpperCamelCase : Optional[Dict[str, Any]] = None , **__UpperCamelCase : int , ) ->None: '''simple docstring''' _UpperCAmelCase = {} if sp_model_kwargs is None else sp_model_kwargs super().__init__( bos_token=lowerCAmelCase__ , eos_token=lowerCAmelCase__ , sep_token=lowerCAmelCase__ , unk_token=lowerCAmelCase__ , pad_token=lowerCAmelCase__ , cls_token=lowerCAmelCase__ , mask_token=lowerCAmelCase__ , sp_model_kwargs=self.sp_model_kwargs , **lowerCAmelCase__ , ) try: import sentencepiece as spm except ImportError: logger.warning( """You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece""" """ pip install sentencepiece""" ) raise _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(str(lowerCAmelCase__ ) ) _UpperCAmelCase = 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' # put special tokens and [unused] tokens into the vocab _UpperCAmelCase = {"""[PAD]""": 0, """[CLS]""": 1, """[SEP]""": 2, """[UNK]""": 3, """[MASK]""": 4} for i in range(10 ): _UpperCAmelCase = f"""[unused{i}]""" _UpperCAmelCase = 5 + i # The first "real" token "," has position 15 in the embedding vocab and position 3 in the spm vocab _UpperCAmelCase = 12 _UpperCAmelCase = {v: k for k, v in self.fairseq_tokens_to_ids.items()} for k in self.fairseq_tokens_to_ids.keys(): self.unique_no_split_tokens.append(lowerCAmelCase__ ) def __getstate__( self : Any ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.__dict__.copy() _UpperCAmelCase = None return state def __setstate__( self : List[Any] , __UpperCamelCase : str ) ->str: '''simple docstring''' _UpperCAmelCase = d try: import sentencepiece as spm except ImportError: logger.warning( """You need to install SentencePiece to use XLMRobertaTokenizer: https://github.com/google/sentencepiece""" """ pip install sentencepiece""" ) raise # for backward compatibility if not hasattr(self , """sp_model_kwargs""" ): _UpperCAmelCase = {} _UpperCAmelCase = spm.SentencePieceProcessor(**self.sp_model_kwargs ) self.sp_model.Load(self.vocab_file ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None , __UpperCamelCase : bool = False ) ->List[int]: '''simple docstring''' if already_has_special_tokens: return super().get_special_tokens_mask( token_ids_a=lowerCAmelCase__ , token_ids_a=lowerCAmelCase__ , already_has_special_tokens=lowerCAmelCase__ ) if token_ids_a is None: return ([0] * len(lowerCAmelCase__ )) + [1] return ([0] * len(lowerCAmelCase__ )) + [1] + ([0] * len(lowerCAmelCase__ )) + [1] def _snake_case ( self : int , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None ) ->List[int]: '''simple docstring''' _UpperCAmelCase = [self.sep_token_id] if token_ids_a is None: return len(token_ids_a + sep ) * [0] return len(token_ids_a + sep + sep + token_ids_a + sep ) * [0] @property def _snake_case ( self : int ) ->int: '''simple docstring''' return len(self.sp_model ) + self.fairseq_offset def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = {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 : Optional[Any] , __UpperCamelCase : str ) ->str: '''simple docstring''' return self.sp_model.encode(lowerCAmelCase__ , out_type=lowerCAmelCase__ ) def _snake_case ( self : Any , __UpperCamelCase : int ) ->Tuple: '''simple docstring''' if token in self.fairseq_tokens_to_ids: return self.fairseq_tokens_to_ids[token] _UpperCAmelCase = 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 : str , __UpperCamelCase : int ) ->Tuple: '''simple docstring''' 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 : Union[str, Any] , __UpperCamelCase : Any ) ->str: '''simple docstring''' _UpperCAmelCase = """""".join(lowerCAmelCase__ ).replace(lowerCAmelCase__ , """ """ ).strip() return out_string def _snake_case ( self : Any , __UpperCamelCase : str , __UpperCamelCase : Optional[str] = None ) ->Tuple[str]: '''simple docstring''' if not os.path.isdir(lowerCAmelCase__ ): logger.error(f"""Vocabulary path ({save_directory}) should be a directory""" ) return _UpperCAmelCase = os.path.join( lowerCAmelCase__ , (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] ) if os.path.abspath(self.vocab_file ) != os.path.abspath(lowerCAmelCase__ ) and os.path.isfile(self.vocab_file ): copyfile(self.vocab_file , lowerCAmelCase__ ) elif not os.path.isfile(self.vocab_file ): with open(lowerCAmelCase__ , """wb""" ) as fi: _UpperCAmelCase = self.sp_model.serialized_model_proto() fi.write(lowerCAmelCase__ ) return (out_vocab_file,) def _snake_case ( self : Dict , __UpperCamelCase : List[int] , __UpperCamelCase : Optional[List[int]] = None ) ->List[int]: '''simple docstring''' if token_ids_a is None: return token_ids_a + [self.sep_token_id] _UpperCAmelCase = [self.sep_token_id] return token_ids_a + sep + token_ids_a + sep
701
"""simple docstring""" import argparse import json import math import os import time import traceback import zipfile from collections import Counter import requests def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{workflow_run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() job_links.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return job_links except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{worflow_run_id}/artifacts?per_page=100""" _UpperCAmelCase = requests.get(_A , headers=_A ).json() _UpperCAmelCase = {} try: artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" , headers=_A ).json() artifacts.update({artifact["""name"""]: artifact["""archive_download_url"""] for artifact in result["""artifacts"""]} ) return artifacts except Exception: print(F"""Unknown error, could not fetch links:\n{traceback.format_exc()}""" ) return {} def _UpperCamelCase ( _A , _A , _A , _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = None if token is not None: _UpperCAmelCase = {"""Accept""": """application/vnd.github+json""", """Authorization""": F"""Bearer {token}"""} _UpperCAmelCase = requests.get(_A , headers=_A , allow_redirects=_A ) _UpperCAmelCase = result.headers["""Location"""] _UpperCAmelCase = requests.get(_A , allow_redirects=_A ) _UpperCAmelCase = os.path.join(_A , F"""{artifact_name}.zip""" ) with open(_A , """wb""" ) as fp: fp.write(response.content ) def _UpperCamelCase ( _A , _A=None ) -> Dict: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [] _UpperCAmelCase = None with zipfile.ZipFile(_A ) as z: for filename in z.namelist(): if not os.path.isdir(_A ): # read the file if filename in ["failures_line.txt", "summary_short.txt", "job_name.txt"]: with z.open(_A ) as f: for line in f: _UpperCAmelCase = line.decode("""UTF-8""" ).strip() if filename == "failures_line.txt": try: # `error_line` is the place where `error` occurs _UpperCAmelCase = line[: line.index(""": """ )] _UpperCAmelCase = line[line.index(""": """ ) + len(""": """ ) :] errors.append([error_line, error] ) except Exception: # skip un-related lines pass elif filename == "summary_short.txt" and line.startswith("""FAILED """ ): # `test` is the test method that failed _UpperCAmelCase = line[len("""FAILED """ ) :] failed_tests.append(_A ) elif filename == "job_name.txt": _UpperCAmelCase = line if len(_A ) != len(_A ): raise ValueError( F"""`errors` and `failed_tests` should have the same number of elements. Got {len(_A )} for `errors` """ F"""and {len(_A )} for `failed_tests` instead. The test reports in {artifact_zip_path} have some""" """ problem.""" ) _UpperCAmelCase = None if job_name and job_links: _UpperCAmelCase = job_links.get(_A , _A ) # A list with elements of the form (line of error, error, failed test) _UpperCAmelCase = [x + [y] + [job_link] for x, y in zip(_A , _A )] return result def _UpperCamelCase ( _A , _A=None ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = [os.path.join(_A , _A ) for p in os.listdir(_A ) if p.endswith(""".zip""" )] for p in paths: errors.extend(get_errors_from_single_artifact(_A , job_links=_A ) ) return errors def _UpperCamelCase ( _A , _A=None ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = Counter() counter.update([x[1] for x in logs] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {} for error, count in counts: if error_filter is None or error not in error_filter: _UpperCAmelCase = {"""count""": count, """failed_tests""": [(x[2], x[0]) for x in logs if x[1] == error]} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = test.split("""::""" )[0] if test.startswith("""tests/models/""" ): _UpperCAmelCase = test.split("""/""" )[2] else: _UpperCAmelCase = None return test def _UpperCamelCase ( _A , _A=None ) -> Any: """simple docstring""" _UpperCAmelCase = [(x[0], x[1], get_model(x[2] )) for x in logs] _UpperCAmelCase = [x for x in logs if x[2] is not None] _UpperCAmelCase = {x[2] for x in logs} _UpperCAmelCase = {} for test in tests: _UpperCAmelCase = Counter() # count by errors in `test` counter.update([x[1] for x in logs if x[2] == test] ) _UpperCAmelCase = counter.most_common() _UpperCAmelCase = {error: count for error, count in counts if (error_filter is None or error not in error_filter)} _UpperCAmelCase = sum(error_counts.values() ) if n_errors > 0: _UpperCAmelCase = {"""count""": n_errors, """errors""": error_counts} _UpperCAmelCase = dict(sorted(r.items() , key=lambda _A : item[1]["count"] , reverse=_A ) ) return r def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = """| no. | error | status |""" _UpperCAmelCase = """|-:|:-|:-|""" _UpperCAmelCase = [header, sep] for error in reduced_by_error: _UpperCAmelCase = reduced_by_error[error]["""count"""] _UpperCAmelCase = F"""| {count} | {error[:1_0_0]} | |""" lines.append(_A ) return "\n".join(_A ) def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = """| model | no. of errors | major error | count |""" _UpperCAmelCase = """|-:|-:|-:|-:|""" _UpperCAmelCase = [header, sep] for model in reduced_by_model: _UpperCAmelCase = reduced_by_model[model]["""count"""] _UpperCAmelCase ,_UpperCAmelCase = list(reduced_by_model[model]["""errors"""].items() )[0] _UpperCAmelCase = F"""| {model} | {count} | {error[:6_0]} | {_count} |""" lines.append(_A ) return "\n".join(_A ) if __name__ == "__main__": a : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument('''--workflow_run_id''', type=str, required=True, help='''A GitHub Actions workflow run id.''') parser.add_argument( '''--output_dir''', type=str, required=True, help='''Where to store the downloaded artifacts and other result files.''', ) parser.add_argument('''--token''', default=None, type=str, help='''A token that has actions:read permission.''') a : Dict = parser.parse_args() os.makedirs(args.output_dir, exist_ok=True) a : Tuple = get_job_links(args.workflow_run_id, token=args.token) a : Tuple = {} # To deal with `workflow_call` event, where a job name is the combination of the job names in the caller and callee. # For example, `PyTorch 1.11 / Model tests (models/albert, single-gpu)`. if _job_links: for k, v in _job_links.items(): # This is how GitHub actions combine job names. if " / " in k: a : List[Any] = k.find(''' / ''') a : Tuple = k[index + len(''' / ''') :] a : int = v with open(os.path.join(args.output_dir, '''job_links.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(job_links, fp, ensure_ascii=False, indent=4) a : Tuple = get_artifacts_links(args.workflow_run_id, token=args.token) with open(os.path.join(args.output_dir, '''artifacts.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(artifacts, fp, ensure_ascii=False, indent=4) for idx, (name, url) in enumerate(artifacts.items()): download_artifact(name, url, args.output_dir, args.token) # Be gentle to GitHub time.sleep(1) a : Optional[int] = get_all_errors(args.output_dir, job_links=job_links) # `e[1]` is the error a : Union[str, Any] = Counter() counter.update([e[1] for e in errors]) # print the top 30 most common test errors a : Optional[int] = counter.most_common(3_0) for item in most_common: print(item) with open(os.path.join(args.output_dir, '''errors.json'''), '''w''', encoding='''UTF-8''') as fp: json.dump(errors, fp, ensure_ascii=False, indent=4) a : int = reduce_by_error(errors) a : str = reduce_by_model(errors) a : int = make_github_table(reduced_by_error) a : Optional[int] = make_github_table_per_model(reduced_by_model) with open(os.path.join(args.output_dir, '''reduced_by_error.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa) with open(os.path.join(args.output_dir, '''reduced_by_model.txt'''), '''w''', encoding='''UTF-8''') as fp: fp.write(sa)
19
0
"""simple docstring""" import argparse from pathlib import Path from typing import Dict, OrderedDict, Tuple import torch from audiocraft.models import MusicGen from transformers import ( AutoFeatureExtractor, AutoTokenizer, EncodecModel, MusicgenDecoderConfig, MusicgenForConditionalGeneration, MusicgenProcessor, TaEncoderModel, ) from transformers.models.musicgen.modeling_musicgen import MusicgenForCausalLM from transformers.utils import logging logging.set_verbosity_info() a : Union[str, Any] = logging.get_logger(__name__) a : int = ['model.decoder.embed_positions.weights'] def _UpperCamelCase ( _A ) -> str: if "emb" in name: _UpperCAmelCase = name.replace("""emb""" , """model.decoder.embed_tokens""" ) if "transformer" in name: _UpperCAmelCase = name.replace("""transformer""" , """model.decoder""" ) if "cross_attention" in name: _UpperCAmelCase = name.replace("""cross_attention""" , """encoder_attn""" ) if "linear1" in name: _UpperCAmelCase = name.replace("""linear1""" , """fc1""" ) if "linear2" in name: _UpperCAmelCase = name.replace("""linear2""" , """fc2""" ) if "norm1" in name: _UpperCAmelCase = name.replace("""norm1""" , """self_attn_layer_norm""" ) if "norm_cross" in name: _UpperCAmelCase = name.replace("""norm_cross""" , """encoder_attn_layer_norm""" ) if "norm2" in name: _UpperCAmelCase = name.replace("""norm2""" , """final_layer_norm""" ) if "out_norm" in name: _UpperCAmelCase = name.replace("""out_norm""" , """model.decoder.layer_norm""" ) if "linears" in name: _UpperCAmelCase = name.replace("""linears""" , """lm_heads""" ) if "condition_provider.conditioners.description.output_proj" in name: _UpperCAmelCase = name.replace("""condition_provider.conditioners.description.output_proj""" , """enc_to_dec_proj""" ) return name def _UpperCamelCase ( _A , _A ) -> Tuple[Dict, Dict]: _UpperCAmelCase = list(state_dict.keys() ) _UpperCAmelCase = {} for key in keys: _UpperCAmelCase = state_dict.pop(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = rename_keys(_SCREAMING_SNAKE_CASE ) if "in_proj_weight" in key: # split fused qkv proj _UpperCAmelCase = val[:hidden_size, :] _UpperCAmelCase = val[hidden_size : 2 * hidden_size, :] _UpperCAmelCase = val[-hidden_size:, :] elif "enc_to_dec_proj" in key: _UpperCAmelCase = val else: _UpperCAmelCase = val return state_dict, enc_dec_proj_state_dict def _UpperCamelCase ( _A ) -> MusicgenDecoderConfig: if checkpoint == "small": # default config values _UpperCAmelCase = 1_0_2_4 _UpperCAmelCase = 2_4 _UpperCAmelCase = 1_6 elif checkpoint == "medium": _UpperCAmelCase = 1_5_3_6 _UpperCAmelCase = 4_8 _UpperCAmelCase = 2_4 elif checkpoint == "large": _UpperCAmelCase = 2_0_4_8 _UpperCAmelCase = 4_8 _UpperCAmelCase = 3_2 else: raise ValueError(F"""Checkpoint should be one of `['small', 'medium', 'large']`, got {checkpoint}.""" ) _UpperCAmelCase = MusicgenDecoderConfig( hidden_size=_SCREAMING_SNAKE_CASE , ffn_dim=hidden_size * 4 , num_hidden_layers=_SCREAMING_SNAKE_CASE , num_attention_heads=_SCREAMING_SNAKE_CASE , ) return config @torch.no_grad() def _UpperCamelCase ( _A , _A=None , _A=None , _A="cpu" ) -> Tuple: _UpperCAmelCase = MusicGen.get_pretrained(_SCREAMING_SNAKE_CASE , device=_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = decoder_config_from_checkpoint(_SCREAMING_SNAKE_CASE ) _UpperCAmelCase = fairseq_model.lm.state_dict() _UpperCAmelCase ,_UpperCAmelCase = rename_state_dict( _SCREAMING_SNAKE_CASE , hidden_size=decoder_config.hidden_size ) _UpperCAmelCase = TaEncoderModel.from_pretrained("""t5-base""" ) _UpperCAmelCase = EncodecModel.from_pretrained("""facebook/encodec_32khz""" ) _UpperCAmelCase = MusicgenForCausalLM(_SCREAMING_SNAKE_CASE ).eval() # load all decoder weights - expect that we'll be missing embeddings and enc-dec projection _UpperCAmelCase ,_UpperCAmelCase = decoder.load_state_dict(_SCREAMING_SNAKE_CASE , strict=_SCREAMING_SNAKE_CASE ) for key in missing_keys.copy(): if key.startswith(("""text_encoder""", """audio_encoder""") ) or key in EXPECTED_MISSING_KEYS: missing_keys.remove(_SCREAMING_SNAKE_CASE ) if len(_SCREAMING_SNAKE_CASE ) > 0: raise ValueError(F"""Missing key(s) in state_dict: {missing_keys}""" ) if len(_SCREAMING_SNAKE_CASE ) > 0: raise ValueError(F"""Unexpected key(s) in state_dict: {unexpected_keys}""" ) # init the composite model _UpperCAmelCase = MusicgenForConditionalGeneration(text_encoder=_SCREAMING_SNAKE_CASE , audio_encoder=_SCREAMING_SNAKE_CASE , decoder=_SCREAMING_SNAKE_CASE ) # load the pre-trained enc-dec projection (from the decoder state dict) model.enc_to_dec_proj.load_state_dict(_SCREAMING_SNAKE_CASE ) # check we can do a forward pass _UpperCAmelCase = torch.arange(0 , 8 , dtype=torch.long ).reshape(2 , -1 ) _UpperCAmelCase = input_ids.reshape(2 * 4 , -1 ) with torch.no_grad(): _UpperCAmelCase = model(input_ids=_SCREAMING_SNAKE_CASE , decoder_input_ids=_SCREAMING_SNAKE_CASE ).logits if logits.shape != (8, 1, 2_0_4_8): raise ValueError("""Incorrect shape for logits""" ) # now construct the processor _UpperCAmelCase = AutoTokenizer.from_pretrained("""t5-base""" ) _UpperCAmelCase = AutoFeatureExtractor.from_pretrained("""facebook/encodec_32khz""" , padding_side="""left""" ) _UpperCAmelCase = MusicgenProcessor(feature_extractor=_SCREAMING_SNAKE_CASE , tokenizer=_SCREAMING_SNAKE_CASE ) # set the appropriate bos/pad token ids _UpperCAmelCase = 2_0_4_8 _UpperCAmelCase = 2_0_4_8 # set other default generation config params _UpperCAmelCase = int(3_0 * audio_encoder.config.frame_rate ) _UpperCAmelCase = True _UpperCAmelCase = 3.0 if pytorch_dump_folder is not None: Path(_SCREAMING_SNAKE_CASE ).mkdir(exist_ok=_SCREAMING_SNAKE_CASE ) logger.info(F"""Saving model {checkpoint} to {pytorch_dump_folder}""" ) model.save_pretrained(_SCREAMING_SNAKE_CASE ) processor.save_pretrained(_SCREAMING_SNAKE_CASE ) if repo_id: logger.info(F"""Pushing model {checkpoint} to {repo_id}""" ) model.push_to_hub(_SCREAMING_SNAKE_CASE ) processor.push_to_hub(_SCREAMING_SNAKE_CASE ) if __name__ == "__main__": a : Tuple = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--checkpoint''', default='''small''', type=str, help='''Checkpoint size of the MusicGen model you\'d like to convert. Can be one of: `[\'small\', \'medium\', \'large\']`.''', ) parser.add_argument( '''--pytorch_dump_folder''', required=True, default=None, type=str, help='''Path to the output PyTorch model directory.''', ) parser.add_argument( '''--push_to_hub''', default=None, type=str, help='''Where to upload the converted model on the 🤗 hub.''' ) parser.add_argument( '''--device''', default='''cpu''', type=str, help='''Torch device to run the conversion, either cpu or cuda.''' ) a : int = parser.parse_args() convert_musicgen_checkpoint(args.checkpoint, args.pytorch_dump_folder, args.push_to_hub)
702
"""simple docstring""" import re import warnings from contextlib import contextmanager from ...processing_utils import ProcessorMixin class a_ ( _UpperCAmelCase ): a : Any = ['image_processor', 'tokenizer'] a : Optional[int] = 'AutoImageProcessor' a : Any = 'AutoTokenizer' def __init__( self : List[str] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : List[str]=None , **__UpperCamelCase : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = None if "feature_extractor" in kwargs: warnings.warn( """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`""" """ instead.""" , __UpperCamelCase , ) _UpperCAmelCase = kwargs.pop("""feature_extractor""" ) _UpperCAmelCase = 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__(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def __call__( self : Union[str, Any] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->List[str]: '''simple docstring''' if self._in_target_context_manager: return self.current_processor(*__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""images""" , __UpperCamelCase ) _UpperCAmelCase = kwargs.pop("""text""" , __UpperCamelCase ) if len(__UpperCamelCase ) > 0: _UpperCAmelCase = args[0] _UpperCAmelCase = args[1:] if images is None and text is None: raise ValueError("""You need to specify either an `images` or `text` input to process.""" ) if images is not None: _UpperCAmelCase = self.image_processor(__UpperCamelCase , *__UpperCamelCase , **__UpperCamelCase ) if text is not None: _UpperCAmelCase = self.tokenizer(__UpperCamelCase , **__UpperCamelCase ) if text is None: return inputs elif images is None: return encodings else: _UpperCAmelCase = encodings["""input_ids"""] return inputs def _snake_case ( self : Union[str, Any] , *__UpperCamelCase : int , **__UpperCamelCase : Tuple ) ->Tuple: '''simple docstring''' return self.tokenizer.batch_decode(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : Tuple , *__UpperCamelCase : int , **__UpperCamelCase : Union[str, Any] ) ->int: '''simple docstring''' return self.tokenizer.decode(*__UpperCamelCase , **__UpperCamelCase ) @contextmanager def _snake_case ( self : Tuple ) ->Union[str, Any]: '''simple docstring''' warnings.warn( """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """ """labels by using the argument `text` of the regular `__call__` method (either in the same call as """ """your images inputs, or in a separate call.""" ) _UpperCAmelCase = True _UpperCAmelCase = self.tokenizer yield _UpperCAmelCase = self.image_processor _UpperCAmelCase = False def _snake_case ( self : str , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any]=False , __UpperCamelCase : Union[str, Any]=None ) ->List[str]: '''simple docstring''' if added_vocab is None: _UpperCAmelCase = self.tokenizer.get_added_vocab() _UpperCAmelCase = {} while tokens: _UpperCAmelCase = re.search(r"""<s_(.*?)>""" , __UpperCamelCase , re.IGNORECASE ) if start_token is None: break _UpperCAmelCase = start_token.group(1 ) _UpperCAmelCase = re.search(rf"""</s_{key}>""" , __UpperCamelCase , re.IGNORECASE ) _UpperCAmelCase = start_token.group() if end_token is None: _UpperCAmelCase = tokens.replace(__UpperCamelCase , """""" ) else: _UpperCAmelCase = end_token.group() _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.escape(__UpperCamelCase ) _UpperCAmelCase = re.search(f"""{start_token_escaped}(.*?){end_token_escaped}""" , __UpperCamelCase , re.IGNORECASE ) if content is not None: _UpperCAmelCase = content.group(1 ).strip() if r"<s_" in content and r"</s_" in content: # non-leaf node _UpperCAmelCase = self.tokenajson(__UpperCamelCase , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if value: if len(__UpperCamelCase ) == 1: _UpperCAmelCase = value[0] _UpperCAmelCase = value else: # leaf nodes _UpperCAmelCase = [] for leaf in content.split(r"""<sep/>""" ): _UpperCAmelCase = leaf.strip() if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>": _UpperCAmelCase = leaf[1:-2] # for categorical special tokens output[key].append(__UpperCamelCase ) if len(output[key] ) == 1: _UpperCAmelCase = output[key][0] _UpperCAmelCase = tokens[tokens.find(__UpperCamelCase ) + len(__UpperCamelCase ) :].strip() if tokens[:6] == r"<sep/>": # non-leaf nodes return [output] + self.tokenajson(tokens[6:] , is_inner_value=__UpperCamelCase , added_vocab=__UpperCamelCase ) if len(__UpperCamelCase ): return [output] if is_inner_value else output else: return [] if is_inner_value else {"text_sequence": tokens} @property def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' warnings.warn( """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""" , __UpperCamelCase , ) return self.image_processor_class @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' warnings.warn( """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""" , __UpperCamelCase , ) return self.image_processor
19
0
"""simple docstring""" import os import socket from contextlib import contextmanager import torch from ..commands.config.default import write_basic_config # noqa: F401 from ..state import PartialState from .dataclasses import DistributedType from .imports import is_deepspeed_available, is_tpu_available from .transformer_engine import convert_model from .versions import is_torch_version if is_deepspeed_available(): from deepspeed import DeepSpeedEngine if is_tpu_available(check_device=False): import torch_xla.core.xla_model as xm def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" if is_torch_version("""<""" , """2.0.0""" ) or not hasattr(_A , """_dynamo""" ): return False return isinstance(_A , torch._dynamo.eval_frame.OptimizedModule ) def _UpperCamelCase ( _A , _A = True ) -> Any: """simple docstring""" _UpperCAmelCase = (torch.nn.parallel.DistributedDataParallel, torch.nn.DataParallel) _UpperCAmelCase = is_compiled_module(_A ) if is_compiled: _UpperCAmelCase = model _UpperCAmelCase = model._orig_mod if is_deepspeed_available(): options += (DeepSpeedEngine,) while isinstance(_A , _A ): _UpperCAmelCase = model.module if not keep_fpaa_wrapper: _UpperCAmelCase = getattr(_A , """forward""" ) _UpperCAmelCase = model.__dict__.pop("""_original_forward""" , _A ) if original_forward is not None: while hasattr(_A , """__wrapped__""" ): _UpperCAmelCase = forward.__wrapped__ if forward == original_forward: break _UpperCAmelCase = forward if getattr(_A , """_converted_to_transformer_engine""" , _A ): convert_model(_A , to_transformer_engine=_A ) if is_compiled: _UpperCAmelCase = model _UpperCAmelCase = compiled_model return model def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" PartialState().wait_for_everyone() def _UpperCamelCase ( _A , _A ) -> Union[str, Any]: """simple docstring""" if PartialState().distributed_type == DistributedType.TPU: xm.save(_A , _A ) elif PartialState().local_process_index == 0: torch.save(_A , _A ) @contextmanager def _UpperCamelCase ( **_A ) -> Optional[Any]: """simple docstring""" for key, value in kwargs.items(): _UpperCAmelCase = str(_A ) yield for key in kwargs: if key.upper() in os.environ: del os.environ[key.upper()] def _UpperCamelCase ( _A ) -> str: """simple docstring""" if not hasattr(_A , """__qualname__""" ) and not hasattr(_A , """__name__""" ): _UpperCAmelCase = getattr(_A , """__class__""" , _A ) if hasattr(_A , """__qualname__""" ): return obj.__qualname__ if hasattr(_A , """__name__""" ): return obj.__name__ return str(_A ) def _UpperCamelCase ( _A , _A ) -> int: """simple docstring""" for key, value in source.items(): if isinstance(_A , _A ): _UpperCAmelCase = destination.setdefault(_A , {} ) merge_dicts(_A , _A ) else: _UpperCAmelCase = value return destination def _UpperCamelCase ( _A = None ) -> bool: """simple docstring""" if port is None: _UpperCAmelCase = 2_9_5_0_0 with socket.socket(socket.AF_INET , socket.SOCK_STREAM ) as s: return s.connect_ex(("""localhost""", port) ) == 0
703
"""simple docstring""" import colorsys from PIL import Image # type: ignore def _UpperCamelCase ( _A , _A , _A ) -> float: """simple docstring""" _UpperCAmelCase = x _UpperCAmelCase = y for step in range(_A ): # noqa: B007 _UpperCAmelCase = a * a - b * b + x _UpperCAmelCase = 2 * a * b + y _UpperCAmelCase = a_new # divergence happens for all complex number with an absolute value # greater than 4 if a * a + b * b > 4: break return step / (max_step - 1) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return (2_5_5, 2_5_5, 2_5_5) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" if distance == 1: return (0, 0, 0) else: return tuple(round(i * 2_5_5 ) for i in colorsys.hsv_to_rgb(_A , 1 , 1 ) ) def _UpperCamelCase ( _A = 8_0_0 , _A = 6_0_0 , _A = -0.6 , _A = 0 , _A = 3.2 , _A = 5_0 , _A = True , ) -> Image.Image: """simple docstring""" _UpperCAmelCase = Image.new("""RGB""" , (image_width, image_height) ) _UpperCAmelCase = img.load() # loop through the image-coordinates for image_x in range(_A ): for image_y in range(_A ): # determine the figure-coordinates based on the image-coordinates _UpperCAmelCase = figure_width / image_width * image_height _UpperCAmelCase = figure_center_x + (image_x / image_width - 0.5) * figure_width _UpperCAmelCase = figure_center_y + (image_y / image_height - 0.5) * figure_height _UpperCAmelCase = get_distance(_A , _A , _A ) # color the corresponding pixel based on the selected coloring-function if use_distance_color_coding: _UpperCAmelCase = get_color_coded_rgb(_A ) else: _UpperCAmelCase = get_black_and_white_rgb(_A ) return img if __name__ == "__main__": import doctest doctest.testmod() # colored version, full figure a : List[str] = get_image() # uncomment for colored version, different section, zoomed in # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4, # figure_width = 0.8) # uncomment for black and white version, full figure # img = get_image(use_distance_color_coding = False) # uncomment to save the image # img.save("mandelbrot.png") img.show()
19
0
"""simple docstring""" def _UpperCamelCase ( ) -> list[list[int]]: """simple docstring""" return [list(range(1_0_0_0 - i , -1_0_0_0 - i , -1 ) ) for i in range(1_0_0_0 )] a : List[Any] = generate_large_matrix() a : Optional[int] = ( [[4, 3, 2, -1], [3, 2, 1, -1], [1, 1, -1, -2], [-1, -1, -2, -3]], [[3, 2], [1, 0]], [[7, 7, 6]], [[7, 7, 6], [-1, -2, -3]], grid, ) def _UpperCamelCase ( _A ) -> None: """simple docstring""" assert all(row == sorted(_lowercase , reverse=_lowercase ) for row in grid ) assert all(list(_lowercase ) == sorted(_lowercase , reverse=_lowercase ) for col in zip(*_lowercase ) ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = 0 _UpperCAmelCase = len(_lowercase ) - 1 # Edge cases such as no values or all numbers are negative. if not array or array[0] < 0: return 0 while right + 1 > left: _UpperCAmelCase = (left + right) // 2 _UpperCAmelCase = array[mid] # Num must be negative and the index must be greater than or equal to 0. if num < 0 and array[mid - 1] >= 0: return mid if num >= 0: _UpperCAmelCase = mid + 1 else: _UpperCAmelCase = mid - 1 # No negative numbers so return the last index of the array + 1 which is the length. return len(_lowercase ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = 0 _UpperCAmelCase = len(grid[0] ) for i in range(len(_lowercase ) ): _UpperCAmelCase = find_negative_index(grid[i][:bound] ) total += bound return (len(_lowercase ) * len(grid[0] )) - total def _UpperCamelCase ( _A ) -> int: """simple docstring""" return len([number for row in grid for number in row if number < 0] ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = 0 for row in grid: for i, number in enumerate(_lowercase ): if number < 0: total += len(_lowercase ) - i break return total def _UpperCamelCase ( ) -> None: """simple docstring""" from timeit import timeit print("""Running benchmarks""" ) _UpperCAmelCase = ( 'from __main__ import count_negatives_binary_search, ' 'count_negatives_brute_force, count_negatives_brute_force_with_break, grid' ) for func in ( "count_negatives_binary_search", # took 0.7727 seconds "count_negatives_brute_force_with_break", # took 4.6505 seconds "count_negatives_brute_force", # took 12.8160 seconds ): _UpperCAmelCase = timeit(F"""{func}(grid=grid)""" , setup=_lowercase , number=5_0_0 ) print(F"""{func}() took {time:0.4f} seconds""" ) if __name__ == "__main__": import doctest doctest.testmod() benchmark()
704
"""simple docstring""" from typing import Optional from torch import nn from .transformer_ad import TransformeraDModel, TransformeraDModelOutput class a_ ( nn.Module ): def __init__( self : List[str] , __UpperCamelCase : int = 16 , __UpperCamelCase : int = 88 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : int = 1 , __UpperCamelCase : float = 0.0 , __UpperCamelCase : int = 32 , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : bool = False , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : Optional[int] = None , __UpperCamelCase : str = "geglu" , __UpperCamelCase : Optional[int] = None , ) ->Dict: '''simple docstring''' super().__init__() _UpperCAmelCase = nn.ModuleList( [ TransformeraDModel( num_attention_heads=__UpperCamelCase , attention_head_dim=__UpperCamelCase , in_channels=__UpperCamelCase , num_layers=__UpperCamelCase , dropout=__UpperCamelCase , norm_num_groups=__UpperCamelCase , cross_attention_dim=__UpperCamelCase , attention_bias=__UpperCamelCase , sample_size=__UpperCamelCase , num_vector_embeds=__UpperCamelCase , activation_fn=__UpperCamelCase , num_embeds_ada_norm=__UpperCamelCase , ) for _ in range(2 ) ] ) # Variables that can be set by a pipeline: # The ratio of transformer1 to transformer2's output states to be combined during inference _UpperCAmelCase = 0.5 # The shape of `encoder_hidden_states` is expected to be # `(batch_size, condition_lengths[0]+condition_lengths[1], num_features)` _UpperCAmelCase = [77, 2_57] # Which transformer to use to encode which condition. # E.g. `(1, 0)` means that we'll use `transformers[1](conditions[0])` and `transformers[0](conditions[1])` _UpperCAmelCase = [1, 0] def _snake_case ( self : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : bool = True , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = hidden_states _UpperCAmelCase = [] _UpperCAmelCase = 0 # attention_mask is not used yet for i in range(2 ): # for each of the two transformers, pass the corresponding condition tokens _UpperCAmelCase = encoder_hidden_states[:, tokens_start : tokens_start + self.condition_lengths[i]] _UpperCAmelCase = self.transformer_index_for_condition[i] _UpperCAmelCase = self.transformers[transformer_index]( __UpperCamelCase , encoder_hidden_states=__UpperCamelCase , timestep=__UpperCamelCase , cross_attention_kwargs=__UpperCamelCase , return_dict=__UpperCamelCase , )[0] encoded_states.append(encoded_state - input_states ) tokens_start += self.condition_lengths[i] _UpperCAmelCase = encoded_states[0] * self.mix_ratio + encoded_states[1] * (1 - self.mix_ratio) _UpperCAmelCase = output_states + input_states if not return_dict: return (output_states,) return TransformeraDModelOutput(sample=__UpperCamelCase )
19
0
"""simple docstring""" from math import factorial a : Tuple = {str(d): factorial(d) for d in range(1_0)} def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" return sum(DIGIT_FACTORIAL[d] for d in str(_A ) ) def _UpperCamelCase ( ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = 7 * factorial(9 ) + 1 return sum(i for i in range(3 , _A ) if sum_of_digit_factorial(_A ) == i ) if __name__ == "__main__": print(F"{solution() = }")
705
"""simple docstring""" import argparse import torch from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert from transformers.utils import logging logging.set_verbosity_info() def _UpperCamelCase ( _A , _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = LxmertConfig.from_json_file(_A ) print(F"""Building PyTorch model from configuration: {config}""" ) _UpperCAmelCase = LxmertForPreTraining(_A ) # Load weights from tf checkpoint load_tf_weights_in_lxmert(_A , _A , _A ) # Save pytorch-model print(F"""Save PyTorch model to {pytorch_dump_path}""" ) torch.save(model.state_dict() , _A ) if __name__ == "__main__": a : Dict = argparse.ArgumentParser() # Required parameters parser.add_argument( '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.''' ) parser.add_argument( '''--config_file''', default=None, type=str, required=True, help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''', ) parser.add_argument( '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.''' ) a : Union[str, Any] = parser.parse_args() convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
19
0
a : Any = 8.31_44_62 # Unit - J mol-1 K-1 def _UpperCamelCase ( _A , _A , _A ) -> float: """simple docstring""" if moles < 0 or kelvin < 0 or volume < 0: raise ValueError("""Invalid inputs. Enter positive value.""" ) return moles * kelvin * UNIVERSAL_GAS_CONSTANT / volume def _UpperCamelCase ( _A , _A , _A ) -> float: """simple docstring""" if moles < 0 or kelvin < 0 or pressure < 0: raise ValueError("""Invalid inputs. Enter positive value.""" ) return moles * kelvin * UNIVERSAL_GAS_CONSTANT / pressure if __name__ == "__main__": from doctest import testmod testmod()
706
"""simple docstring""" import argparse import os import re import packaging.version a : str = '''examples/''' a : List[str] = { '''examples''': (re.compile(r'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''), '''init''': (re.compile(r'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''), '''setup''': (re.compile(r'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), r'''\1version="VERSION",'''), '''doc''': (re.compile(r'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''), } a : Tuple = { '''init''': '''src/diffusers/__init__.py''', '''setup''': '''setup.py''', } a : List[str] = '''README.md''' def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase ,_UpperCAmelCase = REPLACE_PATTERNS[pattern] _UpperCAmelCase = replace.replace("""VERSION""" , _A ) _UpperCAmelCase = re_pattern.sub(_A , _A ) with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.write(_A ) def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" for folder, directories, fnames in os.walk(_A ): # Removing some of the folders with non-actively maintained examples from the walk if "research_projects" in directories: directories.remove("""research_projects""" ) if "legacy" in directories: directories.remove("""legacy""" ) for fname in fnames: if fname.endswith(""".py""" ): update_version_in_file(os.path.join(_A , _A ) , _A , pattern="""examples""" ) def _UpperCamelCase ( _A , _A=False ) -> int: """simple docstring""" for pattern, fname in REPLACE_FILES.items(): update_version_in_file(_A , _A , _A ) if not patch: update_version_in_examples(_A ) def _UpperCamelCase ( ) -> Any: """simple docstring""" _UpperCAmelCase = """🤗 Transformers currently provides the following architectures""" _UpperCAmelCase = """1. Want to contribute a new model?""" with open(_A , """r""" , encoding="""utf-8""" , newline="""\n""" ) as f: _UpperCAmelCase = f.readlines() # Find the start of the list. _UpperCAmelCase = 0 while not lines[start_index].startswith(_start_prompt ): start_index += 1 start_index += 1 _UpperCAmelCase = start_index # Update the lines in the model list. while not lines[index].startswith(_end_prompt ): if lines[index].startswith("""1.""" ): _UpperCAmelCase = lines[index].replace( """https://huggingface.co/docs/diffusers/main/model_doc""" , """https://huggingface.co/docs/diffusers/model_doc""" , ) index += 1 with open(_A , """w""" , encoding="""utf-8""" , newline="""\n""" ) as f: f.writelines(_A ) def _UpperCamelCase ( ) -> Optional[int]: """simple docstring""" with open(REPLACE_FILES["""init"""] , """r""" ) as f: _UpperCAmelCase = f.read() _UpperCAmelCase = REPLACE_PATTERNS["""init"""][0].search(_A ).groups()[0] return packaging.version.parse(_A ) def _UpperCamelCase ( _A=False ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() if patch and default_version.is_devrelease: raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" ) if default_version.is_devrelease: _UpperCAmelCase = default_version.base_version elif patch: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}""" else: _UpperCAmelCase = F"""{default_version.major}.{default_version.minor + 1}.0""" # Now let's ask nicely if that's the right one. _UpperCAmelCase = input(F"""Which version are you releasing? [{default_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = default_version print(F"""Updating version to {version}.""" ) global_version_update(_A , patch=_A ) def _UpperCamelCase ( ) -> List[Any]: """simple docstring""" _UpperCAmelCase = get_version() _UpperCAmelCase = F"""{current_version.major}.{current_version.minor + 1}.0.dev0""" _UpperCAmelCase = current_version.base_version # Check with the user we got that right. _UpperCAmelCase = input(F"""Which version are we developing now? [{dev_version}]""" ) if len(_A ) == 0: _UpperCAmelCase = dev_version print(F"""Updating version to {version}.""" ) global_version_update(_A ) # print("Cleaning main README, don't forget to run `make fix-copies`.") # clean_main_ref_in_model_list() if __name__ == "__main__": a : Dict = argparse.ArgumentParser() parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''') parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''') a : Tuple = parser.parse_args() if not args.post_release: pre_release_work(patch=args.patch) elif args.patch: print('''Nothing to do after a patch :-)''') else: post_release_work()
19
0
"""simple docstring""" import copy import os from typing import Union from ...configuration_utils import PretrainedConfig from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES from ...utils import logging from ..auto import CONFIG_MAPPING a : Tuple = logging.get_logger(__name__) a : List[Any] = { "salesforce/blip2-opt-2.7b": "https://huggingface.co/salesforce/blip2-opt-2.7b/resolve/main/config.json", } class a_ ( UpperCAmelCase_ ): a : List[Any] = 'blip_2_vision_model' def __init__( self : List[str] , __UpperCamelCase : str=14_08 , __UpperCamelCase : Any=61_44 , __UpperCamelCase : List[Any]=39 , __UpperCamelCase : Optional[int]=16 , __UpperCamelCase : Optional[Any]=2_24 , __UpperCamelCase : Tuple=14 , __UpperCamelCase : Union[str, Any]="gelu" , __UpperCamelCase : List[Any]=0.0_0_0_0_1 , __UpperCamelCase : List[str]=0.0 , __UpperCamelCase : str=1e-10 , __UpperCamelCase : Union[str, Any]=True , **__UpperCamelCase : str , ) ->Optional[int]: '''simple docstring''' super().__init__(**_lowercase ) _UpperCAmelCase = hidden_size _UpperCAmelCase = intermediate_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = patch_size _UpperCAmelCase = image_size _UpperCAmelCase = initializer_range _UpperCAmelCase = attention_dropout _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = hidden_act _UpperCAmelCase = qkv_bias @classmethod def _snake_case ( cls : Any , __UpperCamelCase : int , **__UpperCamelCase : Dict ) ->"PretrainedConfig": '''simple docstring''' cls._set_token_in_kwargs(_lowercase ) _UpperCAmelCase = cls.get_config_dict(_lowercase , **_lowercase ) # get the vision config dict if we are loading from Blip2Config if config_dict.get("""model_type""" ) == "blip-2": _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(_lowercase , **_lowercase ) class a_ ( UpperCAmelCase_ ): a : int = 'blip_2_qformer' def __init__( self : List[Any] , __UpperCamelCase : Union[str, Any]=3_05_22 , __UpperCamelCase : Union[str, Any]=7_68 , __UpperCamelCase : Union[str, Any]=12 , __UpperCamelCase : List[Any]=12 , __UpperCamelCase : Union[str, Any]=30_72 , __UpperCamelCase : Tuple="gelu" , __UpperCamelCase : Union[str, Any]=0.1 , __UpperCamelCase : str=0.1 , __UpperCamelCase : List[str]=5_12 , __UpperCamelCase : List[str]=0.0_2 , __UpperCamelCase : Tuple=1e-12 , __UpperCamelCase : str=0 , __UpperCamelCase : Tuple="absolute" , __UpperCamelCase : str=2 , __UpperCamelCase : int=14_08 , **__UpperCamelCase : str , ) ->Any: '''simple docstring''' super().__init__(pad_token_id=_lowercase , **_lowercase ) _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = position_embedding_type _UpperCAmelCase = cross_attention_frequency _UpperCAmelCase = encoder_hidden_size @classmethod def _snake_case ( cls : int , __UpperCamelCase : str , **__UpperCamelCase : List[Any] ) ->"PretrainedConfig": '''simple docstring''' cls._set_token_in_kwargs(_lowercase ) _UpperCAmelCase = cls.get_config_dict(_lowercase , **_lowercase ) # get the qformer config dict if we are loading from Blip2Config if config_dict.get("""model_type""" ) == "blip-2": _UpperCAmelCase = config_dict['qformer_config'] if "model_type" in config_dict and hasattr(cls , """model_type""" ) and config_dict["model_type"] != cls.model_type: logger.warning( f"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """ f"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""" ) return cls.from_dict(_lowercase , **_lowercase ) class a_ ( UpperCAmelCase_ ): a : Optional[Any] = 'blip-2' a : str = True def __init__( self : Dict , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : int=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Dict=32 , **__UpperCamelCase : Union[str, Any] ) ->int: '''simple docstring''' super().__init__(**_lowercase ) if vision_config is None: _UpperCAmelCase = {} logger.info("""vision_config is None. initializing the Blip2VisionConfig with default values.""" ) if qformer_config is None: _UpperCAmelCase = {} logger.info("""qformer_config is None. Initializing the Blip2QFormerConfig with default values.""" ) if text_config is None: _UpperCAmelCase = {} logger.info("""text_config is None. Initializing the text config with default values (`OPTConfig`).""" ) _UpperCAmelCase = BlipaVisionConfig(**_lowercase ) _UpperCAmelCase = BlipaQFormerConfig(**_lowercase ) _UpperCAmelCase = text_config['model_type'] if 'model_type' in text_config else 'opt' _UpperCAmelCase = CONFIG_MAPPING[text_model_type](**_lowercase ) _UpperCAmelCase = self.text_config.tie_word_embeddings _UpperCAmelCase = self.text_config.is_encoder_decoder _UpperCAmelCase = num_query_tokens _UpperCAmelCase = self.vision_config.hidden_size _UpperCAmelCase = self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES _UpperCAmelCase = 1.0 _UpperCAmelCase = 0.0_2 @classmethod def _snake_case ( cls : Union[str, Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , **__UpperCamelCase : List[str] , ) ->Optional[int]: '''simple docstring''' return cls( vision_config=vision_config.to_dict() , qformer_config=qformer_config.to_dict() , text_config=text_config.to_dict() , **_lowercase , ) def _snake_case ( self : List[str] ) ->Any: '''simple docstring''' _UpperCAmelCase = copy.deepcopy(self.__dict__ ) _UpperCAmelCase = self.vision_config.to_dict() _UpperCAmelCase = self.qformer_config.to_dict() _UpperCAmelCase = self.text_config.to_dict() _UpperCAmelCase = self.__class__.model_type return output
707
"""simple docstring""" from __future__ import annotations def _UpperCamelCase ( _A ) -> None: """simple docstring""" create_state_space_tree(_A , [] , 0 , [0 for i in range(len(_A ) )] ) def _UpperCamelCase ( _A , _A , _A , _A , ) -> None: """simple docstring""" if index == len(_A ): print(_A ) return for i in range(len(_A ) ): if not index_used[i]: current_sequence.append(sequence[i] ) _UpperCAmelCase = True create_state_space_tree(_A , _A , index + 1 , _A ) current_sequence.pop() _UpperCAmelCase = False a : list[int | str] = [3, 1, 2, 4] generate_all_permutations(sequence) a : list[int | str] = ["A", "B", "C"] generate_all_permutations(sequence_a)
19
0
"""simple docstring""" import sys a : Union[str, Any] = ( '''73167176531330624919225119674426574742355349194934''' '''96983520312774506326239578318016984801869478851843''' '''85861560789112949495459501737958331952853208805511''' '''12540698747158523863050715693290963295227443043557''' '''66896648950445244523161731856403098711121722383113''' '''62229893423380308135336276614282806444486645238749''' '''30358907296290491560440772390713810515859307960866''' '''70172427121883998797908792274921901699720888093776''' '''65727333001053367881220235421809751254540594752243''' '''52584907711670556013604839586446706324415722155397''' '''53697817977846174064955149290862569321978468622482''' '''83972241375657056057490261407972968652414535100474''' '''82166370484403199890008895243450658541227588666881''' '''16427171479924442928230863465674813919123162824586''' '''17866458359124566529476545682848912883142607690042''' '''24219022671055626321111109370544217506941658960408''' '''07198403850962455444362981230987879927244284909188''' '''84580156166097919133875499200524063689912560717606''' '''05886116467109405077541002256983155200055935729725''' '''71636269561882670428252483600823257530420752963450''' ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = 1 for digit in s: product *= int(__A ) return product def _UpperCamelCase ( _A = N ) -> int: """simple docstring""" _UpperCAmelCase = -sys.maxsize - 1 _UpperCAmelCase = n[:1_3] _UpperCAmelCase = 1_3 while cur_index < len(__A ) - 1_3: if int(n[cur_index] ) >= int(substr[0] ): _UpperCAmelCase = substr[1:] + n[cur_index] cur_index += 1 else: _UpperCAmelCase = max(__A , str_eval(__A ) ) _UpperCAmelCase = n[cur_index : cur_index + 1_3] cur_index += 1_3 return largest_product if __name__ == "__main__": print(F"{solution() = }")
708
"""simple docstring""" import inspect import unittest from transformers import DPTConfig from transformers.file_utils import is_torch_available, is_vision_available from transformers.models.auto import get_values from transformers.testing_utils import require_torch, require_vision, slow, torch_device 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 MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST if is_vision_available(): from PIL import Image from transformers import DPTImageProcessor class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int]=2 , __UpperCamelCase : int=32 , __UpperCamelCase : Tuple=16 , __UpperCamelCase : Dict=3 , __UpperCamelCase : Dict=True , __UpperCamelCase : Optional[Any]=True , __UpperCamelCase : Optional[Any]=32 , __UpperCamelCase : Any=4 , __UpperCamelCase : Optional[int]=[0, 1, 2, 3] , __UpperCamelCase : str=4 , __UpperCamelCase : Optional[Any]=37 , __UpperCamelCase : str="gelu" , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : Any=0.1 , __UpperCamelCase : Any=0.0_2 , __UpperCamelCase : Optional[int]=3 , __UpperCamelCase : int=[1, 3_84, 24, 24] , __UpperCamelCase : Union[str, Any]=True , __UpperCamelCase : Any=None , ) ->Optional[Any]: '''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 = backbone_out_indices _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = num_labels _UpperCAmelCase = backbone_featmap_shape _UpperCAmelCase = scope _UpperCAmelCase = is_hybrid # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token) _UpperCAmelCase = (image_size // patch_size) ** 2 _UpperCAmelCase = num_patches + 1 def _snake_case ( self : str ) ->int: '''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.image_size, self.image_size] , self.num_labels ) _UpperCAmelCase = self.get_config() return config, pixel_values, labels def _snake_case ( self : List[str] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = { """global_padding""": """same""", """layer_type""": """bottleneck""", """depths""": [3, 4, 9], """out_features""": ["""stage1""", """stage2""", """stage3"""], """embedding_dynamic_padding""": True, """hidden_sizes""": [96, 1_92, 3_84, 7_68], """num_groups""": 2, } return DPTConfig( 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 , backbone_out_indices=self.backbone_out_indices , 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 , is_hybrid=self.is_hybrid , backbone_config=__UpperCamelCase , backbone_featmap_shape=self.backbone_featmap_shape , ) def _snake_case ( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = DPTModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.last_hidden_state.shape , (self.batch_size, self.seq_length, self.hidden_size) ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : str , __UpperCamelCase : List[Any] ) ->int: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase ) self.parent.assertEqual(result.predicted_depth.shape , (self.batch_size, self.image_size, self.image_size) ) def _snake_case ( self : Any , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = self.num_labels _UpperCAmelCase = DPTForSemanticSegmentation(__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model(__UpperCamelCase , labels=__UpperCamelCase ) self.parent.assertEqual( result.logits.shape , (self.batch_size, self.num_labels, self.image_size, self.image_size) ) def _snake_case ( self : Tuple ) ->Any: '''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 a_ ( _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : Dict = (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else () a : int = ( { 'depth-estimation': DPTForDepthEstimation, 'feature-extraction': DPTModel, 'image-segmentation': DPTForSemanticSegmentation, } if is_torch_available() else {} ) a : str = False a : List[str] = False a : Dict = False def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = DPTModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase , has_text_modality=__UpperCamelCase , hidden_size=37 ) def _snake_case ( self : Optional[int] ) ->Any: '''simple docstring''' self.config_tester.run_common_tests() @unittest.skip(reason="""DPT does not use inputs_embeds""" ) def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' pass def _snake_case ( self : int ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) self.assertIsInstance(model.get_input_embeddings() , (nn.Module) ) _UpperCAmelCase = model.get_output_embeddings() self.assertTrue(x is None or isinstance(__UpperCamelCase , nn.Linear ) ) def _snake_case ( self : Optional[int] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = inspect.signature(model.forward ) # signature.parameters is an OrderedDict => so arg_names order is deterministic _UpperCAmelCase = [*signature.parameters.keys()] _UpperCAmelCase = ["""pixel_values"""] self.assertListEqual(arg_names[:1] , __UpperCamelCase ) def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model(*__UpperCamelCase ) def _snake_case ( self : str ) ->int: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_depth_estimation(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_for_semantic_segmentation(*__UpperCamelCase ) def _snake_case ( self : str ) ->Any: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ): continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' for model_class in self.all_model_classes: if model_class.__name__ == "DPTForDepthEstimation": continue _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = False _UpperCAmelCase = True if model_class in get_values(__UpperCamelCase ) or not model_class.supports_gradient_checkpointing: continue _UpperCAmelCase = model_class(__UpperCamelCase ) model.to(__UpperCamelCase ) model.gradient_checkpointing_enable() model.train() _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase , return_labels=__UpperCamelCase ) _UpperCAmelCase = model(**__UpperCamelCase ).loss loss.backward() def _snake_case ( self : Tuple ) ->List[str]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = _config_zero_init(__UpperCamelCase ) for model_class in self.all_model_classes: _UpperCAmelCase = model_class(config=__UpperCamelCase ) # Skip the check for the backbone _UpperCAmelCase = [] for name, module in model.named_modules(): if module.__class__.__name__ == "DPTViTHybridEmbeddings": _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""" , ) @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" ) def _snake_case ( self : Dict ) ->Tuple: '''simple docstring''' pass @slow def _snake_case ( self : Optional[int] ) ->List[Any]: '''simple docstring''' for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]: _UpperCAmelCase = DPTModel.from_pretrained(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() _UpperCAmelCase = """add""" with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = DPTForDepthEstimation(__UpperCamelCase ) def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" ) return image @require_torch @require_vision @slow class a_ ( unittest.TestCase ): def _snake_case ( self : Any ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = DPTImageProcessor.from_pretrained("""Intel/dpt-hybrid-midas""" ) _UpperCAmelCase = DPTForDepthEstimation.from_pretrained("""Intel/dpt-hybrid-midas""" ).to(__UpperCamelCase ) _UpperCAmelCase = prepare_img() _UpperCAmelCase = image_processor(images=__UpperCamelCase , return_tensors="""pt""" ).to(__UpperCamelCase ) # forward pass with torch.no_grad(): _UpperCAmelCase = model(**__UpperCamelCase ) _UpperCAmelCase = outputs.predicted_depth # verify the predicted depth _UpperCAmelCase = torch.Size((1, 3_84, 3_84) ) self.assertEqual(predicted_depth.shape , __UpperCamelCase ) _UpperCAmelCase = torch.tensor( [[[5.6_4_3_7, 5.6_1_4_6, 5.6_5_1_1], [5.4_3_7_1, 5.5_6_4_9, 5.5_9_5_8], [5.5_2_1_5, 5.5_1_8_4, 5.5_2_9_3]]] ).to(__UpperCamelCase ) self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 1_00 , __UpperCamelCase , atol=1e-4 ) )
19
0
"""simple docstring""" import pickle import numpy as np from matplotlib import pyplot as plt class a_ : def __init__( self : Dict , __UpperCamelCase : str , __UpperCamelCase : Dict , __UpperCamelCase : List[str] , __UpperCamelCase : Any , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Any=0.2 , __UpperCamelCase : Dict=0.2 ) ->Any: '''simple docstring''' _UpperCAmelCase = bp_numa _UpperCAmelCase = bp_numa _UpperCAmelCase = bp_numa _UpperCAmelCase = conva_get[:2] _UpperCAmelCase = conva_get[2] _UpperCAmelCase = size_pa _UpperCAmelCase = rate_w _UpperCAmelCase = rate_t _UpperCAmelCase = [ np.mat(-1 * np.random.rand(self.conva[0] , self.conva[0] ) + 0.5 ) for i in range(self.conva[1] ) ] _UpperCAmelCase = np.mat(-1 * np.random.rand(self.num_bpa , self.num_bpa ) + 0.5 ) _UpperCAmelCase = np.mat(-1 * np.random.rand(self.num_bpa , self.num_bpa ) + 0.5 ) _UpperCAmelCase = -2 * np.random.rand(self.conva[1] ) + 1 _UpperCAmelCase = -2 * np.random.rand(self.num_bpa ) + 1 _UpperCAmelCase = -2 * np.random.rand(self.num_bpa ) + 1 def _snake_case ( self : List[Any] , __UpperCamelCase : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = { """num_bp1""": self.num_bpa, """num_bp2""": self.num_bpa, """num_bp3""": self.num_bpa, """conv1""": self.conva, """step_conv1""": self.step_conva, """size_pooling1""": self.size_poolinga, """rate_weight""": self.rate_weight, """rate_thre""": self.rate_thre, """w_conv1""": self.w_conva, """wkj""": self.wkj, """vji""": self.vji, """thre_conv1""": self.thre_conva, """thre_bp2""": self.thre_bpa, """thre_bp3""": self.thre_bpa, } with open(_lowerCAmelCase , """wb""" ) as f: pickle.dump(_lowerCAmelCase , _lowerCAmelCase ) print(f"""Model saved: {save_path}""" ) @classmethod def _snake_case ( cls : Dict , __UpperCamelCase : List[Any] ) ->List[str]: '''simple docstring''' with open(_lowerCAmelCase , """rb""" ) as f: _UpperCAmelCase = pickle.load(_lowerCAmelCase ) # noqa: S301 _UpperCAmelCase = model_dic.get("""conv1""" ) conv_get.append(model_dic.get("""step_conv1""" ) ) _UpperCAmelCase = model_dic.get("""size_pooling1""" ) _UpperCAmelCase = model_dic.get("""num_bp1""" ) _UpperCAmelCase = model_dic.get("""num_bp2""" ) _UpperCAmelCase = model_dic.get("""num_bp3""" ) _UpperCAmelCase = model_dic.get("""rate_weight""" ) _UpperCAmelCase = model_dic.get("""rate_thre""" ) # create model instance _UpperCAmelCase = CNN(_lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase , _lowerCAmelCase ) # modify model parameter _UpperCAmelCase = model_dic.get("""w_conv1""" ) _UpperCAmelCase = model_dic.get("""wkj""" ) _UpperCAmelCase = model_dic.get("""vji""" ) _UpperCAmelCase = model_dic.get("""thre_conv1""" ) _UpperCAmelCase = model_dic.get("""thre_bp2""" ) _UpperCAmelCase = model_dic.get("""thre_bp3""" ) return conv_ins def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' return 1 / (1 + np.exp(-1 * x )) def _snake_case ( self : str , __UpperCamelCase : List[str] ) ->Tuple: '''simple docstring''' return round(_lowerCAmelCase , 3 ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Tuple , __UpperCamelCase : Dict , __UpperCamelCase : int , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = convs[0] _UpperCAmelCase = convs[1] _UpperCAmelCase = np.shape(_lowerCAmelCase )[0] # get the data slice of original image data, data_focus _UpperCAmelCase = [] for i_focus in range(0 , size_data - size_conv + 1 , _lowerCAmelCase ): for j_focus in range(0 , size_data - size_conv + 1 , _lowerCAmelCase ): _UpperCAmelCase = data[ i_focus : i_focus + size_conv, j_focus : j_focus + size_conv ] data_focus.append(_lowerCAmelCase ) # calculate the feature map of every single kernel, and saved as list of matrix _UpperCAmelCase = [] _UpperCAmelCase = int((size_data - size_conv) / conv_step + 1 ) for i_map in range(_lowerCAmelCase ): _UpperCAmelCase = [] for i_focus in range(len(_lowerCAmelCase ) ): _UpperCAmelCase = ( np.sum(np.multiply(data_focus[i_focus] , w_convs[i_map] ) ) - thre_convs[i_map] ) featuremap.append(self.sig(_lowerCAmelCase ) ) _UpperCAmelCase = np.asmatrix(_lowerCAmelCase ).reshape( _lowerCAmelCase , _lowerCAmelCase ) data_featuremap.append(_lowerCAmelCase ) # expanding the data slice to One dimenssion _UpperCAmelCase = [] for each_focus in data_focus: focusa_list.extend(self.Expand_Mat(_lowerCAmelCase ) ) _UpperCAmelCase = np.asarray(_lowerCAmelCase ) return focus_list, data_featuremap def _snake_case ( self : Union[str, Any] , __UpperCamelCase : Tuple , __UpperCamelCase : Any , __UpperCamelCase : int="average_pool" ) ->Any: '''simple docstring''' _UpperCAmelCase = len(featuremaps[0] ) _UpperCAmelCase = int(size_map / size_pooling ) _UpperCAmelCase = [] for i_map in range(len(_lowerCAmelCase ) ): _UpperCAmelCase = featuremaps[i_map] _UpperCAmelCase = [] for i_focus in range(0 , _lowerCAmelCase , _lowerCAmelCase ): for j_focus in range(0 , _lowerCAmelCase , _lowerCAmelCase ): _UpperCAmelCase = feature_map[ i_focus : i_focus + size_pooling, j_focus : j_focus + size_pooling, ] if pooling_type == "average_pool": # average pooling map_pooled.append(np.average(_lowerCAmelCase ) ) elif pooling_type == "max_pooling": # max pooling map_pooled.append(np.max(_lowerCAmelCase ) ) _UpperCAmelCase = np.asmatrix(_lowerCAmelCase ).reshape(_lowerCAmelCase , _lowerCAmelCase ) featuremap_pooled.append(_lowerCAmelCase ) return featuremap_pooled def _snake_case ( self : int , __UpperCamelCase : str ) ->Tuple: '''simple docstring''' _UpperCAmelCase = [] for i in range(len(_lowerCAmelCase ) ): _UpperCAmelCase = np.shape(data[i] ) _UpperCAmelCase = data[i].reshape(1 , shapes[0] * shapes[1] ) _UpperCAmelCase = data_listed.getA().tolist()[0] data_expanded.extend(_lowerCAmelCase ) _UpperCAmelCase = np.asarray(_lowerCAmelCase ) return data_expanded def _snake_case ( self : Union[str, Any] , __UpperCamelCase : str ) ->Any: '''simple docstring''' _UpperCAmelCase = np.asarray(_lowerCAmelCase ) _UpperCAmelCase = np.shape(_lowerCAmelCase ) _UpperCAmelCase = data_mat.reshape(1 , shapes[0] * shapes[1] ) return data_expanded def _snake_case ( self : List[Any] , __UpperCamelCase : int , __UpperCamelCase : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple , __UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = [] _UpperCAmelCase = 0 for i_map in range(_lowerCAmelCase ): _UpperCAmelCase = np.ones((size_map, size_map) ) for i in range(0 , _lowerCAmelCase , _lowerCAmelCase ): for j in range(0 , _lowerCAmelCase , _lowerCAmelCase ): _UpperCAmelCase = pd_pool[ i_pool ] _UpperCAmelCase = i_pool + 1 _UpperCAmelCase = np.multiply( _lowerCAmelCase , np.multiply(out_map[i_map] , (1 - out_map[i_map]) ) ) pd_all.append(_lowerCAmelCase ) return pd_all def _snake_case ( self : str , __UpperCamelCase : Tuple , __UpperCamelCase : str , __UpperCamelCase : Optional[Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Optional[int]=bool ) ->Optional[Any]: '''simple docstring''' print("""----------------------Start Training-------------------------""" ) print((""" - - Shape: Train_Data """, np.shape(_lowerCAmelCase )) ) print((""" - - Shape: Teach_Data """, np.shape(_lowerCAmelCase )) ) _UpperCAmelCase = 0 _UpperCAmelCase = [] _UpperCAmelCase = 1_00_00 while rp < n_repeat and mse >= error_accuracy: _UpperCAmelCase = 0 print(f"""-------------Learning Time {rp}--------------""" ) for p in range(len(_lowerCAmelCase ) ): # print('------------Learning Image: %d--------------'%p) _UpperCAmelCase = np.asmatrix(datas_train[p] ) _UpperCAmelCase = np.asarray(datas_teach[p] ) _UpperCAmelCase ,_UpperCAmelCase = self.convolute( _lowerCAmelCase , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) _UpperCAmelCase = self.pooling(_lowerCAmelCase , self.size_poolinga ) _UpperCAmelCase = np.shape(_lowerCAmelCase ) _UpperCAmelCase = self._expand(_lowerCAmelCase ) _UpperCAmelCase = data_bp_input _UpperCAmelCase = np.dot(_lowerCAmelCase , self.vji.T ) - self.thre_bpa _UpperCAmelCase = self.sig(_lowerCAmelCase ) _UpperCAmelCase = np.dot(_lowerCAmelCase , self.wkj.T ) - self.thre_bpa _UpperCAmelCase = self.sig(_lowerCAmelCase ) # --------------Model Leaning ------------------------ # calculate error and gradient--------------- _UpperCAmelCase = np.multiply( (data_teach - bp_outa) , np.multiply(_lowerCAmelCase , (1 - bp_outa) ) ) _UpperCAmelCase = np.multiply( np.dot(_lowerCAmelCase , self.wkj ) , np.multiply(_lowerCAmelCase , (1 - bp_outa) ) ) _UpperCAmelCase = np.dot(_lowerCAmelCase , self.vji ) _UpperCAmelCase = pd_i_all / (self.size_poolinga * self.size_poolinga) _UpperCAmelCase = pd_conva_pooled.T.getA().tolist() _UpperCAmelCase = self._calculate_gradient_from_pool( _lowerCAmelCase , _lowerCAmelCase , shape_featuremapa[0] , shape_featuremapa[1] , self.size_poolinga , ) # weight and threshold learning process--------- # convolution layer for k_conv in range(self.conva[1] ): _UpperCAmelCase = self._expand_mat(pd_conva_all[k_conv] ) _UpperCAmelCase = self.rate_weight * np.dot(_lowerCAmelCase , _lowerCAmelCase ) _UpperCAmelCase = self.w_conva[k_conv] + delta_w.reshape( (self.conva[0], self.conva[0]) ) _UpperCAmelCase = ( self.thre_conva[k_conv] - np.sum(pd_conva_all[k_conv] ) * self.rate_thre ) # all connected layer _UpperCAmelCase = self.wkj + pd_k_all.T * bp_outa * self.rate_weight _UpperCAmelCase = self.vji + pd_j_all.T * bp_outa * self.rate_weight _UpperCAmelCase = self.thre_bpa - pd_k_all * self.rate_thre _UpperCAmelCase = self.thre_bpa - pd_j_all * self.rate_thre # calculate the sum error of all single image _UpperCAmelCase = np.sum(abs(data_teach - bp_outa ) ) error_count += errors # print(' ----Teach ',data_teach) # print(' ----BP_output ',bp_out3) _UpperCAmelCase = rp + 1 _UpperCAmelCase = error_count / patterns all_mse.append(_lowerCAmelCase ) def draw_error(): _UpperCAmelCase = [error_accuracy for i in range(int(n_repeat * 1.2 ) )] plt.plot(_lowerCAmelCase , """+-""" ) plt.plot(_lowerCAmelCase , """r--""" ) plt.xlabel("""Learning Times""" ) plt.ylabel("""All_mse""" ) plt.grid(_lowerCAmelCase , alpha=0.5 ) plt.show() print("""------------------Training Complished---------------------""" ) print((""" - - Training epoch: """, rp, f""" - - Mse: {mse:.6f}""") ) if draw_e: draw_error() return mse def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = [] print("""-------------------Start Testing-------------------------""" ) print((""" - - Shape: Test_Data """, np.shape(_lowerCAmelCase )) ) for p in range(len(_lowerCAmelCase ) ): _UpperCAmelCase = np.asmatrix(datas_test[p] ) _UpperCAmelCase ,_UpperCAmelCase = self.convolute( _lowerCAmelCase , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) _UpperCAmelCase = self.pooling(_lowerCAmelCase , self.size_poolinga ) _UpperCAmelCase = self._expand(_lowerCAmelCase ) _UpperCAmelCase = data_bp_input _UpperCAmelCase = bp_outa * self.vji.T - self.thre_bpa _UpperCAmelCase = self.sig(_lowerCAmelCase ) _UpperCAmelCase = bp_outa * self.wkj.T - self.thre_bpa _UpperCAmelCase = self.sig(_lowerCAmelCase ) produce_out.extend(bp_outa.getA().tolist() ) _UpperCAmelCase = [list(map(self.do_round , _lowerCAmelCase ) ) for each in produce_out] return np.asarray(_lowerCAmelCase ) def _snake_case ( self : Dict , __UpperCamelCase : List[str] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = np.asmatrix(_lowerCAmelCase ) _UpperCAmelCase ,_UpperCAmelCase = self.convolute( _lowerCAmelCase , self.conva , self.w_conva , self.thre_conva , conv_step=self.step_conva , ) _UpperCAmelCase = self.pooling(_lowerCAmelCase , self.size_poolinga ) return data_conveda, data_pooleda if __name__ == "__main__": pass
709
"""simple docstring""" import enum import warnings from ..tokenization_utils import TruncationStrategy from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging from .base import PIPELINE_INIT_ARGS, Pipeline if is_tf_available(): import tensorflow as tf from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if is_torch_available(): from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING a : List[str] = logging.get_logger(__name__) class a_ ( enum.Enum ): a : Optional[Any] = 0 a : Dict = 1 @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'generated' def __init__( self : int , *__UpperCamelCase : Optional[int] , **__UpperCamelCase : str ) ->Any: '''simple docstring''' super().__init__(*__UpperCamelCase , **__UpperCamelCase ) self.check_model_type( TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING if self.framework == """tf""" else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING ) def _snake_case ( self : Optional[int] , __UpperCamelCase : List[Any]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : int=None , __UpperCamelCase : Tuple=None , __UpperCamelCase : Dict=None , **__UpperCamelCase : Any , ) ->Tuple: '''simple docstring''' _UpperCAmelCase = {} if truncation is not None: _UpperCAmelCase = truncation _UpperCAmelCase = generate_kwargs _UpperCAmelCase = {} if return_tensors is not None and return_type is None: _UpperCAmelCase = ReturnType.TENSORS if return_tensors else ReturnType.TEXT if return_type is not None: _UpperCAmelCase = return_type if clean_up_tokenization_spaces is not None: _UpperCAmelCase = clean_up_tokenization_spaces if stop_sequence is not None: _UpperCAmelCase = self.tokenizer.encode(__UpperCamelCase , add_special_tokens=__UpperCamelCase ) if len(__UpperCamelCase ) > 1: warnings.warn( """Stopping on a multiple token sequence is not yet supported on transformers. The first token of""" """ the stop sequence will be used as the stop sequence string in the interim.""" ) _UpperCAmelCase = stop_sequence_ids[0] return preprocess_params, forward_params, postprocess_params def _snake_case ( self : int , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' return True def _snake_case ( self : Optional[Any] , *__UpperCamelCase : Any , __UpperCamelCase : Dict ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.model.config.prefix if self.model.config.prefix is not None else """""" if isinstance(args[0] , __UpperCamelCase ): if self.tokenizer.pad_token_id is None: raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input""" ) _UpperCAmelCase = ([prefix + arg for arg in args[0]],) _UpperCAmelCase = True elif isinstance(args[0] , __UpperCamelCase ): _UpperCAmelCase = (prefix + args[0],) _UpperCAmelCase = False else: raise ValueError( f""" `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`""" ) _UpperCAmelCase = self.tokenizer(*__UpperCamelCase , padding=__UpperCamelCase , truncation=__UpperCamelCase , return_tensors=self.framework ) # This is produced by tokenizers but is an invalid generate kwargs if "token_type_ids" in inputs: del inputs["token_type_ids"] return inputs def __call__( self : Dict , *__UpperCamelCase : str , **__UpperCamelCase : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = super().__call__(*__UpperCamelCase , **__UpperCamelCase ) if ( isinstance(args[0] , __UpperCamelCase ) and all(isinstance(__UpperCamelCase , __UpperCamelCase ) for el in args[0] ) and all(len(__UpperCamelCase ) == 1 for res in result ) ): return [res[0] for res in result] return result def _snake_case ( self : List[str] , __UpperCamelCase : Any , __UpperCamelCase : str=TruncationStrategy.DO_NOT_TRUNCATE , **__UpperCamelCase : Optional[int] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self._parse_and_tokenize(__UpperCamelCase , truncation=__UpperCamelCase , **__UpperCamelCase ) return inputs def _snake_case ( self : str , __UpperCamelCase : Dict , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' if self.framework == "pt": _UpperCAmelCase ,_UpperCAmelCase = model_inputs["""input_ids"""].shape elif self.framework == "tf": _UpperCAmelCase ,_UpperCAmelCase = tf.shape(model_inputs["""input_ids"""] ).numpy() _UpperCAmelCase = generate_kwargs.get("""min_length""" , self.model.config.min_length ) _UpperCAmelCase = generate_kwargs.get("""max_length""" , self.model.config.max_length ) self.check_inputs(__UpperCamelCase , generate_kwargs["""min_length"""] , generate_kwargs["""max_length"""] ) _UpperCAmelCase = self.model.generate(**__UpperCamelCase , **__UpperCamelCase ) _UpperCAmelCase = output_ids.shape[0] if self.framework == "pt": _UpperCAmelCase = output_ids.reshape(__UpperCamelCase , out_b // in_b , *output_ids.shape[1:] ) elif self.framework == "tf": _UpperCAmelCase = tf.reshape(__UpperCamelCase , (in_b, out_b // in_b, *output_ids.shape[1:]) ) return {"output_ids": output_ids} def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : Union[str, Any]=ReturnType.TEXT , __UpperCamelCase : int=False ) ->Any: '''simple docstring''' _UpperCAmelCase = [] for output_ids in model_outputs["output_ids"][0]: if return_type == ReturnType.TENSORS: _UpperCAmelCase = {f"""{self.return_name}_token_ids""": output_ids} elif return_type == ReturnType.TEXT: _UpperCAmelCase = { f"""{self.return_name}_text""": self.tokenizer.decode( __UpperCamelCase , skip_special_tokens=__UpperCamelCase , clean_up_tokenization_spaces=__UpperCamelCase , ) } records.append(__UpperCamelCase ) return records @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : List[Any] = 'summary' def __call__( self : Optional[Any] , *__UpperCamelCase : Optional[Any] , **__UpperCamelCase : Optional[int] ) ->Any: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase ) def _snake_case ( self : str , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->bool: '''simple docstring''' if max_length < min_length: logger.warning(f"""Your min_length={min_length} must be inferior than your max_length={max_length}.""" ) if input_length < max_length: logger.warning( f"""Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is """ """a summarization task, where outputs shorter than the input are typically wanted, you might """ f"""consider decreasing max_length manually, e.g. summarizer('...', max_length={input_length//2})""" ) @add_end_docstrings(_UpperCAmelCase ) class a_ ( _UpperCAmelCase ): a : Optional[int] = 'translation' def _snake_case ( self : Union[str, Any] , __UpperCamelCase : int , __UpperCamelCase : int , __UpperCamelCase : int ) ->Any: '''simple docstring''' if input_length > 0.9 * max_length: logger.warning( f"""Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider """ """increasing your max_length manually, e.g. translator('...', max_length=400)""" ) return True def _snake_case ( self : Tuple , *__UpperCamelCase : List[str] , __UpperCamelCase : Tuple=TruncationStrategy.DO_NOT_TRUNCATE , __UpperCamelCase : Tuple=None , __UpperCamelCase : Union[str, Any]=None ) ->Tuple: '''simple docstring''' if getattr(self.tokenizer , """_build_translation_inputs""" , __UpperCamelCase ): return self.tokenizer._build_translation_inputs( *__UpperCamelCase , return_tensors=self.framework , truncation=__UpperCamelCase , src_lang=__UpperCamelCase , tgt_lang=__UpperCamelCase ) else: return super()._parse_and_tokenize(*__UpperCamelCase , truncation=__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : int=None , __UpperCamelCase : int=None , **__UpperCamelCase : Any ) ->int: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = super()._sanitize_parameters(**__UpperCamelCase ) if src_lang is not None: _UpperCAmelCase = src_lang if tgt_lang is not None: _UpperCAmelCase = tgt_lang if src_lang is None and tgt_lang is None: # Backward compatibility, direct arguments use is preferred. _UpperCAmelCase = kwargs.get("""task""" , self.task ) _UpperCAmelCase = task.split("""_""" ) if task and len(__UpperCamelCase ) == 4: # translation, XX, to YY _UpperCAmelCase = items[1] _UpperCAmelCase = items[3] return preprocess_params, forward_params, postprocess_params def __call__( self : List[str] , *__UpperCamelCase : str , **__UpperCamelCase : Optional[Any] ) ->int: '''simple docstring''' return super().__call__(*__UpperCamelCase , **__UpperCamelCase )
19
0
"""simple docstring""" class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->str: _UpperCAmelCase = set_counts _UpperCAmelCase = max(UpperCamelCase_ ) _UpperCAmelCase = len(UpperCamelCase_ ) _UpperCAmelCase = [1] * num_sets _UpperCAmelCase = list(range(UpperCamelCase_ ) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : str ) ->Any: _UpperCAmelCase = self.get_parent(UpperCamelCase_ ) _UpperCAmelCase = self.get_parent(UpperCamelCase_ ) if src_parent == dst_parent: return False if self.ranks[dst_parent] >= self.ranks[src_parent]: self.set_counts[dst_parent] += self.set_counts[src_parent] _UpperCAmelCase = 0 _UpperCAmelCase = dst_parent if self.ranks[dst_parent] == self.ranks[src_parent]: self.ranks[dst_parent] += 1 _UpperCAmelCase = self.set_counts[dst_parent] else: self.set_counts[src_parent] += self.set_counts[dst_parent] _UpperCAmelCase = 0 _UpperCAmelCase = src_parent _UpperCAmelCase = self.set_counts[src_parent] _UpperCAmelCase = max(self.max_set , UpperCamelCase_ ) return True def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict ) ->List[str]: if self.parents[disj_set] == disj_set: return disj_set _UpperCAmelCase = self.get_parent(self.parents[disj_set] ) return self.parents[disj_set]
710
"""simple docstring""" import unittest import numpy as np import torch from transformers import CLIPTextConfig, CLIPTextModel from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device enable_full_determinism() class a_ ( unittest.TestCase ): @property def _snake_case ( self : Dict ) ->int: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = UNetaDModel( block_out_channels=(32, 64) , layers_per_block=2 , sample_size=32 , in_channels=3 , out_channels=3 , down_block_types=("""DownBlock2D""", """AttnDownBlock2D""") , up_block_types=("""AttnUpBlock2D""", """UpBlock2D""") , ) return model @property def _snake_case ( self : Optional[Any] ) ->str: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = VQModel( block_out_channels=[32, 64] , in_channels=3 , out_channels=3 , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] , latent_channels=3 , ) return model @property def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' torch.manual_seed(0 ) _UpperCAmelCase = CLIPTextConfig( bos_token_id=0 , eos_token_id=2 , hidden_size=32 , intermediate_size=37 , layer_norm_eps=1e-05 , num_attention_heads=4 , num_hidden_layers=5 , pad_token_id=1 , vocab_size=10_00 , ) return CLIPTextModel(__UpperCamelCase ) def _snake_case ( self : List[str] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.dummy_uncond_unet _UpperCAmelCase = DDIMScheduler() _UpperCAmelCase = self.dummy_vq_model _UpperCAmelCase = LDMPipeline(unet=__UpperCamelCase , vqvae=__UpperCamelCase , scheduler=__UpperCamelCase ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" ).images _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=2 , output_type="""numpy""" , return_dict=__UpperCamelCase )[0] _UpperCAmelCase = image[0, -3:, -3:, -1] _UpperCAmelCase = image_from_tuple[0, -3:, -3:, -1] assert image.shape == (1, 64, 64, 3) _UpperCAmelCase = np.array([0.8_5_1_2, 0.8_1_8, 0.6_4_1_1, 0.6_8_0_8, 0.4_4_6_5, 0.5_6_1_8, 0.4_6, 0.6_2_3_1, 0.5_1_7_2] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < tolerance @slow @require_torch class a_ ( unittest.TestCase ): def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256""" ) ldm.to(__UpperCamelCase ) ldm.set_progress_bar_config(disable=__UpperCamelCase ) _UpperCAmelCase = torch.manual_seed(0 ) _UpperCAmelCase = ldm(generator=__UpperCamelCase , num_inference_steps=5 , output_type="""numpy""" ).images _UpperCAmelCase = image[0, -3:, -3:, -1] assert image.shape == (1, 2_56, 2_56, 3) _UpperCAmelCase = np.array([0.4_3_9_9, 0.4_4_9_7_5, 0.4_6_8_2_5, 0.4_7_4, 0.4_3_5_9, 0.4_5_8_1, 0.4_5_0_9_5, 0.4_3_4_1, 0.4_4_4_7] ) _UpperCAmelCase = 1e-2 if torch_device != """mps""" else 3e-2 assert np.abs(image_slice.flatten() - expected_slice ).max() < tolerance
19
0
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import ( OptionalDependencyNotAvailable, _LazyModule, is_torch_available, ) a : str = { 'configuration_falcon': ['FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FalconConfig'], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : Dict = [ '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 : Dict = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
711
"""simple docstring""" import re from filelock import FileLock try: import nltk a : str = True except (ImportError, ModuleNotFoundError): a : List[str] = False if NLTK_AVAILABLE: with FileLock('''.lock''') as lock: nltk.download('''punkt''', quiet=True) def _UpperCamelCase ( _A ) -> str: """simple docstring""" re.sub("""<n>""" , """""" , _A ) # 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(_A ) )
19
0
"""simple docstring""" import logging import torch from torch import nn from torch.nn import CrossEntropyLoss, MSELoss from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward from transformers.models.bert.modeling_bert import ( BERT_INPUTS_DOCSTRING, BERT_START_DOCSTRING, BertEncoder, BertModel, BertPreTrainedModel, ) a : Optional[int] = logging.getLogger(__name__) class a_ ( UpperCamelCase_ ): '''simple docstring''' def _snake_case ( self : Tuple , __UpperCamelCase : Any , __UpperCamelCase : Tuple , __UpperCamelCase : List[Any]=None , __UpperCamelCase : int=None ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.layer[current_layer](_a , _a , head_mask[current_layer] ) _UpperCAmelCase = layer_outputs[0] return hidden_states @add_start_docstrings( 'The bare Bert Model transformer with PABEE outputting raw hidden-states without any specific head on top.' , UpperCamelCase_ , ) class a_ ( UpperCamelCase_ ): '''simple docstring''' def __init__( self : Optional[int] , __UpperCamelCase : List[str] ) ->Dict: '''simple docstring''' super().__init__(_a ) _UpperCAmelCase = BertEncoderWithPabee(_a ) self.init_weights() _UpperCAmelCase = 0 _UpperCAmelCase = 0 _UpperCAmelCase = 0 _UpperCAmelCase = 0 def _snake_case ( self : int , __UpperCamelCase : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = threshold def _snake_case ( self : Dict , __UpperCamelCase : Tuple ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = patience def _snake_case ( self : int ) ->str: '''simple docstring''' _UpperCAmelCase = 0 _UpperCAmelCase = 0 def _snake_case ( self : Union[str, Any] ) ->Tuple: '''simple docstring''' _UpperCAmelCase = self.inference_layers_num / self.inference_instances_num _UpperCAmelCase = ( f"""*** Patience = {self.patience} Avg. Inference Layers = {avg_inf_layers:.2f} Speed Up =""" f""" {1 - avg_inf_layers / self.config.num_hidden_layers:.2f} ***""" ) print(_a ) @add_start_docstrings_to_model_forward(_a ) def _snake_case ( self : Any , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : int=None , __UpperCamelCase : str=None , __UpperCamelCase : List[Any]=None , __UpperCamelCase : List[str]=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : str=None , __UpperCamelCase : Dict=None , __UpperCamelCase : Any=False , ) ->List[str]: '''simple docstring''' if input_ids is not None and inputs_embeds is not None: raise ValueError("""You cannot specify both input_ids and inputs_embeds at the same time""" ) elif input_ids is not None: _UpperCAmelCase = input_ids.size() elif inputs_embeds is not None: _UpperCAmelCase = inputs_embeds.size()[:-1] else: raise ValueError("""You have to specify either input_ids or inputs_embeds""" ) _UpperCAmelCase = input_ids.device if input_ids is not None else inputs_embeds.device if attention_mask is None: _UpperCAmelCase = torch.ones(_a , device=_a ) if token_type_ids is None: _UpperCAmelCase = torch.zeros(_a , dtype=torch.long , device=_a ) # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] # ourselves in which case we just need to make it broadcastable to all heads. _UpperCAmelCase = self.get_extended_attention_mask(_a , _a , _a ) # If a 2D ou 3D attention mask is provided for the cross-attention # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length] if self.config.is_decoder and encoder_hidden_states is not None: _UpperCAmelCase = encoder_hidden_states.size() _UpperCAmelCase = (encoder_batch_size, encoder_sequence_length) if encoder_attention_mask is None: _UpperCAmelCase = torch.ones(_a , device=_a ) _UpperCAmelCase = self.invert_attention_mask(_a ) else: _UpperCAmelCase = None # Prepare head mask if needed # 1.0 in head_mask indicate we keep the head # attention_probs has shape bsz x n_heads x N x N # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads] # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length] _UpperCAmelCase = self.get_head_mask(_a , self.config.num_hidden_layers ) _UpperCAmelCase = self.embeddings( input_ids=_a , position_ids=_a , token_type_ids=_a , inputs_embeds=_a ) _UpperCAmelCase = embedding_output if self.training: _UpperCAmelCase = [] for i in range(self.config.num_hidden_layers ): _UpperCAmelCase = self.encoder.adaptive_forward( _a , current_layer=_a , attention_mask=_a , head_mask=_a ) _UpperCAmelCase = self.pooler(_a ) _UpperCAmelCase = output_layers[i](output_dropout(_a ) ) res.append(_a ) elif self.patience == 0: # Use all layers for inference _UpperCAmelCase = self.encoder( _a , attention_mask=_a , head_mask=_a , encoder_hidden_states=_a , encoder_attention_mask=_a , ) _UpperCAmelCase = self.pooler(encoder_outputs[0] ) _UpperCAmelCase = [output_layers[self.config.num_hidden_layers - 1](_a )] else: _UpperCAmelCase = 0 _UpperCAmelCase = None _UpperCAmelCase = 0 for i in range(self.config.num_hidden_layers ): calculated_layer_num += 1 _UpperCAmelCase = self.encoder.adaptive_forward( _a , current_layer=_a , attention_mask=_a , head_mask=_a ) _UpperCAmelCase = self.pooler(_a ) _UpperCAmelCase = output_layers[i](_a ) if regression: _UpperCAmelCase = logits.detach() if patient_result is not None: _UpperCAmelCase = patient_result.detach() if (patient_result is not None) and torch.abs(patient_result - labels ) < self.regression_threshold: patient_counter += 1 else: _UpperCAmelCase = 0 else: _UpperCAmelCase = logits.detach().argmax(dim=1 ) if patient_result is not None: _UpperCAmelCase = patient_result.detach().argmax(dim=1 ) if (patient_result is not None) and torch.all(labels.eq(_a ) ): patient_counter += 1 else: _UpperCAmelCase = 0 _UpperCAmelCase = logits if patient_counter == self.patience: break _UpperCAmelCase = [patient_result] self.inference_layers_num += calculated_layer_num self.inference_instances_num += 1 return res @add_start_docstrings( 'Bert Model transformer with PABEE and a sequence classification/regression head on top (a linear layer on top of\n the pooled output) e.g. for GLUE tasks. ' , UpperCamelCase_ , ) class a_ ( UpperCamelCase_ ): '''simple docstring''' def __init__( self : Tuple , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' super().__init__(_a ) _UpperCAmelCase = config.num_labels _UpperCAmelCase = BertModelWithPabee(_a ) _UpperCAmelCase = nn.Dropout(config.hidden_dropout_prob ) _UpperCAmelCase = nn.ModuleList( [nn.Linear(config.hidden_size , self.config.num_labels ) for _ in range(config.num_hidden_layers )] ) self.init_weights() @add_start_docstrings_to_model_forward(_a ) def _snake_case ( self : int , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Any=None , __UpperCamelCase : Any=None , __UpperCamelCase : Union[str, Any]=None , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : str=None , __UpperCamelCase : Union[str, Any]=None , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = self.bert( input_ids=_a , attention_mask=_a , token_type_ids=_a , position_ids=_a , head_mask=_a , inputs_embeds=_a , output_dropout=self.dropout , output_layers=self.classifiers , regression=self.num_labels == 1 , ) _UpperCAmelCase = (logits[-1],) if labels is not None: _UpperCAmelCase = None _UpperCAmelCase = 0 for ix, logits_item in enumerate(_a ): if self.num_labels == 1: # We are doing regression _UpperCAmelCase = MSELoss() _UpperCAmelCase = loss_fct(logits_item.view(-1 ) , labels.view(-1 ) ) else: _UpperCAmelCase = CrossEntropyLoss() _UpperCAmelCase = loss_fct(logits_item.view(-1 , self.num_labels ) , labels.view(-1 ) ) if total_loss is None: _UpperCAmelCase = loss else: total_loss += loss * (ix + 1) total_weights += ix + 1 _UpperCAmelCase = (total_loss / total_weights,) + outputs return outputs
712
"""simple docstring""" import unittest from transformers import PegasusConfig, PegasusTokenizer, is_flax_available from transformers.testing_utils import require_flax, slow from ...test_configuration_common import ConfigTester 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 : str = '''platform''' import jax import jax.numpy as jnp import numpy as np from transformers import FlaxPegasusForConditionalGeneration, FlaxPegasusModel @require_flax class a_ : a : List[Any] = PegasusConfig a : Dict = {} a : List[Any] = 'gelu' def __init__( self : Any , __UpperCamelCase : Dict , __UpperCamelCase : Tuple=13 , __UpperCamelCase : Tuple=7 , __UpperCamelCase : Tuple=True , __UpperCamelCase : Any=False , __UpperCamelCase : Any=99 , __UpperCamelCase : Optional[int]=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : List[str]=4 , __UpperCamelCase : Dict=37 , __UpperCamelCase : int=0.1 , __UpperCamelCase : Dict=0.1 , __UpperCamelCase : Optional[Any]=20 , __UpperCamelCase : Tuple=2 , __UpperCamelCase : Optional[int]=1 , __UpperCamelCase : Tuple=0 , ) ->int: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = bos_token_id def _snake_case ( self : Union[str, Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length - 1] , self.vocab_size ).clip(3 , self.vocab_size ) _UpperCAmelCase = np.expand_dims(np.array([self.eos_token_id] * self.batch_size ) , 1 ) _UpperCAmelCase = np.concatenate([input_ids, eos_tensor] , axis=1 ) _UpperCAmelCase = ids_tensor([self.batch_size, self.seq_length] , self.vocab_size ) _UpperCAmelCase = self.config_cls( vocab_size=self.vocab_size , d_model=self.hidden_size , encoder_layers=self.num_hidden_layers , decoder_layers=self.num_hidden_layers , encoder_attention_heads=self.num_attention_heads , decoder_attention_heads=self.num_attention_heads , encoder_ffn_dim=self.intermediate_size , decoder_ffn_dim=self.intermediate_size , dropout=self.hidden_dropout_prob , attention_dropout=self.attention_probs_dropout_prob , max_position_embeddings=self.max_position_embeddings , eos_token_ids=[2] , bos_token_id=self.bos_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.pad_token_id , **self.config_updates , ) _UpperCAmelCase = prepare_pegasus_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, inputs_dict def _snake_case ( self : Tuple , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : List[Any] ) ->Any: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.ones((decoder_input_ids.shape[0], max_decoder_length) , dtype="""i4""" ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _snake_case ( self : Any , __UpperCamelCase : List[str] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = 20 _UpperCAmelCase = model_class_name(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] ) _UpperCAmelCase ,_UpperCAmelCase = ( inputs_dict["""decoder_input_ids"""], inputs_dict["""decoder_attention_mask"""], ) _UpperCAmelCase = jnp.concatenate( [ decoder_attention_mask, jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ), ] , axis=-1 , ) _UpperCAmelCase = model.init_cache(decoder_input_ids.shape[0] , __UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = jnp.broadcast_to( jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :] , (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1) , ) _UpperCAmelCase = model.decode( decoder_input_ids[:, :-1] , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase , past_key_values=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]] , dtype="""i4""" ) _UpperCAmelCase = model.decode( decoder_input_ids[:, -1:] , __UpperCamelCase , past_key_values=outputs_cache.past_key_values , decoder_attention_mask=__UpperCamelCase , decoder_position_ids=__UpperCamelCase , ) _UpperCAmelCase = model.decode(__UpperCamelCase , __UpperCamelCase , decoder_attention_mask=__UpperCamelCase ) _UpperCAmelCase = np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) ) self.parent.assertTrue(diff < 1e-3 , msg=f"""Max diff is {diff}""" ) def _UpperCamelCase ( _A , _A , _A , _A=None , _A=None , ) -> int: """simple docstring""" if attention_mask is None: _UpperCAmelCase = np.not_equal(_A , config.pad_token_id ).astype(np.inta ) if decoder_attention_mask is None: _UpperCAmelCase = np.concatenate( [ np.ones(decoder_input_ids[:, :1].shape , dtype=np.inta ), np.not_equal(decoder_input_ids[:, 1:] , config.pad_token_id ).astype(np.inta ), ] , axis=-1 , ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, } @require_flax class a_ ( _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( ( FlaxPegasusForConditionalGeneration, FlaxPegasusModel, ) if is_flax_available() else () ) a : Any = (FlaxPegasusForConditionalGeneration,) if is_flax_available() else () a : Any = True a : int = False a : Union[str, Any] = False a : Optional[int] = False def _snake_case ( self : Union[str, Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusModelTester(self ) _UpperCAmelCase = ConfigTester(self , config_class=__UpperCamelCase ) def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' self.config_tester.run_common_tests() def _snake_case ( self : Optional[int] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: self.model_tester.check_use_cache_forward_with_attn_mask(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) def _snake_case ( self : Dict ) ->List[Any]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = self._prepare_for_class(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model_class(__UpperCamelCase ) @jax.jit def encode_jitted(__UpperCamelCase : List[Any] , __UpperCamelCase : str=None , **__UpperCamelCase : int ): return model.encode(input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = encode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) def _snake_case ( self : List[Any] ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.model_tester.prepare_config_and_inputs_for_common() for model_class in self.all_model_classes: with self.subTest(model_class.__name__ ): _UpperCAmelCase = model_class(__UpperCamelCase ) _UpperCAmelCase = model.encode(inputs_dict["""input_ids"""] , inputs_dict["""attention_mask"""] ) _UpperCAmelCase = { """decoder_input_ids""": inputs_dict["""decoder_input_ids"""], """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""], """encoder_outputs""": encoder_outputs, } @jax.jit def decode_jitted(__UpperCamelCase : Union[str, Any] , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Tuple ): return model.decode( decoder_input_ids=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , encoder_outputs=__UpperCamelCase , ) with self.subTest("""JIT Enabled""" ): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() with self.subTest("""JIT Disabled""" ): with jax.disable_jit(): _UpperCAmelCase = decode_jitted(**__UpperCamelCase ).to_tuple() self.assertEqual(len(__UpperCamelCase ) , len(__UpperCamelCase ) ) for jitted_output, output in zip(__UpperCamelCase , __UpperCamelCase ): self.assertEqual(jitted_output.shape , output.shape ) @slow def _snake_case ( self : int ) ->int: '''simple docstring''' for model_class_name in self.all_model_classes: _UpperCAmelCase = model_class_name.from_pretrained("""google/pegasus-large""" , from_pt=__UpperCamelCase ) _UpperCAmelCase = np.ones((1, 1) ) _UpperCAmelCase = model(__UpperCamelCase ) self.assertIsNotNone(__UpperCamelCase ) @slow def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' _UpperCAmelCase = FlaxPegasusForConditionalGeneration.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = PegasusTokenizer.from_pretrained("""google/pegasus-xsum""" ) _UpperCAmelCase = [ """ PG&E stated it scheduled the blackouts in response to forecasts for high winds amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow.""", """ The London trio are up for best UK act and best album, as well as getting two nominations in the best song category.\"We got told like this morning 'Oh I think you're nominated'\", said Dappy.\"And I was like 'Oh yeah, which one?' And now we've got nominated for four awards. I mean, wow!\"Bandmate Fazer added: \"We thought it's best of us to come down and mingle with everyone and say hello to the cameras. And now we find we've got four nominations.\"The band have two shots at the best song prize, getting the nod for their Tynchy Stryder collaboration Number One, and single Strong Again.Their album Uncle B will also go up against records by the likes of Beyonce and Kanye West.N-Dubz picked up the best newcomer Mobo in 2007, but female member Tulisa said they wouldn't be too disappointed if they didn't win this time around.\"At the end of the day we're grateful to be where we are in our careers.\"If it don't happen then it don't happen - live to fight another day and keep on making albums and hits for the fans.\"Dappy also revealed they could be performing live several times on the night.The group will be doing Number One and also a possible rendition of the War Child single, I Got Soul.The charity song is a re-working of The Killers' All These Things That I've Done and is set to feature artists like Chipmunk, Ironik and Pixie Lott.This year's Mobos will be held outside of London for the first time, in Glasgow on 30 September.N-Dubz said they were looking forward to performing for their Scottish fans and boasted about their recent shows north of the border.\"We just done Edinburgh the other day,\" said Dappy.\"We smashed up an N-Dubz show over there. We done Aberdeen about three or four months ago - we smashed up that show over there! Everywhere we go we smash it up!\" """, ] _UpperCAmelCase = [ """California's largest electricity provider has turned off power to hundreds of thousands of customers.""", """Pop group N-Dubz have revealed they were surprised to get four nominations for this year's Mobo Awards.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""np""" , truncation=__UpperCamelCase , max_length=5_12 , padding=__UpperCamelCase ) _UpperCAmelCase = model.generate(**__UpperCamelCase , num_beams=2 ).sequences _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase , skip_special_tokens=__UpperCamelCase ) assert tgt_text == decoded
19
0
"""simple docstring""" import os import unittest from transformers import FunnelTokenizer, FunnelTokenizerFast from transformers.models.funnel.tokenization_funnel import VOCAB_FILES_NAMES from transformers.testing_utils import require_tokenizers from ...test_tokenization_common import TokenizerTesterMixin @require_tokenizers class a_ ( _snake_case , unittest.TestCase ): a : Union[str, Any] = FunnelTokenizer a : Dict = FunnelTokenizerFast a : List[str] = True a : Optional[Any] = True def _snake_case ( self : List[str] ) ->Union[str, Any]: '''simple docstring''' super().setUp() _UpperCAmelCase = [ """<unk>""", """<cls>""", """<sep>""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing""", """,""", """low""", """lowest""", ] _UpperCAmelCase = os.path.join(self.tmpdirname , VOCAB_FILES_NAMES["""vocab_file"""] ) with open(self.vocab_file , """w""" , encoding="""utf-8""" ) as vocab_writer: vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens] ) ) def _snake_case ( self : List[Any] , **__UpperCamelCase : str ) ->Optional[Any]: '''simple docstring''' return FunnelTokenizer.from_pretrained(self.tmpdirname , **__UpperCamelCase ) def _snake_case ( self : List[str] , **__UpperCamelCase : Union[str, Any] ) ->List[Any]: '''simple docstring''' return FunnelTokenizerFast.from_pretrained(self.tmpdirname , **__UpperCamelCase ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : int ) ->Tuple: '''simple docstring''' _UpperCAmelCase = """UNwant\u00E9d,running""" _UpperCAmelCase = """unwanted, running""" return input_text, output_text def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = self.tokenizer_class(self.vocab_file ) _UpperCAmelCase = tokenizer.tokenize("""UNwant\u00E9d,running""" ) self.assertListEqual(__UpperCamelCase , ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""] ) self.assertListEqual(tokenizer.convert_tokens_to_ids(__UpperCamelCase ) , [7, 4, 5, 10, 8, 9] ) def _snake_case ( self : Any ) ->Dict: '''simple docstring''' _UpperCAmelCase = self.get_tokenizers(do_lower_case=__UpperCamelCase ) for tokenizer in tokenizers: _UpperCAmelCase = tokenizer("""UNwant\u00E9d,running""" ) _UpperCAmelCase = len(inputs["""input_ids"""] ) - 1 self.assertListEqual(inputs["""token_type_ids"""] , [2] + [0] * sentence_len ) _UpperCAmelCase = tokenizer("""UNwant\u00E9d,running""" , """UNwant\u00E9d,running""" ) self.assertListEqual(inputs["""token_type_ids"""] , [2] + [0] * sentence_len + [1] * sentence_len )
713
"""simple docstring""" import tempfile import unittest from transformers import TaConfig, is_torch_available from transformers.testing_utils import ( require_sentencepiece, require_tokenizers, require_torch, slow, torch_device, ) from ...generation.test_utils import GenerationTesterMixin from ...test_modeling_common import ModelTesterMixin, ids_tensor from ...test_pipeline_mixin import PipelineTesterMixin if is_torch_available(): import torch from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel class a_ : def __init__( self : Tuple , __UpperCamelCase : Optional[int] , __UpperCamelCase : List[Any]=99 , __UpperCamelCase : Optional[int]=13 , __UpperCamelCase : List[str]=7 , __UpperCamelCase : List[Any]=9 , __UpperCamelCase : List[Any]=True , __UpperCamelCase : str=True , __UpperCamelCase : int=False , __UpperCamelCase : int=32 , __UpperCamelCase : Dict=5 , __UpperCamelCase : Optional[int]=4 , __UpperCamelCase : Any=37 , __UpperCamelCase : List[Any]=8 , __UpperCamelCase : Optional[int]=0.1 , __UpperCamelCase : str=0.0_0_2 , __UpperCamelCase : Union[str, Any]=1 , __UpperCamelCase : List[Any]=0 , __UpperCamelCase : Tuple=0 , __UpperCamelCase : Optional[int]=None , __UpperCamelCase : Any=None , ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = parent _UpperCAmelCase = batch_size _UpperCAmelCase = encoder_seq_length _UpperCAmelCase = decoder_seq_length # For common tests _UpperCAmelCase = self.decoder_seq_length _UpperCAmelCase = is_training _UpperCAmelCase = use_attention_mask _UpperCAmelCase = use_labels _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = d_ff _UpperCAmelCase = relative_attention_num_buckets _UpperCAmelCase = dropout_rate _UpperCAmelCase = initializer_factor _UpperCAmelCase = eos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = decoder_start_token_id _UpperCAmelCase = None _UpperCAmelCase = decoder_layers def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' return TaConfig.from_pretrained("""google/umt5-base""" ) def _snake_case ( self : List[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Tuple=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : Any=None , __UpperCamelCase : str=None , ) ->int: '''simple docstring''' if attention_mask is None: _UpperCAmelCase = input_ids.ne(config.pad_token_id ) if decoder_attention_mask is None: _UpperCAmelCase = decoder_input_ids.ne(config.pad_token_id ) if head_mask is None: _UpperCAmelCase = torch.ones(config.num_hidden_layers , config.num_attention_heads , device=__UpperCamelCase ) if decoder_head_mask is None: _UpperCAmelCase = torch.ones(config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) if cross_attn_head_mask is None: _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_attention_heads , device=__UpperCamelCase ) return { "input_ids": input_ids, "decoder_input_ids": decoder_input_ids, "attention_mask": attention_mask, "decoder_attention_mask": decoder_attention_mask, "head_mask": head_mask, "decoder_head_mask": decoder_head_mask, "cross_attn_head_mask": cross_attn_head_mask, } def _snake_case ( self : List[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = ids_tensor([self.batch_size, self.encoder_seq_length] , self.vocab_size ) _UpperCAmelCase = ids_tensor([self.batch_size, self.decoder_seq_length] , self.vocab_size ) # we need to clamp the input ids here to avoid having pad token in between # this is because for NllbMoe the position_ids are prepared such that # all pad tokens have pos id = 2 and rest are between 2..seq_length # and the seq_length here is seq_length - num_pad_tokens # but when using past, there is no way of knowing if the past input ids had # pad tokens in them, which results in incorrect seq_lenth and which in turn results in # position_ids being off by num_pad_tokens in past input _UpperCAmelCase = input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = decoder_input_ids.clamp(self.pad_token_id + 1 ) _UpperCAmelCase = self.get_config() _UpperCAmelCase = config.num_attention_heads _UpperCAmelCase = self.prepare_inputs_dict(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) return config, input_dict def _snake_case ( self : Union[str, Any] ) ->Any: '''simple docstring''' _UpperCAmelCase ,_UpperCAmelCase = self.prepare_config_and_inputs() return config, inputs_dict def _snake_case ( self : Dict ) ->List[str]: '''simple docstring''' return TaConfig( vocab_size=1_66 , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : Tuple ) ->Dict: '''simple docstring''' return TaConfig( vocab_size=self.vocab_size , d_model=self.hidden_size , d_ff=self.d_ff , d_kv=self.hidden_size // self.num_attention_heads , num_layers=self.num_hidden_layers , num_decoder_layers=self.decoder_layers , num_heads=self.num_attention_heads , relative_attention_num_buckets=self.relative_attention_num_buckets , dropout_rate=self.dropout_rate , initializer_factor=self.initializer_factor , eos_token_id=self.eos_token_id , bos_token_id=self.pad_token_id , pad_token_id=self.pad_token_id , decoder_start_token_id=self.decoder_start_token_id , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Any , __UpperCamelCase : Dict , __UpperCamelCase : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : List[str] , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ) model.to(__UpperCamelCase ) model.eval() _UpperCAmelCase = model( input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase , attention_mask=__UpperCamelCase , decoder_attention_mask=__UpperCamelCase , ) _UpperCAmelCase = model(input_ids=__UpperCamelCase , decoder_input_ids=__UpperCamelCase ) _UpperCAmelCase = result.last_hidden_state _UpperCAmelCase = result.past_key_values _UpperCAmelCase = result.encoder_last_hidden_state self.parent.assertEqual(encoder_output.size() , (self.batch_size, self.encoder_seq_length, self.hidden_size) ) self.parent.assertEqual(decoder_output.size() , (self.batch_size, self.decoder_seq_length, self.hidden_size) ) # There should be `num_layers` key value embeddings stored in decoder_past self.parent.assertEqual(len(__UpperCamelCase ) , config.num_layers ) # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple self.parent.assertEqual(len(decoder_past[0] ) , 4 ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Dict , __UpperCamelCase : Optional[int] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] , ) ->str: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).get_decoder().to(__UpperCamelCase ).eval() # first forward pass _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase ) _UpperCAmelCase = model(__UpperCamelCase , use_cache=__UpperCamelCase ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) ) self.parent.assertTrue(len(__UpperCamelCase ) == len(__UpperCamelCase ) + 1 ) _UpperCAmelCase ,_UpperCAmelCase = outputs.to_tuple() # create hypothetical next token and extent to next_input_ids _UpperCAmelCase = ids_tensor((self.batch_size, 1) , config.vocab_size ) # append to next input_ids and _UpperCAmelCase = torch.cat([input_ids, next_tokens] , dim=-1 ) _UpperCAmelCase = model(__UpperCamelCase )["""last_hidden_state"""] _UpperCAmelCase = model(__UpperCamelCase , past_key_values=__UpperCamelCase )["""last_hidden_state"""] # select random slice _UpperCAmelCase = ids_tensor((1,) , output_from_past.shape[-1] ).item() _UpperCAmelCase = output_from_no_past[:, -1, random_slice_idx].detach() _UpperCAmelCase = output_from_past[:, 0, random_slice_idx].detach() # test that outputs are equal for slice self.parent.assertTrue(torch.allclose(__UpperCamelCase , __UpperCamelCase , atol=1e-3 ) ) def _snake_case ( self : Optional[int] , __UpperCamelCase : int , __UpperCamelCase : Dict , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = UMTaModel(config=__UpperCamelCase ).to(__UpperCamelCase ).half().eval() _UpperCAmelCase = model(**__UpperCamelCase )["""last_hidden_state"""] self.parent.assertFalse(torch.isnan(__UpperCamelCase ).any().item() ) @require_torch class a_ ( _UpperCAmelCase , _UpperCAmelCase , _UpperCAmelCase , unittest.TestCase ): a : List[str] = ( (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else () ) a : Tuple = (UMTaForConditionalGeneration,) if is_torch_available() else () a : Optional[Any] = ( { 'conversational': UMTaForConditionalGeneration, 'feature-extraction': UMTaModel, 'summarization': UMTaForConditionalGeneration, 'text2text-generation': UMTaForConditionalGeneration, 'translation': UMTaForConditionalGeneration, 'question-answering': UMTaForQuestionAnswering, } if is_torch_available() else {} ) a : Any = True a : Optional[int] = False a : Any = False a : Optional[int] = True a : Optional[Any] = True # The small UMT5 model needs higher percentages for CPU/MP tests a : int = [0.8, 0.9] def _snake_case ( self : Optional[Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = UMTaModelTester(self ) @unittest.skip("""Test has a segmentation fault on torch 1.8.0""" ) def _snake_case ( self : Union[str, Any] ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = UMTaModel(config_and_inputs[0] ).to(__UpperCamelCase ) with tempfile.TemporaryDirectory() as tmpdirname: torch.onnx.export( __UpperCamelCase , (config_and_inputs[1], config_and_inputs[3], config_and_inputs[2]) , f"""{tmpdirname}/t5_test.onnx""" , export_params=__UpperCamelCase , opset_version=9 , input_names=["""input_ids""", """decoder_input_ids"""] , ) @unittest.skipIf(torch_device == """cpu""" , """Cant do half precision""" ) def _snake_case ( self : Tuple ) ->Optional[int]: '''simple docstring''' _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() self.model_tester.create_and_check_model_fpaa_forward(*__UpperCamelCase ) def _snake_case ( self : Any ) ->Any: '''simple docstring''' _UpperCAmelCase = ["""encoder_attentions""", """decoder_attentions""", """cross_attentions"""] _UpperCAmelCase = self.model_tester.prepare_config_and_inputs() _UpperCAmelCase = config_and_inputs[0] _UpperCAmelCase = UMTaForConditionalGeneration(__UpperCamelCase ).eval() model.to(__UpperCamelCase ) _UpperCAmelCase = { """head_mask""": torch.zeros(config.num_layers , config.num_heads , device=__UpperCamelCase ), """decoder_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), """cross_attn_head_mask""": torch.zeros(config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ), } for attn_name, (name, mask) in zip(__UpperCamelCase , head_masking.items() ): _UpperCAmelCase = {name: mask} # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified if name == "head_mask": _UpperCAmelCase = torch.ones( config.num_decoder_layers , config.num_heads , device=__UpperCamelCase ) _UpperCAmelCase = model.generate( config_and_inputs[1]["""input_ids"""] , num_beams=1 , max_length=3 , output_attentions=__UpperCamelCase , return_dict_in_generate=__UpperCamelCase , **__UpperCamelCase , ) # We check the state of decoder_attentions and cross_attentions just from the last step _UpperCAmelCase = out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1] self.assertEqual(sum([w.sum().item() for w in attn_weights] ) , 0.0 ) @unittest.skip("""Does not work on the tiny model as we keep hitting edge cases.""" ) def _snake_case ( self : Tuple ) ->List[Any]: '''simple docstring''' pass @require_torch @require_sentencepiece @require_tokenizers class a_ ( unittest.TestCase ): @slow @unittest.skip( """Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged""" ) def _snake_case ( self : Optional[Any] ) ->Optional[Any]: '''simple docstring''' _UpperCAmelCase = UMTaForConditionalGeneration.from_pretrained("""google/umt5-small""" , return_dict=__UpperCamelCase ).to(__UpperCamelCase ) _UpperCAmelCase = AutoTokenizer.from_pretrained("""google/umt5-small""" , use_fast=__UpperCamelCase , legacy=__UpperCamelCase ) _UpperCAmelCase = [ """Bonjour monsieur <extra_id_0> bien <extra_id_1>.""", """No se como puedo <extra_id_0>.""", """This is the reason why we <extra_id_0> them.""", """The <extra_id_0> walks in <extra_id_1>, seats""", """A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.""", ] _UpperCAmelCase = tokenizer(__UpperCamelCase , return_tensors="""pt""" , padding=__UpperCamelCase ).input_ids # fmt: off _UpperCAmelCase = torch.tensor( [ [ 3_85_30, 21_07_03, 25_62_99, 14_10, 25_62_98, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 8_26, 3_21, 6_71, 2_59_22, 25_62_99, 2_74, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 14_60, 3_39, 3_12, 1_90_14, 1_06_20, 7_58, 25_62_99, 23_55,2_74, 1, 0, 0, 0, 0, 0, 0,0, 0], [ 5_17, 25_62_99, 1_48_69, 2_81, 3_01, 25_62_98, 2_75, 11_99_83,1, 0, 0, 0, 0, 0, 0, 0,0, 0], [ 3_20, 25_62_99, 1_48_69, 2_81, 22_34, 2_89, 22_75, 3_33,6_13_91, 2_89, 25_62_98, 5_43, 25_62_97, 16_87_14, 3_29, 25_62_96,2_74, 1], ] ) # fmt: on torch.testing.assert_allclose(__UpperCamelCase , __UpperCamelCase ) _UpperCAmelCase = model.generate(input_ids.to(__UpperCamelCase ) ) _UpperCAmelCase = [ """<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>""", """<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", """<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>""", ] _UpperCAmelCase = tokenizer.batch_decode(__UpperCamelCase ) self.assertEqual(__UpperCamelCase , __UpperCamelCase )
19
0
"""simple docstring""" import argparse from pathlib import Path import torch from packaging import version from torch.onnx import export from diffusers import AutoencoderKL a : Dict = version.parse(version.parse(torch.__version__).base_version) < version.parse('''1.11''') def _UpperCamelCase ( _A , _A , _A , _A , _A , _A , _A , _A=False , ) -> Union[str, Any]: """simple docstring""" output_path.parent.mkdir(parents=lowerCAmelCase__ , exist_ok=lowerCAmelCase__ ) # PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11, # so we check the torch version for backwards compatibility if is_torch_less_than_1_11: export( lowerCAmelCase__ , lowerCAmelCase__ , f=output_path.as_posix() , input_names=lowerCAmelCase__ , output_names=lowerCAmelCase__ , dynamic_axes=lowerCAmelCase__ , do_constant_folding=lowerCAmelCase__ , use_external_data_format=lowerCAmelCase__ , enable_onnx_checker=lowerCAmelCase__ , opset_version=lowerCAmelCase__ , ) else: export( lowerCAmelCase__ , lowerCAmelCase__ , f=output_path.as_posix() , input_names=lowerCAmelCase__ , output_names=lowerCAmelCase__ , dynamic_axes=lowerCAmelCase__ , do_constant_folding=lowerCAmelCase__ , opset_version=lowerCAmelCase__ , ) @torch.no_grad() def _UpperCamelCase ( _A , _A , _A , _A = False ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = torch.floataa if fpaa else torch.floataa if fpaa and torch.cuda.is_available(): _UpperCAmelCase = """cuda""" elif fpaa and not torch.cuda.is_available(): raise ValueError("""`float16` model export is only supported on GPUs with CUDA""" ) else: _UpperCAmelCase = """cpu""" _UpperCAmelCase = Path(lowerCAmelCase__ ) # VAE DECODER _UpperCAmelCase = AutoencoderKL.from_pretrained(model_path + """/vae""" ) _UpperCAmelCase = vae_decoder.config.latent_channels # forward only through the decoder part _UpperCAmelCase = vae_decoder.decode onnx_export( lowerCAmelCase__ , model_args=( torch.randn(1 , lowerCAmelCase__ , 2_5 , 2_5 ).to(device=lowerCAmelCase__ , dtype=lowerCAmelCase__ ), False, ) , output_path=output_path / """vae_decoder""" / """model.onnx""" , ordered_input_names=["""latent_sample""", """return_dict"""] , output_names=["""sample"""] , dynamic_axes={ """latent_sample""": {0: """batch""", 1: """channels""", 2: """height""", 3: """width"""}, } , opset=lowerCAmelCase__ , ) del vae_decoder if __name__ == "__main__": a : Any = argparse.ArgumentParser() parser.add_argument( '''--model_path''', type=str, required=True, help='''Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).''', ) parser.add_argument('''--output_path''', type=str, required=True, help='''Path to the output model.''') parser.add_argument( '''--opset''', default=1_4, type=int, help='''The version of the ONNX operator set to use.''', ) parser.add_argument('''--fp16''', action='''store_true''', default=False, help='''Export the models in `float16` mode''') a : Any = parser.parse_args() print(args.output_path) convert_models(args.model_path, args.output_path, args.opset, args.fpaa) print('''SD: Done: ONNX''')
714
"""simple docstring""" import copy import os import tempfile from unittest import TestCase from unittest.mock import patch import numpy as np import pyarrow as pa import pyarrow.parquet as pq import pytest from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence from datasets.features import ArrayaD, ClassLabel, Features, Image, Value from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects from datasets.keyhash import DuplicatedKeysError, InvalidKeyError from .utils import require_pil class a_ ( _UpperCAmelCase ): def _snake_case ( self : str ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : Any ) ->List[str]: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] ) , type=pa.intaa() ) def _snake_case ( self : Optional[int] ) ->Tuple: '''simple docstring''' with self.assertRaises(__UpperCamelCase ): _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""bool""" ) , type=Value("""int64""" ) ) ) def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : str ) ->Dict: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=Value("""int64""" ) ) ) def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([1, 2, 3] , try_type=Value("""int32""" ) ) ) self.assertEqual(arr.type , pa.intaa() ) def _snake_case ( self : List[str] ) ->Any: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=Value("""int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) def _snake_case ( self : List[Any] ) ->List[Any]: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : List[Any] ) ->Optional[Any]: '''simple docstring''' with self.assertRaises((TypeError, pa.lib.ArrowInvalid) ): _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , type=ArrayaD((1, 3) , """int64""" ) ) ) def _snake_case ( self : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence([[[1, 2, 3]]] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , ArrayaDExtensionType((1, 3) , """int64""" ) ) def _snake_case ( self : Optional[int] ) ->Dict: '''simple docstring''' _UpperCAmelCase = pa.array(TypedSequence(["""foo""", """bar"""] , try_type=ArrayaD((1, 3) , """int64""" ) ) ) self.assertEqual(arr.type , pa.string() ) @require_pil def _snake_case ( self : str ) ->Optional[Any]: '''simple docstring''' import PIL.Image _UpperCAmelCase = PIL.Image.fromarray(np.arange(10 , dtype=np.uinta ).reshape(2 , 5 ) ) with patch( """datasets.arrow_writer.cast_to_python_objects""" , side_effect=__UpperCamelCase ) as mock_cast_to_python_objects: _UpperCAmelCase = pa.array(TypedSequence([{"""path""": None, """bytes""": b"""image_bytes"""}, pil_image] , type=Image() ) ) _UpperCAmelCase ,_UpperCAmelCase = mock_cast_to_python_objects.call_args_list[-1] self.assertIn("""optimize_list_casting""" , __UpperCamelCase ) self.assertFalse(kwargs["""optimize_list_casting"""] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferReader(_A ) if isinstance(_A , pa.Buffer ) else pa.memory_map(_A ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() assert len(pa_table.to_batches() ) == expected_num_chunks assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} del pa_table @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Optional[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} ) with ArrowWriter(stream=_A , features=_A ) as writer: writer.write({"""labels""": 0} ) writer.write({"""labels""": 1} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == features.arrow_schema assert writer._schema.metadata == features.arrow_schema.metadata _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pa.ipc.open_stream(_A ) _UpperCAmelCase = f.read_all() _UpperCAmelCase = pa_table.schema assert pa_table.num_rows == 2 assert schema == features.arrow_schema assert schema.metadata == features.arrow_schema.metadata assert features == Features.from_arrow_schema(_A ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=[1, 2] ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: with pytest.raises(_A ): writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1_0 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=1_0 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() @pytest.mark.parametrize("""writer_batch_size""" , [None, 2, 1_0] ) def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter( stream=_A , writer_batch_size=_A , hash_salt="""split_name""" , check_duplicates=_A , ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} , key=1 ) writer.write({"""col_1""": """bar""", """col_2""": 2} , key=2 ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) writer.write_batch({"""col_1""": [], """col_2""": []} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) @pytest.mark.parametrize("""writer_batch_size""" , [None, 1, 1_0] ) @pytest.mark.parametrize( """fields""" , [None, {"""col_1""": pa.string(), """col_2""": pa.intaa()}, {"""col_1""": pa.string(), """col_2""": pa.intaa()}] ) def _UpperCamelCase ( _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() _UpperCAmelCase = pa.schema(_A ) if fields else None with ArrowWriter(stream=_A , schema=_A , writer_batch_size=_A ) as writer: writer.write_row(pa.Table.from_pydict({"""col_1""": ["""foo"""], """col_2""": [1]} ) ) writer.write_row(pa.Table.from_pydict({"""col_1""": ["""bar"""], """col_2""": [2]} ) ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 if not fields: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(output.getvalue() , expected_num_chunks=num_examples if writer_batch_size == 1 else 1 ) def _UpperCamelCase ( ) -> str: """simple docstring""" with tempfile.TemporaryDirectory() as tmp_dir: _UpperCAmelCase = {"""col_1""": pa.string(), """col_2""": pa.intaa()} _UpperCAmelCase = os.path.join(_A , """test.arrow""" ) with ArrowWriter(path=_A , schema=pa.schema(_A ) ) as writer: writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert writer._schema == pa.schema(_A , metadata=writer._schema.metadata ) _check_output(_A , 1 ) def _UpperCamelCase ( _A ) -> int: """simple docstring""" if pa.types.is_list(_A ): return get_base_dtype(arr_type.value_type ) else: return arr_type def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" if isinstance(lst[0] , _A ): change_first_primitive_element_in_list(lst[0] , _A ) else: _UpperCAmelCase = value @pytest.mark.parametrize("""optimized_int_type, expected_dtype""" , [(None, pa.intaa()), (Value("""int32""" ), pa.intaa())] ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.array(TypedSequence(_A , optimized_int_type=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype @pytest.mark.parametrize( """col, expected_dtype""" , [ ("""attention_mask""", pa.inta()), ("""special_tokens_mask""", pa.inta()), ("""token_type_ids""", pa.inta()), ("""input_ids""", pa.intaa()), ("""other""", pa.intaa()), ] , ) @pytest.mark.parametrize("""sequence""" , [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]] ) def _UpperCamelCase ( _A , _A , _A ) -> str: """simple docstring""" _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == expected_dtype # not in range if col != "other": # avoids errors due to in-place modifications _UpperCAmelCase = copy.deepcopy(_A ) _UpperCAmelCase = np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1 change_first_primitive_element_in_list(_A , _A ) _UpperCAmelCase = pa.array(OptimizedTypedSequence(_A , col=_A ) ) assert get_base_dtype(arr.type ) == pa.intaa() @pytest.mark.parametrize("""raise_exception""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Dict: """simple docstring""" _UpperCAmelCase = str(tmp_path / """dataset-train.arrow""" ) try: with ArrowWriter(path=_A ) as writer: if raise_exception: raise pa.lib.ArrowInvalid() else: writer.stream.close() except pa.lib.ArrowInvalid: pass finally: assert writer.stream.closed def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" _UpperCAmelCase = """mock://dataset-train.arrow""" with ArrowWriter(path=_A , storage_options=mockfs.storage_options ) as writer: assert isinstance(writer._fs , type(_A ) ) assert writer._fs.storage_options == mockfs.storage_options writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 assert mockfs.exists(_A ) def _UpperCamelCase ( ) -> Dict: """simple docstring""" _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter(stream=_A ) as writer: writer.write({"""col_1""": """foo""", """col_2""": 1} ) writer.write({"""col_1""": """bar""", """col_2""": 2} ) _UpperCAmelCase ,_UpperCAmelCase = writer.finalize() assert num_examples == 2 assert num_bytes > 0 _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]} @require_pil @pytest.mark.parametrize("""embed_local_files""" , [False, True] ) def _UpperCamelCase ( _A , _A ) -> Any: """simple docstring""" import PIL.Image _UpperCAmelCase = str(tmp_path / """test_image_rgb.jpg""" ) PIL.Image.fromarray(np.zeros((5, 5) , dtype=np.uinta ) ).save(_A , format="""png""" ) _UpperCAmelCase = pa.BufferOutputStream() with ParquetWriter( stream=_A , features=Features({"""image""": Image()} ) , embed_local_files=_A ) as writer: writer.write({"""image""": image_path} ) writer.finalize() _UpperCAmelCase = pa.BufferReader(output.getvalue() ) _UpperCAmelCase = pq.read_table(_A ) _UpperCAmelCase = pa_table.to_pydict() if embed_local_files: assert isinstance(out["""image"""][0]["""path"""] , _A ) with open(_A , """rb""" ) as f: assert out["image"][0]["bytes"] == f.read() else: assert out["image"][0]["path"] == image_path assert out["image"][0]["bytes"] is None def _UpperCamelCase ( ) -> int: """simple docstring""" _UpperCAmelCase = pa.schema([pa.field("""col_1""" , pa.string() , nullable=_A )] ) _UpperCAmelCase = pa.BufferOutputStream() with ArrowWriter(stream=_A ) as writer: writer._build_writer(inferred_schema=_A ) assert writer._schema == pa.schema([pa.field("""col_1""" , pa.string() )] )
19
0
"""simple docstring""" from ...configuration_utils import PretrainedConfig from ...utils import logging a : Optional[int] = logging.get_logger(__name__) a : int = { "weiweishi/roc-bert-base-zh": "https://huggingface.co/weiweishi/roc-bert-base-zh/resolve/main/config.json", } class a_ ( __lowerCAmelCase ): a : Dict = 'roc_bert' def __init__( self : Optional[int] , __UpperCamelCase : Union[str, Any]=3_05_22 , __UpperCamelCase : int=7_68 , __UpperCamelCase : Any=12 , __UpperCamelCase : List[str]=12 , __UpperCamelCase : Tuple=30_72 , __UpperCamelCase : int="gelu" , __UpperCamelCase : Any=0.1 , __UpperCamelCase : List[str]=0.1 , __UpperCamelCase : List[Any]=5_12 , __UpperCamelCase : Union[str, Any]=2 , __UpperCamelCase : Tuple=0.0_2 , __UpperCamelCase : List[Any]=1e-12 , __UpperCamelCase : Optional[int]=True , __UpperCamelCase : List[Any]=0 , __UpperCamelCase : int="absolute" , __UpperCamelCase : Optional[Any]=None , __UpperCamelCase : List[str]=True , __UpperCamelCase : Any=True , __UpperCamelCase : Tuple=7_68 , __UpperCamelCase : int=9_10 , __UpperCamelCase : Optional[Any]=5_12 , __UpperCamelCase : List[str]=2_48_58 , __UpperCamelCase : Tuple=True , **__UpperCamelCase : Optional[Any] , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = vocab_size _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_act _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = initializer_range _UpperCAmelCase = type_vocab_size _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = use_cache _UpperCAmelCase = enable_pronunciation _UpperCAmelCase = enable_shape _UpperCAmelCase = pronunciation_embed_dim _UpperCAmelCase = pronunciation_vocab_size _UpperCAmelCase = shape_embed_dim _UpperCAmelCase = shape_vocab_size _UpperCAmelCase = concat_input _UpperCAmelCase = position_embedding_type _UpperCAmelCase = classifier_dropout super().__init__(pad_token_id=_UpperCamelCase , **_UpperCamelCase )
715
"""simple docstring""" # Lint as: python3 import sys from collections.abc import Mapping from typing import TYPE_CHECKING, Dict, Optional import numpy as np import pyarrow as pa from .. import config from ..utils.logging import get_logger from ..utils.py_utils import map_nested from .formatting import TensorFormatter if TYPE_CHECKING: import jax import jaxlib a : List[Any] = get_logger() a : Optional[dict] = None class a_ ( TensorFormatter[Mapping, 'jax.Array', Mapping] ): def __init__( self : int , __UpperCamelCase : List[str]=None , __UpperCamelCase : Optional[int]=None , **__UpperCamelCase : int ) ->Tuple: '''simple docstring''' super().__init__(features=__UpperCamelCase ) import jax from jaxlib.xla_client import Device if isinstance(__UpperCamelCase , __UpperCamelCase ): raise ValueError( f"""Expected {device} to be a `str` not {type(__UpperCamelCase )}, as `jaxlib.xla_extension.Device` """ """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """ """the device with `str()` to get its string identifier that will be internally mapped """ """to the actual `jaxlib.xla_extension.Device`.""" ) _UpperCAmelCase = device if isinstance(__UpperCamelCase , __UpperCamelCase ) else str(jax.devices()[0] ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() if self.device not in list(DEVICE_MAPPING.keys() ): logger.warning( f"""Device with string identifier {self.device} not listed among the available """ f"""devices: {list(DEVICE_MAPPING.keys() )}, so falling back to the default """ f"""device: {str(jax.devices()[0] )}.""" ) _UpperCAmelCase = str(jax.devices()[0] ) _UpperCAmelCase = jnp_array_kwargs @staticmethod def _snake_case ( ) ->Dict[str, "jaxlib.xla_extension.Device"]: '''simple docstring''' import jax return {str(__UpperCamelCase ): device for device in jax.devices()} def _snake_case ( self : Dict , __UpperCamelCase : Any ) ->Union[str, Any]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , __UpperCamelCase ) and column: if all( isinstance(__UpperCamelCase , jax.Array ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column ): return jnp.stack(__UpperCamelCase , axis=0 ) return column def _snake_case ( self : List[str] , __UpperCamelCase : Any ) ->Optional[int]: '''simple docstring''' import jax import jax.numpy as jnp if isinstance(__UpperCamelCase , (str, bytes, type(__UpperCamelCase )) ): return value elif isinstance(__UpperCamelCase , (np.character, np.ndarray) ) and np.issubdtype(value.dtype , np.character ): return value.tolist() _UpperCAmelCase = {} if isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.integer ): # the default int precision depends on the jax config # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision if jax.config.jax_enable_xaa: _UpperCAmelCase = {"""dtype""": jnp.intaa} else: _UpperCAmelCase = {"""dtype""": jnp.intaa} elif isinstance(__UpperCamelCase , (np.number, np.ndarray) ) and np.issubdtype(value.dtype , np.floating ): _UpperCAmelCase = {"""dtype""": jnp.floataa} elif config.PIL_AVAILABLE and "PIL" in sys.modules: import PIL.Image if isinstance(__UpperCamelCase , PIL.Image.Image ): _UpperCAmelCase = np.asarray(__UpperCamelCase ) # using global variable since `jaxlib.xla_extension.Device` is not serializable neither # with `pickle` nor with `dill`, so we need to use a global variable instead global DEVICE_MAPPING if DEVICE_MAPPING is None: _UpperCAmelCase = self._map_devices_to_str() with jax.default_device(DEVICE_MAPPING[self.device] ): # calling jnp.array on a np.ndarray does copy the data # see https://github.com/google/jax/issues/4486 return jnp.array(__UpperCamelCase , **{**default_dtype, **self.jnp_array_kwargs} ) def _snake_case ( self : Union[str, Any] , __UpperCamelCase : List[str] ) ->Any: '''simple docstring''' import jax # support for torch, tf, jax etc. if config.TORCH_AVAILABLE and "torch" in sys.modules: import torch if isinstance(__UpperCamelCase , torch.Tensor ): return self._tensorize(data_struct.detach().cpu().numpy()[()] ) if hasattr(__UpperCamelCase , """__array__""" ) and not isinstance(__UpperCamelCase , jax.Array ): _UpperCAmelCase = data_struct.__array__() # support for nested types like struct of list of struct if isinstance(__UpperCamelCase , np.ndarray ): if data_struct.dtype == object: # jax arrays cannot be instantied from an array of objects return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) elif isinstance(__UpperCamelCase , (list, tuple) ): return self._consolidate([self.recursive_tensorize(__UpperCamelCase ) for substruct in data_struct] ) return self._tensorize(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : dict ) ->int: '''simple docstring''' return map_nested(self._recursive_tensorize , __UpperCamelCase , map_list=__UpperCamelCase ) def _snake_case ( self : Dict , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_row(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_row(__UpperCamelCase ) return self.recursive_tensorize(__UpperCamelCase ) def _snake_case ( self : Optional[int] , __UpperCamelCase : pa.Table ) ->"jax.Array": '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_column(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_column(__UpperCamelCase , pa_table.column_names[0] ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) _UpperCAmelCase = self._consolidate(__UpperCamelCase ) return column def _snake_case ( self : Optional[Any] , __UpperCamelCase : pa.Table ) ->Mapping: '''simple docstring''' _UpperCAmelCase = self.numpy_arrow_extractor().extract_batch(__UpperCamelCase ) _UpperCAmelCase = self.python_features_decoder.decode_batch(__UpperCamelCase ) _UpperCAmelCase = self.recursive_tensorize(__UpperCamelCase ) for column_name in batch: _UpperCAmelCase = self._consolidate(batch[column_name] ) return batch
19
0
"""simple docstring""" import warnings from ...configuration_utils import PretrainedConfig from ...utils import logging a : List[str] = logging.get_logger(__name__) a : int = { '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/config.json''', '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/config.json''', } class a_ ( a__ ): '''simple docstring''' a : Union[str, Any] = 'xlnet' a : Optional[int] = ['mems'] a : Any = { 'n_token': 'vocab_size', # Backward compatibility 'hidden_size': 'd_model', 'num_attention_heads': 'n_head', 'num_hidden_layers': 'n_layer', } def __init__( self : Tuple , __UpperCamelCase : int=3_20_00 , __UpperCamelCase : Tuple=10_24 , __UpperCamelCase : Union[str, Any]=24 , __UpperCamelCase : Any=16 , __UpperCamelCase : Dict=40_96 , __UpperCamelCase : List[str]="gelu" , __UpperCamelCase : Tuple=True , __UpperCamelCase : List[Any]="bi" , __UpperCamelCase : str=0.0_2 , __UpperCamelCase : int=1e-12 , __UpperCamelCase : str=0.1 , __UpperCamelCase : str=5_12 , __UpperCamelCase : Dict=None , __UpperCamelCase : Optional[int]=True , __UpperCamelCase : Dict=False , __UpperCamelCase : List[Any]=False , __UpperCamelCase : List[Any]=-1 , __UpperCamelCase : Optional[Any]=False , __UpperCamelCase : List[Any]="last" , __UpperCamelCase : Any=True , __UpperCamelCase : List[str]="tanh" , __UpperCamelCase : List[str]=0.1 , __UpperCamelCase : str=5 , __UpperCamelCase : Optional[Any]=5 , __UpperCamelCase : Any=5 , __UpperCamelCase : str=1 , __UpperCamelCase : List[str]=2 , **__UpperCamelCase : Union[str, Any] , ) ->List[str]: '''simple docstring''' _UpperCAmelCase = vocab_size _UpperCAmelCase = d_model _UpperCAmelCase = n_layer _UpperCAmelCase = n_head if d_model % n_head != 0: raise ValueError(f"""'d_model % n_head' ({d_model % n_head}) should be equal to 0""" ) if "d_head" in kwargs: if kwargs["d_head"] != d_model // n_head: raise ValueError( f"""`d_head` ({kwargs["d_head"]}) should be equal to `d_model // n_head` ({d_model // n_head})""" ) _UpperCAmelCase = d_model // n_head _UpperCAmelCase = ff_activation _UpperCAmelCase = d_inner _UpperCAmelCase = untie_r _UpperCAmelCase = attn_type _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = dropout _UpperCAmelCase = mem_len _UpperCAmelCase = reuse_len _UpperCAmelCase = bi_data _UpperCAmelCase = clamp_len _UpperCAmelCase = same_length _UpperCAmelCase = summary_type _UpperCAmelCase = summary_use_proj _UpperCAmelCase = summary_activation _UpperCAmelCase = summary_last_dropout _UpperCAmelCase = start_n_top _UpperCAmelCase = end_n_top _UpperCAmelCase = bos_token_id _UpperCAmelCase = pad_token_id _UpperCAmelCase = eos_token_id if "use_cache" in kwargs: warnings.warn( """The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`""" """ instead.""" , _A , ) _UpperCAmelCase = kwargs['use_cache'] _UpperCAmelCase = use_mems_eval _UpperCAmelCase = use_mems_train super().__init__(pad_token_id=_A , bos_token_id=_A , eos_token_id=_A , **_A ) @property def _snake_case ( self : Optional[Any] ) ->Dict: '''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 _snake_case ( self : List[str] , __UpperCamelCase : 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.""" )
716
"""simple docstring""" from typing import TYPE_CHECKING from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available a : Tuple = { '''configuration_pegasus_x''': ['''PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''PegasusXConfig'''], } try: if not is_torch_available(): raise OptionalDependencyNotAvailable() except OptionalDependencyNotAvailable: pass else: a : List[str] = [ '''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 : Dict = _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
19
0
"""simple docstring""" def _UpperCamelCase ( _A = 1_0_0_0_0_0_0 ) -> List[str]: """simple docstring""" _UpperCAmelCase = [i - 1 for i in range(limit + 1 )] for i in range(2 , limit + 1 ): if phi[i] == i - 1: for j in range(2 * i , limit + 1 , _lowerCamelCase ): phi[j] -= phi[j] // i return sum(phi[2 : limit + 1] ) if __name__ == "__main__": print(solution())
717
"""simple docstring""" import collections import json import math import os import re import time from fnmatch import fnmatch from typing import Dict import requests from slack_sdk import WebClient a : int = WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN''']) def _UpperCamelCase ( _A ) -> List[str]: """simple docstring""" _UpperCAmelCase = test_results.split(""" """ ) _UpperCAmelCase = 0 _UpperCAmelCase = 0 # When the output is short enough, the output is surrounded by = signs: "== OUTPUT ==" # When it is too long, those signs are not present. _UpperCAmelCase = expressions[-2] if """=""" in expressions[-1] else expressions[-1] for i, expression in enumerate(_A ): if "failed" in expression: failed += int(expressions[i - 1] ) if "passed" in expression: success += int(expressions[i - 1] ) return failed, success, time_spent def _UpperCamelCase ( _A ) -> int: """simple docstring""" _UpperCAmelCase = {} _UpperCAmelCase = None _UpperCAmelCase = False for line in failures_short_lines.split("""\n""" ): if re.search(R"""_ \[doctest\]""" , _A ): _UpperCAmelCase = True _UpperCAmelCase = line.split(""" """ )[2] elif in_error and not line.split(""" """ )[0].isdigit(): _UpperCAmelCase = line _UpperCAmelCase = False return failures class a_ : def __init__( self : Union[str, Any] , __UpperCamelCase : str , __UpperCamelCase : Dict ) ->Union[str, Any]: '''simple docstring''' _UpperCAmelCase = title _UpperCAmelCase = doc_test_results["""time_spent"""].split(""",""" )[0] _UpperCAmelCase = doc_test_results["""success"""] _UpperCAmelCase = doc_test_results["""failures"""] _UpperCAmelCase = self.n_success + self.n_failures # Failures and success of the modeling tests _UpperCAmelCase = doc_test_results @property def _snake_case ( self : int ) ->str: '''simple docstring''' _UpperCAmelCase = [self._time_spent] _UpperCAmelCase = 0 for time in time_spent: _UpperCAmelCase = time.split(""":""" ) # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute. if len(__UpperCamelCase ) == 1: _UpperCAmelCase = [0, 0, time_parts[0]] _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = int(time_parts[0] ), int(time_parts[1] ), float(time_parts[2] ) total_secs += hours * 36_00 + minutes * 60 + seconds _UpperCAmelCase ,_UpperCAmelCase ,_UpperCAmelCase = total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60 return f"""{int(__UpperCamelCase )}h{int(__UpperCamelCase )}m{int(__UpperCamelCase )}s""" @property def _snake_case ( self : List[Any] ) ->Dict: '''simple docstring''' return {"type": "header", "text": {"type": "plain_text", "text": self.title}} @property def _snake_case ( self : Optional[Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": f"""🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.""", "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : Union[str, Any] ) ->Dict: '''simple docstring''' return { "type": "section", "text": { "type": "plain_text", "text": ( f"""There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in""" f""" {self.time}.""" ), "emoji": True, }, "accessory": { "type": "button", "text": {"type": "plain_text", "text": "Check Action results", "emoji": True}, "url": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } @property def _snake_case ( self : List[str] ) ->Dict: '''simple docstring''' _UpperCAmelCase = 40 _UpperCAmelCase = {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase , __UpperCamelCase )} _UpperCAmelCase = """""" for category, failures in category_failures.items(): if len(__UpperCamelCase ) == 0: continue if report != "": report += "\n\n" report += f"""*{category} failures*:""".ljust(line_length // 2 ).rjust(line_length // 2 ) + "\n" report += "`" report += "`\n`".join(__UpperCamelCase ) report += "`" return { "type": "section", "text": { "type": "mrkdwn", "text": f"""The following examples had failures:\n\n\n{report}\n""", }, } @property def _snake_case ( self : Union[str, Any] ) ->str: '''simple docstring''' _UpperCAmelCase = [self.header] if self.n_failures > 0: blocks.append(self.failures ) if self.n_failures > 0: blocks.extend([self.category_failures] ) if self.n_failures == 0: blocks.append(self.no_failures ) return json.dumps(__UpperCamelCase ) @staticmethod def _snake_case ( ) ->Any: '''simple docstring''' _UpperCAmelCase = [ { """type""": """section""", """text""": { """type""": """plain_text""", """text""": """There was an issue running the tests.""", }, """accessory""": { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """Check Action results""", """emoji""": True}, """url""": f"""https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}""", }, } ] print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(__UpperCamelCase )} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text="""There was an issue running the tests.""" , blocks=__UpperCamelCase , ) def _snake_case ( self : Tuple ) ->Optional[Any]: '''simple docstring''' print("""Sending the following payload""" ) print(json.dumps({"""blocks""": json.loads(self.payload )} ) ) _UpperCAmelCase = f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed.""" _UpperCAmelCase = client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , blocks=self.payload , text=__UpperCamelCase , ) def _snake_case ( self : List[Any] , __UpperCamelCase : Optional[int] , __UpperCamelCase : Any , __UpperCamelCase : Any , __UpperCamelCase : List[str] ) ->str: '''simple docstring''' _UpperCAmelCase = """""" for key, value in failures.items(): _UpperCAmelCase = value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase ) > 2_50 else value failures_text += f"""*{key}*\n_{value}_\n\n""" _UpperCAmelCase = job_name _UpperCAmelCase = {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}} if job_link is not None: _UpperCAmelCase = { """type""": """button""", """text""": {"""type""": """plain_text""", """text""": """GitHub Action job""", """emoji""": True}, """url""": job_link, } return [ {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}}, content, {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}}, ] def _snake_case ( self : int ) ->Optional[Any]: '''simple docstring''' if self.thread_ts is None: raise ValueError("""Can only post reply if a post has been made.""" ) _UpperCAmelCase = self.doc_test_results.pop("""job_link""" ) self.doc_test_results.pop("""failures""" ) self.doc_test_results.pop("""success""" ) self.doc_test_results.pop("""time_spent""" ) _UpperCAmelCase = sorted(self.doc_test_results.items() , key=lambda __UpperCamelCase : t[0] ) for job, job_result in sorted_dict: if len(job_result["""failures"""] ): _UpperCAmelCase = f"""*Num failures* :{len(job_result["failed"] )} \n""" _UpperCAmelCase = job_result["""failures"""] _UpperCAmelCase = self.get_reply_blocks(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , text=__UpperCamelCase ) print("""Sending the following reply""" ) print(json.dumps({"""blocks""": blocks} ) ) client.chat_postMessage( channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""] , text=f"""Results for {job}""" , blocks=__UpperCamelCase , thread_ts=self.thread_ts["""ts"""] , ) time.sleep(1 ) def _UpperCamelCase ( ) -> List[str]: """simple docstring""" _UpperCAmelCase = os.environ["""GITHUB_RUN_ID"""] _UpperCAmelCase = F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100""" _UpperCAmelCase = requests.get(_A ).json() _UpperCAmelCase = {} try: jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) _UpperCAmelCase = math.ceil((result["""total_count"""] - 1_0_0) / 1_0_0 ) for i in range(_A ): _UpperCAmelCase = requests.get(url + F"""&page={i + 2}""" ).json() jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]} ) return jobs except Exception as e: print("""Unknown error, could not fetch links.""" , _A ) return {} def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" _UpperCAmelCase = {} if os.path.exists(_A ): _UpperCAmelCase = os.listdir(_A ) for file in files: try: with open(os.path.join(_A , _A ) , encoding="""utf-8""" ) as f: _UpperCAmelCase = f.read() except UnicodeDecodeError as e: raise ValueError(F"""Could not open {os.path.join(_A , _A )}.""" ) from e return _artifact def _UpperCamelCase ( ) -> int: """simple docstring""" class a_ : def __init__( self : List[Any] , __UpperCamelCase : str ) ->Tuple: '''simple docstring''' _UpperCAmelCase = name _UpperCAmelCase = [] def __str__( self : int ) ->Optional[Any]: '''simple docstring''' return self.name def _snake_case ( self : Dict , __UpperCamelCase : str ) ->int: '''simple docstring''' self.paths.append({"""name""": self.name, """path""": path} ) _UpperCAmelCase = {} _UpperCAmelCase = filter(os.path.isdir , os.listdir() ) for directory in directories: _UpperCAmelCase = directory if artifact_name not in _available_artifacts: _UpperCAmelCase = Artifact(_A ) _available_artifacts[artifact_name].add_path(_A ) return _available_artifacts if __name__ == "__main__": a : Dict = get_job_links() a : Dict = retrieve_available_artifacts() a : Optional[int] = collections.OrderedDict( [ ('''*.py''', '''API Examples'''), ('''*.md''', '''MD Examples'''), ] ) # This dict will contain all the information relative to each doc test category: # - failed: list of failed tests # - failures: dict in the format 'test': 'error_message' a : Dict = { v: { '''failed''': [], '''failures''': {}, } for v in docs.values() } # Link to the GitHub Action job a : int = github_actions_job_links.get('''run_doctests''') a : Tuple = available_artifacts['''doc_tests_gpu_test_reports'''].paths[0] a : Optional[Any] = retrieve_artifact(artifact_path['''name''']) if "stats" in artifact: a , a , a : str = handle_test_results(artifact['''stats''']) a : Tuple = failed a : int = success a : Any = time_spent[1:-1] + ''', ''' a : Dict = extract_first_line_failure(artifact['''failures_short''']) for line in artifact["summary_short"].split('''\n'''): if re.search('''FAILED''', line): a : List[Any] = line.replace('''FAILED ''', '''''') a : Tuple = line.split()[0].replace('''\n''', '''''') if "::" in line: a , a : Union[str, Any] = line.split('''::''') else: a , a : Optional[Any] = line, line for file_regex in docs.keys(): if fnmatch(file_path, file_regex): a : List[Any] = docs[file_regex] doc_test_results[category]["failed"].append(test) a : Optional[Any] = all_failures[test] if test in all_failures else '''N/A''' a : List[str] = failure break a : List[Any] = Message('''🤗 Results of the doc tests.''', doc_test_results) message.post() message.post_reply()
19
0
from ...configuration_utils import PretrainedConfig from ...utils import logging a : Tuple = logging.get_logger(__name__) a : Dict = { "microsoft/markuplm-base": "https://huggingface.co/microsoft/markuplm-base/resolve/main/config.json", "microsoft/markuplm-large": "https://huggingface.co/microsoft/markuplm-large/resolve/main/config.json", } class a_ ( _UpperCAmelCase ): a : List[str] = 'markuplm' def __init__( self : Any , __UpperCamelCase : str=3_05_22 , __UpperCamelCase : int=7_68 , __UpperCamelCase : str=12 , __UpperCamelCase : Union[str, Any]=12 , __UpperCamelCase : Any=30_72 , __UpperCamelCase : List[Any]="gelu" , __UpperCamelCase : int=0.1 , __UpperCamelCase : Tuple=0.1 , __UpperCamelCase : Union[str, Any]=5_12 , __UpperCamelCase : Dict=2 , __UpperCamelCase : str=0.0_2 , __UpperCamelCase : Optional[int]=1e-12 , __UpperCamelCase : Optional[Any]=0 , __UpperCamelCase : Any=0 , __UpperCamelCase : Optional[int]=2 , __UpperCamelCase : Optional[int]=2_56 , __UpperCamelCase : Optional[Any]=10_24 , __UpperCamelCase : Union[str, Any]=2_16 , __UpperCamelCase : Optional[int]=10_01 , __UpperCamelCase : str=32 , __UpperCamelCase : List[str]=50 , __UpperCamelCase : List[str]="absolute" , __UpperCamelCase : List[str]=True , __UpperCamelCase : Union[str, Any]=None , **__UpperCamelCase : int , ) ->int: '''simple docstring''' super().__init__( pad_token_id=lowerCamelCase_ , bos_token_id=lowerCamelCase_ , eos_token_id=lowerCamelCase_ , **lowerCamelCase_ , ) _UpperCAmelCase = vocab_size _UpperCAmelCase = hidden_size _UpperCAmelCase = num_hidden_layers _UpperCAmelCase = num_attention_heads _UpperCAmelCase = hidden_act _UpperCAmelCase = intermediate_size _UpperCAmelCase = hidden_dropout_prob _UpperCAmelCase = attention_probs_dropout_prob _UpperCAmelCase = max_position_embeddings _UpperCAmelCase = type_vocab_size _UpperCAmelCase = initializer_range _UpperCAmelCase = layer_norm_eps _UpperCAmelCase = position_embedding_type _UpperCAmelCase = use_cache _UpperCAmelCase = classifier_dropout # additional properties _UpperCAmelCase = max_depth _UpperCAmelCase = max_xpath_tag_unit_embeddings _UpperCAmelCase = max_xpath_subs_unit_embeddings _UpperCAmelCase = tag_pad_id _UpperCAmelCase = subs_pad_id _UpperCAmelCase = xpath_unit_hidden_size
718
"""simple docstring""" import asyncio import os import re import sys import tempfile import unittest from contextlib import contextmanager from copy import deepcopy from distutils.util import strtobool from enum import Enum from importlib.util import find_spec from pathlib import Path from unittest.mock import patch import pyarrow as pa import pytest import requests from packaging import version from datasets import config if config.PY_VERSION < version.parse('''3.8'''): import importlib_metadata else: import importlib.metadata as importlib_metadata def _UpperCamelCase ( _A , _A=False ) -> str: """simple docstring""" try: _UpperCAmelCase = os.environ[key] except KeyError: # KEY isn't set, default to `default`. _UpperCAmelCase = default else: # KEY is set, convert it to True or False. try: _UpperCAmelCase = strtobool(_A ) except ValueError: # More values are supported, but let's keep the message simple. raise ValueError(F"""If set, {key} must be yes or no.""" ) return _value a : Union[str, Any] = parse_flag_from_env('''RUN_SLOW''', default=False) a : Tuple = parse_flag_from_env('''RUN_REMOTE''', default=False) a : Union[str, Any] = parse_flag_from_env('''RUN_LOCAL''', default=True) a : int = parse_flag_from_env('''RUN_PACKAGED''', default=True) # Compression a : List[Any] = pytest.mark.skipif(not config.LZ4_AVAILABLE, reason='''test requires lz4''') a : List[Any] = pytest.mark.skipif(not config.PY7ZR_AVAILABLE, reason='''test requires py7zr''') a : Optional[Any] = pytest.mark.skipif(not config.ZSTANDARD_AVAILABLE, reason='''test requires zstandard''') # Audio a : int = pytest.mark.skipif( # On Windows and OS X, soundfile installs sndfile find_spec('''soundfile''') is None or version.parse(importlib_metadata.version('''soundfile''')) < version.parse('''0.12.0'''), reason='''test requires sndfile>=0.12.1: \'pip install \"soundfile>=0.12.1\"\'; ''', ) # Beam a : Tuple = pytest.mark.skipif( not config.BEAM_AVAILABLE or config.DILL_VERSION >= version.parse('''0.3.2'''), reason='''test requires apache-beam and a compatible dill version''', ) # Dill-cloudpickle compatibility a : Any = pytest.mark.skipif( config.DILL_VERSION <= version.parse('''0.3.2'''), reason='''test requires dill>0.3.2 for cloudpickle compatibility''', ) # Windows a : int = pytest.mark.skipif( sys.platform == '''win32''', reason='''test should not be run on Windows''', ) def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import faiss # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires faiss""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" try: import regex # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires regex""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" try: import elasticsearch # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires elasticsearch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" try: import sqlalchemy # noqa except ImportError: _UpperCAmelCase = unittest.skip("""test requires sqlalchemy""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Union[str, Any]: """simple docstring""" if not config.TORCH_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires PyTorch""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[Any]: """simple docstring""" if not config.TF_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires TensorFlow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" if not config.JAX_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires JAX""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not config.PIL_AVAILABLE: _UpperCAmelCase = unittest.skip("""test requires Pillow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> str: """simple docstring""" try: import transformers # noqa F401 except ImportError: return unittest.skip("""test requires transformers""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import tiktoken # noqa F401 except ImportError: return unittest.skip("""test requires tiktoken""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import spacy # noqa F401 except ImportError: return unittest.skip("""test requires spacy""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> int: """simple docstring""" def _require_spacy_model(_A ): try: import spacy # noqa F401 spacy.load(_A ) except ImportError: return unittest.skip("""test requires spacy""" )(_A ) except OSError: return unittest.skip("""test requires spacy model '{}'""".format(_A ) )(_A ) else: return test_case return _require_spacy_model def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" try: import pyspark # noqa F401 except ImportError: return unittest.skip("""test requires pyspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> List[Any]: """simple docstring""" try: import joblibspark # noqa F401 except ImportError: return unittest.skip("""test requires joblibspark""" )(_A ) else: return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_slow_tests or _run_slow_tests == 0: _UpperCAmelCase = unittest.skip("""test is slow""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Any: """simple docstring""" if not _run_local_tests or _run_local_tests == 0: _UpperCAmelCase = unittest.skip("""test is local""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Optional[int]: """simple docstring""" if not _run_packaged_tests or _run_packaged_tests == 0: _UpperCAmelCase = unittest.skip("""test is packaged""" )(_A ) return test_case def _UpperCamelCase ( _A ) -> Dict: """simple docstring""" if not _run_remote_tests or _run_remote_tests == 0: _UpperCAmelCase = unittest.skip("""test requires remote""" )(_A ) return test_case def _UpperCamelCase ( *_A ) -> Dict: """simple docstring""" def decorate(cls ): for name, fn in cls.__dict__.items(): if callable(_A ) and name.startswith("""test""" ): for decorator in decorators: _UpperCAmelCase = decorator(_A ) setattr(cls , _A , _A ) return cls return decorate class a_ ( _UpperCAmelCase ): pass class a_ ( _UpperCAmelCase ): a : Any = 0 a : Optional[Any] = 1 a : int = 2 @contextmanager def _UpperCamelCase ( _A=OfflineSimulationMode.CONNECTION_FAILS , _A=1e-16 ) -> List[Any]: """simple docstring""" _UpperCAmelCase = requests.Session().request def timeout_request(_A , _A , _A , **_A ): # Change the url to an invalid url so that the connection hangs _UpperCAmelCase = """https://10.255.255.1""" if kwargs.get("""timeout""" ) is None: raise RequestWouldHangIndefinitelyError( F"""Tried a call to {url} in offline mode with no timeout set. Please set a timeout.""" ) _UpperCAmelCase = timeout try: return online_request(_A , _A , **_A ) except Exception as e: # The following changes in the error are just here to make the offline timeout error prettier _UpperCAmelCase = url _UpperCAmelCase = e.args[0] _UpperCAmelCase = (max_retry_error.args[0].replace("""10.255.255.1""" , F"""OfflineMock[{url}]""" ),) _UpperCAmelCase = (max_retry_error,) raise def raise_connection_error(_A , _A , **_A ): raise requests.ConnectionError("""Offline mode is enabled.""" , request=_A ) if mode is OfflineSimulationMode.CONNECTION_FAILS: with patch("""requests.Session.send""" , _A ): yield elif mode is OfflineSimulationMode.CONNECTION_TIMES_OUT: # inspired from https://stackoverflow.com/a/904609 with patch("""requests.Session.request""" , _A ): yield elif mode is OfflineSimulationMode.HF_DATASETS_OFFLINE_SET_TO_1: with patch("""datasets.config.HF_DATASETS_OFFLINE""" , _A ): yield else: raise ValueError("""Please use a value from the OfflineSimulationMode enum.""" ) @contextmanager def _UpperCamelCase ( *_A , **_A ) -> str: """simple docstring""" _UpperCAmelCase = str(Path().resolve() ) with tempfile.TemporaryDirectory(*_A , **_A ) as tmp_dir: try: os.chdir(_A ) yield finally: os.chdir(_A ) @contextmanager def _UpperCamelCase ( ) -> Any: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory > 0, "Arrow memory didn't increase." @contextmanager def _UpperCamelCase ( ) -> Union[str, Any]: """simple docstring""" import gc gc.collect() _UpperCAmelCase = pa.total_allocated_bytes() yield assert pa.total_allocated_bytes() - previous_allocated_memory <= 0, "Arrow memory wasn't expected to increase." def _UpperCamelCase ( _A , _A ) -> str: """simple docstring""" return deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() == deepcopy(_A ).integers(0 , 1_0_0 , 1_0 ).tolist() def _UpperCamelCase ( _A ) -> Tuple: """simple docstring""" import decorator from requests.exceptions import HTTPError def _wrapper(_A , *_A , **_A ): try: return func(*_A , **_A ) except HTTPError as err: if str(_A ).startswith("""500""" ) or str(_A ).startswith("""502""" ): pytest.xfail(str(_A ) ) raise err return decorator.decorator(_wrapper , _A ) class a_ : def __init__( self : int , __UpperCamelCase : List[Any] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[str] ) ->int: '''simple docstring''' _UpperCAmelCase = returncode _UpperCAmelCase = stdout _UpperCAmelCase = stderr async def _UpperCamelCase ( _A , _A ) -> Union[str, Any]: """simple docstring""" while True: _UpperCAmelCase = await stream.readline() if line: callback(_A ) else: break async def _UpperCamelCase ( _A , _A=None , _A=None , _A=None , _A=False , _A=False ) -> _RunOutput: """simple docstring""" if echo: print("""\nRunning: """ , """ """.join(_A ) ) _UpperCAmelCase = await asyncio.create_subprocess_exec( cmd[0] , *cmd[1:] , stdin=_A , stdout=asyncio.subprocess.PIPE , stderr=asyncio.subprocess.PIPE , env=_A , ) # note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe # https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait # # If it starts hanging, will need to switch to the following code. The problem is that no data # will be seen until it's done and if it hangs for example there will be no debug info. # out, err = await p.communicate() # return _RunOutput(p.returncode, out, err) _UpperCAmelCase = [] _UpperCAmelCase = [] def tee(_A , _A , _A , _A="" ): _UpperCAmelCase = line.decode("""utf-8""" ).rstrip() sink.append(_A ) if not quiet: print(_A , _A , file=_A ) # XXX: the timeout doesn't seem to make any difference here await asyncio.wait( [ _read_stream(p.stdout , lambda _A : tee(_A , _A , sys.stdout , label="""stdout:""" ) ), _read_stream(p.stderr , lambda _A : tee(_A , _A , sys.stderr , label="""stderr:""" ) ), ] , timeout=_A , ) return _RunOutput(await p.wait() , _A , _A ) def _UpperCamelCase ( _A , _A=None , _A=None , _A=1_8_0 , _A=False , _A=True ) -> _RunOutput: """simple docstring""" _UpperCAmelCase = asyncio.get_event_loop() _UpperCAmelCase = loop.run_until_complete( _stream_subprocess(_A , env=_A , stdin=_A , timeout=_A , quiet=_A , echo=_A ) ) _UpperCAmelCase = """ """.join(_A ) if result.returncode > 0: _UpperCAmelCase = """\n""".join(result.stderr ) raise RuntimeError( F"""'{cmd_str}' failed with returncode {result.returncode}\n\n""" F"""The combined stderr from workers follows:\n{stderr}""" ) # check that the subprocess actually did run and produced some output, should the test rely on # the remote side to do the testing if not result.stdout and not result.stderr: raise RuntimeError(F"""'{cmd_str}' produced no output.""" ) return result def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = os.environ.get("""PYTEST_XDIST_WORKER""" , """gw0""" ) _UpperCAmelCase = re.sub(R"""^gw""" , """""" , _A , 0 , re.M ) return int(_A ) def _UpperCamelCase ( ) -> Tuple: """simple docstring""" _UpperCAmelCase = 2_9_5_0_0 _UpperCAmelCase = pytest_xdist_worker_id() return port + uniq_delta
19
0
"""simple docstring""" from __future__ import annotations a : Tuple = """#""" class a_ : def __init__( self : Dict ) ->None: '''simple docstring''' _UpperCAmelCase = {} def _snake_case ( self : int , __UpperCamelCase : Dict ) ->None: '''simple docstring''' _UpperCAmelCase = self._trie for char in text: if char not in trie: _UpperCAmelCase = {} _UpperCAmelCase = trie[char] _UpperCAmelCase = True def _snake_case ( self : str , __UpperCamelCase : Optional[Any] ) ->tuple | list: '''simple docstring''' _UpperCAmelCase = self._trie for char in prefix: if char in trie: _UpperCAmelCase = trie[char] else: return [] return self._elements(snake_case_ ) def _snake_case ( self : str , __UpperCamelCase : Dict ) ->tuple: '''simple docstring''' _UpperCAmelCase = [] for c, v in d.items(): _UpperCAmelCase = [""" """] if c == END else [(c + s) for s in self._elements(snake_case_ )] result.extend(snake_case_ ) return tuple(snake_case_ ) a : Union[str, Any] = Trie() a : Any = ("""depart""", """detergent""", """daring""", """dog""", """deer""", """deal""") for word in words: trie.insert_word(word) def _UpperCamelCase ( _A ) -> tuple: """simple docstring""" _UpperCAmelCase = trie.find_word(_A ) return tuple(string + word for word in suffixes ) def _UpperCamelCase ( ) -> None: """simple docstring""" print(autocomplete_using_trie("""de""" ) ) if __name__ == "__main__": import doctest doctest.testmod() main()
719
"""simple docstring""" from pathlib import PurePosixPath from typing import Optional import fsspec from fsspec import AbstractFileSystem from huggingface_hub.hf_api import DatasetInfo from ..utils.file_utils import get_authentication_headers_for_url from ..utils.hub import hf_hub_url class a_ ( _UpperCAmelCase ): a : List[Any] = '' a : Union[str, Any] = 'hf-legacy' # "hf://"" is reserved for hffs def __init__( self : Tuple , __UpperCamelCase : Optional[DatasetInfo] = None , __UpperCamelCase : Optional[str] = None , **__UpperCamelCase : Any , ) ->Any: '''simple docstring''' super().__init__(self , **__UpperCamelCase ) _UpperCAmelCase = repo_info _UpperCAmelCase = token _UpperCAmelCase = None def _snake_case ( self : List[str] ) ->List[str]: '''simple docstring''' if self.dir_cache is None: _UpperCAmelCase = {} for hf_file in self.repo_info.siblings: # TODO(QL): add sizes _UpperCAmelCase = { """name""": hf_file.rfilename, """size""": None, """type""": """file""", } self.dir_cache.update( { str(__UpperCamelCase ): {"""name""": str(__UpperCamelCase ), """size""": None, """type""": """directory"""} for d in list(PurePosixPath(hf_file.rfilename ).parents )[:-1] } ) def _snake_case ( self : Tuple , __UpperCamelCase : str , __UpperCamelCase : str = "rb" , **__UpperCamelCase : Any , ) ->List[str]: '''simple docstring''' if not isinstance(self.repo_info , __UpperCamelCase ): raise NotImplementedError(f"""Open is only implemented for dataset repositories, but got {self.repo_info}""" ) _UpperCAmelCase = hf_hub_url(self.repo_info.id , __UpperCamelCase , revision=self.repo_info.sha ) return fsspec.open( __UpperCamelCase , mode=__UpperCamelCase , headers=get_authentication_headers_for_url(__UpperCamelCase , use_auth_token=self.token ) , client_kwargs={"""trust_env""": True} , ).open() def _snake_case ( self : int , __UpperCamelCase : int , **__UpperCamelCase : Dict ) ->Tuple: '''simple docstring''' self._get_dirs() _UpperCAmelCase = self._strip_protocol(__UpperCamelCase ) if path in self.dir_cache: return self.dir_cache[path] else: raise FileNotFoundError(__UpperCamelCase ) def _snake_case ( self : List[str] , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : Tuple=False , **__UpperCamelCase : List[str] ) ->Optional[Any]: '''simple docstring''' self._get_dirs() _UpperCAmelCase = PurePosixPath(path.strip("""/""" ) ) _UpperCAmelCase = {} for p, f in self.dir_cache.items(): _UpperCAmelCase = PurePosixPath(p.strip("""/""" ) ) _UpperCAmelCase = p.parent if root == path: _UpperCAmelCase = f _UpperCAmelCase = list(paths.values() ) if detail: return out else: return sorted(f["""name"""] for f in out )
19
0
from __future__ import annotations def _UpperCamelCase ( _A , _A , _A , _A ) -> List[Any]: """simple docstring""" _UpperCAmelCase = [] _UpperCAmelCase = 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 ) ) _UpperCAmelCase = result + left + right return input_list def _UpperCamelCase ( _A ) -> str: """simple docstring""" if len(__UpperCamelCase ) <= 1: return input_list _UpperCAmelCase = list(__UpperCamelCase ) # iteration for two-way merging _UpperCAmelCase = 2 while p <= len(__UpperCamelCase ): # getting low, high and middle value for merge-sort of single list for i in range(0 , len(__UpperCamelCase ) , __UpperCamelCase ): _UpperCAmelCase = i _UpperCAmelCase = i + p - 1 _UpperCAmelCase = (low + high + 1) // 2 _UpperCAmelCase = merge(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase , __UpperCamelCase ) # final merge of last two parts if p * 2 >= len(__UpperCamelCase ): _UpperCAmelCase = i _UpperCAmelCase = merge(__UpperCamelCase , 0 , __UpperCamelCase , len(__UpperCamelCase ) - 1 ) break p *= 2 return input_list if __name__ == "__main__": a : Optional[Any] = input('''Enter numbers separated by a comma:\n''').strip() if user_input == "": a : str = [] else: a : List[Any] = [int(item.strip()) for item in user_input.split(''',''')] print(iter_merge_sort(unsorted))
720
"""simple docstring""" import itertools import os from collections import Counter, defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed import numpy as np import datasets from .execute import check_correctness a : Optional[Any] = '''\ @misc{chen2021evaluating, title={Evaluating Large Language Models Trained on Code}, author={Mark Chen and Jerry Tworek and Heewoo Jun and Qiming Yuan \ and Henrique Ponde de Oliveira Pinto and Jared Kaplan and Harri Edwards \ and Yuri Burda and Nicholas Joseph and Greg Brockman and Alex Ray \ and Raul Puri and Gretchen Krueger and Michael Petrov and Heidy Khlaaf \ and Girish Sastry and Pamela Mishkin and Brooke Chan and Scott Gray \ and Nick Ryder and Mikhail Pavlov and Alethea Power and Lukasz Kaiser \ and Mohammad Bavarian and Clemens Winter and Philippe Tillet \ and Felipe Petroski Such and Dave Cummings and Matthias Plappert \ and Fotios Chantzis and Elizabeth Barnes and Ariel Herbert-Voss \ and William Hebgen Guss and Alex Nichol and Alex Paino and Nikolas Tezak \ and Jie Tang and Igor Babuschkin and Suchir Balaji and Shantanu Jain \ and William Saunders and Christopher Hesse and Andrew N. Carr \ and Jan Leike and Josh Achiam and Vedant Misra and Evan Morikawa \ and Alec Radford and Matthew Knight and Miles Brundage and Mira Murati \ and Katie Mayer and Peter Welinder and Bob McGrew and Dario Amodei \ and Sam McCandlish and Ilya Sutskever and Wojciech Zaremba}, year={2021}, eprint={2107.03374}, archivePrefix={arXiv}, primaryClass={cs.LG} } ''' a : List[str] = '''\ This metric implements the evaluation harness for the HumanEval problem solving dataset described in the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). ''' a : Any = ''' Calculates how good are predictions given some references, using certain scores Args: predictions: list of candidates to evaluate. Each candidates should be a list of strings with several code candidates to solve the problem. references: a list with a test for each prediction. Each test should evaluate the correctness of a code candidate. k: number of code candidates to consider in the evaluation (Default: [1, 10, 100]) num_workers: number of workers used to evaluate the canidate programs (Default: 4). timeout: Returns: pass_at_k: dict with pass rates for each k results: dict with granular results of each unittest Examples: >>> code_eval = datasets.load_metric("code_eval") >>> test_cases = ["assert add(2,3)==5"] >>> candidates = [["def add(a,b): return a*b", "def add(a, b): return a+b"]] >>> pass_at_k, results = code_eval.compute(references=test_cases, predictions=candidates, k=[1, 2]) >>> print(pass_at_k) {\'pass@1\': 0.5, \'pass@2\': 1.0} ''' a : int = ''' ################################################################################ !!!WARNING!!! ################################################################################ The "code_eval" metric executes untrusted model-generated code in Python. Although it is highly unlikely that model-generated code will do something overtly malicious in response to this test suite, model-generated code may act destructively due to a lack of model capability or alignment. Users are strongly encouraged to sandbox this evaluation suite so that it does not perform destructive actions on their host or network. For more information on how OpenAI sandboxes its code, see the paper "Evaluating Large Language Models Trained on Code" (https://arxiv.org/abs/2107.03374). Once you have read this disclaimer and taken appropriate precautions, set the environment variable HF_ALLOW_CODE_EVAL="1". Within Python you can to this with: >>> import os >>> os.environ["HF_ALLOW_CODE_EVAL"] = "1" ################################################################################\ ''' a : List[Any] = '''The MIT License Copyright (c) OpenAI (https://openai.com) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.''' @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION , _KWARGS_DESCRIPTION ) class a_ ( datasets.Metric ): def _snake_case ( self : Tuple ) ->Tuple: '''simple docstring''' return datasets.MetricInfo( # This is the description that will appear on the metrics page. description=_DESCRIPTION , citation=_CITATION , inputs_description=_KWARGS_DESCRIPTION , features=datasets.Features( { """predictions""": datasets.Sequence(datasets.Value("""string""" ) ), """references""": datasets.Value("""string""" ), } ) , homepage="""https://github.com/openai/human-eval""" , codebase_urls=["""https://github.com/openai/human-eval"""] , reference_urls=["""https://github.com/openai/human-eval"""] , license=_LICENSE , ) def _snake_case ( self : Optional[Any] , __UpperCamelCase : Dict , __UpperCamelCase : Union[str, Any] , __UpperCamelCase : List[Any]=[1, 10, 1_00] , __UpperCamelCase : Dict=4 , __UpperCamelCase : Tuple=3.0 ) ->Union[str, Any]: '''simple docstring''' if os.getenv("""HF_ALLOW_CODE_EVAL""" , 0 ) != "1": raise ValueError(_WARNING ) if os.name == "nt": raise NotImplementedError("""This metric is currently not supported on Windows.""" ) with ThreadPoolExecutor(max_workers=__UpperCamelCase ) as executor: _UpperCAmelCase = [] _UpperCAmelCase = Counter() _UpperCAmelCase = 0 _UpperCAmelCase = defaultdict(__UpperCamelCase ) for task_id, (candidates, test_case) in enumerate(zip(__UpperCamelCase , __UpperCamelCase ) ): for candidate in candidates: _UpperCAmelCase = candidate + """\n""" + test_case _UpperCAmelCase = (test_program, timeout, task_id, completion_id[task_id]) _UpperCAmelCase = executor.submit(__UpperCamelCase , *__UpperCamelCase ) futures.append(__UpperCamelCase ) completion_id[task_id] += 1 n_samples += 1 for future in as_completed(__UpperCamelCase ): _UpperCAmelCase = future.result() results[result["task_id"]].append((result["""completion_id"""], result) ) _UpperCAmelCase ,_UpperCAmelCase = [], [] for result in results.values(): result.sort() _UpperCAmelCase = [r[1]["""passed"""] for r in result] total.append(len(__UpperCamelCase ) ) correct.append(sum(__UpperCamelCase ) ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = np.array(__UpperCamelCase ) _UpperCAmelCase = k _UpperCAmelCase = {f"""pass@{k}""": estimate_pass_at_k(__UpperCamelCase , __UpperCamelCase , __UpperCamelCase ).mean() for k in ks if (total >= k).all()} return pass_at_k, results def _UpperCamelCase ( _A , _A , _A ) -> Dict: """simple docstring""" def estimator(_A , _A , _A ) -> float: if n - c < k: return 1.0 return 1.0 - np.prod(1.0 - k / np.arange(n - c + 1 , n + 1 ) ) if isinstance(_A , _A ): _UpperCAmelCase = itertools.repeat(_A , len(_A ) ) else: assert len(_A ) == len(_A ) _UpperCAmelCase = iter(_A ) return np.array([estimator(int(_A ) , int(_A ) , _A ) for n, c in zip(_A , _A )] )
19
0